Claude Fable 5.2 Migration: What Breaks

Swapping a model ID used to be the easy part of an LLM upgrade. With reasoning models that send their thinking back on every turn, it isn't any more: the API now checks that the conversation behind each thinking block hasn't changed since the block was written.

Claude Fable 5.2 (claude-fable-5-2), released by Anthropic on November 9, 2026, is built for long-horizon agentic work, and Anthropic's own migration guide calls the move from Fable 5.1 "mostly drop-in." It costs 20% less per token than Fable 5.1. Four changes can still break working code: the preserved-thinking prefix check now applies to every account, Fable 5.1 and Opus 5.5 can't read Fable 5.2's thinking blocks, the older computer_20251124 tool returns a 400 error, and an advisor-tool executor on Fable 5.2 accepts only a Fable 5.2 or Mythos 5.2 advisor. If your code builds its own messages array, test it before you move traffic.

I'll use one integration throughout: a Python pull request review agent for an acme-api repository. It keeps a 180,000-token snapshot of the code in a cached prefix, runs about 20 turns per pull request, trims old tool results to save tokens, and falls back to Claude Opus 5.5 when a request is declined. Every one of those habits matters on Fable 5.2.

What Fable 5.2 Changes Next to Fable 5.1 and Opus 5.5

The facts below come from Anthropic's announcement, its pricing page and the Fable 5.2 migration guide, all checked on November 10, 2026. Prices are USD per million tokens (MTok).

All three have a 1M-token context window and 128,000 max output tokens. Fable 5.2 keeps Fable 5.1's API surface: adaptive thinking is always on, and disabling thinking, assistant prefill and forced tool choice all return a 400. On Amazon Bedrock the ID is anthropic.claude-fable-5-2. Fable 5.2 also has its own rate limit, with lower token limits than Opus 5.5 at each tier.

Anthropic's own advice is to start most coding work on Opus 5.5 and move up to Fable 5.2 when evals at higher effort fall short.

What One Pull Request Review Costs on Each Model

The per-token gap between Fable 5.2 and Opus 5.5 is exactly 2x, but a cached agent session doesn't pay per-token list prices evenly. Here is the review agent priced turn by turn: the 180,000-token prefix is written to the 5-minute cache on turn 1, and each later turn reads everything cached so far, writes the previous reply plus 2,500 new input tokens, and produces 5,000 output tokens. The fast mode row applies the standard cache multipliers to its $16 base, as the pricing page specifies.

Python
Copy
# One 20-turn PR review session, priced from Anthropic's pricing page (2026-11-10).
# USD per million tokens: base input, 5-minute cache write, cache read, output.
PRICES = {
    "claude-fable-5-1":        (10.00, 12.50, 0.25, 50.00),
    "claude-fable-5-2":        ( 8.00, 10.00, 0.20, 40.00),
    "claude-fable-5-2 (fast)": (16.00, 20.00, 0.40, 80.00),
    "claude-opus-5-5":         ( 4.00,  5.00, 0.20, 20.00),
}
PREFIX, NEW_IN, OUT, TURNS = 180_000, 2_500, 5_000, 20

def session_cost(base_in, write, read, out):
    cached, total = 0, 0.0
    for turn in range(1, TURNS + 1):
        written = PREFIX + NEW_IN if turn == 1 else OUT + NEW_IN  # last reply + new input
        total += cached * read + written * write + OUT * out
        cached += written
    return total / 1_000_000

for model, p in PRICES.items():
    print(f"{model:<24} ${session_cost(*p):6.2f}")

text
Copy
claude-fable-5-1         $ 10.25
claude-fable-5-2         $  8.20
claude-fable-5-2 (fast)  $ 16.40
claude-opus-5-5          $  4.58

Fable 5.2 lands at 1.8x Opus 5.5 here, not 2x, because a cache read costs $0.20 per MTok on both models (2.5% of base input on Fable 5.2, 5% on Opus 5.5). The 4.75 million tokens of cache reads in this session cost $0.95 on either one. Cache writes and output are where the gap lives.

The script holds token counts constant, and that's the weak assumtion. Anthropic's FrontierCode 2.0 chart puts Fable 5.2 at High effort at 45.3%, about level with Opus 5.5's best score of 45.5%, "for roughly half the cost per task." On its FrontierSWE v2 table Fable 5.2 scores 69.9% against 56.3% for Fable 5.1 and 62.3% for Opus 5.5. These are vendor-run numbers with safeguards on, so treat them as a reason to run your own eval, not as the eval. For reviews nobody waits on, the Batch API halves Fable 5.2 to $4 / $20 (fast mode isn't available there).

Why Fable 5.2 Rejects Edited Conversation History

Every thinking block Fable 5.2 returns is valid only against its prefix: the top-level system prompt, the tools list and every message that came before it. Change any of that, send the old thinking block back, and the request fails the prefix check. Fable 5.1 and Opus 5.5 enforce the check by default only for accounts created on or after August 31, 2026. Fable 5.2 enforces it for every account, whatever its age, so code that has run cleanly on an older account for months can start failing on the day you change the model name. The error reads:

text
Copy
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.

Retrying the same body fails the same way every time. Our review agent hits this as soon as it replaces an old tool_result with [trimmed], because shortening an earlier tool result invalidates every thinking block that came after it.

The preserved thinking docs list what is safe. Appending messages is fine, and so is changing effort, max_tokens or tool_choice, moving cache_control markers, or letting server-side compaction and context editing trim content. Removing thinking blocks from the start or end of the history is allowed too, though the model loses that reasoning. Editing or deleting an earlier message, rebuilding the system prompt with today's date, adding or removing a tool in tools, and re-rendering context in the first user message are all edits. So is an unpinned MCP connector tool list that changes between requests, which breaks Fable 5.2's blocks but not Fable 5.1's. None of this touches you if Claude Code, the Claude Agent SDK, Claude Managed Agents or claude.ai manages the history.

How to Find the Edits Before You Switch

Start without an API key. Log the request bodies your integration sends over a few normal turns, then check that system and tools match and that each request's messages are an unchanged prefix of the next one's:

Python
Copy
# Compare consecutive request bodies the way the prefix check does:
# system and tools must match, and the older request's messages must be an unchanged prefix of the newer one's.
import json, sys

def clean(x):  # moving cache_control markers is allowed, so ignore them
    if isinstance(x, dict):
        return {k: clean(v) for k, v in x.items() if k != "cache_control"}
    return [clean(v) for v in x] if isinstance(x, list) else x

def first_edit(old, new):
    old, new = clean(old), clean(new)
    for key in ("system", "tools"):
        if old.get(key) != new.get(key):
            return f"`{key}` changed"
    for i, msg in enumerate(old["messages"]):
        if i >= len(new["messages"]) or new["messages"][i] != msg:
            return f"messages[{i}] ({msg['role']}) was edited or removed"
    return None

paths = sys.argv[1:]
for a, b in zip(paths, paths[1:]):
    edit = first_edit(json.load(open(a)), json.load(open(b)))
    print(f"{a} -> {b}: {edit or 'append-only, OK'}")

Run against two logged turns from the review agent, it points straight at the trimmed tool result:

text
Copy
logs/turn-01.json -> logs/turn-02.json: messages[2] (user) was edited or removed

The script is stricter than the API in one way: it flags thinking blocks removed from the start or end of the history, which the API allows. Then confirm against the API itself. Add the thinking-binding-controls-2026-08-01 beta header, set thinking.block_binding.prefix_mismatch_behavior to "drop_block", run a normal session, and log the top-level input_transformations array on each response. Every entry with reason: "prefix_binding_mismatch" is an edit to fix. The check works from any account, because setting prefix_mismatch_behavior opts the request in. This is the request shape from Anthropic's docs; I couldn't run it here without an API key:

Python
Copy
response = client.beta.messages.create(
    model="claude-fable-5-2",
    max_tokens=16000,
    thinking={"type": "adaptive", "block_binding": {"prefix_mismatch_behavior": "drop_block"}},
    messages=messages,
    betas=["thinking-binding-controls-2026-08-01"],
)
print(response.input_transformations)

In production, Anthropic suggests leaving the setting at its default, "error", if a mismatch can only mean a bug. "drop_block" keeps requests succeeding but makes the model re-create the lost reasoning, which raises output tokens, so use it as a stopgap. The real fix for our agent is to shorten a tool result before it's first sent, or to let server-side context editing clear old results.

The Other Changes That Return 400s or Drop Reasoning

Fallbacks lose Fable 5.2's reasoning. On the Claude API, Fable 5.2 reads thinking blocks from Fable 5.1 and Opus 5.5, but neither of them can read Fable 5.2's. When our agent falls back to Opus 5.5, the API drops those blocks, the request still succeeds, and the dropped tokens aren't billed. The first turn after teh switch runs without that reasoning, which usually costs more output. With the beta header, those drops show up as model_binding_mismatch. Anthropic's server-side fallback for Fable 5.2 (fallbacks: "default", in beta) only targets Opus 4.8 and Opus 5.

Computer use needs the new toolset. A computer_20251124 tool entry returns a 400 on every platform except Amazon Bedrock. Declare computer_toolset_20260801 instead, with no name or display dimensions and no beta header, then update your agent loop for the toolset.

Advisor pairs are locked. With the advisor tool (beta), a Fable 5.2 executor accepts only claude-fable-5-2 or claude-mythos-5-2 as its advisor; anything else, Fable 5.1 included, returns a 400 invalid_request_error. Changing the advisor's model is itself an edit to tools, so make it in new conversations. The reverse works: every executor model accepts Fable 5.2 as its advisor, which is a low-risk way to try it behind an Opus 5.5 agent. Its advice comes back encrypted.

Coming from Opus 5.5 adds two more. Fable 5.2 requires 30-day data retention, and an organization or workspace under zero data retention gets a 400 on every request until retention is configured. In organizations with customer-managed encryption keys, structured outputs (strict: true, output_config.format) aren't available on Fable 5.2.

Effort and Fast Mode Move the Bill More Than the Price Cut

Fable 5.2 defaults to high effort on the API, and Opus 5.5 defaults to medium. A request that omits effort runs one level higher after the switch, succeeds, and simply costs more. Claude apps and Claude Code use medium, according to the announcement. Set effort explicitly and re-run your effort sweep. Anthropic's guidance is to start at high, step up to xhigh only where you've measured a gain, and keep max for ceiling tests.

Three behavior changes are worth knowing before they show up on a dashboard. A prompt line like "answer directly without deliberating" no longer stops Fable 5.2 from thinking at medium and above, so lower the effort instead. Thinking counts toward max_tokens, so a small limit can end a response with stop_reason: "max_tokens" before any text arrives. And at xhigh and max in agentic coding products, Anthropic saw Fable 5.2 start subagents to review its own work, which can account for a large share of a session's cost.

Fast mode is one field: speed: "fast", no beta header. It delivers up to 2.5x higher output tokens per second at $16 / $80, but it doesn't improve time to first token, it has its own rate limit that returns a 429 with retry-after, and falling back to standard speed is a prompt cache miss, because the two speeds don't share cached prefixes. The response's usage.speed field tells you which one ran. For our review agent, fast mode doubles a review from $8.20 to $16.40 to get a comment back sooner, which nobody on the team would notice. For a developer pairing with an agent in real time, it can be worth it.

In Claude Code, /model fable (or claude --model fable) selects Fable 5.2. It needs Claude Code v2.1.321 or later, no plan uses a Fable model as its default, and on Pro, Max, Team and Enterprise plans a claude-fable-5-1 model saved in user settings moves to the fable alias automatically.

Conclusion

If Claude Code or the Agent SDK manages your conversations, switch to Fable 5.2 now: the prefix check doesn't apply, and the same work costs 20% less per token. If you run your own agent loop on the Messages API, run a drop_block test session first, fix every edit it finds, then check computer use, advisor pairs and fallbacks. If Opus 5.5 already does the job, stay on it and try Fable 5.2 as an advisor, setting effort explicitly before you compare bills. Under zero data retention, nothing works until a workspace has 30-day retention.

Related DevToolLab Tools

• JSON Diff - paste two logged request bodies and get the exact path, such as messages[2], that changed between turns.
• Prompt Caching Calculator - enter Fable 5.2's rates ($8 input, $10 cache write, $0.20 cache read) as custom prices to model your own prefix size and hit rate.
• JSONL Viewer - open a JSON Lines log of API responses as a searchable table and find the input_transformations entries the beta header adds.
• cURL to Code - turn the cURL examples in Anthropic's docs into Python, JavaScript or Go for a quick test.

Related Guides

• Claude Sonnet 5.5 vs Opus 5.5 for Coding
• Prompt Caching Guide
• Claude Fable 5 Shutdown Explained
• Best Open-Source Agent Harnesses