Every agent pitch deck has the same slide: a task that took a human 40 minutes, done by an agent for $0.30 of tokens. The math is real. It's also the least complete cost picture in modern software.
We run agentic systems in production for clients, which means we see the invoices and the architecture behind them. The gap between what the API bills and what the task costs is where agent projects quietly lose their business case. This post is an itemized breakdown of that gap, and of what keeps it under control.
The token bill is the tip you can see
Start with the visible part, because even that gets underestimated. A demo run of an agent is one pass through the loop. A production run is not:
- Agents read far more than they write. Every step re-sends the accumulated context: instructions, tool results, conversation history. A 12-step task can easily consume 20 times the input tokens of its final answer. Input tokens look cheap per unit, but agents buy them in bulk.
- Retries multiply everything. Malformed tool calls, schema violations, timeouts. Each one replays a step with the full context attached. A system that retries 15% of its steps also pays for those tokens at every later step, because the failures ride along in the history.
- Loops are the tail risk. An agent that gets stuck re-planning burns tokens at machine speed until something stops it. Without hard step and budget caps, your worst-case task cost is unbounded, and sooner or later the worst case will run overnight.
None of this makes agents uneconomical. It makes unbounded agents uneconomical. Cap the steps, cap the spend per task, and the visible bill becomes predictable.
The invoice nobody itemizes: everything around the model
The second layer never shows up on the provider invoice, which is why it surprises teams at the end of the quarter:
- Tool calls have their own meters. Search APIs, geocoding, enrichment services, headless browsing, sandboxed code execution. Every agent step that touches the world touches something billed. The travel agent we built for YGO searches, packages, and books through third-party APIs on every run, and Ruma pulls more than eight hundred results from the Kayak and Odynn APIs per search. We've seen agent systems where third-party API spend exceeded the token bill.
- Orchestration is real infrastructure. Queues, state stores, sandboxes, and long-running workers that babysit multi-minute tasks. An agent that "just runs" does so on machinery with its own monthly cost and its own on-call rotation.
- Observability is non-negotiable and not free. Full traces of every step, with inputs, tool results, decisions, and costs, are the only way to debug an agent after the fact. Storing and querying those traces is a real line item. Not having them is a far more expensive one.
- Evaluation runs are recurring spend. Every prompt or model change should re-run your eval suite before it ships. Cheap per run, and exactly the kind of cost that stays invisible until someone multiplies it by "every merge."
The biggest line item is human attention
Here's the one that decides whether an agent has a business case at all: how much human time does a completed task still consume?
Early in production, the honest answer is "a lot," and that's fine, as long as it's designed to shrink:
- Review is a percentage, not a phase. Ship with humans checking most outputs, then ratchet down as measured accuracy earns it: 100%, then 25%, then spot-checks on a risk-scored sample. Teams that treat review as a temporary launch tax, with no mechanism to reduce it, are running a copilot and paying for an agent.
- Escalations cost double. A task the agent fails lands on a human after burning its tokens and tool calls. You pay for the attempt and for the manual redo. Escalation rate is the single most important number in agent economics, and it belongs on the same dashboard as the token bill.
- False confidence is the expensive failure. An agent that's wrong convincingly pushes review cost downstream to whoever catches the mistake, and sometimes that's a customer. Guardrails and grounding checks aren't quality garnish. They're what keeps the review loop cheap.
What keeps production agents economical
The good news is that every cost above responds to engineering. The agent systems that hold their business case share the same habits, and none of them are glamorous:
- Route by difficulty. Most steps in most tasks are easy: classification, extraction, formatting. Send those to a small model and save the frontier model for planning and hard reasoning. In our work this typically takes 60 to 80% off the token bill with no measurable quality loss, which mirrors what we see cutting inference costs on non-agent systems too.
- Cache what repeats. Agents re-derive the same sub-results constantly. The same document summarized, the same entity looked up. A result cache in front of the tools and a prompt cache in front of the model turn repeat work into lookups.
- Bound every loop. Max steps, max wall-clock, max spend per task, enforced by the orchestrator rather than politely requested in the prompt. The degraded path, handing the task to a human with everything gathered so far, is a feature, not a failure.
- Meter per task, not per month. The unit that matters is cost per completed task, human time included. When that number sits on a dashboard next to escalation rate, cost regressions get caught the week they ship instead of the quarter after.
Priced this way, the comparison that actually matters, the agent versus the process it replaces, usually still lands firmly in the agent's favor. It just lands three to ten times higher than the pitch-deck slide. Knowing that before you scale is the difference between a rollout and a write-off.
Budget for the system, not the model
The model is the engine. The cost is the whole vehicle. Token pricing will keep falling, as it has every year, but retries, tools, orchestration, observability, and human review don't ride that curve. They respond only to deliberate engineering.
So when you're sizing an agent project, budget for the system: the bounded loops, the routing, the traces, the shrinking review process. That's the infrastructure work we do at Nortik when we take agents to production, and it's what turns an impressive demo into a line item the CFO stops asking about.
