On September 1, Anthropic announced Claude Fable 5.1. Most of the post is about capability and safeguards, and the benchmark table is the part that will get quoted. I read the pricing paragraph instead, because it is short and it changes something. Input is still $10 per million tokens and output is still $50. The only line that moved is cache reads: 75% cheaper, $0.25 per million, down from $1. Anthropic’s own estimate is that this makes Fable 5.1 about 25% cheaper than Fable 5 for typical workloads, and up to about 45% cheaper for highly agentic work.
Those two percentages come from one price cut, and the difference between them is a lesson about where an agent’s money goes. I run a site where agents do a large share of the operational work: Claude sessions ship code against written house rules, four MCP servers manage content, publishing and remote admin work, and a hook archives each conversation before context compaction. I wrote about that lifecycle in The Agent Development Lifecycle at n=1. This is the cost engineering half of the same story: how I read the new price sheet, and why cheaper reads make cache misses the thing to design against.
The cut landed on the line agents actually pay#
A chat request is mostly fresh input and fresh output. An agent loop is not. Every turn resends the whole conversation so far: the system prompt, the tool definitions, every earlier turn and every tool result. A 40-turn task sends its first turn 40 times. Total input grows with roughly the square of the turn count, and prompt caching is the only reason that arithmetic is survivable: everything already cached is billed at the read rate instead of the base rate.
That is why the same price cut gives two different answers. In a workload where cached input is a small slice of the bill, a 75% discount on that slice is a rounding error. In a loop where cached input dominates, the discount is most of the bill. Anthropic’s 25% and 45% are two points on that curve, and the longer and more tool-heavy your loops are, the closer you sit to the second one.
| Price line (per million tokens) | Fable 5 | Fable 5.1 | Where it shows up in a loop |
|---|---|---|---|
| Base input | $10 | $10 | The new turn, and anything you failed to cache |
| 5-minute cache write | $12.50 | $12.50 | The first time a prefix is seen, and after every miss |
| 1-hour cache write | $20 | $20 | Same, when you pay for the longer lifetime |
| Cache read | $1 | $0.25 | Every earlier turn, on every later turn: the bulk of agent input |
| Output | $50 | $50 | What the model writes, including its thinking |
The table is the argument. Four lines did not move. The fifth is the one that gets multiplied by the turn count, and it just became four times cheaper.
A miss now costs fifty hits#
Here is the part the announcement does not spell out. Cheaper reads make misses more expensive in the only sense that matters for design: relative to a hit. A 5-minute cache write costs 1.25× base input. On Fable 5, a read cost 0.1×, so one miss was worth twelve and a half hits. On Fable 5.1 a read costs 0.025×, so one miss is worth fifty. Rebuilding a cold prefix costs exactly what it did last week, but the thing it is being compared to got four times cheaper.
Put numbers on it. Take a loop with a 100K-token stable prefix: system prompt, tool schemas, house rules, the conversation so far. Reading that prefix on a turn costs 2.5 cents. Rebuilding it after a miss costs $1.25. One avoidable miss now buys fifty turns of correct behavior. On a per-turn basis the loop got cheaper; on a per-mistake basis it got more punishing, and the mistakes are the ones your harness makes, not the model’s.
Anthropic’s own guidance for Claude Code, published in mid-August, two and a half weeks before the release, in Maximizing the value of your Claude Code sessions, lists the same culprits from the other side of the counter: every model has its own cache, so a mid-session switch prefills the entire conversation again at full price; effort is part of the cache key; a compaction rewrites the conversation and invalidates it; and the entry expires after an hour on a subscription or five minutes on an API key. Those were good habits at $1 per million. At $0.25 they are the difference between the 25% and the 45%.
The industrial version and the n=1 version#
Uber published its own numbers a few days earlier in Running a Software Factory Efficiently at Uber Scale: weekly agent requests up 9.4× between February and August, total spend roughly flat since April, and cost per session down 52% from its June peak. Their levers are the ones the price sheet rewards. They moved interactive sessions to the 1-hour cache lifetime because engineers leave sessions idle for more than five minutes. They trigger compaction at 400K tokens even on 1M-context models, trading window for cache stability. And they found that loading 100-plus MCP tools added 50K to 70K tokens of schema overhead to the first prompt, resent on every turn, until they switched to on-demand tool resolution.
My site is the smallest possible version of the same system, and the same levers show up, in miniature. I did not design them for the cache. They emerged because they made the agents predictable, and the cache is a side effect of predictability.
| Lever | At Uber scale | On a one-person site |
|---|---|---|
| Stable prefix | Tool schemas resolved on demand (CLI tool resolution and tool search) instead of loaded up front | House rules and skills live in the repository, so every session starts from the same bytes |
| Cache lifetime | 1-hour lifetime for interactive sessions, 5-minute for short-lived subagents | Sessions run on the 1-hour lifetime Claude Code uses on a subscription; the human is the slow part of the loop |
| Compaction | Triggered at 400K tokens, before the window fills, to keep the burst predictable | Treated as an event: a hook archives the conversation to the admin API right before it fires |
| Bulky reads | Code-mode execution for SQL queries instead of raw tool results, 55% to 71% fewer tokens | Subagents fan out the reading and return a summary; the main context never sees the raw pages |
| Tool surface | A gateway of more than 1,000 MCP servers, with tool search that scales to thousands of tools | Four small MCP servers with a handful of tools each, behind one guarded admin API |
The honest caveat: I do not have a bill breakdown to show you, and I am not going to invent one. What I can say is that the shape of the discipline does not depend on scale. A stable prefix, a cache lifetime that matches how the loop actually pauses, compaction as a deliberate act instead of a surprise, and heavy reads pushed into subagents. Uber needs all of that to keep spend flat at 9.4× growth. I need it so that a session that has been idle while I reviewed a diff does not come back and re-bill the whole conversation.
The API now enforces what the price sheet rewards#
There is a second change in the Fable 5.1 release that reads like a safety feature and behaves like a cost rule. Anthropic describes anti-distillation mechanisms that prevent new API accounts from manually editing prior context in a multi-turn conversation while preserving the transcript of the model’s earlier thinking. In plain terms: on this model, a harness that rewrites earlier turns and keeps the thinking around them is no longer allowed. Edited history was already a guaranteed cache miss, because the prefix hash changes at the edit point and everything after it is rebuilt. Now, for new accounts, it is also disallowed.
I think that alignment is good news, and not only for Anthropic. Append-only conversations are the correct design anyway. A harness that mutates history is a harness whose state you cannot replay, diff, or audit, which is the same complaint I have about agents that keep state in their own memory instead of in documents. The rule that makes the cache work is the rule that makes the system inspectable. Fable 5.1 makes it mandatory for new accounts whenever the thinking transcript is kept; you should treat it as mandatory regardless.
What I would not do#
The reflex response to an expensive model is a cascade: route easy turns to a cheaper model and keep the expensive one for hard ones. On an agent loop that reflex now fights the cache. Caches are per model, so every hop between models is a full re-prefill at the write rate, and at a fifty-to-one miss-to-hit ratio a cascade has to save a lot of output tokens to pay for its own misses. The cheaper move is one model, and effort set once at the start of the session. Fable 5.1 exposes five effort levels, which puts that dial inside the model rather than between models.
The other thing I would not do is reach for the 1-hour lifetime by default. It costs 2× base input to write instead of 1.25×, so it needs more reads to pay off, and a read refreshes the timer at no extra cost on either lifetime. Continuous loops keep the 5-minute entry warm on their own. The 1-hour write pays for itself only in the window where a human takes twenty minutes to answer, which is exactly the interactive session Uber moved, and exactly the session I run. Pick the lifetime from how the loop actually pauses, not from the bigger number.
- Put everything stable first: tools, then system prompt, then history. Anything that varies per request (timestamps, request ids, the user’s question) goes after the last cache breakpoint.
- Set model and effort at session start and leave them alone. A mid-session switch rebuilds the whole conversation at the write rate.
- Make the harness append-only. Never edit or drop earlier turns; Fable 5.1 no longer allows it for new accounts, and it was a full miss before that.
- Treat compaction as a scheduled event, not an accident. Archive what you need first, then compact once, while the old entry is still warm.
- Match the cache lifetime to the loop’s real pauses: 5 minutes for continuous automation, 1 hour for sessions that wait on a human.
- Move bulky reads into subagents that return a summary. The parent’s prefix stays byte-stable and small.
- Watch the usage meters every turn. cache_read_input_tokens should dominate; cache_creation_input_tokens should be one turn’s worth.
The price cut made every cached turn nearly free and every uncached turn a decision. Cache discipline is the cost engineering now.