Claude Fable 5.1 Migration Guide: What Breaks, What's New, What to Fix First

On September 1, 2026, Anthropic quietly shipped Claude Fable 5.1 and Claude Mythos 5.1 on the Developer Platform. If you're running production traffic on Claude Fable 5 or Opus 5 and you upgrade the model string without reading the release notes, you will ship a 400 error to production. Two tool_choice values that worked fine on every prior model — any and tool — are no longer supported, and the API rejects the request outright instead of silently falling back.

That's the headline risk. But the release also brings real upgrades: a 1M-token context window, a 128k max output ceiling, always-on adaptive thinking, meaningfully cheaper cache reads, and four new beta controls (strict tool use, preserved thinking, per-message effort, turn-scoped system messages) that solve problems agent builders have been hacking around for months.

This guide walks through exactly what changed, what will break in your existing integration, and how to migrate without an incident.

What's Actually New in Fable 5.1 and Mythos 5.1

Fable 5.1 is the direct successor to Fable 5 for long-running agentic coding, knowledge work, and research tasks. Mythos 5.1 ships alongside it as the model track for Anthropic's Project Glasswing participants. Both models land with the same platform-level changes:

1M token context window — roughly 4x what most teams are used to designing around, enough to hold entire monorepos or long document sets in a single request without chunking.
128k max output tokens — long-form generation (full test suites, multi-file refactors, long reports) no longer needs to be split across multiple turns just to avoid truncation.
Always-on adaptive thinking — the model decides internally how much reasoning a given turn needs rather than you toggling extended thinking on or off per request.
Lower cache read pricing — Anthropic cut the cost of cache_read_input_tokens further, which compounds with prompt caching to reduce the effective cost of long conversation histories and large system prompts.
Text watermarking and C2PA content credentials — text generated by these models carries Anthropic's watermark, and image/video files retrieved through the Files API carry C2PA Content Credentials, both aimed at provenance and AI-content detection use cases.

If you're studying for the Claude Certified Architect exam, this release matters beyond the changelog: architecture decisions around context window sizing, caching strategy, and tool-use reliability are exactly the kind of scenario-based questions the CCA Foundations and Professional exams test.

Breaking Change #1: `tool_choice: any` and `tool_choice: tool` Now Return a 400

This is the change that will actually break running code. On Fable 5.1 and Mythos 5.1:

python# This now fails on Fable 5.1 / Mythos 5.1
response = client.messages.create(
    model="claude-fable-5-1",
    tool_choice={"type": "any"},  # 400 error
    tools=[...],
    messages=[...]
)

tool_choice: {"type": "auto"} and tool_choice: {"type": "none"} are unchanged and still work exactly as before. But if your code path ever forces the model to call some tool (any) or forces it to call one specific tool by name (tool), that request now returns a 400 instead of the tool call it used to guarantee. Why it matters: a lot of production agent code uses any/tool specifically to force deterministic tool invocation — for example, a routing step that must always call a classify_intent function before anything else happens. That pattern is now unsupported on these models. The fix: Anthropic's replacement path is strict tool use or structured outputs, both new in this release:

python# Strict tool use — keep tool_choice: auto, add strict: true
response = client.messages.create(
    model="claude-fable-5-1",
    tool_choice={"type": "auto"},
    tools=[{
        "name": "classify_intent",
        "strict": True,
        "input_schema": {...}
    }],
    messages=[...]
)

Strict tool use guarantees schema-conformant arguments when the model does call the tool, without forcing the call itself. If your actual requirement is "the model must call this tool on this turn" rather than "if it calls a tool, the arguments must be valid," the new turn-scoped system messages beta is the better fit — see below.

Breaking Change #2: Thinking Blocks Don't Carry Backward

Thinking blocks produced by Fable 5.1 and Mythos 5.1 are preserved only for the model that produced them, or a newer one — older models can't read them. If your architecture routes a conversation across model versions (say, Fable 5 for cheap turns and Fable 5.1 for complex ones, or a fallback chain that drops to an older model on rate limits), any thinking block generated by 5.1 will be unreadable if that conversation later hits an older model.

The fix: treat thinking blocks as version-pinned. If you build fallback or multi-model routing logic, strip or regenerate thinking blocks when a conversation crosses a model-version boundary, and don't assume a thinking block survives a downgrade.

4 New Beta Controls Worth Adopting

Beyond the breaking changes, four beta features address real pain points:

1. Strict tool use — guarantees schema-valid tool call arguments (covered above). Use it anywhere malformed tool arguments have caused silent failures downstream. 2. Structured outputs — guaranteed schema conformance for the model's actual text response, not just tool arguments. If you've been parsing JSON out of Claude's response with regex and a retry loop, this is what replaces that loop. 3. Per-message effort — lets you set reasoning effort on a per-message basis rather than per-request or globally, so a single conversation can mix a quick classification turn with a deep multi-step reasoning turn without spinning up separate API calls. 4. Turn-scoped system messages — append a role: "system" message after the latest user turn to require a specific tool call for that turn only, then leave it in history afterward. This is the direct replacement for the tool_choice: tool pattern broken by change #1 — it gets you deterministic tool invocation without losing auto mode's flexibility on every other turn.

All four are beta and require explicit opt-in via beta headers — check the Claude Platform release notes for the current header names before enabling in production.

Why the Cache Pricing Change Matters More Than It Looks

It's easy to skim past "lower cache read pricing" as a footnote, but it compounds with the larger context window in a way worth doing the math on. Prompt caching already discounts cache_read_input_tokens heavily versus fresh input tokens — Fable 5.1 pushes that discount further. If your application re-sends a large, mostly-static system prompt or tool schema on every turn (a common pattern for agents with 20+ tool definitions), the combination of a bigger cacheable prefix and a cheaper read rate means the marginal cost of each additional turn in a long conversation drops noticeably.

The catch is that this only pays off if your prompt prefix stays byte-identical between requests — the same constraint that's always governed Claude's prompt cache. A 1M-token context window makes it tempting to just keep stuffing more history into the request rather than pruning it, but every token you add to a prompt that changes turn-to-turn is a token you're paying full price for, not the discounted cache rate. Bigger limits are not a substitute for cache-aware prompt design; if anything, they raise the cost of getting cache invalidation wrong, since a busted cache on a 1M-token prefix is a much more expensive mistake than on a 200k-token one.

If you're not already monitoring cache_read_input_tokens versus input_tokens in your usage logs, add that dashboard before you migrate — it's the single clearest signal of whether the new pricing is actually helping your bill or whether something in your request shape is quietly busting the cache on every call.

How This Affects the Claude Certified Architect Exam

Anthropic's certification stack — Claude Certified Associate Foundations, Claude Certified Developer Foundations, Claude Certified Architect Foundations, and Claude Certified Architect Professional — tests scenario-based judgment, not model trivia. That means a question won't ask "what's the max output of Fable 5.1," but it might describe an agent that forces tool calls with tool_choice: tool, breaks after a model upgrade, and ask you to identify the fix. Understanding why strict tool use and turn-scoped system messages exist — not just that they exist — is what separates a guess from a confident answer on the 120-minute, 60-question Architect Foundations exam.

The same applies to context-window and caching questions: expect scenarios where a candidate architecture over-relies on a large context window instead of retrieval or summarization, and the correct answer involves recognizing the cost and latency tradeoff rather than assuming "bigger context is always better."

Migration Checklist

Before you flip the model string in production, grep your codebase for these three things:

Search for tool_choice with "type": "any" or "type": "tool" across every API call site. Each one needs to move to strict tool use, structured outputs, or turn-scoped system messages.

Audit any multi-model fallback or routing logic for thinking-block reuse across model versions. Add a strip/regenerate step at version boundaries.

Re-check context and output budgets. With 1M context and 128k output now available, any chunking logic you built to work around the old 200k/64k limits may now be unnecessary complexity — but don't remove it blind; validate cost impact first, since a bigger context window means bigger bills if you're not pruning history.

Run your integration test suite against claude-fable-5-1 in a staging environment with production-shaped traffic before cutting over. The 400 errors from breaking change #1 are the kind of failure that only shows up under real tool-calling load, not in a quick smoke test.

Key Takeaways

tool_choice: any and tool_choice: tool are removed on Fable 5.1 and Mythos 5.1 — they return a 400 error instead of a graceful fallback. auto and none are unaffected.
Thinking blocks are version-pinned — a block from 5.1 can't be read by older models, which matters for any multi-model fallback architecture.
Strict tool use, structured outputs, per-message effort, and turn-scoped system messages are the four new beta controls, and together they replace most of the reasons teams used forced tool_choice in the first place.
1M context, 128k output, and cheaper cache reads are the headline upgrades, but re-validate your chunking and cost assumptions before you rely on the bigger limits.

Next Steps

If you're prepping for the Claude Certified Architect exam, tool-use reliability patterns and context-window architecture decisions like these show up directly in the scenario-based questions. AI for Anything's CCA practice test bank covers exactly this kind of API-behavior scenario with explanations, not just multiple-choice guessing. Start with a free sample quiz before you sit the proctored exam.

Sources: