Claude Fable 5.1: 75% Cheaper Cache, Three Things It Breaks

What changed

• Two models, one day. Claude Fable 5.1 (claude-fable-5-1) and Claude Mythos 5.1 (claude-mythos-5-1) shipped on 1 September 2026. Mythos 5.1 is the same set of capabilities, restricted to Project Glasswing participants.
• One price moved. Cache reads went from $1.00 to $0.25 per million tokens — a 75% cut. Base input, both cache-write tiers, output and batch pricing are all unchanged.
• Forced tool use is gone. A tool_choice of {"type":"any"} or {"type":"tool","name":"..."} now returns a 400.
• Thinking blocks travel forwards only. Fable 5.1 can read earlier models' thinking; no earlier model can read Fable 5.1's.
• History is effectively append-only. Editing anything before a Fable 5.1 thinking block invalidates that block and every block after it.
• Specs. A 1M-token context window as both the default and the maximum, at standard per-token pricing across the whole window; 128k maximum output tokens; adaptive thinking always on, with depth set by the effort parameter.

Point releases are usually a paragraph in a changelog. This one is a pricing decision and a migration bundled together, and the two halves land on different desks. Your finance lead will care about the first half. Whoever owns your agent loop needs to read the second, because it contains three changes that are code changes rather than configuration changes — and one of them behaves differently depending on when your account was created.

Anthropic's own what's new page for Fable 5.1 is the primary source for everything below, and it is unusually blunt about the breakage. That is worth a small amount of credit: a vendor that tells you plainly which of its guarantees it has withdrawn is easier to plan around than one that lets you find out in production.

The one line of your bill that got cheaper

Here is the full rate card, and what moved.

The ratio is the cleaner way to hold it in your head. On other Claude models a cache read costs 0.1 times base input. On Fable 5.1 and Mythos 5.1 it costs 0.025 times base input. The minimum cacheable prompt length stays at 512 tokens, so nothing about which prompts qualify has changed — only what the hits cost you.

The arithmetic, so you can substitute your own numbers

Take a long-horizon agent session: a 200,000-token cached prefix — system prompt, tool definitions, a repository map, a few reference documents — re-read on each of 50 turns. That is 200,000 x 50 = 10,000,000 cache-read tokens, or 10 million tokens, per session.

• At the old $1.00 per million: 10 x $1.00 = $10.00 in cache reads for that session.
• At the new $0.25 per million: 10 x $0.25 = $2.50 for the identical session.
• Difference: $7.50, on that line alone. Run 200 such sessions a day and the same arithmetic gives $2,000 against $500.

To be explicit about what that is and is not: this is an illustration of the published per-token rates, not a benchmark and not a measured saving from a real workload. Substitute your own prefix size and turn count and the shape holds — the saving scales linearly with how much cached context you re-read and how many times you re-read it. What it does not do is change your write side. Cache writes are unchanged at $12.50 and $20, so a workload that churns its prefix, invalidating and rewriting the cache constantly, sees very little of this. The teams who benefit most are the ones with a large, genuinely stable prefix and a long session on top of it. If you have not built for that shape, our guide to prompt caching across Claude, GPT and Gemini is the place to start, and the wider mechanics sit in our inference cost economics playbook.

Breaking change one: forced tool use returns a 400

If your code ever pins the model to a tool, it stops working. tool_choice of {"type":"any"} or {"type":"tool","name":"..."} returns a 400 invalid_request_error with the message tool_choice: type "tool" and "any" are not supported for this model. The same validation runs on the token-counting endpoint, so you cannot even price the request. The default {"type":"auto"} and {"type":"none"} are unaffected.

# FAILS on claude-fable-5-1 — and on /v1/messages/count_tokens too
{
  "model": "claude-fable-5-1",
  "tools": [{ "name": "lookup_invoice", "input_schema": {"type": "object"} }],
  "tool_choice": {"type": "any"}
}

# HTTP 400 invalid_request_error
# tool_choice: type "tool" and "any" are not supported for this model.

# WORKS — default routing, a strict schema, and the rule stated in the prompt
{
  "model": "claude-fable-5-1",
  "tools": [{ "name": "lookup_invoice", "strict": true,
              "input_schema": {"type": "object"} }],
  "tool_choice": {"type": "auto"},
  "system": "When the user asks about a bill, call lookup_invoice before answering."
}

Anthropic's reasoning is worth understanding rather than just working around, because it tells you what the replacement should look like. Thinking is always on for this model. A forced tool call skips it — so instead of reasoning and then calling, the model writes its working-out into the tool arguments, and argument quality drops. The prohibition is a quality guard, not an arbitrary restriction.

The recommended replacements are two, and you can use both. Keep tool_choice on auto and set strict: true on the tool, which gives you schema conformance without the forcing. Or move the schema out of tools entirely and use structured outputs. In both cases, state in the prompt when the tool applies, in plain language. Teams that used forced tool use as a cheap way to guarantee JSON shape will find structured outputs is the better fit anyway.

Breaking change two: thinking blocks only travel forwards

Every thinking block now records which model produced it, and preservation runs in one direction. Fable 5.1 reads earlier models' thinking blocks. No earlier model reads Fable 5.1's. Move a conversation onto Fable 5.1 and its reasoning comes with it; move a conversation from Fable 5.1 back to Opus 5, Fable 5 or anything older and the reasoning is lost for the turns that run there.

This matters far more than it sounds if you run a routing layer — and plenty of Indian and UK teams do, precisely to keep costs down. Sending the cheap turns to a smaller model and escalating the hard ones is a sensible pattern, but the escalation direction is now asymmetric. Escalating up to Fable 5.1 is lossless. Falling back down is not.

That silent-drop behaviour is the reason to treat model routing as something you instrument rather than something you assume works. It is also a reminder that portability between models is a property you have to design for, not one you get. We have written before about why every team should write an LLM vendor exit plan before it needs one, and the argument only gets stronger as reasoning state becomes model-bound. Anthropic itself demonstrated how fast a model can become unavailable when US export controls pulled Fable 5 and Mythos 5 earlier this year.

Breaking change three: your conversation history is append-only

This is the one that will cost engineering time. Modifying anything before a Fable 5.1 thinking block — the top-level system prompt, the tools array, or an earlier message — errors on the next request, or drops the block if you opt in to that behaviour. Replay an invalidated block and you get a 400 whose message says The block is bound to a different conversation. Mythos 5.1 does not run this check.

Note the nuance in that last pair. A rotating signed URL pointing at the same file is fine, because the bytes are identical. A URL that is stable but serves regenerated content is not. And removing a thinking block from anywhere other than the start of the run invalidates every block after it — trimming from the front is safe, trimming from the middle is not.

# INVALIDATES every later thinking block
messages[0]["content"] = REMINDER + original_first_message  # injected, then removed next turn
tools  = build_tools()                    # rebuilt from a dict, key order shifts per request
system = f"Today is {today}. You are..."  # regenerated on every request

# SAFE
#   append new turns only
#   drop a leading run of thinking blocks, oldest first
#   let server-side compaction or context editing trim the history
#   move cache_control markers freely
#   change `effort` between requests

Read that list of invalidating patterns again and notice how ordinary they are. Injecting a per-request reminder into the first user message is a standard trick. So is rebuilding the tools array from a dictionary whose key order is not guaranteed. So is stamping today's date into the system prompt. None of these look like mutations of history to the person who wrote them. All of them are.

Two teams, identical code, different behaviour

The enforcement split is the detail most likely to produce a genuinely confusing production incident, so it is worth stating on its own. The check is enforced for accounts created on or after 31 August 2026. For accounts created before that date, the API records the mismatch but acts on it only if the request sets thinking.block_binding.prefix_mismatch_behavior.

The practical consequence: two teams running the same code against the same model can see different behaviour, and so can two environments inside one company. A staging account opened last week enforces. A production account opened last year does not, until somebody sets the parameter. A contractor's sandbox behaves differently from the client's estate. You will debug this by comparing request payloads and finding them identical, which is the worst kind of debugging there is. Check the creation date of every account you deploy against, write it down, and make it the first question anyone asks when a Fable 5.1 conversation fails in one environment and not another.

The fork in the road: managed harness or hand-rolled loop

Here is the part that decides whether this release costs you a fortnight or an afternoon. Claude Code, claude.ai, Claude Managed Agents and the Claude Agent SDK keep the conversation prefix intact for you. If your agent runs on any of those, the append-only requirement is somebody else's problem. Hand-built messages arrays are the risk.

That is a real fork in the road, and it lands hardest on exactly the teams who were being careful. Plenty of engineering groups in Bengaluru and London built their own agent harness for good reasons: to control token spend precisely, to trim and rewrite history aggressively, to inject state at the point in the conversation where it was cheapest. Rewriting history was the optimisation. Under Fable 5.1 it is the failure mode. The teams who took the framework and accepted its opinions get this for free; the teams who wrote their own loop to save money now pay for that choice in migration effort.

None of which makes the managed path automatically right. Owning your loop still buys you portability, observability and the ability to move providers without a rewrite — and the agent framework market is competitive enough that the choice between the OpenAI, Google and Anthropic SDKs is a genuine architectural decision rather than a formality. But the cost of that ownership just went up, and it went up in a way that will recur. If a vendor can make conversation history append-only in a point release, expect further constraints on how you are allowed to assemble a request. Price that into the build-versus-adopt decision rather than treating it as a one-off.

The pragmatic middle path, if you own your loop and want to keep it: stop mutating and start appending. Put per-request context in the newest user message rather than editing an old one. Build the tools array once per conversation and freeze it. Keep the system prompt static and move anything volatile — dates, session state, status lines — into the current turn. Every one of those changes also improves your cache-hit rate, which is how you actually collect the 75% saving. The two halves of this release are more aligned than they first appear.

What else arrived, and what shifts without a code change

Five things are purely additive. Per-message effort can now be set mid-conversation behind the mid-conversation-output-config-2026-07-01 beta header, and it does not invalidate the prompt cache. Turn-scoped system messages arrive behind mid-conversation-system-clear-at-2026-08-21, with clear_at: "next_user_message". Readable progress updates between tool calls come from thinking.display: "updates" behind thinking-display-updates-2026-08-18. The cache-read price is the fourth. The fifth is content provenance: Anthropic's statistical text watermark is applied to generated text on every platform, and signed C2PA Content Credentials are attached to supported image, video and audio files retrieved through the Files API. The watermark adds no tokens and no hidden characters, and carries no information about the user or the organisation.

Then there is a set of behaviour differences that appear with no code change at all, and these deserve a place in your test plan. Parallel tool calling is more variable — Fable 5.1 may issue one tool call per turn where Fable 5 batched several, which costs tokens, round trips and wall-clock time but not answer quality. There are fewer progress updates during long tool runs, especially at higher effort. At low effort the model answers from memory more often and calls search and retrieval tools less. Prose is denser in places. Chat formatting is lighter, with less use of bold, headers and lists than earlier Claude models. Quotations from summarised documents may come back unmarked. And it is more likely to rewrite a whole file for a small edit — same result, more output tokens, more time.

Several of those are cost items dressed as style notes. Output is $50 per million tokens; a model that rewrites whole files for one-line edits spends that line faster than one that patches. If you are running a tight budget, the cache-read saving on the input side and the rewrite tendency on the output side pull against each other, and which wins depends entirely on your workload. Measure both before you conclude the release is cheaper for you. This is the same lesson from Anthropic's June billing split: the headline rate and the effective rate are different numbers.

What has not changed is also worth listing, because it saves a round of failed requests. thinking: {"type":"enabled"} with budget_tokens and {"type":"disabled"} both still return 400 — omit thinking entirely or send {"type":"adaptive"}. thinking.display still defaults to "omitted", with "summarized" available; the raw chain of thought is never returned. Interleaved thinking is automatic with no beta header. Prefilling the assistant response returns 400. Non-default temperature, top_p or top_k return 400. And the tokenizer is the same one introduced with Claude Opus 4.7 and carried by Fable 5 — so against models older than Opus 4.7, the same text produces roughly 30% more tokens, which matters if you are comparing bills across a migration rather than comparing rates.

Where it runs, and what to do this week

Availability is broad. Fable 5.1 is on the Claude API for all customers; on AWS through Amazon Bedrock as anthropic.claude-fable-5-1 and through the Claude Platform on AWS as claude-fable-5-1; on Google Cloud through Vertex as claude-fable-5-1; and on Microsoft Foundry, running on Anthropic infrastructure. For teams with data-residency commitments, the Bedrock route through the Mumbai and London regions is the familiar one, and the multi-cloud spread means the model is not a single-vendor dependency in the narrow sense. Both models carry 30-day data retention and are not available under zero data retention unless Anthropic expressly authorises it, and both are Covered Models. Permitted fallback targets are Claude Opus 4.8 and Claude Opus 5; you are not billed for a refusal that arrives before any output, and fallback credit refunds the prompt-cache cost of switching models.

Anthropic's own positioning is refreshingly unpushy: start most workloads on Claude Opus 5, and reach for Fable 5.1 for demanding reasoning and long-horizon agentic work, or when your evals on Opus 5 at higher effort still fall short. The capability gains concentrate in six areas — agentic coding over long sessions, knowledge work across documents, spreadsheets and slides, research and search, vision on dense charts, filings and tables in PDFs, long-context work across the full 1M window, and computer use — and the gap to Fable 5 is widest at higher effort. Multilingual performance is on par with Fable 5, which is a fair thing to know if your product serves Indian language users and you were hoping for a lift there.

So the week's work, in order. Grep your codebase for tool_choice and fix any forced use before anything else — that one fails loudly and is the easiest to close. Set the thinking-binding-controls-2026-08-01 beta header wherever you route between models, so silent drops become visible drops. Audit your request builder for the four invalidating patterns and move anything volatile into the newest turn. Record the creation date of every account you deploy against, because that single fact determines whether the append-only check bites. Then, and only then, model the cache saving on your own numbers. It is a genuine cut and it will show up on the bill — but it arrives attached to a migration, and pretending otherwise is how a pricing win turns into an outage. This is the second Fable release in a year to move the ground under agent builders, and if you were around for the original Fable 5 launch you will recognise the pattern: the capability headline gets the attention, and the API contract quietly does the damage.