Anthropic released Claude Fable 5.1 on September 1, 2026, and the way to read the announcement is to separate two claims that sound like one. Anthropic says the model costs “an estimated 25% less than Fable 5 for typical workloads” and up to about 45% less for heavily agentic work. It also says, in the same post, that pricing “is otherwise the same as Fable 5’s: $10 per million input tokens and $50 per million output tokens.” Both are true. The per-token price did not fall; a single billing line item did, and the size of your saving depends entirely on how much of your bill that line item was.
The line item is the cache read. When you send a long prompt — a system prompt, a tool list, a codebase, a conversation so far — the provider can store the processed form of that prefix and charge less to re-read it on the next call than to process it fresh. On every other current Claude model, a cache read costs 10% of the base input rate. On Fable 5.1 it costs 2.5%: $0.25 per million tokens, down from $1.00. Nothing else on the price sheet moved.
- 01One cell changed, and it is not the headline one.Input stays at $10 per million tokens, output at $50, cache writes at $12.50 and $20, batch at $5 and $25. Cache reads fell from $1.00 to $0.25 — a 75% cut on 2.5% of the base input rate, where every other Claude model charges 10%.
- 02The 25% and 45% figures are measured bills, not list prices.Anthropic derived them from four weeks of its own August 2026 usage at default effort across Claude Enterprise, Claude Code and the API. A workload with no reusable prefix saves nothing, because it was never paying for cache reads.
- 03Three API changes break code that worked on Fable 5.Forced tool use now returns a 400. Thinking blocks only travel forward to newer models. Editing an earlier turn invalidates every thinking block after it — enforced today for API accounts created on or after August 31, 2026, and expected for everyone at a future release.
- 04Effort is the larger lever, and it needs re-testing.Anthropic states that Fable 5.1 at medium effort roughly matches Fable 5 at lower cost, and that effort-level names do not represent the same amount of thinking across models. An effort sweep you ran on Fable 5 does not transfer.
01 — The priceSix cells on the price sheet. One of them moved. #
The clearest way to read a release like this is to put the old and new rate sheets side by side and mark which cells are identical. Five of the six are. The rates below come from Anthropic’s own model documentation for Fable 5.1 and Fable 5; the same figures are carried in our maintained per-million-token price index, whose Anthropic rows were refreshed the day this model shipped.
| Billing line | Fable 5 | Fable 5.1 | Change |
|---|---|---|---|
| Synchronous Messages API | |||
| Base input | $10.00 | $10.00 | unchanged |
| Output | $50.00 | $50.00 | unchanged |
| Cache write, 5 minute | $12.50 | $12.50 | unchanged |
| Cache write, 1 hour | $20.00 | $20.00 | unchanged |
| Cache read | $1.00 | $0.25 | −75% |
| Message Batches API | |||
| Batch input and output | $5.00 / $25.00 | $5.00 / $25.00 | unchanged |
The ratio is the part worth remembering. Anthropic prices cache reads at 10% of base input on every other current Claude model, and OpenAI and Google publish the same multiplier on theirs. Fable 5.1 is 0.025 times base input rather than 0.1. It is not the lowest ratio on the market — Meta's Contributor tier sits at 2.0%, in exchange for training permission, and DeepSeek's cache-hit rates work out around 3.2% — but it is the lowest a US frontier lab has published. The shortcut a lot of cost models use — take the input rate, divide by ten, call it the cached rate — now produces a number four times too high on this one model. If your forecasting spreadsheet has that division hard-coded, it is the first thing to fix.
The comparison that matters more is inside Anthropic’s own lineup. Claude Opus 5 charges $0.50 per million tokens for a cache read. Fable 5.1 charges $0.25. On that one billing line, the flagship is now half the price of the mid-tier model, while costing twice as much on input and output. Anthropic’s migration guide states this plainly for teams moving up from Opus 5, and it sets up an arithmetic question the “2x the price” framing never asked: at what point in a long session does the cheaper cache outweigh the dearer everything else?
Anthropic states the effect as a measured result rather than a rate change: costs for typical workloads are “reduced by around 25% relative to Fable 5,” with savings of “up to around 45%” on complex coding and highly agentic tasks. The stated method is indexed cost of running the same workloads “at usage-based pricing measured at default effort over four weeks of actual usage in August 2026,” where the typical case spans Claude Enterprise, Claude Code and the API, and the highly agentic case is context-heavy, tool-heavy work in which cache reads make up most of the cost.
02 — Your billWhether you save anything depends on one ratio. #
A 75% cut on a line item saves you 75% of that line item and nothing else. So the useful question is not “how much cheaper is Fable 5.1” but “what share of my Fable bill is cache reads.” Three shapes of workload sit at very different points on that spectrum, and only one of them gets near the headline number.
Long agentic sessions
Any tool-calling run that re-sends a large stable prefix on every turn. Cache reads dominate the token bill by construction, because the prefix is read once per turn and grows. This is the shape Anthropic measured at up to roughly 45%, and the shape where the change is worth acting on.
Mixed production traffic
A product that caches a system prompt and some retrieved context but generates a lot per call. Cache reads are a real but minority share, and output at $50 per million is untouched. Anthropic's blended figure of about 25% was measured on this kind of mix across its own surfaces.
Short, one-shot calls
A single-turn call under the 512-token minimum cacheable length, or any call with no reusable prefix. There are no cache reads to discount, so the saving is zero and Fable 5.1 costs exactly what Fable 5 cost. This is where Anthropic's own advice, to start with Opus 5, applies most plainly.
One consequence is worth flagging because it inverts a common optimisation. Teams running long sessions often compact aggressively — summarising the conversation and discarding history — specifically to keep the cached prefix small and the bill down. Anthropic now says that on Fable 5.1, “compacting early to save cost may no longer be the right cost-intelligence tradeoff,” and suggests testing later compaction points. When re-reading context costs a quarter of what it did, throwing context away to save money buys less and costs more in lost continuity.
The second lever is likely larger than the first, and it is the one most teams will skip. Fable 5.1 defaults to high
effort on the Claude API and in Claude Code, but medium
in Claude Cowork and on claude.ai — so the same prompt can behave differently depending on where you ran it. Anthropic states that at medium, “results roughly match Claude Fable 5 at lower cost,” and that at low, the model “is often competitive with Claude Opus and Claude Sonnet models on cost per task while scoring higher.” It also says explicitly that effort-level names do not correspond to the same amount of thinking across models, which means an effort sweep you ran on Fable 5 does not carry over. Run it again. Our earlier walkthrough of cache and batch cost engineering on Fable 5 still describes the mechanics correctly; only the cache-read rate in it is now out of date.
Here is the arithmetic the Opus 5 comparison invites, worked through. Every figure is our multiplication of Anthropic’s published rates, so it is labelled derived and not a vendor claim. Take one turn of an agent loop with a cached context of C tokens, I tokens of fresh input and O tokens of output, all billed per million. Fable 5.1 costs 10I + 0.25C + 50O; Opus 5 costs 5I + 0.5C + 25O. Fable comes out cheaper once 0.25C exceeds 5I + 25O — that is, once the cached context is larger than 20 times the fresh input plus 100 times the output.
| Cached context | Opus 5, reads only | Fable 5.1, reads only | Opus 5, with write | Fable 5.1, with write |
|---|---|---|---|---|
| 50,000 tokens | $0.060 | $0.083 | $0.079 | $0.120 |
| 140,000 tokens | $0.105 | $0.105 | $0.124 | $0.143 |
| 215,000 tokens | $0.143 | $0.124 | $0.161 | $0.161 |
| 300,000 tokens | $0.185 | $0.145 | $0.204 | $0.183 |
| 600,000 tokens | $0.335 | $0.220 | $0.354 | $0.258 |
Read the crossover rows. At those per-turn sizes, Fable 5.1’s turn costs the same as Opus 5’s at about 140,000 tokens of cached context and less beyond it; add the cache write for each turn’s new tokens and the crossover moves out to roughly 215,000. At 300,000 tokens the flagship’s turn is 22% cheaper than the mid-tier’s on reads alone and 10% cheaper with writes; at 600,000 it is 34% and 27% cheaper. None of this touches quality, which is the reason Anthropic gives for choosing between the two. It only says that for the long-context, tool-heavy sessions Fable is meant for, “twice the price” describes the rate card and not the bill.
03 — MigrationThree changes that turn working code into a 400. #
This is the part of the release that got the least coverage and will cost the most time. Anthropic lists three breaking changes for anyone already calling Fable 5. If you use Claude Code, claude.ai, Claude Managed Agents or the Claude Agent SDK, all three are handled for you. If your own code assembles the messages
array, all three are yours to check.
| What changed | How it fails | What to do instead |
|---|---|---|
| Forced tool use is not supported | A request with tool_choice set to any or to a named tool returns a 400 invalid_request_error . The token-counting endpoint applies the same validation. auto and none are unchanged. |
For schema-valid JSON, keep auto and use strict tool use or structured outputs. To make the model reach for a tool, say when the tool applies in the prompt. Anthropic’s stated reason is that thinking is always on and a forced call would skip it, pushing the model’s working-out into the tool arguments. |
| Thinking blocks only travel forward | Fable 5.1 can read earlier models’ thinking; no earlier model can read Fable 5.1’s. A conversation that moves onto 5.1 keeps its reasoning. One that falls back from 5.1 to Opus 5 loses it for the turns that run there. Unreadable blocks are dropped silently and are not billed. | Audit any router or fallback that switches models mid-conversation. Send the thinking-binding-controls-2026-08-01 beta header to have drops reported in an input_transformations array instead of happening quietly. |
| Editing an earlier turn invalidates thinking blocks | Modifying the system prompt, the tool list, or any earlier message before a thinking block produces a 400 on the next request, with a message stating the block is bound to a different conversation. Enforced for API accounts created on or after August 31, 2026; recorded but not acted on for older accounts unless you opt in. | Treat the conversation as append-only. Send per-turn reminders as turn-scoped system messages that clear themselves, change instructions or tools with mid-conversation system messages rather than rebuilding system or tools , and let server-side compaction or context editing do the trimming. |
The third row deserves the most attention because of its shape. It is enforced today only for accounts created on or after August 31, 2026 — which is to say, accounts created essentially now — and Anthropic says it expects the check to apply to all users at future model releases. So a team on an older account can migrate to Fable 5.1, see nothing break, and inherit the failure at the next upgrade instead. The patterns that trip it are ordinary: injecting a per-request reminder into an earlier turn and removing it next time, summarising older turns in place, rebuilding the system prompt mid-session. These are also the patterns that invalidate the prompt cache, so fixing them pays twice.
Anthropic publishes a way to find out whether you are affected without waiting for the error: run a session with prefix_mismatch_behavior
set to drop_block
and log the input_transformations
it reports. Entries tagged prefix_binding_mismatch
are the ones to fix; entries tagged model_binding_mismatch
after a model switch are expected. If nothing is reported, your harness is already append-only. Anthropic adds one line for anyone who ships a tool other people run with their own keys: test with the field set, because new accounts are enforced by default even if yours is not.
Two further items apply if you are coming from Opus 5 rather than Fable 5. Opus 5 accepts thinking
set to disabled
at high effort or lower; Fable 5.1 returns a 400 for it at any effort, so the field has to go and token spend has to be controlled with lower effort instead. And Fable 5.1 runs a broader set of safety classifiers than Opus 5’s cyber-only set, so code that only ever saw a cyber
refusal category should expect bio
and reasoning_extraction
as well.
04 — BehaviourThe model also acts differently, and two fixes are deletions. #
Separately from the API changes, Anthropic documents seven ways Fable 5.1 behaves differently from Fable 5 with no code change at all. Most have a one-line prompt fix. Two of them are unusual in that the fix is to remove an instruction you already have, because the instruction was written to restrain an older model and now pushes in the wrong direction.
Fewer progress updates during long tool runs, more so at higher effort, so an agent can appear to go silent for minutes. Any prompt line telling the model to hold its findings for the final response now compounds this and should be deleted. The updates it does write arrive as thinking blocks, which come back empty under the default display setting.Less formatting in chat, not more. Fable 5.1 reaches for bold, headers and lists less than earlier models. Anti-formatting rules written for models that over-formatted now suppress structure the content needs. Delete them rather than tune them.More variable parallel tool calling. In coding and computer-use loops where the next independent reads are implied rather than named, the model may issue one call per turn. Answer quality is unaffected; turns, tokens and wall-clock time are not.More answers from memory at low effort. The model calls search and retrieval tools less often at the lowest setting. Raise effort for those turns or add a nudge that recognising a name is not the same as knowing its current state.Denser prose, with longer sentences and fewer paragraph breaks, and** whole-file rewriteswhere a targeted edit would do — the same result, more output tokens. Unmarked quotations when summarising documents.**Fable 5.1 is more likely than Fable 5 to reproduce passages of a source without marking them as quotations. For anything that summarises fetched material this is both an accuracy problem and a plagiarism problem, and Anthropic’s prescribed fix is a full worked example in the system prompt rather than a rule.
05 — EvidenceEvery launch number is vendor-run. #
Anthropic publishes a comparison table across Fable 5.1, Fable 5, Opus 5 and GPT-5.6 Sol. It is vendor-run, and it is unusually well annotated for a vendor table — which is worth crediting and also worth reading closely, because the annotations carry most of the caveats.
| Benchmark | Fable 5.1 | Fable 5 | Opus 5 | GPT-5.6 Sol |
|---|---|---|---|---|
| Terminal-Bench-Science 0.1 | 52.6% | 24.7% | 29.0% | 22.4% |
| Terminal-Bench 4.0 | 55.8% | 42.0% | 52.3% | 37.3% |
| GDPval-AA v2 (Elo) | 1853 | 1723 | 1824 | 1711 |
| OSWorld 2.0, strict | 41.7% | 36.1% | 39.6% | Not published |
| Humanity’s Last Exam, with tools | 65.0% | 63.8% | 63.6% | Not published |
| AutomationBench | 31.4% | 17.1% | 26.9% | 19.6% |
| CursorBench 3.2.0 | 73.4% | 70.5% | 70.0% | 67.2% |
Three things in that table are easy to misread. The first is the OSWorld row: Anthropic shows no GPT-5.6 Sol figure, and says why — the scores are on the benchmark authors’ August 2026 task release, which is not directly comparable to previously published OSWorld 2.0 results. Filling that cell from an older source would silently merge two different benchmarks. The second is the version number on Terminal-Bench. These are 4.0 results; the Terminal-Bench figures that circulated in comparisons earlier this year were 2.1, and the two do not belong in one table.
The third is the Terminal-Bench-Science line, which is where the headline gap sits — 52.6% against Fable 5’s 24.7% — and where Anthropic does something worth noting. It publishes the public leaderboard’s own numbers for the two models it can be checked against, Opus 5 at 30.0% and Fable 5 at 21.4%, alongside its reproductions of 29.0% and 24.7%, and states that both sit within noise given a standard error of 3.5 to 4.5 points. A vendor showing you where its harness disagrees with the public leaderboard is not nothing. It is still a vendor-run table, and the doubling should be reported as Anthropic’s measurement until somebody independent runs it.
The same standard applies to the scientific results in the announcement, all of which are Anthropic-reported and unreplicated at publication: protein binders with affinities ten times the best entries in Adaptyv Bio’s design competitions on three targets, a new Venus elevation map at two to three kilometre resolution rather than ten to twenty, and GPU kernels that sped seven open-source biology models by up to 2.5 times with identical outputs. They are interesting claims and they are the vendor’s claims.
06 — Fine printSafeguards loosened. Data retention did not. #
Two changes here matter to anyone buying rather than building. The first is a genuine loosening of the safety classifiers that made Fable 5 frustrating for security work. Fable 5.1 is now permitted to identify vulnerabilities in source code — defensive work — though not to develop exploits for them, and Anthropic says Claude Code users should see around 60% fewer interventions per session from its cyber safeguards. On the biology side, the latest safeguards fire 85% less often on benign elementary-biology and medical questions, a change that applies to Fable 5 as well. Penetration testing, exploit generation, binary-based vulnerability scanning and life-sciences research and development are all still redirected to the Opus models, so a refusal path is still required rather than optional. The permitted fallback targets for Fable 5.1 are Opus 4.8 and Opus 5, a refusal that arrives before any output is not billed, and fallback credit refunds the prompt-cache cost of the switch.
The second is the one to read twice, because the announcement and the documentation sound like they disagree. The announcement introduces Enterprise Frontier Safeguards, under which customer data sits in the customer’s own cloud infrastructure and human review is done by the customer, and describes it as giving “complete privacy (the same as a zero data retention policy).” The model documentation, meanwhile, states that Fable 5.1 and Mythos 5.1 “carry 30-day data retention and aren’t available under zero data retention unless expressly authorized by Anthropic.” Opus 5, by contrast, is available under zero data retention — which makes this the one respect in which moving up a tier is a step back. Both statements are accurate. Zero data retention on this model is an express authorisation granted to eligible customers, not a default you get by asking, and it is positioned as the stopgap until Enterprise Frontier Safeguards arrives.
Which it has not. Enterprise Frontier Safeguards is announced, built with more than a hundred customers and the three major cloud providers, and rolling out “in phases, starting this fall.” It is not available today. Any procurement conversation that treats it as a shipped control is a conversation about a roadmap. If data terms are the deciding factor in a build, our census of coding-agent data terms covers how the rest of the field words the same commitments.
Anthropic also tightened its anti-distillation measures. API accounts created from September 1, 2026 onwards can no longer manually edit Claude’s prior context in a multi-turn conversation while preserving the transcript of its prior thinking, which Anthropic describes as closing a common, publicly documented technique for extracting a model’s reasoning. Existing accounts are not affected today, but the company says the change will apply to all users at future model releases, and that a small number of customers’ custom integrations will be affected when it does. It is the same underlying constraint as the append-only rule above, arriving from a different direction.
07 — The decisionAnthropic’s own advice is to start with Opus 5. #
That is worth stating plainly, because it is buried in the documentation rather than the announcement: “For most workloads, start with Claude Opus 5. Use Claude Fable 5.1 for demanding reasoning and long-horizon agentic work, or when your evals on Claude Opus 5 at higher effort still fall short.” Opus 5 is half the price per token in both directions. The routing question is not which model is best; it is whether your workload is the shape that Fable earns.
The specifications that decide most of this are unchanged from Fable 5 and easy to check: a one-million-token context window that is both the default and the maximum, priced at the standard per-token rate across the whole window; 128,000 maximum output tokens; adaptive thinking always on, with no manual token budget; text and images in, text out. The knowledge cutoff moved to June 2026, a month later than Opus 5’s. Anthropic commits to keeping the model available until no sooner than September 1, 2027. A side-by-side of the older Fable generation against OpenAI’s flagship is in our GPT-5.6 Sol and Fable 5 price and access comparison, and the fixed-budget arithmetic behind all of it is in what $200 a month of AI actually buys.
08 — ConclusionA cheaper bill is not a lower price. #
Read the release as one line item falling, three behaviours breaking, and an effort sweep you have to run again.
The 25% figure is real and it is measured, but it is a measurement of Anthropic’s workloads, not a discount applied to yours. Work out what share of your Fable bill is cache reads before you forecast anything. If the answer is “most of it,” the change is significant and you should also revisit how early you compact. If the answer is “almost none,” Fable 5.1 costs you exactly what Fable 5 did, and the interesting question was always whether the workload needed Fable at all.
The migration risk sits somewhere most release coverage did not look. Forced tool use returning a 400 is loud and will be found in minutes. The thinking-block rules are quiet: a fallback router loses reasoning without saying so, and the prefix check only bites accounts created from the end of August — which means a team on an older account can pass this migration and fail the next one for a reason introduced today.
And two of the recommended fixes are deletions. If your prompts still carry an instruction to suppress formatting, or to hold findings until the end, they were written for a model that needed restraining and are now working against you. A model upgrade is a good moment to read your own system prompt and ask which lines are still solving a problem that exists.