In November 2025, a market-research pipeline of four LangChain agents entered an unintended loop: the Analyzer generated content, the Verifier demanded more analysis, back and forth for eleven days. Nobody noticed until the bill arrived — $47,000. Root cause: no per-agent budget caps and no enforcement layer, only monitoring dashboards that nobody checked.
That same year, Uber rolled out Claude Code to about 5,000 engineers. Adoption jumped from 32% to 84% between December and March. By April the entire annual AI budget was gone. Monthly API costs per engineer ran $500–$2,000. Uber's response was a $1,500/month hard cap per employee per tool.
These are not edge cases. They are what happens when you run agents on infrastructure designed for single-turn chatbot calls. The missing piece is a budget layer — enforced at the platform level, not written into a system prompt.
Why agent costs run away
Agent costs don't grow linearly. They compound, and the mechanics are structural.
Context accumulation is the single biggest invisible cost. LLM calls are stateless — every round-trip re-sends the full conversation history. A 5-step agent loop costs about 3.2× more than a single chatbot call for the same task. At 50 steps the multiplier exceeds 30×. At 200 steps (a typical autonomous debugging session) it exceeds 100×. A 30-team audit found that re-sent context accounts for 62% of total agent bill — more than tool definitions, reasoning output, system prompts, and retries combined.
Infinite tool loops are the second mechanism. The LLM interprets every error as "task incomplete" and retries. Many framework defaults set max_iterations to None. There is no circuit breaker for "same tool, same args, tenth time in a row."
Recursive spawned agents multiply the problem. A multi-agent system with depth 5 and branching factor 3 produces 243 concurrent agents, each billing independently. Anthropic's own research found multi-agent systems use about 15× the tokens of a single chat.
The 90th-percentile developer runs up $1,650/month. The 99th percentile exceeds $4,200. The spread has nothing to do with productivity — it's driven by model choice and loop management.
Monitoring is not enforcement
Every team we talk to builds dashboards. They tag API calls, set up Slack alerts for sessions over $20, forward invoices to finance. The problem is fundamental: an alert fires after the spend has already happened. A loop running for eleven days with no one watching means eleven days of alerts nobody saw.
The gap between "alert fired" and "session stopped" is exactly where damage compounds. And alerts at 2 AM require a human who is awake and authorized to act. Most organizations don't have that person.
This is the difference between monitoring (reports what happened) and enforcement (stops what is about to happen). Few agent platforms distinguish them.
What the frameworks actually give you
The major frameworks punish you for using them in production by making you build cost governance yourself:
| Framework | Iteration limit | Token budget | Enforcement level |
|---|---|---|---|
| LangGraph | Via state machine | Manual tracking only | Graph-level |
| CrewAI | max_iter (default 15) | None | Agent-level |
| AutoGen | max_consecutive_auto_reply | None — docs say "not provided" | Requires external layer |
OpenAI and Anthropic give you per-call max_tokens and per-org usage dashboards. Neither has session-level budgets or per-agent cost enforcement. The guidance is architectural: use smaller models for simple tasks, enable prompt caching, cap your context. Good advice, none of it enforceable at the platform level.
Prompt-layer cost instructions are fragile. Models override "stop if this costs too much" when they are task-motivated. Budget enforcement must sit outside the agent's reasoning loop — in the infrastructure layer.
What a budget layer actually looks like
A budget primitive for agents has three properties:
Hard per-agent daily caps. Evaluated before each API call, not after. When the cap is met, the call is rejected — no prompt can talk around it.
Fail-closed by default. A misconfigured agent does not spend unbounded money. Its budget is its ceiling, and the platform enforces it.
Outside the agent's control. The agent cannot see or override its own budget. The enforcement is at the transport or orchestration layer, invisible to the model.
Teams that implement this pattern — hard per-agent caps, context pruning, model tier routing — typically reduce agent costs by 55–75% within 30 days. One organization went from $87K/month to $24K/month with no measured productivity loss.
The infrastructure gap is the real blocker
The $47,000 loop, Uber's wiped budget, the solo developer who burned $4,200 over a weekend — these are not failures of AI. They are failures of infrastructure designed for single-turn prompts, then retrofitted to run persistent, stateful agents.
Every organization running agents in production will hit this wall. The teams that survive it are the ones that treat cost governance as a platform capability, not a monitoring problem.
Alpi ships budget as a platform primitive: per-agent daily caps enforced at the infrastructure layer, fail-closed, outside the agent's reasoning loop. It is the difference between asking an agent to be frugal and giving it no choice.
Install it and see the source today: uv tool install alpi-agent