The Jevons trap: why cheaper tokens made your AI bill bigger
TL;DR: The price of a token keeps dropping, and your AI bill keeps going up. That is not a contradiction — it is the Jevons paradox: when a resource gets cheaper, people use so much more of it that total spend rises anyway. The practical consequence is blunt. Waiting for prices to fall is not a cost strategy, because falling prices are exactly what pulls usage up. The only lever that keeps paying off no matter where token prices go is cutting the waste that lives in your code.
The paradox in one line
In 1865 the economist William Stanley Jevons noticed that more efficient steam engines did not reduce Britain's coal consumption — they increased it, because cheaper power made coal worth using for far more things. The ai cost jevons paradox is the same shape: every time a provider cuts per-token prices or ships a cheaper model, the economics of sending a token improve, so teams send dramatically more of them. Price per unit goes down; units go up faster; the invoice goes up. Cheaper tokens, bigger bills.
The numbers (survey and proxy indices, not audited revenue)
The market data points the same way — with one caveat up front, because our whole brand rests on it: these are survey responses and payment-card indices, not audited vendor revenue. Read them as directional, not as a ground-truth ledger.
- Menlo Ventures' mid-year 2025 survey put enterprise LLM API spend at roughly $3.5B in November 2024, rising to about $8.4B by mid-2025 — more than doubling in six months (via bigdatawire.com).
- The same line of reporting pegged full-year 2025 enterprise GenAI spend at around $37B, roughly 3.2x year over year.
- Ramp's payment data — a proxy index built from what its customers actually paid — shows token usage up about 1,001% against dollar spend up about 497% over January 2025 to April 2026. Apollo's chief economist summed the pattern up as "cheaper tokens, bigger bills" (apollo.com).
That last split is the paradox in a single statistic. Usage grew roughly twice as fast as spend, which means the effective price per token fell hard — and yet the dollars still nearly quintupled. Efficiency did not shrink the bill. It enlarged the appetite.
(For transparency: an earlier version of the "spend is doubling" story leaned on a token-expenditure index we could not stand up under scrutiny, so we have dropped it entirely. The direction — llm spend rising — is well supported by the Menlo and Ramp figures above without it.)
Why "just wait for prices to drop" is not a cost strategy
It is tempting to treat your AI bill as a problem that time will solve. Models get cheaper every quarter; surely the line flattens eventually. The data above says otherwise, and the mechanism explains why.
When the price of a token falls, three things happen more or less at once. Existing features get called more often because they are now cheap enough to use casually. Features that were previously uneconomic — long-context summarization, agent loops that make dozens of calls, "just run it on everything" batch jobs — suddenly clear the bar and ship. And the context you send per call tends to grow, because padding a prompt feels free when the unit price is tiny. Each price cut widens the surface area of what you are willing to spend on. That is demand expanding to swallow the saving.
So "wait for it to get cheaper" is, in practice, "wait for the thing that makes us use more." The provider's price curve is not on your side here; it is the engine of the trap. Relative to the bill you would otherwise have, a price drop you do not act on is a saving that quietly converts itself into extra volume.
The only lever that survives a price war
Here is the part that actually matters. A price cut is a one-time, external gift that the Jevons dynamic eats. A fix to how your code spends tokens is a permanent, internal multiplier that compounds on every single run — and keeps compounding whichever way prices move. If tokens get cheaper, your trimmed, right-sized, cached code gets cheaper too, from a lower base. If usage explodes, you are multiplying a smaller number by that growth instead of a bloated one.
The levers that behave this way are not exotic. They are the same handful of code patterns we see driving almost every large bill:
- The right model for the task. A frontier model doing classification, routing, or extraction is often paying 20x–100x for a job a cheaper tier handles fine.
- Caching the stable prefix. Re-sending the same system prompt and tool schemas on every loop iteration is pure repeated spend — and re-sent context is frequently the single largest line item, the subject of the 62% problem.
- Caps on loops and outputs. An uncapped agent loop or a missing
max_tokensis an open tap that a cheaper token price only makes easier to leave running. - Trimmed context. Sending a whole file or a full transcript when a slice would do is waste that scales directly with your traffic.
We walk through all six patterns, how to size each one honestly, and the order to tackle them in, in the complete LLM cost optimization guide. The common thread is that none of them depend on what tokens cost. They are structural. They shrink the number of tokens you send and the price tier you send them at — and a smaller input is smaller at every price point in history and every price point to come.
What this means for your code
The macro story and the micro fix line up neatly. The market is telling you that the pool of AI spend — and therefore the pool of waste inside it — is growing fast, and that falling prices will not drain it. The only thing that durably lowers your bill is changing what your code does on each call, because that is the one variable a price war cannot reach.
When we audited 15 open-source AI products, the waste was never on a dashboard labelled "the problem" — it was in the code: a frontier model on a trivial task, an uncached loop, a stuffed context window. Those findings do not expire when the next price cut lands. If anything, cheaper tokens make them easier to accumulate, because every wasteful pattern feels too small to matter until volume multiplies it.
That is the whole reason erabot works at code-time rather than at the invoice. We scan your source, estimate the waste per call site with every assumption marked as an assumption, and — before recommending a cheaper model — shadow-test that it actually holds quality on your traffic. No fake data, no fake savings. If you want to see where your own code is leaking, point erabot at a repo at erabot.ai. The fix you make today keeps paying off long after the next price drop has been swallowed by the next surge in usage.