Token minimizing: price finished work, not tokens

The price of intelligence has collapsed and the bill has gone up anyway. That is the first thing to understand about token economics in 2026: per-token rates are down roughly 98% since early 2024, according to Cockroach Labs' analysis of agentic spend, while enterprise AI invoices keep climbing. Nothing is broken. The unit being priced changed, and almost nobody changed their accounting with it.

This is not a piece about saving pennies on inference. It is about the three decisions that actually determine whether a corporate AI program pays for itself: what you let a model decide, which model you attach to it, and who in the organization is accountable for the credits it burns.

The number that explains the bill

A 2026 study of eight frontier models working SWE-bench Verified tasks, published on arXiv as 2604.22750, measured what agentic coding actually consumes: an average of 4.17 million tokens per task, against 3,390 for code chat and 1,190 for code reasoning. Same models, same benchmark, roughly a thousandfold difference between asking a question and letting an agent work.

The same study found input-to-output ratios around 154:1, runs on the same task varying by up to 30x in total tokens, and no consistent quality gain on the expensive runs. Vantage's session analysis lands in the same place: input tokens re-sent on every turn dominate the total, because turn 40 carries every file read and every failed attempt from turns 1 to 39.

So the spend is not in the answers. It is in the retelling of the problem.

Price finished work, not tokens

A budget model at one cent per call with a 75% success rate costs more per resolved task than a frontier model at three cents with a 95% success rate, once you count the retries, the fallbacks and the human glance on the failures. The per-token comparison says the opposite, which is why so many downgrades quietly invert themselves.

Three amplifiers do the damage:

Silent retries. A weaker model fails schema validation more often, and most harnesses simply re-run the call, sending the entire prompt again. Token usage can multiply two to five times with no change in traffic, and the extra spend is attributed to "normal load".

Fallback chains. Cheap model first, frontier on failure, is correct engineering and double billing. Every failed cheap attempt is paid for twice.

The prompt-length tax. A weaker model needs more examples and more instruction to hit the same quality bar, and that heavier prompt is then re-sent on every retry and carried into every fallback.

The metric that belongs on the dashboard is cost per successful task: total spend divided by tasks that ended usable, with retry rate and effective prompt size reported beside it. If your observability reports tokens by model but not cost by resolved task, you are reading the one number most likely to be wrong.

Define what is AI and what is automation

Most corporate AI spend is really three different things wearing the same badge, and they fail in completely different ways.

The discipline is a single question: can the rule be written? If yes, write the rule. A model belongs only where the input is genuinely unconstrained language or image, or where the branching is too wide to enumerate. Everything else is code, and code is free per run, testable, and boring in the way that finance departments love.

This distinction is also the answer to the accountability question. A rule that runs ten thousand times is a fixed cost. A model call that runs ten thousand times is a variable cost with a tail. An agent that runs ten thousand times is a procurement decision.

The routing ladder

Attach the smallest model that clears the task, and reserve the frontier for the work that cannot be specified in advance: production-scope refactors, migrations, security review, and the failures nobody can reproduce. That is the same argument FrugalGPT made in 2023, where a learned cascade matched frontier quality with up to 98% lower cost, and RouteLLM later demonstrated on MT-Bench at 85% lower cost while holding 95% of GPT-4 quality and sending only 14% of queries to the strong model.

Published list rates per million tokens, as of November 2026:

Note the output column. Output is five to six times input on most flagship models, which means verbose reasoning is not free, and a cheaper model that writes three times as much to reach the same answer can lose.

Three levers stack on top of list price, and they are larger than the choice of model: prompt caching (Anthropic charges 0.1x base input on a cache read, 1.25x to write a five-minute cache), the batch API (50% off on both OpenAI and Anthropic), and context discipline. A cached batch request can land near 5% of a standard, uncached one.

Where the credits actually die

Creators lose credits to debugging, and the debugging is usually the agent failing to understand the situation rather than the model being too small. Drew Breunig's catalog of context failures is the cleanest map: poisoning, where one bad fact gets referenced forever; distraction, where a long context overwhelms what the model already knows; confusion, where irrelevant facts bend the answer; and clash, where tools and instructions contradict each other. Anthropic's own engineering guidance says the same thing more bluntly: as token count rises, the ability to recall accurately falls.

Four practical consequences for anyone paying the bill:

1. Long sessions are a cost center, not a virtue. Around 200k–300k tokens of context is where careful teams start a fresh thread rather than pushing on.
2. Isolate before you escalate. A subagent reading one directory costs a fraction of a frontier model re-reading the repo. Escalation should buy reasoning, not context.
3. Cap retries at two, then escalate with the trace attached. An uncapped retry loop at turn 40 is the most expensive object in most AI budgets.
4. If a human cannot see the failure in one line, the agent cannot either. Unclear errors are an observability problem. Structured logs, the exact command, and the exact assertion are worth more than any prompt rewrite.

Who owns the credits

The average user does not know which resource to spend, what it costs, or who to ask. That is not a training problem, it is a governance gap, and it shows up as a line item nobody can defend at quarter end.

What works is unglamorous:

• A named owner per agent or workflow, not per team.
• A published ladder: what each tier costs, what needs approval, who approves it. One page.
• Per-run caps on tokens and tool calls, enforced in code rather than in policy.
• Monthly showback by workflow, including retries and escalations, so a downgrade that inverted itself is visible before finance finds it.

What to do this week

The work is small and it is all measurement.

1. Instrument cost per resolved task, retry rate and effective prompt size for your three biggest AI workflows.
2. Take the three most frequently repeated model calls and ask whether they are rules. Convert the ones that are.
3. Write the escalation contract down: what triggers a rung up, what triggers a rung down.
4. Turn on caching for anything with a static system prompt and batch anything that does not need an answer in the next hour.
5. Put a name on every agent in production, and put that name on the invoice line.

Tokens are the cheap part of this. Ambiguity is what corporations are actually buying, and ambiguity is priced by the hour.