Claude Fable 5.1 Migration Guide: The 3 Breaking Changes and How to Fix Them

If you use Claude through Claude Code, claude.ai, Managed Agents or the Agent SDK, you can mostly relax. Those products manage your conversation history, and Anthropic says the history rule does not apply to them. This guide is for people who run their own Messages API loop: custom agent harnesses, tool routers, fallback chains between models, and any code that trims or rewrites old turns to save tokens. That last group is the one most likely to hit a 400 in production.

Fable 5.1 costs the same as Fable 5 on paper: $10 per million input tokens and $50 per million output tokens. The change is in caching. Cache hits and refreshes are now billed at 0.025 times the base input price instead of the usual 0.1, which comes to $0.25 per million tokens. Anthropic estimates that makes Fable 5.1 about 25% cheaper than Fable 5 for typical workloads, and up to about 45% cheaper for agent work that re-reads the same context over and over. If you run long agent loops, this is the part of the release that shows up on your invoice.

Batch requests on Fable 5.1 cost $5 input and $25 output per million tokens. The tokenizer is the same one Fable 5 uses, so your token counts should not change. Before you switch, check two account settings. Fable 5.1 requires 30-day data retention, and requests from an organization without it get a 400 invalid_request_error. It is also not offered on Priority Tier, which Fable 5 was.

On Fable 5 you could force a tool call with tool_choice set to {"type": "any"} or {"type": "tool", "name": "..."}. On claude-fable-5-1, both return a 400 invalid_request_error with this message:

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

The check runs on the Messages API, the Message Batches API and the token counting endpoint, so a batch job will fail the same way a live request does. auto (the default) and none still work.

Anthropic's reason is quality. Thinking is always on for Fable 5.1, and a forced tool call would skip it, so the model would end up doing its reasoning inside the tool arguments. Those arguments come out worse.

Before (works on Fable 5, fails on Fable 5.1):

record_summary_tool = {
    "name": "record_summary",
    "description": "Record the structured summary of the document.",
    "input_schema": {
        "type": "object",
        "properties": {"summary": {"type": "string"}},
        "required": ["summary"],
    },
}

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 (Anthropic's documented fix): leave tool_choice at auto, name the tool in the instruction, and set strict: True so the call matches your schema.

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.",
        }
    ],
)

The docs cover two edge cases. If the only reason you forced a tool was to get JSON that matches a schema, drop the tool and use JSON outputs (output_config.format) instead. If your application needs a specific tool on a specific turn, append a mid-conversation system message after the latest user turn. It needs no beta header:

{
    "role": "system",
    "content": "Tool-use requirement for the current turn: the application requires a call to the search_help_center tool in your response to the user's latest message. Begin your response with the search_help_center tool call. Do not reply with text only.",
},

Every thinking block records which model produced it. Fable 5.1 can read its own blocks and blocks from Mythos 5.1, Opus 5, Fable 5, Mythos 5 and earlier models. The reverse does not hold: apart from Mythos 5.1, none of those models can read a Fable 5.1 block.

So what happens when a conversation moves from Fable 5.1 to an older model, through a router switch, a client-side retry, or a refusal fallback? The request still succeeds. The API removes the blocks the target model cannot read, you are not billed for those dropped input tokens, and the older model re-plans without that reasoning. Anthropic warns this can raise cost and latency on the first turn after the switch.

The drop is silent by default. To see it, send the thinking-binding-controls-2026-08-01 beta header. Responses then include an input_transformations array that names each dropped block:

{
  "input_transformations": [
    {
      "type": "thinking_dropped",
      "path": "messages.3.content.0",
      "reason": "model_binding_mismatch"
    }
  ]
}

In practice, keep passing thinking blocks back unchanged on every turn, including empty ones. Don't strip them to "help" the older model, because the API already does that. Add the beta header in any router or fallback path and log input_transformations, so you can see how often a downgrade happens and what the re-planning costs you.

If you use server-side fallbacks, the permitted fallback targets for Fable 5.1 are claude-opus-4-8 and claude-opus-5. Neither receives Fable 5.1's thinking blocks, so every fallback starts its reasoning from scratch.

Each Fable 5.1 thinking block is valid only against the system prompt, tools and conversation history that came before it. If your code builds the messages array itself and changes anything earlier in the conversation, the thinking that followed no longer matches. On accounts that enforce the check you get a 400 like this:

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". That setting requires the `thinking-binding-controls-2026-08-01` value in the `anthropic-beta` header.

The API enforces this for accounts created on or after August 31, 2026. Older accounts have the mismatch recorded but not acted on, unless the request sets prefix_mismatch_behavior. Anthropic's announcement says the rule will apply to all users with future model releases, so older accounts should fix it now too. It does not apply if Claude Code, claude.ai, Managed Agents or the Agent SDK manages your history, and Mythos 5.1 does not run this check.

The error is permanent for that request body, so a retry loop will not clear it. You have two ways to continue. Strip the thinking blocks from the history and retry once, or opt into dropping the mismatched blocks automatically:

response = client.beta.messages.create(
    model="claude-fable-5-1",
    max_tokens=16000,
    thinking={
        "type": "adaptive",
        "block_binding": {"prefix_mismatch_behavior": "drop_block"},
    },
    messages=[
        {
            "role": "user",
            "content": "What is the greatest common divisor of 1071 and 462?",
        }
    ],
    betas=["thinking-binding-controls-2026-08-01"],
)

print(f"Input transformations: {len(response.input_transformations or [])}")

With drop_block, the API drops the mismatched block and every thinking block after it, and reports each one with reason: "prefix_binding_mismatch". The default is error.

The better fix is to stop editing history at all. Anthropic lists the patterns that break and what to use instead:

Still safe: appending new turns, removing thinking blocks oldest-first, changing effort, max_tokens or cache_control, and server-side compaction or context editing.

Anthropic suggests a three-step audit. Diff consecutive request bodies to find where your code rewrites history. Run a session with drop_block and log input_transformations to see what gets dropped. Then pick error or drop_block for production. For CI, set error so any history edit fails the run.

If you are coming straight from Fable 5, these already applied. If you are coming from Opus 5 or an older model, they are new to you:

• thinking: {"type": "disabled"} and manual extended thinking with budget_tokens both return a 400. Omit thinking or send {"type": "adaptive"}, and use effort to control depth.
• Prefilling the assistant message returns a 400. Put that guidance in the system prompt instead.
• Non-default temperature, top_p or top_k values return a 400.
• Coming from Opus 5, text between tool calls now arrives as thinking blocks instead of text blocks, and the price goes from $5 / $25 to $10 / $50.

Some changes won't throw errors but will show up in your evals. Anthropic says Fable 5.1 makes fewer parallel tool calls in long agent loops, sends fewer progress messages, runs fewer searches at low effort, and writes denser prose with less chat-style formatting. If your parser expects markdown bullets, check it.

In Anthropic's own products, Fable 5.1 defaults to high effort in Claude Code and medium in Claude Cowork and on claude.ai. If you want to compare it with other current models before you commit, our task-by-task model guide covers where Fable 5.1 fits, and the AI API price index tracks what it costs next to OpenAI, Google and the open-weight providers.

1. Confirm your organization has 30-day data retention and is not relying on Priority Tier.
2. Change the model ID to claude-fable-5-1, or run /claude-api migrate in Claude Code.
3. Search your code for tool_choice. Replace any and named-tool values with auto, name the tool in the prompt, and add strict: True to the tool.
4. Check for thinking set to disabled, budget_tokens, assistant prefill and non-default sampling parameters if you are not coming from Fable 5.
5. Diff consecutive request bodies in a real session. Any change to earlier turns, the system prompt or the tools list needs one of the replacements above.
6. Add the thinking-binding-controls-2026-08-01 beta header in staging and log input_transformations.
7. Test on an API account created on or after August 31, 2026, or with prefix_mismatch_behavior set to error.
8. Re-run your evals at high, xhigh and max effort and pick a setting based on results, not habit.

• Anthropic: Migrating to Claude Fable 5.1 and Claude Mythos 5.1
• Anthropic: What's new in Claude Fable 5.1
• Anthropic: Claude Fable 5.1 and Mythos 5.1 announcement
• Anthropic: API pricing
• Anthropic: Building with thinking
• Anthropic: Preserved thinking and block binding
• Anthropic: Effort
• Anthropic: API release notes

What are the breaking changes in Claude Fable 5.1?

Anthropic lists three for apps moving from Fable 5. Forced tool use (tool_choice set to any or to a named tool) now returns a 400 error. Earlier models cannot read Fable 5.1's thinking blocks, so they are dropped if a conversation moves to an older model. And editing earlier turns invalidates the thinking blocks that follow, which returns a 400 on accounts created on or after August 31, 2026.

Why does tool_choice any return an error on Claude Fable 5.1?

Thinking is always on for Fable 5.1, and a forced tool call would skip it. Anthropic says the model would then put its reasoning into the tool arguments, which lowers their quality. The fix is to leave tool_choice at auto, name the tool in your instruction, and set strict to true on the tool so the call matches your schema.

Is Claude Fable 5.1 more expensive than Fable 5?

No. Input and output stay at $10 and $50 per million tokens. The only price change is cache reads, which drop from $1 to $0.25 per million tokens. Anthropic estimates Fable 5.1 costs about 25% less than Fable 5 on typical workloads and up to about 45% less on highly agentic work.

Can I switch a conversation from Fable 5.1 back to an older Claude model?

Yes, the request still succeeds. The API removes the Fable 5.1 thinking blocks the older model cannot read, and you are not billed for those dropped tokens. The older model has to re-plan without that reasoning, which can raise cost and latency on the first turn after the switch.

Does Claude Code migrate my project to Fable 5.1 automatically?

Anthropic documents a bundled Claude API skill for this. In Claude Code, run /claude-api migrate. It swaps the model ID, applies breaking parameter changes, prefill replacement and effort calibration across your code base, and asks you to confirm the scope before editing any files. It then gives you a checklist of things to verify by hand.

Written by

Paras Tiwari

Founder, Spectrum AI Labs

Founder of Spectrum AI Labs — testing AI tools and models, and writing up what actually ships.

More about Paras →