Finance teams signed off on AI budgets built from pilot data. Then production happened. Uber burned through its entire 2026 AI budget by April, four months in, after rolling Claude Code out to roughly 5,000 engineers. A healthcare enterprise quietly ran up more than six million dollars in unplanned inference costs over six months. Microsoft started canceling internal Claude Code licenses over unsustainable token bills. None of this is a pricing problem. It's an architecture problem that finance is only now able to see.
The pilot-to-production gap is not a rounding error
Pilots are cheap because pilots are small. A handful of engineers running a coding assistant a few times a day looks nothing like an org-wide rollout where every developer fires off dozens of agentic sessions, each one spawning sub-agent calls, retries, and planning loops. Royal Bank of Canada saw token usage jump 500% in six months. That's not 500% more people using AI. That's the same headcount generating exponentially more tokens per person, because agentic workflows don't scale linearly the way chatbot usage does.
The pattern shows up everywhere teams have looked closely. Monthly API costs per engineer now commonly run between $500 and $2,000. Enterprise inference has become the dominant line item in AI budgets, reportedly accounting for around 85% of total spend at some organizations. And one enterprise reportedly spent $500 million in a single month after granting AI access with no usage caps. None of these numbers were in anyone's original forecast, because the forecasts were built on chatbot-era assumptions: cost scales with prompts, prompts scale with headcount, headcount is known. Agents broke that chain.
Why agents cost so much more than a chatbot query
Gartner's analysis puts agentic workflows at 5 to 30 times the token consumption of a standard chatbot query for the same task. The reason isn't that agents are smarter or that the underlying model got more expensive per token. It's that a single user-initiated agentic task now triggers 10 to 20 separate model calls: plan, act, observe, re-plan, call a tool, check the result, decide whether to continue. Each of those calls is a full API request with its own input context.
That's where the real cost sits. Stanford's Digital Economy Lab found that re-sent context accounts for 62% of total agent inference spend. Most agent frameworks work by resending the entire prior conversation as input on every new step. If a task has ten phases, phase ten doesn't just cost the tokens for phase ten's work. It costs the tokens for the model to re-read phases one through nine first, every single time, before it does anything new.
The bill isn't for what the agent does. It's for what it has to re-read, every step, just to remember what it already did.
This compounds badly. A 20-step agent loop doesn't have linearly growing cost, it has roughly quadratic growth in context tokens, because step 20 re-reads everything from steps 1 through 19. Teams that budget based on "average tokens per call" from early testing get blindsided because early testing rarely runs tasks long enough to hit the compounding part of the curve.
Cost per prompt was never the right unit
Most of the org-level confusion traces back to measuring the wrong thing. Cost per prompt made sense when a user typed a question and got an answer. It stops making sense the moment a single user action triggers a chain of 10 to 20 model calls with unpredictable branching, retries, and sub-agent delegation. Two users asking for functionally identical outcomes can generate wildly different token bills depending on how many tool calls the agent decided it needed, how many times it second-guessed itself, and how much context had accumulated by the time it finished.
The unit that actually maps to business value is cost per completed task. That number is harder to compute, because it requires tracing a task end to end across every model call it spawned, including sub-agents that never surface in a user-facing log. But it's the only number that lets you compare an agent workflow against the process it replaced, or against a different agent architecture doing the same job with fewer steps.
Prototype estimates are structurally wrong, not just optimistic
Teams that estimate production token spend from a prototype are almost always low, and not by a little. Production multi-agent systems commonly run 3 to 10 times higher token usage than early estimates predicted. This isn't a forecasting failure so much as a structural blind spot: prototypes are usually built and tested as single-agent, single-pass flows. Production systems add retry logic, validation loops, sub-agent delegation for specialized subtasks, and iterative planning calls that fire when the first plan doesn't work. Every one of those additions was necessary for reliability. Every one of them multiplies token spend in ways that don't show up until the system is actually running against real, messy inputs.
This is the same lesson infrastructure teams learned with cloud compute a decade ago, just compressed into months instead of years: staging environments never reveal your real cost profile, because staging doesn't have production's volume, production's edge cases, or production's retry storms.
The industry response: a standards body, finally
The scale of the problem has now produced an institutional response. The Linux Foundation unveiled a