The takeaway: From tonight, Claude Fable 5 bills by the token on every major paid plan — and the single biggest lever for cutting that bill is one most users have never touched. Prompt caching lets the model skip re-reading text it has already seen, and all three major providers now price a cached read at 10% of the normal input rate. Used well, it makes the difference between an agent session that costs $50 and one that costs $10. Here's how it works, the real arithmetic, and the traps that silently switch it off.

Why the model keeps re-reading everything

A chat model is stateless: it doesn't remember your conversation between turns. Every time you send a message, the entire conversation so far — system instructions, tool definitions, every earlier message, that 80-page document you attached — is sent back and processed again, and you pay input-token prices for all of it, every turn. (Our context-window explainer covers why.) For a chat that's a few pennies. For a coding agent that re-sends a 50,000-token working context thirty times an hour, it's the whole bill.

Prompt caching attacks exactly this. If the beginning of your request is byte-for-byte identical to a recent one, the provider can reuse the internal computation it already did for that prefix instead of redoing it — and charges you a fraction of the price for the tokens it skipped.

What the three big providers charge

The headline numbers, from the providers' own current pricing pages:

The convergence is the story: whatever provider you use, a token the model has recently seen costs a tenth of a fresh one. On Claude Fable 5, that's $1 instead of $10 per million input tokens; on Opus 4.8, $0.50 instead of $5; on GPT-5.6 Sol, $0.50 instead of $5.

Anthropic's version has the friendliest small print: a 5-minute cache lifetime that — per its documentation — "is refreshed for no additional cost each time the cached content is used". An agent making a request every couple of minutes keeps its cache alive all session for one initial write. Bursty use with longer gaps can pay 2× for a one-hour cache instead — which pays for itself on the second hit.

The arithmetic that matters tonight

Take the workload our Fable-cliff guide used: a coding-agent turn that re-sends about 50,000 input tokens.

• Uncached, on Fable 5: 50,000 tokens × $10 per million = $0.50 per turn, before output.
• With 90% of that context cached: 45,000 cached tokens cost $0.045, the fresh 5,000 cost $0.05 — call it $0.10 per turn, roughly an 80% cut.
• The one-off entry fee: the first turn writes the cache at 1.25× — $0.625 instead of $0.50 — recouped on the very first reuse.

Over a hundred-turn session, that's roughly $50 of input becoming $10–11. Two honest caveats: output tokens (Fable's $50 per million) are untouched by caching — nothing discounts what the model writes — and Anthropic's own pricing page still carries the footnote that its newest models' tokenizer "produces approximately 30% more tokens for the same text", so budget against real usage, not naive word counts.

Context engineering: the craft that makes caching work

Caching only pays if your requests actually have a stable prefix — and that's a design discipline with a name: context engineering. Anthropic's engineering team defines the goal as finding "the smallest set of high-signal tokens that maximize the likelihood of your desired outcome". The practitioners who run agents at scale are blunter: in a widely-cited write-up of building the Manus agent, Yichao Ji called the KV-cache hit rate "the single most important metric for a production-stage AI agent".

The working rules are simple to state:

1. Stable content first, volatile content last. System instructions and tool definitions go at the top and never change mid-session; anything that varies per request (the user's latest message, retrieved documents) goes after the cache breakpoint.
2. Never put a timestamp in your system prompt. One changed byte anywhere in the prefix invalidates everything after it — the classic silent cache-killer is a helpful little "Current time: 14:07:03" at the top of every request.
3. Append, don't edit. Agents that rewrite earlier conversation history throw the cache away every turn; agents that only add to the end keep it.
4. Check it's actually working. The API response reports cached-token counts (Anthropic's cache_read_input_tokens, for instance). If that number is zero on repeated requests, something in your prefix is quietly changing.

The traps

• Small prompts silently don't cache. Below a per-model minimum, the request processes uncached with no error — and the minimums vary more than you'd guess: 512 tokens on Fable 5, 1,024 on Opus 4.8 and Sonnet 5, but 4,096 on Haiku 4.5.
• Five minutes is five minutes. Step away for a coffee mid-session and the next request pays full write price again (unless you bought the 1-hour tier).
• Changing anything structural busts everything — swapping models, adding a tool, reordering system blocks. Set the harness up once, then leave the prefix alone.
• It stacks with the other discounts. On Anthropic, caching multipliers combine with the Batch API's 50% discount for non-urgent work — cached batch input on Fable 5 comes out at about 50 cents per million.

If you're one of the subscribers deciding tonight whether Fable 5 is worth paying for by the token, this is the honest bottom line: the sticker price is $10 in and $50 out, but a well-engineered harness pays the sticker price only on what's genuinely new each turn. The people for whom Fable stays affordable from tomorrow are, mostly, the people whose tooling already treats the cache as a first-class citizen. Now you know what they know.