Claude Fable 5.1: Fix These 3 Breaking API Changes Now

Claude Fable 5.1 shipped September 1 as a near-drop-in replacement for Fable 5 — same tokenizer, same pricing, same context window. Near being the operative word. Three API changes arrived with it, and at least one of them is a silent production bomb: any code that forces a specific tool call is throwing a 400 error right now. If you haven’t audited your integration yet, here is what to fix and in what order.

What Changed (And What Didn’t)

The safe list is long: per-token input and output pricing, API surface, rate limits, refusal handling, and the 1M-token context window are all unchanged from Fable 5. Cache reads dropped from $1.00 to $0.25 per million tokens — a 75% cut that compounds fast for agentic workloads. What’s not safe: forced tool choice, thinking block portability across models, and in-place conversation history edits.

Breaking Change 1: tool_choice “any” and “tool” Return 400

This is the one that bites first. Claude Fable 5 accepted four values for tool_choice: auto, none, any, and tool. Fable 5.1 accepts two: auto and none. Passing anything else returns a 400 invalid_request_error:

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

The fix is a three-part swap. Change tool_choice to auto, add strict: true and "additionalProperties": false to the tool’s input_schema, and name the required tool explicitly in the prompt instruction. Here’s what that looks like in Python:

# Before (Fable 5) — throws 400 on Fable 5.1
response = client.messages.create(
    model="claude-fable-5",
    max_tokens=16000,
    tools=[record_summary_tool],
    tool_choice={"type": "tool", "name": "record_summary"},
    messages=[{"role": "user", "content": "Summarize: The meeting moved to Thursday."}],
)

# After (Fable 5.1)
record_summary_tool = {
    "name": "record_summary",
    "description": "Record the structured summary of the document.",
    "strict": True,
    "input_schema": {
        "type": "object",
        "properties": {"summary": {"type": "string"}},
        "required": ["summary"],
        "additionalProperties": False,
    },
}

response = client.messages.create(
    model="claude-fable-5-1",
    max_tokens=16000,
    tools=[record_summary_tool],
    tool_choice={"type": "auto"},
    messages=[{
        "role": "user",
        "content": "Summarize: The meeting moved to Thursday. Call the record_summary tool with your result.",
    }],
)

If you need to force a tool call mid-conversation without breaking prompt cache hits on earlier turns, there’s a cleaner alternative: append a role: "system" message at the end of the messages array for that specific turn. This scopes the instruction to the current turn only while keeping earlier messages byte-identical for caching. And if you were forcing tool use purely to get schema-conformant JSON, skip the tool entirely and use output_config.format (JSON outputs) instead — it’s cleaner and doesn’t hit this restriction.

Breaking Change 2: Thinking Blocks Don’t Travel Backwards

Fable 5.1 can read thinking blocks from every older Claude model. The reverse is not true. If your routing or retry logic ever sends a Fable 5.1 conversation to Fable 5, Opus 5, or any earlier model, those models cannot read the 5.1 thinking blocks.

The API handles this silently: it drops the unreadable blocks before the older model sees them, bills you nothing for the dropped tokens, and lets the request succeed. The catch is that the model re-plans without the prior reasoning, which means the first turn after a model switch costs more and runs slower. This failure mode is easy to miss in production because there’s no error — just degraded behavior.

To diagnose it, add the beta header thinking-binding-controls-2026-08-01 to your requests. Responses will include an input_transformations array that names each dropped block with reason: "model_binding_mismatch". If you’re building a router or using server-side fallbacks, instrument this before you assume your fallback logic is working correctly.

Breaking Change 3: Editing Conversation History Breaks Thinking Blocks

Every thinking block Fable 5.1 emits is cryptographically bound to the exact system prompt, tools list, and conversation prefix that preceded it. Edit any earlier turn in-place and the block’s signature becomes invalid. On accounts created on or after August 31, 2026, the API enforces this with a 400 error:

messages.5.content.0: Invalid `signature` in `thinking` block. The block is bound to a different conversation. Remove the block, or set `thinking.block_binding.prefix_mismatch_behavior` to "drop_block".

Two things worth knowing here. First, retry loops will not save you — the error is permanent for that exact request body. Second, if your account predates August 31, the API currently logs the mismatch without enforcing it, but Anthropic has said enforcement is coming for all accounts on future models. The window to fix this without a production incident is now, not later.

The fix is straightforward: adopt append-only conversation history. Never modify an earlier turn; only add new messages. If you need to recover from a mismatched block, either strip the thinking blocks from history before retrying or add the beta header with prefix_mismatch_behavior: "drop_block" — the API will drop the conflicting blocks and continue without throwing an error.

The Upside: 75% Cheaper Cache Reads

After the patches, there’s a real payoff. Cache reads at $0.25 per million tokens versus the previous $1.00 is a meaningful number for any application keeping a large system prompt or tool list warm in the prompt cache. Input and output token prices didn’t move, so the gains are entirely in the repeated-context case — which is exactly where agentic workloads live. If you’re running long-context agents, the cache savings alone likely justify the migration work.

Migration Checklist

• Update model string: claude-fable-5 → claude-fable-5-1
• Remove all tool_choice: {type: "any"} patterns
• Remove all tool_choice: {type: "tool", name: "..."} patterns
• Add strict: true and "additionalProperties": false to tool definitions
• Name required tools explicitly in prompt instructions
• Audit any routing or retry logic that might fall back to an older model
• Switch to append-only conversation history semantics
• If on ZDR: contact your Anthropic account team before migrating

Anthropic’s official migration guide covers all three changes with before/after code in eight languages. The automated path is to run /claude-api migrate in Claude Code, which handles the model ID swap and parameter changes across your codebase with a confirmation step before touching any files. For background on the strict tool use pattern that replaces forced tool choice, the Anthropic docs have a dedicated page. And if you want external context on what Fable 5.1 actually gains beyond the cache cut, MarktechPost’s coverage of the 52.6% Terminal-Bench-Science score is worth a read.