Why your AI agents are burning 30x more tokens than you think

Token prices fell roughly 80% between 2025 and 2026. Enterprise LLM spend still doubled. If that sounds contradictory, it's because everyone is measuring the wrong variable — price per token — while the thing actually driving the bill is how many tokens a single task now consumes.

The paradox nobody priced in

Every vendor announcement in the last eighteen months has been about cheaper tokens. And they weren't lying — per-token pricing genuinely collapsed. But enterprise AI API spend passed $8.4B in 2025 and is on track to double again, and inference now eats roughly 85% of the average AI budget. The gap between "tokens got cheaper" and "bills got bigger" has one name: agents.

A chatbot answers a question and stops. An agent plans, calls a tool, reads the result, re-evaluates, calls another tool, checks its own work, and sometimes starts over. Every one of those steps re-sends the accumulated context, and every one of those steps is billed. According to Gartner's March 2026 analysis, agentic workflows consume 5 to 30 times more tokens per completed task than an equivalent single-turn chatbot interaction. Some teams running heavy tool-calling loops report figures closer to 50x for their heaviest workloads.

What's actually happening inside the loop

An agent isn't one API call — it's a chain of them, and the chain compounds in ways that are easy to miss until you look at the raw request log:

• Context re-transmission. Like any multi-turn conversation, every step resends the full history: the original task, every tool result so far, every intermediate reasoning step. A 20-step agent run doesn't cost 20x a single call — it costs the sum of a rapidly growing context, every single step.
• Tool-call retries. A failed API call, a malformed JSON argument, a tool that returns an error — the agent typically retries, and each retry is a full billable round trip, context included.
• Self-verification passes. Modern agent frameworks add a "check your own output" step by default, because it measurably improves task success rates. It also roughly doubles the token cost of every task that uses it.
• Parallel sub-agents. Orchestration patterns that fan a task out to multiple sub-agents multiply the base cost by however many sub-agents run — often without a human ever choosing that multiplier explicitly. It's a default in the framework, not a deliberate trade-off.

The $4,200 weekend

This isn't theoretical. One widely-cited incident from a developer running an autonomous refactoring agent over a long weekend on a single client project: $4,200 in API fees, unattended, before anyone noticed. No single call was unusual. The agent simply kept working, kept re-reading context, kept retrying failed steps — and nothing was watching the meter in real time.

This is the pattern behind a broader statistic that should worry every finance team adopting agentic tooling: 60% of AI projects now exceed their original cost estimate by 30-50%, and 85% of companies miss their AI cost forecasts by more than 10% — a quarter of them by 50% or more. The estimates aren't wrong because people can't do math. They're wrong because the estimate was built on chatbot-era assumptions about tokens per task, and agents broke that assumption quietly.

Why it stays invisible until the invoice

A single agent step looks completely normal in isolation — a few hundred tokens of tool output, a reasonable-looking API call. Nothing about it trips an alarm. The cost only becomes visible when you aggregate across the full task chain, and most teams don't have that view. They have per-request logs, not per-task cost roll-ups. By the time someone builds the query that sums an agent run end-to-end, the spend has already happened for weeks.

This is also why per-token pricing headlines are actively misleading for budgeting purposes. A 50% price cut on the underlying model means nothing if the same task now runs through three times as many billable steps as it did six months ago, on the previous version of your agent framework.

What to instrument before you scale agents

Teams that keep agent costs under control share the same instrumentation, put in place before the agent ships to production rather than after the first surprise invoice:

• Cost per completed task, not per API call. Tag every step in an agent run with a shared task ID and roll up cost at the task level. A single call looking cheap tells you nothing; a task costing $8 to complete a $0.50 job tells you everything.
• A hard step ceiling. Cap the maximum number of tool-call iterations per task. Most runaway-cost incidents are loops that should have terminated and didn't.
• Per-agent, per-run budget guardrails. A dollar ceiling per task, enforced in real time, not reviewed after the fact. This is the single control that would have stopped the $4,200 weekend at $200.
• Retry and self-verification cost tracking, isolated. Know what fraction of your agent spend is the actual task versus overhead — retries, re-checks, re-planning. That ratio tells you exactly where to optimize first.
• Anomaly detection on task-level cost, not just daily total. A daily spend chart smooths over the one agent run that cost 40x its peers. Per-task baselines catch it immediately.

The bottom line

Cheaper tokens were never going to save your budget on their own, because agents don't buy fewer tokens with the savings — they spend the same dollars on more steps. The teams that will run agentic AI profitably in 2026 aren't the ones waiting for the next price cut. They're the ones who can see, task by task, exactly where every token went — and who put a ceiling on the loop before it needed one.