Token Economics: Why AI Bills Explode While Token Prices Fall

In May 2026, Fortune reported that Uber had burned through its entire 2026 AI budget in four months — while its president and COO publicly questioned whether the spending was even paying off. Days later, Bloomberg reported the company's response: a cap of $1,500 in monthly token spending per employee — per AI coding tool. And Uber is not an outlier — it's just the company that got the headline.

Here is the paradox that makes this story interesting: per-token prices have never been lower. Industry analyses put the decline of blended per-token prices at roughly two-thirds year over year. Tokens got cheaper; bills exploded anyway. Understanding why — and what to do about it — is what this guide is for. No PhD required: if you can read a taxi meter, you can understand token economics.

Tokens 101: The Currency of AI

Every interaction with a large language model is billed in tokens — chunks of text roughly four characters long. "Optimization" is about four tokens; a typical English word is one to two. (German speakers pay a small language tax: long compound words like "Suchmaschinenoptimierung" split into more tokens than their English equivalents.)

AI pricing works like a taxi meter — fitting, given who we're talking about. Three rules explain almost everything on your bill:

Rule 1: You pay in both directions — and output costs about 5× more. Everything you send to the model (your prompt, documents, conversation history) is billed as **input tokens**. Everything the model generates is billed as **output tokens** — at roughly five times the input price, because generating text is computationally far more expensive than reading it. With reasoning models, there's a hidden passenger: **thinking tokens** — the model's internal reasoning — are billed as output too, even when you never see them.

Rule 2: The meter re-runs the whole route every time. LLM APIs are stateless. Every message in a conversation resends the *entire* history — system prompt, every previous turn, every tool definition. Turn 20 of a chat doesn't cost one message; it costs twenty. Left unmanaged, conversation costs grow quadratically. This single fact explains more surprise bills than any pricing change ever will.

Rule 3: Agents multiply everything. A chatbot answers once. An **agentic workflow** — the kind that researches, calls tools, checks its own work — makes 5 to 20 model calls per task, each one carrying the full context. A ten-step agent handling 1,000 tasks a day makes over 10,000 LLM calls daily. This is where "a few cents per request" quietly becomes a budget line item.

For scale, current Claude API list prices (per million tokens, as of July 2026 — always check current pricing):

The spread matters more than the absolute numbers: the top tier costs 10× the small model — and other providers follow similar tiered structures. Which brings us to why Uber's bill exploded.

Why Bills Explode While Prices Fall

Economists have a name for what happened to Uber: the Jevons paradox. When a resource gets cheaper, consumption doesn't fall — it rises so much that total spending goes up. Coal in the 1860s, computing in every decade since, and now tokens: inference costs fell dramatically, demand rose faster. Gartner forecasts spending on inference-focused AI applications to more than double in 2026 — overtaking spending on model training for the first time.

Three forces drive the explosion:

1. Agentic adoption. The industry moved from "answer my question" to "complete my task." Task completion means loops, tool calls, self-verification — an order of magnitude more tokens per outcome.
2. Context inflation. RAG pipelines stuff retrieved documents into every request. Longer system prompts, more tools, bigger histories. The average request got heavier even as the per-token price got lighter.
3. Unmetered enthusiasm. This is the actual Uber story. Employees adopted AI coding tools en masse — individually rational, collectively unbudgeted. Uber had even encouraged it with an internal leaderboard ranking teams by AI usage. The problem wasn't the price per token; it was that nobody could connect token spend to outcomes. When Uber's president says he can't link the spending to feature improvements, that's not a pricing problem. It's a measurement problem.

The lesson from Uber's $1,500 cap is not "cap your spending" — a panic cap after the budget is gone is the failure mode. The lesson is that token consumption needs the same discipline as cloud spend a decade ago: visibility first, attribution second, optimization third. Here's how.

Seven Levers to Cut Your Token Bill

Ordered roughly by effort — the first three are configuration changes, not projects.

1. Right-size the model

The most expensive mistake in AI is using a flagship model for work a small model does perfectly: classification, extraction, formatting, routing, summarizing short texts. With a 5–10× price gap between the small and top tiers, routing even half your volume down a tier is a 30–40% saving — before touching anything else. Rule of thumb: use the smallest model that passes your quality bar, and test that bar instead of assuming only the biggest model can do the job.

2. Turn on prompt caching

Remember Rule 2 — you resend the same system prompt, style guide, and history with every call. Prompt caching lets the provider store that repeated prefix: on the Claude API, cached content is re-read at roughly 10% of the normal input price (you pay a one-time write premium of ~1.25×, so caching pays for itself from the second request on). For agents and chat applications, this routinely cuts input costs by 70–90%.

One structural rule to profit from it: caching matches from the beginning of the prompt, so stable content must come first — frozen system prompt, then tools, then documents, with volatile things like timestamps at the very end. A single changing byte early in the prompt (a Current time: … line is the classic offender) silently invalidates everything after it.

3. Batch what isn't urgent

Anything that doesn't need an answer within the hour — nightly reports, bulk meta descriptions, content audits, translation runs — belongs on a batch API, which processes requests asynchronously at a 50% discount. Half price for accepting "within 24 hours, usually under one": for content and SEO teams generating things in bulk, this is the single cheapest win available.

4. Trim what you resend

Audit your heaviest requests and cut ballast: shorten the system prompt (every word in it is billed on every single call), summarize or compact old conversation history instead of resending it verbatim, and retrieve the relevant section of a document instead of pasting all forty pages. A 2,000-token system prompt trimmed to 800 saves 1,200 tokens × every call you ever make.

5. Control the output — it's the expensive direction

Since output costs ~5× input, verbosity is a real budget item. Ask for structured, concise formats ("return a table", "max 200 words") instead of open-ended prose, set sensible output limits, and on reasoning models use the effort controls most providers now offer — low effort for routine tasks, high effort only where correctness genuinely matters. Letting a reasoning model think at maximum depth about a formatting task is like taking the taxi's scenic route on the meter.

6. Load knowledge on demand, not always

The elegant, structural fix: stop paying for context the model might need. Agent Skills are the cleanest example of progressive disclosure — the model preloads only a one-line description of each capability (a few dozen tokens), loads the full instructions only when a task actually needs them, and can run bundled scripts whose code never enters the context window at all: a 500-line script costs the same as its 20-line output. The same principle applies everywhere: don't put in the always-loaded context what can be fetched when relevant.

7. Measure before you optimize — and budget before you panic

Everything above assumes you know where your tokens go. Most teams don't. The minimum viable setup: log token usage per feature (not just per API key), attribute costs to outcomes ("what does one generated content brief cost?"), set soft budgets with alerts before hard caps become necessary, and review the top five most expensive workflows monthly — that's where the savings hide. Uber implemented caps after the budget was gone. The goal is to be the company that never needs to.

What This Means for Content and SEO Teams

Applying the levers to this blog's world: bulk work like meta descriptions, briefs, and audits goes through the batch API at half price on a right-sized model. Your style guide and brand voice live in a cached prefix (or a skill), not pasted into every prompt. Analysis tasks retrieve the relevant crawl data, not the whole export. And the one metric that matters is cost per outcome — per published article, per audit, per brief — not cost per token. A workflow that costs twice as much per call but needs three fewer revision rounds is the cheaper workflow.

Conclusion

Token prices will keep falling, and — thanks to Jevons — bills will keep rising for teams that don't manage consumption. The good news: unlike Uber, you don't need to learn this the expensive way. The playbook fits on a sticky note:

• [ ] Route simple tasks to small models; reserve flagships for hard reasoning
• [ ] Enable prompt caching; put stable content first in every prompt
• [ ] Move non-urgent bulk work to the batch API (50% off)
• [ ] Trim system prompts, compact history, retrieve less
• [ ] Constrain output length and reasoning effort
• [ ] Load expertise on demand (skills), not in every request
• [ ] Measure cost per outcome — and set budgets before you need caps

The teams that win with AI won't be the ones that spend the most on tokens. They'll be the ones that know exactly what each token buys.

Related Articles

• Agent Skills: How to Teach AI Agents Your Workflows - Progressive disclosure in practice
• Tool Use & Function Calling: How LLMs Interact with External Systems - Why agentic workflows multiply token consumption
• Agentic Workflow Patterns - Designing efficient multi-step agent processes
• Prompt Engineering for Content Teams - Writing prompts that do more with fewer tokens