Claude Fable 5.2 API: Migration Guide and Breaking Changes

Anthropic released Claude Fable 5.2 on 9 November 2026, and for most API users the headline is the price: $8 per million input tokens and $40 per million output, down from $10 and $50 on Fable 5.1. The model ID change looks like a one-line swap, but Claude Fable 5.2 also brings four breaking changes, and the one most likely to bite is the preserved thinking prefix check, which now returns a 400 error on every account. This guide covers what changed, what it costs, and how I'd test an existing integration before switching.

What is Claude Fable 5.2?

Claude Fable 5.2 is Anthropic's model for long-horizon agentic work and hard reasoning: agent sessions that run for hours, deep research, and large migrations. Claude Mythos 5.2 is the same underlying model with fewer cybersecurity and biology safeguards, and it is only available to organisations accepted into Anthropic's verification programs, such as the Cyber Verification Program. If you aren't in one of those programs, Fable 5.2 is the model you can call.

The Fable 5.2 model page lists these specs:

Claude Fable 5.2 vs Opus 5.5

One thing worth knowing before you migrate everything: Anthropic itself says to start most coding and knowledge work on Claude Opus 5.5 and move up to Fable only when your evals at higher effort still fall short. Opus 5.5 is half the price at $4 and $20 per million tokens.

Claude Fable 5.2 pricing

The pricing section of the What's new page gives these USD prices per million tokens:

Fast mode gives up to 2.5 times more output tokens per second. On the Claude API you turn it on with speed: "fast" in the request body, and it needs no beta header. On Microsoft Foundry it is a separate model, claude-fable-5-2-fast.

The cheap cache reads matter more than the headline price for agents. A long session that resends a big system prompt and tool list on every turn pays $0.20 instead of $8 per million tokens for the cached part, as long as the prefix doesn't change. That same condition, an unchanged prefix, is what the biggest breaking change is about.

If you are comparing Fable against other providers on cost per task rather than per token, my LLM API pricing comparison walks through that method.

The four breaking changes from Fable 5.1

Anthropic lists four changes that can break code moving from Fable 5.1:

1. The preserved thinking prefix check now applies to every account.
2. Only Fable 5.2 and Mythos 5.2 can read Fable 5.2 thinking blocks.
3. The old computer_20251124 computer use tool returns a 400 error everywhere except Amazon Bedrock.
4. With the advisor tool (beta), a Fable 5.2 executor needs a Fable 5.2 or Mythos 5.2 advisor.

Two older rules still apply too. Adaptive thinking is always on, so thinking: {"type": "enabled"} with budget_tokens and thinking: {"type": "disabled"} both return a 400. Forced tool use, meaning tool_choice of any or a named tool, also returns a 400. Leave out temperature, top_p and top_k as well. If you are coming from Opus 5 or older, those two thinking and tool choice rules are new for you. I covered the October API changes, including the sampling parameter errors, in my Claude API 2026-10-21 migration guide.

1. The prefix check now returns a 400 on every account

Preserved thinking is Anthropic's protection against distillation. Every thinking block the model returns is signed and bound to the exact conversation it came from: the top-level system prompt, the tools list, and every message before the block. If any of those change and you send the old thinking block back, the block fails the check.

On Fable 5.1 this only produced an error on API accounts created on or after 31 August 2026. Older accounts saw no error, so a lot of code that quietly edits its history has been running fine. On Fable 5.2 and Mythos 5.2 the check returns a 400 on every account, whatever its age, according to the preserved thinking docs. The error message starts like this:

messages.1.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".

Anthropic's list of things to check is the most useful part of the docs. These are the patterns I see most in real agent code:

• Rebuilding the system prompt on each turn, for example to insert the current date, a mode flag, or freshly re-read project instructions.
• Re-rendering an environment block in the first user message.
• Shortening or clearing old tool results in place to save tokens.
• Summarising old turns on the client while keeping recent turns with their thinking.
• Adding or removing entries in tools when an MCP server connects after the first turn.
• Dropping a thinking block from the middle of the history, or a serializer that skips thinking blocks whose thinking text is empty. On these models the text is empty by default and the reasoning lives in the signature, so a serializer that "cleans up" empty blocks removes the reasoning.

Changing effort, max_tokens, tool_choice or metadata between requests doesn't count as an edit, and neither does moving cache_control markers.

How to fix prefix edits properly

Each common edit has a replacement that keeps earlier bytes unchanged:

A mid-conversation system message is just another entry in messages:

{
  "role": "system",
  "content": "The user switched the workspace to read-only mode. Do not write files until told otherwise."
}

Once you send it, it is part of the prefix for later turns, so leave it where it is.

The stopgap: drop_block

If you need production traffic working today while you fix the edits, send the thinking-binding-controls-2026-08-01 beta header and set prefix_mismatch_behavior to "drop_block". The API then drops the failing thinking blocks instead of rejecting the request, and lists what it dropped in a top-level input_transformations array. This Python example follows the shape in Anthropic's docs:

import anthropic

client = anthropic.Anthropic()

response = client.beta.messages.create(
    model="claude-fable-5-2",
    max_tokens=16000,
    thinking={
        "type": "adaptive",
        "block_binding": {"prefix_mismatch_behavior": "drop_block"},
    },
    messages=history,  # your stored conversation, sent back exactly as returned
    betas=["thinking-binding-controls-2026-08-01"],
)

for t in response.input_transformations or []:
    # Log these. reason "prefix_binding_mismatch" means your code edited the history.
    print(t.type, t.path, t.reason)

2. Model switches lose Fable 5.2 reasoning

Fable 5.2 can read thinking blocks from Opus 5.5, Sonnet 5.5, Haiku 5.5, Fable 5.1 and older models, so moving a conversation up to Fable 5.2 keeps its reasoning on the Claude API. The reverse doesn't work. No model except Fable 5.2 and Mythos 5.2 reads Fable 5.2 thinking blocks, and that includes Opus 5.5, Fable 5.1, and Fable 5.2's own refusal fallback models, Opus 4.8 and Opus 5.

The API drops unreadable blocks silently and the request still succeeds, so nothing errors. You just pay for the model to reason again. If you run a router that sends easy turns to Sonnet or Haiku and hard turns to Fable, keep sending the full history, because the blocks come back into play when the conversation returns to Fable. Thinking blocks are also tied to the account that produced them, so replaying a transcript from another, unlinked account drops them too.

3. Computer use needs the toolset

Fable 5.2 only supports computer use through computer_toolset_20260801. A request that declares the earlier computer_20251124 tool returns a 400 invalid_request_error on every platform except Amazon Bedrock. If you built a computer use agent on Fable 5.1 with the computer-use-2025-11-24 beta header, migrate it to the toolset before changing the model ID.

4. The advisor must match

With the advisor tool, which is in beta, the advisor has to be at least as capable as the executor. A Fable 5.2 executor accepts only claude-fable-5-2 or claude-mythos-5-2 as its advisor. Changing the advisor's model is an edit to tools, so make that change in new conversations, not in the middle of existing ones.

Refusals and fallback

Fable 5.2 runs safety classifiers that block most cybersecurity work such as penetration testing and exploit generation, and most research biology. Anthropic says Fable 5.2 produced about 55% fewer blocks than Fable 5.1 in its early testing. A refused request still returns HTTP 200, with stop_reason: "refusal" and a stop_details object naming the policy area. Handle that stop reason explicitly, because a client that only checks the HTTP status will treat a refusal as a normal answer. You can retry on Opus 4.8 or Opus 5, the permitted fallback targets, either yourself or with the server-side fallbacks: "default" option, which is in beta.

Effort, fast mode and behaviour changes

The API default effort for Fable 5.2 is high, and Anthropic's advice is to start there and only step up to xhigh for your hardest coding and agent work where you've measured a gain. In Anthropic's own FrontierCode 2.0 results, Fable 5.2 at High effort scored 45.3%, about level with Opus 5.5's best of 45.5%, at roughly half the cost per task. These are vendor numbers, so treat them as a reason to run your own evals rather than a result.

Here is a raw request that sets effort and turns on fast mode:

curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2026-10-21" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-fable-5-2",
    "max_tokens": 16000,
    "speed": "fast",
    "output_config": { "effort": "xhigh" },
    "messages": [
      { "role": "user", "content": "Plan the migration of our billing service from Python to Go." }
    ]
  }'

A few behaviour differences show up without any code change, per the What's new page:

• A prompt line such as "answer directly without deliberating" doesn't stop Fable 5.2 from thinking at medium effort and above. Lower the effort for easy turns instead.
• On long tasks the model sometimes ends a turn with a list of remaining work or an offer to continue, more often at low and medium.
• It follows style rules closely, so a hard sentence length limit written for older models can make its prose choppy.

A quick offline test for prefix edits

Before switching the model ID, I'd capture the request bodies your app sends during a few real conversations, including one with a compaction and one where a tool or MCP server connects late. Then diff consecutive requests. I wrote this small checker for that; it needs only Python 3 and no API key:

#!/usr/bin/env python3
"""Usage: python3 check_prefix.py requests.jsonl  (one request body per line, one conversation)"""
import json, sys

def canon(value):
    return json.dumps(value, sort_keys=True, separators=(",", ":"))

def check(prev, cur):
    problems = []
    if canon(prev.get("system")) != canon(cur.get("system")):
        problems.append("system prompt changed")
    if canon(prev.get("tools")) != canon(cur.get("tools")):
        problems.append("tools list changed (use tool_addition / tool_removal instead)")
    old, new = prev.get("messages", []), cur.get("messages", [])
    if len(new) < len(old):
        problems.append(f"messages shrank from {len(old)} to {len(new)}")
    for i, msg in enumerate(old[: len(new)]):
        if canon(msg) != canon(new[i]):
            problems.append(f"messages[{i}] ({msg.get('role')}) was edited")
            break
    return problems

reqs = [json.loads(l) for l in open(sys.argv[1], encoding="utf-8") if l.strip()]
found = 0
for n in range(1, len(reqs)):
    for p in check(reqs[n - 1], reqs[n]):
        found += 1
        print(f"request {n + 1}: {p}")
print("OK: history is append-only" if not found else f"{found} prefix edit(s) found")
sys.exit(1 if found else 0)

On a test log where the second request re-rendered the date in the system prompt and the third stripped a thinking block from an assistant turn, it prints:

request 2: system prompt changed
request 3: messages[1] (assistant) was edited
2 prefix edit(s) found

It is deliberately stricter than the API. Removing thinking blocks from the very start or end of the history, or all of them, is allowed, and the script flags it anyway. The exit code is 1 on any finding, so you can run it in CI against recorded sessions. Then confirm against the real API by running a session with prefix_mismatch_behavior set to "error", which fails loudly on any edit.

Claude Fable 5.2 migration checklist

• Change the model ID to claude-fable-5-2 (or anthropic.claude-fable-5-2 on Bedrock).
• Remove budget_tokens, thinking: disabled, sampling parameters and forced tool_choice. Use tool_choice: auto with strict: true tools if you need schema-valid JSON.
• Run the prefix diff on recorded sessions, then a real session with prefix_mismatch_behavior: "error".
• Replace system prompt rebuilds and tools edits with mid-conversation system messages and tool_addition / tool_removal.
• Check your router: turns sent from Fable 5.2 to any other model lose Fable's reasoning.
• Move computer use to computer_toolset_20260801 and point the advisor tool at a 5.2 advisor.
• Handle stop_reason: "refusal" and decide on a fallback to Opus 4.8 or Opus 5.
• Confirm 30-day data retention is acceptable for your data, since Fable 5.2 isn't available under zero data retention by default.
• Re-run evals with an effort sweep starting at high, and compare against Opus 5.5 before committing to Fable's price.

Fable 5.2 in GitHub Copilot

If you use Fable through Copilot rather than the API, GitHub made Fable 5.2 generally available on 9 November for Copilot Pro+, Max, Business and Enterprise. Business and Enterprise admins have to enable the Claude Fable 5.2 policy, which is off by default, and it requires data retention by default for Anthropic's safety classifiers. None of the API migration work applies there, because Copilot builds the requests.

For a wider view of choosing between Anthropic's tiers, my Claude Sonnet 5.5 vs Opus migration guide covers the cheaper end of the lineup.