KazenAI
Request a demo

For teams running customer-facing AI agents in production

Per-customer spend authority for AI agents.

Atomic, auditable, fail-closed. Give your AI agents a budget: check each model call against customer, feature, and workflow limits, stop the next model call before the budget is exceeded, and keep a receipt for every allow and deny.

Agent FinOps owns the spending decision. Agent Lens shows the run behind it—without replacing your gateway, observability, or billing stack.

Request a demo See the proof

Available nowOpen-source SDKStart with one workflow and expand

Agent FinOps · Postgres spend authority Recorded run · 2026-10-12

One customer · one budget · concurrent agents

50 agents race one customer’s $5.00 budget.

Allowed
20
Denied before the provider call
30
Reserved
$5.00
Over budget
$0.00
Decision receipts
50
Retried requests that added spend
0
Recorded result of the Agent FinOps concurrency test: 50 workers each asked the Postgres spend authority to reserve $0.25 for the same customer before their model call. It admitted 20, denied 30 before dispatch with a receipt for each, and replayed retried requests without new spend. The test runs against real Postgres in CI.

The operating problem

Your AI agents don’t have a budget.
Your cloud bill doesn’t stop them.

AI agents can make hundreds of model calls, retries, and tool steps without a human approving each one. Existing cost controls were built for invoices and API keys—not for one customer conversation that suddenly costs $40.

  • Spend without ownership

    The invoice shows OpenAI or Anthropic totals. It rarely shows which customer, feature, workflow, or retry pattern drove the bill—so pricing and capacity stay guesswork.

  • Damage before the alert

    By the time a monthly bill or dashboard flags a spike, the expensive runs have finished. A shared key budget also fails when concurrent runs race the same remaining allowance.

  • Success that still fails you

    An agent can return HTTP 200 while burning money on loops and retries. Without run-level context, teams debug anecdotes instead of a clear cost trail.

That gap is the buying reason. If your current stack already answers it for the workflow that matters, you do not need another product. If it does not, start there—not with a platform migration.

What KazenAI does

Control the spend. Explain the run.

One economic decision. The execution evidence attached. Agent FinOps decides whether another call should run and records why. Agent Lens shows what happened inside the same run.

Business contextCustomer Feature Workflow Run
Two connected viewsCost & policy Execution & cause

Budgets for agents

Agent FinOps

What did this workflow cost—and should the next call run?

Give support conversations, research runs, or customers a spending limit. KazenAI checks the agreed model-call path before paid work runs and keeps an explainable allow/deny receipt. Your billing system remains the source of truth for invoices and entitlements.

Attribute the cost
Review model-call costs by customer, feature, workflow, and run instead of relying on a shared provider total.
Set a spending boundary
Apply multi-scope budget checks before the agreed model-call path—one budget across a workflow, even when its steps use different models and providers. Retries are accounted per attempt; a call the provider refuses costs nothing, and when an outcome is unclear the charge stays pending for reconciliation instead of being recorded as zero.
Understand the decision
Inspect an immutable decision receipt—estimated, reserved, and recorded costs, policy versions, and reason codes—for every allow or deny.

Why it spent that much

Agent Lens

What happened inside the run—and why did it become expensive?

A completed request does not explain how an agent got there. Follow the execution to find costly retries, slow steps, and behavior worth fixing.

Follow the execution
Inspect captured model calls, tool use, timing, and retries in a run timeline.
Connect behavior to cost
Review step-level details alongside cost and policy decisions, so an investigation has the context it needs.
Investigate repeated incidents
Group economic incidents and review the decision and run evidence behind recurring denials, overruns, or cost patterns.

Why teams start here

Make autonomous AI economically accountable.

  • Keep your framework, gateway, and billing system

    KazenAI adds customer/feature/workflow attribution, a concurrency-safe spending decision with a receipt, and the run evidence behind it—where your gateway, traces, and billing leave that join unresolved. Agent Lens accepts OpenTelemetry traces, so it sits next to the observability you already run; the same spans export to Datadog APM through a standard OpenTelemetry Collector. With a LiteLLM gateway, either your application or the gateway owns spend accounting for each call—never both—so retries are not double-counted.

  • See spend and cause together

    Attribution without a run story leaves finance guessing. Traces without a budget leave the bill open. KazenAI keeps both in scope.

  • Start focused, then expand

    Begin with the workflow where cost or investigation pain is clearest. Establish the integration and operating model there, then extend it to additional workflows.

Working with your application

Start where the economics matter most.

KazenAI works alongside your existing stack on supported OpenAI and Anthropic paths, including LiteLLM, LangChain, and LangGraph integrations. The first rollout establishes the attribution, policies, and run evidence your team can repeat across more workflows.

  1. Connect the first workflow

    Instrument a supported model-call path. Pass customer (business_subject_ref), feature, workflow, and run identifiers so every event and decision shares business context.

  2. Define the operating policy

    Define FinOps spending policies across the scopes you enforce, choose what Lens may show, and review access, retention, and provider pricing.

  3. Activate and expand

    Test allow and deny paths, retries, concurrent attribution, and failure handling—including safe application behavior after a denial. Activate the first path with agreed rollout criteria, then apply the pattern to additional workflows.

Visibility and enforcement are different. Capturing a trace does not stop a call. Budget checks must be connected to the model-call path and verified there.

For engineering teams

Start with the open-source path.

Install Agent FinOps and KazenAI core from PyPI to inspect the integration locally. When you want hosted cost controls and Agent Lens investigation together, request a demo.

Install Agent FinOps Documentation Core on PyPI View the core on GitHub

Agent FinOps, KazenAI core, and the event schema are open source. Read the developer docs at docs.kazenai.com. Agent Lens is part of the hosted product.

Pricing

Start with the path that fits your team.

The SDK is free and open source. You pay for the hosted spend authority, attribution, receipts, and Lens evidence—launched with founder-led onboarding, or scoped as a broader enterprise rollout.

Open Source

$0

The open-source SDK: local pre-call budget caps and loop detection in your own process. No account needed.

  • Local pre-call budget caps and loop detection
  • Install directly from PyPI
  • Build against the shared event schema
Install from PyPI

Production

$1,500 / month

Hosted Agent FinOps and Agent Lens for one organization, with founder-led rollout of the first workflow and agreed acceptance checks.

  • Shared spend authority across every worker and service
  • Customer, feature, workflow, and run attribution
  • Decision receipts for every allow and deny
  • Agent Lens incident evidence joined to spend
  • First-workflow integration and activation support

$2,500 one-time implementation. Payable after signing, before onboarding starts. Monthly software billing begins when the first agreed workflow is activated.

Request a demo

Enterprise

Custom annual

For broader rollouts that need more workflows, higher-volume usage, additional integrations, or tailored support.

  • Multi-workflow rollout planning
  • Integration and support requirements scoped together
  • Commercial terms aligned to the deployment
Discuss your rollout

Prices are in USD and exclude applicable taxes, model-provider fees, and customer infrastructure. Production usage limits, support, onboarding milestones, expansion scope, renewal, and cancellation terms are agreed in writing before signing. Additional workflows are scoped around usage, data retention, integration, and support—not treated as a separate product.

Before you start

What can I use today?

KazenAI is available now. The open-source Python packages are self-serve on PyPI, and a hosted Agent FinOps and Agent Lens demo is ready for a founder-led walkthrough. Production onboarding starts with the workflow where the business case is clearest, then expands to additional workflows.

Why not configure the tools we already use?

You should, if they already connect per-customer and per-workflow cost, a pre-call spending decision, and the evidence behind the run you need to investigate. KazenAI is for the workflow where that connection is still missing. We review your framework, gateway, billing system, provider API, authentication, and telemetry before confirming support; replacement is not the default.

Does KazenAI replace our billing system?

No. FinOps gives you cost evidence by customer and workflow to inform pricing and allowances; it does not manage entitlements, calculate customer invoices, or charge your users. Your billing system remains the source of truth.

Does a budget guarantee there will be no overspend?

No universal guarantee is offered. Coverage depends on the instrumented call path, estimates, concurrent requests, and provider billing behavior. In-flight or unobserved charges cannot simply be undone. Stopping new calls is not the same as cancelling or safely resuming an agent.

Which providers are supported today?

OpenAI Chat Completions and Anthropic Messages through monitor(), sync and async, streaming and non-streaming, plus tested LiteLLM, LangChain, and LangGraph paths. These paths are verified against the live OpenAI and Anthropic APIs as well as synthetic transports, including multi-step workflows that mix models under one shared budget. We confirm your exact stack before rollout. OpenAI Responses/Realtime, Bedrock/Vertex wrappers, CrewAI, and AutoGen are not supported.

What data do you need for a demo?

A non-confidential description of your workflow, stack, and problem is enough to start. Do not email credentials, prompts, production traces, or customer data. Capture, hosting, access, retention, and deletion requirements are agreed before diagnostic data is shared.

Next step

Bring the AI workflow whose spend you need to bound and explain.

Tell us what your agent does, how customers use it, and where spend, concurrency, or investigation becomes difficult. Dhavan will discuss fit and walk you through the hosted demo.

Request a demo