The list price is not the price your agent pays

Every LLM comparison table on the internet ranks models by dollars per million input tokens. For chat, that is roughly the right number. For an agent, it is close to the least relevant one on the page.

An agent has no memory between requests, so it re-sends its whole conversation every turn: system prompt, tool definitions, every prior message and tool result, then the new bit at the end. Almost all of that is a repeat of what it sent last turn — which means almost all of it is billed not at the input rate but at the cached-read rate. The list price applies only to the sliver that is new.

That rate is published, it varies enormously between vendors, and it appears on essentially no comparison table. Here is what happens when you rank by it instead.

The cheaper model is the expensive one

Xiaomi MiMo-V2.5 lists at $0.14 per million input tokens. Tencent Hunyuan Hy3 lists at $0.132 — 5.7% cheaper. On a price table, Hunyuan wins, and a buyer optimising for cost per million picks it.

Their cached-read rates are $0.0028 and $0.033. One bills a re-read at 2% of its input price, the other at 25%, which makes Hunyuan’s cached token 11.8x the price of MiMo’s.

Run both through a realistic agent session — a 20k-token prefix, 6k appended per turn, 1,500 tokens of output per turn — and the cheaper price tag loses on the first handful of turns, then keeps losing:

The gap widens with every turn, because every turn adds history and history is what the ratio prices. Nothing about that is visible on either pricing page. The same pattern holds one tier up: DeepSeek V4 Flash and ByteDance Doubao Seed 2.1 Turbo both list at about $0.44, cache at 3.2% and 20%, and finish a 60-turn session 3.1x apart.

The ratio is not 10%

The reason this stays hidden is that the three vendors most people benchmark against — Anthropic, OpenAI and Google — all settled on the same figure, so 10% feels like a law of nature. It is a coincidence.

Two things are worth noticing in that table.

OpenAI’s own ratio moved by generation. GPT-4o mini cached at 50% of input, GPT-4.1 at 25%, and everything from GPT-5.x at 10%. A shop that benchmarked cached economics on GPT-4.1 and never re-checked has been carrying a number that is two and a half times too pessimistic.

The ratio survives what the list price does not. It is a pure fraction, so it is immune to currency conversion and to repricing alike, and we got an unplanned demonstration of both while writing this piece. Tencent’s figures above changed under us: we had been converting its CNY card at our snapshot rate, and switched to Tencent Cloud International’s own USD list. The input price moved from $0.141 to $0.132 — a 6.4% correction, on the number every comparison table would have shown. The cache ratio did not move at all: 25.0% on the yuan card, 25.0% on the dollar one, before and after. If you are going to memorise one number about a model, memorise this one rather than the dollar figure.

What the ratio is actually worth

Hold everything else fixed — a model at $1.00 per million input, a 30-turn session — and change only the cache ratio. The bill does not merely shrink; its composition changes:

At the top of that table you are essentially paying to re-read your own conversation. At the bottom, history has stopped mattering and your bill is dominated by output and by genuinely new input — which is the regime you want to be in, and the regime where advice about prompt engineering starts to pay off.

This also sets the headroom: how much more expensive a well-caching model can be and still be the cheaper one.

The 10% line is the one to internalise, because it covers the Western frontier labs: against a rival that gives no cache discount, a model can carry ten times the list price and still be cheaper on the part of the bill that grows. Price tags are not just an imperfect guide here. They can point exactly backwards.

Three costs that live outside the list price

The cached-read rate is the biggest thing missing from comparison tables. It is not the only one.

A storage meter, on two vendors

Google’s explicit context caching bills you twice: once for the cached tokens you read, and again for holding them, per million tokens per hour. On the current card that is $0.50/M/hour for Gemini 3.7 Flash, $1.00 for Gemini 2.5 Flash, and $4.50 for Gemini 2.5 Pro.

Park a 200k-token context on Gemini 2.5 Pro and you are paying about $0.90 an hour, or $7.20 across an eight-hour day, before you send a single request. For an agent that idles between bursts, that is a genuinely different cost shape from Anthropic’s or OpenAI’s one-off write premium — and it does not appear anywhere in a per-million comparison. ByteDance meters storage too, at CNY 0.017 per million tokens per hour on Doubao Seed 2.1 Turbo, which is small but real.

Google’s implicit caching carries no storage charge, which makes the choice between implicit and explicit a cost decision rather than an ergonomic one.

A cliff you only meet once the history is long

Grok 4.6 lists at $2.00 input, $0.50 cached, $6.00 output — competitive with Sonnet 5 and Gemini 3.1 Pro, and cheaper than both on output. Above 200k prompt tokens every rate doubles. The sentence that matters is on xAI’s own pricing page: “requests whose prompt reaches the listed token threshold are billed at the higher rate for all tokens in the request.”

Not the tokens past the threshold. All of them, cached reads included.

An agent’s history only grows, so this is not a risk, it is a schedule. In our 60-turn model the session crosses 200k at turn 30, and the run finishes at $12.25 against the $7.20 the headline rates imply — 70% more:

The lesson generalises past xAI: any threshold pricing is a trap for agentic workloads specifically, because the one thing an agent reliably does is accumulate context. Check whether a rate card has tiers before you check what the rates are.

Tokens are not text

Price is quoted per token; work arrives as text. The conversion between them is the tokenizer, and tokenizers do not agree.

We measured a fixed corpus through each vendor’s own published tokenizer (2026-06-10, script and corpus in the repo). On English prose the field is tight — 5.06 to 5.33 characters per token, a 5% spread. On the content agents actually send it comes apart:

A 36% tokenizer penalty on JSON multiplies straight onto every rate in every column. A model 10% cheaper per token that is 20% less efficient on your payloads is more expensive per unit of work — and no pricing page will tell you, because the pricing page is denominated in the unit that hides it. Anthropic and Google publish no loadable tokenizer, so they cannot be measured this way at all; our token counter uses their published counting endpoints instead.

The discount you did not know you were choosing

Even where a rate is published, it may not be the rate you get.

Alibaba’s Model Studio runs two caches for the same Qwen models. The explicit cache, which you create and manage, reads at 10% of input and charges 125% on the tokens that create it, with a 1,024-token minimum and a five-minute lifetime that resets on a hit. The implicit cache, which happens automatically if you do nothing, reads at 20% — twice the price — with an “indeterminate” lifetime that the system clears when it feels like it.

So the default is the expensive one, and getting the good rate requires work you would only know to do if you read the caching documentation rather than the price list.

The same fork exists elsewhere in gentler forms. OpenAI caches automatically above 1,024 tokens on GPT-5.6 and later, 2,048 on older models, and keeps a prefix eligible for 30 minutes on the newer generation. Anthropic requires you to place explicit breakpoints and offers a five-minute or one-hour lifetime, priced differently. Moonshot’s Kimi caches automatically once a prompt exceeds 256 tokens. DeepSeek caches automatically and, separately, halves every rate outside its peak window — peak being 01:00–04:00 and 06:00–10:00 UTC, which leaves most of the day at half price.

What to compare instead

Four numbers, then a multiplication.

1. The cached-read rate as a fraction of input. This is the single most predictive number for agentic cost, it is currency-independent, and it usually survives repricing.
2. The write premium or storage meter. A one-off multiplier on cache creation (Anthropic 1.25x or 2x, OpenAI 1.25x from GPT-5.6, Alibaba 125%) behaves completely differently from a per-hour storage charge (Google, ByteDance). One scales with how much you cache; the other with how long you keep it.
3. Any threshold where rates change, and whether crossing it reprices the whole request or only the excess. For agents, assume you will cross it.
4. Your own tokenizer efficiency on your own content. Measure it on your real payloads, not on prose.

Then multiply through a session shape rather than comparing per-million rates: a prefix, a per-turn delta, a turn count, an output size. That is what our LLM API calculator does, and the ranking it produces is regularly not the ranking on the price tags.

Three practical rules fall out of all this:

• For one-shot calls, rank by list price. There is no history to re-read, so the headline number is a fair guide. This is why the conventional tables are not wrong so much as wrongly applied.
• For agents, rank by cached rate and check for cliffs. The longer the session, the more completely the cache ratio takes over the bill.
• Re-check the ratio when you re-check anything. OpenAI’s moved 5x across three generations. It is not a constant of the vendor any more than of the market.

The deeper point is that “cheap model” is not a property of a model. It is a property of a model and a workload, and the workload term has been growing for two years while the tables have stayed the same shape. If your work is agentic, the pricing page is answering a question you stopped asking a while ago.

For the mechanics underneath all of this, the 20x in Claude Code caching covers what a cache miss actually costs and why the timer is shorter than you think, and running many agents at once covers what happens to these numbers when the history is split across several workers. How to actually get prompt cache hits covers the breakpoint and threshold rules that decide whether you reach the cached rate at all — which is, after all, the precondition for any of this arithmetic to apply to you.

Sources: vendor pricing and caching documentation for Anthropic, OpenAI, Google, Alibaba Model Studio, xAI, Mistral and Xiaomi MiMo, each read for this article. Model rates from our snapshot, each verified on the vendor’s own page. Tokenizer figures measured 2026-06-10 with scripts/tokenizer-calibration/. Checked 31 August 2026.