Claude Fable 5.1: cache reads at a quarter of the price, and three changes that break existing code

Anthropic released Claude Fable 5.1 on September 1, 2026, alongside Claude Mythos 5.1. They are the same underlying model with different safety classifier settings: Fable 5.1 is generally available with production safeguards, and Mythos 5.1 ships those safeguards loosened for vetted cybersecurity and life-sciences organisations inside Project Glasswing.

The model IDs are claude-fable-5-1 and claude-mythos-5-1.

If you already use Fable 5, the interesting part is not the capability jump. It is a pricing line and three breaking changes.

The price change

Everything is priced the same as Fable 5 except cache reads (all figures USD per million tokens):

	Base input	5m cache write	1h cache write	Cache read	Output
Fable 5.1	$10	$12.50	$20	$0.25	$50
Fable 5	$10	$12.50	$20	$1.00	$50

Cache reads now cost 0.025× the base input price on Fable 5.1 and Mythos 5.1, against 0.1× on every other Claude model. Cache writes and the 512-token minimum cacheable prompt length are unchanged.

Why this matters more than it looks: in a long agent loop, the same system prompt, tool definitions, and conversation prefix get re-read on every single turn. Those re-reads are cache reads, and in a 60-turn session they dominate the bill. Cutting them by 75% takes about 25% off a typical workload and up to roughly 45% off a heavily agentic one — a session that is mostly re-reading a large cached prefix.

Batch processing is $5 input / $25 output per million.

If you have not set up caching, this is the release that makes it worth an afternoon: Prompt caching, implemented.

What actually got better

Anthropic's own framing is that Fable 5.1 extends Fable 5 rather than replacing the tier, with gains concentrated in six areas: long-session agentic coding, document/spreadsheet/slide work, multistep research and search, vision on dense charts and PDFs, long-context reasoning across the full 1M window, and computer use recovery from failed steps. The gap over Fable 5 is widest at higher effort levels.

Two numbers from the launch table are worth keeping:

• Terminal-Bench-Science: 52.6%, against 24.7% for Fable 5 — more than double.
• AutomationBench: 31.4%, against 26.9% for Opus 5 and 17.1% for Fable 5. AutomationBench is meant to measure business workflows, so this is the closest published proxy for "can it run a real multi-step process."

Multilingual performance is flat versus Fable 5.

Should you use it at all?

Anthropic's own guidance is unusually direct: start with Opus 5, and reach for Fable 5.1 for demanding reasoning and long-horizon agentic work, or when your evals on Opus 5 at high effort still fall short.

That is the right order. Fable 5.1 is $10/$50 against Opus 5's $5/$25 — double the input and output price. The cache read discount narrows the gap on cache-heavy sessions but does not close it. See Choosing the right Claude model for the decision structure.

Specs shared by both 5.1 models:

• 1M token context window, default and maximum, at standard per-token pricing across the whole window
• 128k max output tokens
• Adaptive thinking always on — control depth with the effort parameter
• Same tokenizer as Fable 5 (introduced with Opus 4.7). Against models older than 4.7, the same text produces roughly 30% more tokens

Breaking change 1: forced tool use returns a 400

tool_choice set to {"type": "any"} or {"type": "tool", "name": "..."} now fails:

tool_choice: type "tool" and "any" are not supported for this model.

{"type": "auto"} (the default) and {"type": "none"} are unchanged. The same validation applies to the token counting endpoint, so a pre-flight count will fail too.

The reason is structural, not arbitrary. Thinking is always on for these models, and a forced tool call skips it — the model ends up writing its working-out into the tool arguments, which makes the arguments worse.

If you were using forced tool use to guarantee schema-valid JSON, there are two replacements:

# Before — will 400 on Fable 5.1
response = client.messages.create(
    model="claude-fable-5",
    max_tokens=2048,
    tools=[extract_invoice],
    tool_choice={"type": "tool", "name": "extract_invoice"},
    messages=[{"role": "user", "content": invoice_text}],
)

# After — strict tool use with auto choice
response = client.messages.create(
    model="claude-fable-5-1",
    max_tokens=2048,
    tools=[{**extract_invoice, "strict": True}],
    tool_choice={"type": "auto"},
    messages=[
        {
            "role": "user",
            # State when the tool applies. Fable 5.1 follows explicit
            # tool instructions reliably.
            "content": f"Use the extract_invoice tool on this invoice.\n\n{invoice_text}",
        }
    ],
)

The other option is to move the schema off the tool entirely and onto structured outputs, which is the better fit when you want one shaped response rather than a tool call.

Breaking change 2: thinking blocks are bound to the model that produced them

Every thinking block now records which model wrote it, and preservation runs in one direction only. Fable 5.1 can read thinking blocks from Opus 5, Fable 5, Mythos 5, and earlier models. No earlier model can read Fable 5.1's.

Moving a conversation onto Fable 5.1 keeps its reasoning. Moving a conversation from Fable 5.1 back to Opus 5 loses reasoning for the turns that run there.

When a request carries a block the target model cannot read, the API drops it before the model sees it. Dropped blocks are not billed and do not count toward input_tokens. By default the drop is silent. Send the thinking-binding-controls-2026-08-01 beta header and the drop is reported in a top-level input_transformations array instead.

If you run a router, a cheaper-model fallback, or any mid-conversation model switch, turn that header on before you migrate. Silent quality loss in an agent loop is the hardest kind of regression to find. This is also the failure mode behind a lot of why Claude feels inconsistent.

Breaking change 3: editing earlier turns invalidates thinking blocks

This is the one most likely to bite a hand-rolled integration.

Modifying anything before a Fable 5.1 thinking block — the system prompt, the tools array, or an earlier message — errors on the next request. The rejection is a 400 whose message reads The block is bound to a different conversation.

Enforcement depends on account age: the check is enforced for accounts created on or after August 31, 2026. Older accounts have the mismatch recorded but only acted on if the request sets thinking.block_binding.prefix_mismatch_behavior. Mythos 5.1 does not run the check at all.

These patterns invalidate every later thinking block:

• Editing, reordering, or removing an earlier turn while keeping later ones
• Injecting per-request text into an earlier turn — a reminder or status line — that you strip on the next request
• Rebuilding the top-level system prompt or tools array between requests in the same conversation
• An image or document URL that serves different bytes on a later request. The check covers the bytes, not the URL, so a rotating signed URL for the same file is fine

These are safe:

• Removing a leading run of thinking blocks, oldest first
• Server-side compaction or context editing trimming the history
• Moving cache_control markers
• Changing effort between requests

Claude Code, claude.ai, Managed Agents, and the Agent SDK keep the prefix intact for you. If your code builds the messages array itself, you need to check.

The check that tells you in one session: run with the beta header and prefix_mismatch_behavior: "drop_block", then log input_transformations. Any entry with reason: "prefix_binding_mismatch" is your code editing history. Fix those, then pick a production behaviour.

The structural fix is to treat the conversation as append-only. Add instructions with a mid-conversation system message rather than rewriting system; change tools with mid-conversation tool changes rather than rebuilding tools; trim with server-side context editing or compaction rather than client-side splicing. All of those also keep the prompt cache warm, so the append-only discipline pays for itself twice.

Three additive features

Per-message effort (beta)

Header: mid-conversation-output-config-2026-07-01. Supported on Fable 5.1, Mythos 5.1, and Opus 5.

You can now change the effort level mid-conversation without invalidating the prompt cache. Raise it for the hard step, drop it for the routine ones. It works by inserting a role: "system" message carrying only an output_config:

response = client.beta.messages.create(
    model="claude-fable-5-1",
    max_tokens=4096,
    output_config={"effort": "high"},
    messages=[
        {"role": "user", "content": "Plan a migration from SQLite to PostgreSQL in three short steps."},
        {"role": "assistant", "content": "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import and verify row counts."},
        # Effort-only system message: takes effect from the next user turn.
        {"role": "system", "content": [], "output_config": {"effort": "low"}},
        {"role": "user", "content": "Summarize the plan in one sentence."},
    ],
    betas=["mid-conversation-output-config-2026-07-01"],
)

This is the single most useful cost lever in the release for anyone running long sessions. Most agent loops spend high effort on turns that are file reads and status checks. See Minimising token usage and Claude cost optimization.

Turn-scoped system messages (beta)

Header: mid-conversation-system-clear-at-2026-08-21.

Set clear_at: "next_user_message" on a role: "system" message and its text carries system-prompt authority for the current turn only, then stops rendering once a later user message exists:

{
  "role": "system",
  "clear_at": "next_user_message",
  "content": "Results have landed in your inbox. Check it before running more code."
}

The message stays in messages and you keep sending it back verbatim, so nothing earlier changes. The prompt cache keeps matching, later thinking blocks stay valid, and a cleared message costs no input tokens.

This exists precisely because of breaking change 3. The old pattern — inject a per-turn reminder into history, delete it next request — is now the thing that invalidates your thinking blocks. This is the sanctioned replacement.

Progress updates as text (beta)

Header: thinking-display-updates-2026-08-18, via a new thinking.display value of "updates".

Fable 5.1 writes short progress notes between tool calls, each as its own thinking block. Under the default display of "omitted" those come back empty, so a long agentic turn looks silent to your users. With "updates", the progress notes return as text while reasoning stays hidden — any thinking block with non-empty text is a status line you can render.

If your UI shows a spinner during long tool loops, this is the fix.

Behaviour changes with no code change

Seven differences from Fable 5 show up without you touching anything. These are the ones that will make your evals move:

• Parallel tool calling is more variable. Fable 5.1 may issue one tool call per turn where Fable 5 batched several. It shows up in custom coding agents, bash-and-editor harnesses, and computer use. Extra turns cost tokens, round trips, and wall-clock time but do not lower answer quality. Requests that explicitly name several things to fetch still run in parallel — the fix is a one-line batching instruction in your prompt.
• Fewer progress updates during long tool runs, especially at higher effort. Remove any prompt line telling it to hold findings for the final response, and if your UI depends on narration, ask explicitly for an opening line, periodic updates, and a closing recap.
• Answers from memory more often at low effort — it calls search and retrieval tools less. Raise effort for turns that need fresh information, or add a verification nudge.
• Denser prose — longer sentences, fewer paragraph breaks.
• Less formatting in chat — bold, headers, and lists appear less than in earlier Claude models. Anti-formatting rules you wrote for older models can now suppress structure the content needs. Go re-read your system prompts.
• Unmarked quotations in summaries — when summarising documents it is more likely to reproduce source passages without marking them as quotes. If you ship summaries of third-party material, this is a real exposure and you should instruct explicitly.
• Whole-file rewrites for small changes — when editing text files it is more likely to rewrite the whole file than make a targeted edit. Same result, more output tokens and more time.

Unchanged, and worth remembering

• Adaptive thinking is always on. thinking: {"type": "enabled"} with budget_tokens and {"type": "disabled"} both 400. Omit thinking or send {"type": "adaptive"}
• thinking.display still defaults to "omitted"; the raw chain of thought is never returned
• Interleaved thinking is automatic with no beta header
• Prefilling the assistant response returns a 400
• Non-default temperature, top_p, or top_k return a 400
• Refusals still arrive as HTTP 200 with stop_reason: "refusal" and a stop_details object. Permitted fallback targets for Fable 5.1 are Opus 4.8 and Opus 5, and fallback credit refunds the prompt-cache cost of switching. If you have not handled refusals, Claude Fable 5 covers the mechanics

Content provenance and data retention

Text generated by Fable 5.1 and Mythos 5.1 carries Anthropic's statistical text watermark on every platform where the model runs. It adds no tokens or hidden characters, carries no information about you or your organisation, and needs no request or response changes. Images, video, and audio the model produces through the code execution tool carry signed C2PA Content Credentials when retrieved through the Files API.

Both models carry 30-day data retention and are not available under zero data retention unless Anthropic expressly authorises it. Both are Covered Models, as Fable 5 and Mythos 5 are.

That retention requirement is what Enterprise Frontier Safeguards, announced the same day, exists to resolve. If a compliance answer is what is blocking you from Fable, read that next.

Availability

• Claude API: claude-fable-5-1, all customers
• AWS: Bedrock as anthropic.claude-fable-5-1; Claude Platform on AWS as claude-fable-5-1
• Google Cloud: claude-fable-5-1
• Microsoft Foundry: on Anthropic infrastructure

Mythos 5.1 is offered only to approved Project Glasswing customers, through your Anthropic, AWS, or Google Cloud account team.

Claude Code picked up Fable 5.1 in version 2.1.257, where it became the default Fable model with the 1M context window.

Try this today — the 45-minute migration check

Do not swap the model ID in production first. Do this instead, in order.

1. Grep for forced tool use. grep -rn 'tool_choice' across your codebase. Every "type": "any" and "type": "tool" is a 400 waiting to happen. Convert each to strict: true with tool_choice: {"type": "auto"} plus an explicit prompt line naming when the tool applies.

2. Run one real session with the drop-block header on. Set thinking-binding-controls-2026-08-01 and thinking.block_binding.prefix_mismatch_behavior: "drop_block", then log every input_transformations entry. If you see reason: "prefix_binding_mismatch", your code edits history — find the line and move it to a turn-scoped system message or a mid-conversation tool change.

3. Re-run your eval suite at the same effort, then one level lower. The behaviour changes above mean your baselines have moved. If you do not have an eval suite, this release is the argument for building one: Writing evals that catch regressions.

4. Measure the cache read line specifically. Pull one week of usage before and after. The 75% cut only lands if you are actually getting cache hits — if your cache read token count is near zero, the headline saving does not apply to you and the fix is prompt caching, not the model.

The whole check is under an hour and catches all three breaking changes. Skipping step 2 is how a silent thinking-block drop reaches production.

Related: Claude Fable 5 · Claude Opus 5 · Choosing the right Claude model · Enterprise Frontier Safeguards · When your AI model disappears