A DeepSeek V4 Flash agent session that re-sends 40K tokens of scratchpad context on every turn isn’t paying the listed input price 40 times. It pays it once, plus 39 reads at a fraction of that rate. As of this writing, DeepSeek’s own cached-read rate on V4 Flash runs at roughly a fiftieth of the base input price. Check the current DeepSeek V4 Flash row for the live number. That single fact makes the sticker price on the model comparison table nearly irrelevant for anything that loops.
The real product being sold
For chat, providers sell tokens per turn. For agents, they sell tokens per session, and a session is mostly the same context sent again and again with a few new tokens appended. Cache-hit pricing exists because reprocessing identical context is nearly free on the compute side: the provider already has the KV cache resident and just reuses it. What varies by provider isn’t whether they support this. It’s the shape of the discount: how much you pay to write the cache the first time, how long it lives before eviction, and how deep the read discount goes.
Anthropic charges a write premium above the base rate to seed the cache, then a steep discount on reads. Gemini’s context caching adds a storage fee for the idle time between reads. OpenAI’s automatic caching applies with no separate write charge and no storage fee, but the discount depth and TTL are shorter and less controllable. Three different cost curves hide behind what looks like the same feature on the pricing page.
How to compute your effective price
Sticker price is base rate times tokens. Effective price is: (fraction of tokens that are cache misses × base rate) + (fraction that are cache hits × cached rate) + (write premium, amortized over the session). Pull your own traces, count how many input tokens on turn N were already sent on turn N-1, and that’s your hit rate.
Illustrative example, not a live quote: a coding agent runs 20 turns, each resending a growing transcript of 2K new tokens onto a shared 30K-token file context. Turn 1 is a full miss plus a write. Turns 2 through 20 land near 95% cache hits on the shared context and full misses on the new 2K. Run that mix through a model’s actual cache-read and cache-write rates and the effective price per session lands well below what naive sticker-price times total tokens would suggest. Feed your own trace numbers into the calculator instead of trusting this shape for your workload.
Where the ranking flips
Provider price spreads on identical open models run wide. Qwen3 235B A22B shows a spread over 20x between cheapest and priciest listed provider (see the live spread). At a near-zero hit rate, that spread is the whole story: take the cheap one. But once your hit rate clears roughly 80-90%, and the pricier provider’s cached-read rate undercuts the cheap provider’s flat rate by more than that spread, the ranking inverts. Teams pick a provider once, at launch, on sticker price, then never revisit it as their agent loops mature and hit rates climb into the 90s. The provider that looked an order of magnitude more expensive on day one can be cheaper by month three.
The premium that eats the savings
Cache TTLs are usually short, on the order of minutes. An agent that waits on a tool call, a human approval queue, or a slow retrieval step can blow past that window before the next turn arrives. The cache evicts, the next turn becomes a full miss, and if the provider charges a write premium you pay it twice in one session: once at start, again after the idle gap. A support-ticket agent that pauses for human triage between steps, with a median wait longer than the provider’s cache TTL, can turn what looked like a 95%-hit-rate workload on paper into something closer to 40-50% in practice, because every reactivation resets the clock. Sticker-price math never catches this. Trace-based math does, if you log the actual gaps between turns.
Where sticker price still wins
None of this matters for single-shot workloads: classification, one-turn extraction, short-form summarization where each request stands alone. There’s no repeated context to cache, so hit rate sits near zero regardless of TTL or write premium, and the cheapest listed rate on the model comparison table is also the cheapest real rate. Don’t build cache-aware infrastructure for a workload that never resends context. Your hit rate lives in your request logs; measure it there before assuming any of this math applies to you.
The rule
Pull the actual repeat-context fraction from a week of production traces. If it clears roughly 80%, rerank providers by cached-read rate and write premium instead of the number on the pricing table, and recheck that ranking whenever the trends page shows a provider changing its cache terms. If it sits near zero, buy on sticker price and stop there.