Claude Fable 5.1: Cache Read 75% Cheaper, tool_choice Breaks

The short answer to what Claude Fable 5.1 is: released September 1, 2026, claude-fable-5-1 cuts cache-read cost by 75% without changing the price tag ($10/$50 per MTok), but breaks backward compatibility in three places. If your production code uses tool_choice: {"type":"any"} or {"type":"tool"}, or you build message history by hand, read this before skipping ahead — two of the three breaking changes below show up as a direct 400 error, and one shows up silently.

💡 Pro Tip: Before migrating from Fable 5 to 5.1, run a "breakage scan" in staging: grep your codebase for tool_choice and hand-built thinking blocks — the first two items in the official migration guide are exactly these two patterns.

Table of Contents

• Fable 5.1 at a glance: price, context, effort
• Cache-read at $0.25: the real billing impact
• Where it matters, where it doesn't
• BREAKING: tool_choice any/tool now returns 400
• Why this broke: the official rationale
• Migrating to strict tool use and structured outputs
• Thinking-block compatibility and the 400 trap
• What watermarked output means
• Fable 5 → 5.1 migration checklist
• Step-by-step migration flow
• The same migration in Python and TypeScript
• FAQ
• When did Claude Fable 5.1 launch and what's the pricing?
• Why does tool_choice return a 400 error in Fable 5.1?
• How much does the Fable 5.1 cache-read discount lower cost?
• What do I need to change in my code when migrating from Fable 5 to Fable 5.1?
• Conclusion
• Sources

Fable 5.1 at a glance: price, context, effort

Fable 5.1 was announced on September 1, 2026, the same day as Mythos 5.1 (claude-mythos-5-1, available only under Project Glasswing). The model ID is claude-fable-5-1, and it's accessible via the Claude API, Amazon Bedrock, AWS, Google Cloud, and Microsoft Foundry.

The core specs:

• Context window: 1M tokens (the default is also the maximum)
• Output limit: 128k tokens
• Thinking: always-on adaptive thinking — it can't be turned off, only its depth is tuned via the effort parameter
• Tokenizer: identical to Fable 5 (unchanged since Opus 4.7) — the same text produces roughly 30% more tokens than with pre-Opus-4.7 models
• Data retention: a mandatory 30 days; no ZDR (zero data retention) without Anthropic's explicit permission — identical to Fable 5 here too

This is the natural continuation of the approach covered in the Claude 4.7 Opus post — picking the right effort level for each task; in 5.1 as in Fable 5, effort isn't a switch that turns thinking on or off, it's a dial that adjusts how deep the thinking goes.

Pricing table (input/output stayed identical to Fable 5):

Cache-read at $0.25: the real billing impact

The real news here isn't the input/output price, it's the cache-read rate. In Fable 5, reading from cache cost 0.1x the base input price ($1/MTok). In Fable 5.1 that ratio dropped to 0.025x ($0.25/MTok) — a quarter of the standard 0.1x rate used by other models.

In concrete terms: for agent architectures that read a system prompt + tool definitions + long conversation history from cache on every turn, where cache-read is the dominant cost line (long system prompt + short output), cutting that line by 75% shows up directly on the bill. This drop raises the ceiling even further on the "up to 10x cost reduction" we covered in prompt caching — especially for multi-turn agent loops with long system prompts.

Where it matters, where it doesn't

• It matters: Chatbots with long system prompts, multi-tool agents, pipelines talking to MCP servers — all of these re-read the same large context from cache turn after turn.
• It doesn't matter: One-off, short-prompt calls that don't use caching — here the bill doesn't change since input/output pricing already stayed the same.

BREAKING: tool_choice any/tool now returns 400

This is the most critical section here. The following request, which works on Fable 5, fails outright on Fable 5.1:

1curl https://api.anthropic.com/v1/messages \
2  -H "x-api-key: $ANTHROPIC_API_KEY" \
3  -H "anthropic-version: 2023-06-01" \
4  -H "content-type: application/json" \
5  -d '{
6    "model": "claude-fable-5-1",
7    "max_tokens": 1024,
8    "tools": [{"name": "get_weather", "input_schema": {"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]}}],
9    "tool_choice": {"type": "tool", "name": "get_weather"},
10    "messages": [{"role": "user", "content": "Hava nasıl?"}]
11  }'

The error returned is exactly this:

1{
2  "type": "error",
3  "error": {
4    "type": "invalid_request_error",
5    "message": "tool_choice: type \"tool\" and \"any\" are not supported for this model."
6  }
7}

auto and none are unaffected — the problem is limited to the two values that force the model to call a specific tool (or any tool at all). The same validation applies identically on the token-counting endpoint too — try to count tokens with tool_choice:any and you'll get a 400 there as well.

Why this broke: the official rationale

It's worth stressing this isn't a bug, it's a deliberate design decision. In Fable 5.1, thinking is always on. Forcing a tool call makes the model skip its "working out" step and write straight into tool arguments — the result is lower-quality argument generation. Anthropic shut down any/tool forcing entirely to prevent this; the model now either thinks freely and decides to call a tool on its own (auto), or doesn't call one at all (none).

This is the natural consequence of the point we made in Claude Extended Thinking — that thinking isn't a side feature but part of the model's architecture — and in 5.1 that principle is now enforced at the API level.

Migrating to strict tool use and structured outputs

For code that uses tool_choice: any/tool, there are two officially recommended paths:

1. Strict tool use — add strict: true to the tool definition alongside tool_choice: "auto" to guarantee schema compliance without forcing the model:

1{
2  "tools": [
3    {
4      "name": "get_weather",
5      "strict": true,
6      "input_schema": {
7        "type": "object",
8        "properties": { "city": { "type": "string" } },
9        "required": ["city"]
10      }
11    }
12  ],
13  "tool_choice": { "type": "auto" }
14}

2. Structured outputs — move the schema out of the tool definition and into the response format directly; this fits more naturally than a tool call, especially for the "always give me this JSON shape" scenario.

A third, simpler alternative is also officially recommended: explicitly steering the model toward using a tool through the prompt — a clear instruction like "use the get_weather tool to answer the weather question." Fable 5.1 is stated to reliably follow explicit tool instructions, meaning you can steer its behavior without forcing it.

I generally prefer combining both: a clear instruction in the prompt plus strict: true schema validation. This combination comes closest to replicating the "guaranteed to be called" feel of the old tool_choice:tool forcing, without sacrificing thinking quality.

Thinking-block compatibility and the 400 trap

The second breaking change is sneakier, because it doesn't show up immediately — it shows up on the second turn. Compatibility is one-directional: Fable 5.1 can read thinking blocks from Opus 5, Fable 5, Mythos 5, and earlier models — but no older model can read the thinking blocks Fable 5.1 produces. When switching models, the incompatible block is silently dropped by the API; that block isn't counted toward input_tokens and isn't billed.

That's not the actual trap, though. A separate and more critical rule is this: if you change the system prompt, tool definitions, or messages from the previous turn, that turn's thinking blocks are invalidated — and the next request returns a 400 with this error:

1{
2  "type": "error",
3  "error": {
4    "type": "invalid_request_error",
5    "message": "The block is bound to a different conversation"
6  }
7}

This rule is mandatory for accounts created on or after August 31, 2026; for accounts created before that, it stays silent by default and only kicks in if the prefix_mismatch_behavior field is set. For integrations that hand-build their own messages array — that is, programmatically reassembling system/tools/history on every turn — the official guide specifically says: check this code before migrating, because unknowingly changing the previous turn's prefix can trigger this error.

There's an officially defined escape hatch: add this field along with the thinking-binding-controls-2026-08-01 beta header:

1{
2  "thinking": {
3    "block_binding": {
4      "prefix_mismatch_behavior": "drop_block"
5    }
6  }
7}

With this setting, the incompatible block is silently dropped and the reason is reported in the response's input_transformations field as reason: "prefix_binding_mismatch" — so instead of getting the error, you can see exactly what was dropped.

Patterns that stay safe: removing thinking blocks starting from the oldest, using server-side context editing/compaction, moving cache_control, and changing only effort between turns (this doesn't break the prefix).

What watermarked output means

All text output produced by Fable 5.1 and Mythos 5.1 carries Anthropic's statistical text watermark on every platform it's used on. The official assurance is clear on three points: it doesn't change meaning, quality, or readability; it doesn't add extra tokens or hidden characters; and it doesn't carry user or organization information.

In practice this requires no code changes — your request/response handling flow stays the same, you don't need to parse or strip an extra field. In addition, supported image/video/audio files produced by the code execution tool also carry signed C2PA Content Credentials when retrieved via the Files API — a separate verification layer for integrations that want to verify the provenance of media files.

Fable 5 → 5.1 migration checklist

The table below ranks the items you need to check in a real migration by priority:

Step-by-step migration flow

1. Run a grep for tool_choice across your codebase; flag any occurrence of type "any" or "tool".
2. Move every flagged call to the tool_choice:auto + strict:true template; add an explicit tool instruction to the prompt if needed.
3. In code that hand-assembles message history, write a test guaranteeing the previous turn's system/tools fields don't change across turns.
4. Run the test once with prefix_mismatch_behavior:"drop_block" and log the input_transformations field — this is where you catch unexpected drops.
5. If you have a model-router or fallback chain (for example Fable 5.1 → Opus 5 → Sonnet 5), remember thinking blocks are only readable from older to newer; on a 5.1 → older-model transition the block is silently dropped, so don't assume otherwise.
6. Observe in staging for a week, then ship to production.

None of these steps require a mandatory "big rewrite" — the official migration guide characterizes this transition as "mostly drop-in." The real risk is migrating without running the scan at all and learning about the breakage from user reports in production.

There are also three additional optional/beta features: turn-scoped system messages (mid-conversation-system-clear-at-2026-08-21), thinking.display:"updates" (thinking-display-updates-2026-08-18), and the mid-conversation-output-config-2026-07-01 header supporting effort changes between turns. None of these are mandatory migration steps — they're cache-friendly improvements worth trying in large codebase pipelines working with the Claude 1M context window.

The same migration in Python and TypeScript

Below is a Python integration using tool_choice: {"type":"tool"} converted to its 5.1-compatible form:

1# BEFORE (works on Fable 5, returns 400 on Fable 5.1)
2response = client.messages.create(
3    model="claude-fable-5",
4    max_tokens=1024,
5    tools=[weather_tool],
6    tool_choice={"type": "tool", "name": "get_weather"},
7    messages=[{"role": "user", "content": "Hava nasıl?"}],
8)
9 
10# AFTER (strict tool use + explicit prompt instruction)
11weather_tool["strict"] = True
12response = client.messages.create(
13    model="claude-fable-5-1",
14    max_tokens=1024,
15    tools=[weather_tool],
16    tool_choice={"type": "auto"},
17    messages=[
18        {
19            "role": "user",
20            "content": "Hava durumunu cevaplamak için get_weather tool'unu kullan. Şehir: İstanbul",
21        }
22    ],
23)

On the Node/TypeScript side, a simple check that tests the model-router chain:

1// Simple check that verifies thinking-block direction in the fallback chain
2const chain = ["claude-fable-5-1", "claude-opus-5", "claude-sonnet-5"];
3 
4function canReuseThinkingBlock(fromModel: string, toModel: string): boolean {
5  // Only 5.1 and newer models can read a 5.1 block; 5.1 itself can read older models' blocks
6  const rank = (m: string) => chain.indexOf(m);
7  return rank(fromModel) >= rank(toModel);
8}

Adding this check to your fallback logic lets you catch the "older model couldn't read the block" error in CI instead of production.

FAQ

When did Claude Fable 5.1 launch and what's the pricing?

Fable 5.1 launched on September 1, 2026, alongside Mythos 5.1. Input/output pricing stayed exactly the same as Fable 5 ($10/$50 per MTok); the only price change is cache-read: from $1/MTok to $0.25/MTok, a 75% discount. It's accessible via the Claude API, Amazon Bedrock, AWS, Google Cloud, and Microsoft Foundry.

Why does tool_choice return a 400 error in Fable 5.1?

tool_choice: {"type":"any"} and {"type":"tool","name":"..."} are no longer supported in Fable 5.1 and return a 400 with invalid_request_error. The official rationale: always-on thinking conflicts with a forced tool call — the model skips its "working out" step and writes straight into tool arguments, leading to lower-quality argument generation. auto and none are unaffected; the fix is switching to strict tool use or structured outputs.

How much does the Fable 5.1 cache-read discount lower cost?

The cache-read rate dropped from 0.1x to 0.025x the base input price. For multi-turn agent architectures that read a long system prompt and tool definitions from cache on every turn, where cache-read is the dominant cost line (long system prompt + short output), this means a noticeable drop in the total bill — especially in projects already using the prompt caching strategy.

What do I need to change in my code when migrating from Fable 5 to Fable 5.1?

Check three things: (1) move every call using tool_choice:any/tool to strict tool use, (2) in code that hand-assembles message history, guarantee the previous turn's system/tools fields don't change — otherwise you'll get the "block is bound to a different conversation" error, (3) account for thinking blocks only being portable from older models to newer ones in your model-router/fallback chain.

Conclusion

Fable 5.1 cuts cache-read cost by 75% without changing the price tag, while breaking backward compatibility in three places: tool_choice:any/tool now returns 400, older models can't read 5.1's thinking blocks, and the thinking-block prefix has to stay stable across turns. Alongside these are five additive changes: the cache-read price drop, turn-scoped system messages, thinking.display:"updates", effort changes between turns, and watermarked text output — none requiring a mandatory code change. None of this is a surprise "regression"; all of it is explicitly justified in the official docs as deliberate design decisions.

The practical takeaway: every integration using tool_choice or hand-building message history owes itself a scan before migrating. Running that scan over agents on Claude 4.6 Opus or Claude 4.7 Opus, remember Extended Thinking is now mandatory and tool_choice forcing is gone from MCP-based tool chains. To actually pocket the cache-read discount, recalculate your prompt caching architecture at the new rate — in cache-read-heavy setups the per-line cost drops to a quarter ($1 → $0.25/MTok).

Sources

• Claude Platform Release Notes — official announcement of the September 1, 2026 Fable 5.1 launch entry, the tool_choice and thinking-block changes
• What's new in Claude Fable 5.1 — version-specific highlights, the cache-read price, and the watermark explanation
• Claude Models Overview — the current pricing table and model comparison
• Tool use with Claude — the official reference for strict tool use and tool_choice behavior
• Preserved thinking — thinking-block model and prefix compatibility, the block_binding/prefix_mismatch_behavior fields, and cross-turn rules