Claude Fable 5.1 to Fable 5.2: 4 Breaks and 6 Silent Changes to Re-Test

What to re-test before you move Messages API code from Claude Fable 5.1 to 5.2: the three changes that return a 400, the one that drops reasoning silently, the six behavior shifts that pass your tests, and how to measure cost per task.

Yash Amin
20 min

Anthropic's guide for moving from Fable 5.1 to 5.2 starts with one line: update your model ID. The very next step asks whether your code edits conversation history [1].

That second step is where teams get caught. Three changes in Fable 5.2 return a 400 error. One drops the model's reasoning without any error at all. Six more pass every test you already have, then change your output, your bill or what your UI shows.

Model upgrades shifting under you isn't new. When researchers at Stanford and Berkeley tested two versions of GPT-4 three months apart, accuracy on one math task fell from 84% to 51% [12]. Yet LangChain's survey of 1,340 teams found only 52% run offline evals on a test set before they ship [13].

If you're migrating from Fable 5.1 to 5.2, start with the quick check for whether any of this applies to you. Then work through the 10 changes, the 5-step re-test you can run today, and what one task actually costs on each model.

Fable 5.1 vs 5.2: What Changed and What Didn't

Anthropic released Claude Fable 5.2 (claude-fable-5-2) on November 9, 2026 [10]. Most of the API surface matches 5.1. The changes sit in four places: how strictly the API checks your history, which models can read 5.2's reasoning, two tool versions, and price.

What changed

AreaFable 5.1Fable 5.2Re-test?
Prefix check on edited history400 only on accounts created on or after Aug 31, 2026400 on every accountYes, if you build messages
Who can read its thinking blocksFable 5.2 can read 5.1's blocksOnly Fable 5.2 and Mythos 5.2Yes, if you route or fall back
MCP tool list changesNot treated as an editTreated as an editYes, test on 5.2
Computer usecomputer_20251124 or the toolsetToolset only; computer_20251124 is a 400 except on BedrockYes
Advisor toolAny supported advisorOnly claude-fable-5-2 or claude-mythos-5-2; advice is encryptedYes
Price per MTok (input / output)$10 / $50$8 / $40Re-baseline cost per task
Cache reads per MTok$0.25$0.20No
Fast modeNot in Anthropic's fast-mode model list$16 / $80, up to 2.5× output speedOptional
Rate limitsShared pool with Fable 5Its own poolYes, before cutover
Effort calibrationBaselineAt low, 5.2 scored close to 5.1 at higher effort on Anthropic's coding evalsYes, re-run the sweep

What stayed the same

1M token context, 128K max output, the same tokenizer, always-on adaptive thinking, five effort levels with high as the API default, no assistant prefill, no temperature / top_p / top_k, tool_choice limited to auto and none, refusal handling through stop_reason: "refusal", and the 30-day data retention requirement [2].

Two claims worth checking before you rely on them

You'll see posts saying the default effort moved from low to medium, and that the tool_choice default changed. Neither matches Anthropic's migration guide [2]. The API default is high on both models, and forced tool_choice (any or tool) was already a 400 on 5.1. Also, medium is the default in Claude Code and the Claude apps, not the API [11], so effort results from Claude Code aren't comparable to API calls that leave effort unset.

Most of these rows won't touch your code. The next section shows which ones will.

Do You Need to Re-Test?

It depends on who builds the request your app sends.

If Claude Code, claude.ai or the Agent SDK runs your loop

They manage the conversation history, so the prefix check changes nothing for you [1]. One condition from Anthropic's prefix-check docs: with the Agent SDK, the system prompt you pass in must stay the same across the conversation [4]. You still need to re-check cost, rate limits and the six behavior changes. Claude Managed Agents users only change the model name, plus the advisor model if they use one [2].

If your code builds the messages array

Everything on this page applies. Start with the prefix check in the next section. It is the change most likely to return a 400 on day one.

If you route between models, fall back or replay stored conversations

This is the group most exposed to the silent break. A router that sends a 5.2 conversation to 5.1 or Opus 5.5, or a replay through a different account, drops 5.2's reasoning without an error.

Decision tree: if Claude Code, claude.ai, Managed Agents or the Agent SDK manages your history, re-test cost, rate limits and the 6 silent changes only. Otherwise run the prefix-check test; if you switch models, fall back on refusals or replay stored conversations, read break 2; if you use computer use or the advisor tool, read breaks 3 and 4; then go to the 6 silent changes.
Three questions decide how much of this guide applies to you.

Find your setup

Your setupWhat breaks or drifts on 5.2Where to look
A support bot that summarizes old turns to save contextPrefix-check 400 on the next turnBreak 1
A system prompt that includes today's date400 on the first request after midnightBreak 1
A router with 5.2 primary and a 5.1 or Opus 5.5 fallbackReasoning dropped silently; the next turn costs more and runs slowerBreak 2
An eval pipeline replaying production conversations from another accountThinking blocks dropped with no errorBreak 2
A computer-use agent on the Claude API or Google Cloud400 on computer_20251124Break 3
A long-running coding agent with a chat UI that renders only textEnds turns early; UI looks frozen between tool callsSilent changes 3 and 6
A planner at xhigh or max that can spawn subagentsMore subagents, higher costSilent change 5

If a row matched, here's what fails first.

The 4 Breaking Changes (3 Return a 400, 1 Fails Silently)

Three of these show up in your error logs. The fourth doesn't, which makes it the one to check first if you route between models.

1. The prefix check now applies to every account (400)

On 5.1, the API enforced this check by default only for accounts created on or after August 31, 2026. On older accounts, an edited history reached the model with no error [10]. On 5.2 it's enforced for everyone. So code that edits history can pass on 5.1 and fail on 5.2 with no other change. Anthropic ties the change to its anti-distillation work: it stops callers from editing Claude's earlier context to pull out its reasoning [11].

What “The block is bound to a different conversation” means

A thinking block is valid only against the exact system prompt, tools and messages that came before it when Claude wrote it. Anthropic calls that content the block's prefix [4]. Change the prefix, send the old block back, and you get:

Calculation
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 error has no error_code. Match only the substring The block is bound to a different conversation, because Anthropic says the rest of the text can change. Retrying the same request body fails the same way [2].

Which history edits trigger it

EditTriggers the 400?Append-only alternative
Changing one word of a tool descriptionYesBuild tools once per conversation
Today's date in the system promptYes, after midnightPut the date in a new user message
Summarizing or trimming turns in placeYesUse the API's threshold compaction or context editing, which don't count
Deleting, moving or editing an earlier messageYesAppend a correction as a new message
Dropping a thinking block from the middleYesDrop only the oldest, the newest or all of them
Stripping thinking blocks with empty textYesSend each assistant turn back exactly as returned
Changed content at the same file URLYesUse a new URL for new content
Changing model, effort, max_tokens, metadata or cache_controlNoNot needed
Appending a new turnNoNot needed

Anthropic's rule for staying safe has three parts: send each assistant turn back exactly as the API returned it, build system and tools once per conversation, and put every update in a new message at the end [4]. If your harness compacts context today, our guide to context engineering for production agents covers the append-only patterns in more depth.

Two conversation timelines. Append-only history (system and tools, turn 1, turn 2, new turn appended) passes. Edited history, where turn 2 is summarized in place, makes the turn 3 thinking block fail with 'The block is bound to a different conversation.'
Appending passes. Editing any earlier turn invalidates every thinking block after it.

MCP tool lists: test this on 5.2, not 5.1

With the MCP connector, a server whose tool list changes between requests counts as an edit for Fable 5.2 blocks only. Fable 5.1 and Opus 5.5 don't flag it [2]. A pre-switch test on 5.1 passes, and production on 5.2 fails. Run the test against claude-fable-5-2, or pin the server's tool list.

2. Older models can't read 5.2 thinking blocks (silent)

Fable 5.2 reads thinking blocks from 5.1, Opus 5.5 and other earlier models, so a conversation moving up to 5.2 keeps its reasoning. The reverse doesn't work. No model except Fable 5.2 and Mythos 5.2 can read 5.2's blocks. That includes Fable 5.1, Opus 5.5, and Fable 5.2's own refusal fallbacks, Opus 4.8 and Opus 5 [1].

When a request carries a block the model can't read, the API drops it and the request succeeds. The dropped block isn't billed, but the migration guide warns the next turn “can raise cost and latency” because the model works without that reasoning [2].

Matrix of who can read thinking blocks. Fable 5.2 blocks are kept by Fable 5.2 and Mythos 5.2, and dropped by Fable 5.1, Opus 5.5, and the Opus 4.8 and Opus 5 fallbacks. Fable 5.1 blocks are kept by Fable 5.2 and Fable 5.1. Opus 5.5 blocks are kept by Fable 5.2 and Opus 5.5.
Moving up to 5.2 keeps reasoning. Moving away from 5.2 drops it. Documented for the Claude API and Google Cloud (Google managed).

The same thing happens across accounts. Fable 5.2 blocks work only in the account that produced them, or one linked to it. On the Claude API the account is the organization; on Bedrock, the AWS account; on Google Cloud (Google managed), the project. Replay a conversation through a different one and the blocks drop with no error [6].

Anthropic's advice: keep sending the whole conversation. Don't strip blocks yourself, and don't keep a separate history per model. Blocks become readable again when the conversation returns to a model that can read them [6].

3. computer_20251124 returns a 400 (except on Bedrock)

5.1 accepted both the old tool and the new toolset. 5.2 accepts only computer_toolset_20260801, except on Amazon Bedrock. The upgrade is more than a rename [9]. You remove the beta header, drop the display fields, dispatch on name + toolset_name, add "toolset_name": "computer" to every tool_result, stop at the first failed action in a turn, and resize screenshots yourself. Zoom is now on by default. The toolset adds about 4,520 input tokens per request, and turning zoom off saves about 410 of them.

Changing tools is an edit (break 1), so roll this out in new conversations only.

4. The advisor must be claude-fable-5-2 or claude-mythos-5-2 (400)

A Fable 5.2 executor accepts only a 5.2 advisor. claude-fable-5-1 as advisor returns a 400. A 5.2 advisor also returns its advice encrypted, so any code that logs or parses the advice text has to change [1]. Changing the advisor model is an edit to tools, so switch it in new conversations.

Those four show up in logs, or in the test later on this page. The next six don't.

The 6 Silent Changes That Pass Your Tests

These come from Anthropic's own testing, reported in its Fable 5.2 prompting guide [3]. We haven't found an independent replication yet, which is one more reason to run them on your workload.

1. Effort levels are recalibrated

  • What you'll see: different quality and token use at the same effort value.
  • Why: the levels rank the same way, but the amount of thinking at each level differs. At low, 5.2 scored close to what 5.1 did at higher effort on Anthropic's coding evals. xhigh raised scores slightly and used many more tokens [7].
  • Test: set effort: "high" explicitly and run your evals at medium and xhigh too. Don't carry 5.1 settings over.

2. “Think less” lines are ignored at medium and above

  • What you'll see: responses with stop_reason: "max_tokens" that contain a thinking block and no text.
  • Why: 5.1 usually followed a line like “answer directly without deliberating”. 5.2 keeps thinking at medium and above, and at high it thinks before almost every reply, greetings included. Thinking counts toward max_tokens [3].
  • Fix: remove the line, lower effort, or raise max_tokens.

3. It stops early on long tasks

  • What you'll see: a turn that ends with a list of what's left, an offer to continue, or a stop at an ordinary obstacle. It happens more at low and medium.
  • Fix: add Anthropic's “Finishing work” system-prompt text. In Anthropic's replay of coding sessions at medium, about half as many sessions ended with work left undone. Output tokens rose about 30%, so measure the cost [3].

4. Approval rules are read literally, and caution piles up

  • What you'll see: an agent that asks permission for routine work, or refuses to retry.
  • Why: in one of Anthropic's simulated tasks, a rule saying “sending messages to people outside this conversation” needs approval made the model hold back about half of its routine messages to colleagues. Old notes like “never retry” in memory files get followed closely too, mostly in multi-agent setups [3].
  • Fix: name the exact actions that need approval, name the steps that don't, and write exceptions into “never” rules. Approve with specifics, not “continue”.

5. More subagent delegation at xhigh and max

  • What you'll see: more subagent calls and a higher bill on the same task.
  • Why: at xhigh and max, 5.2 used subagents to review its own work. 5.1 didn't on the same tasks [3].
  • Fix: review your delegation instructions. In Anthropic's test, a longer, cost-focused subagent tool description roughly halved the number of subagents at high. Subagents normally start their own conversations, so they don't inherit 5.2's thinking blocks.

6. Progress updates arrive as thinking blocks

  • What you'll see: a UI that looks frozen during long turns.
  • Why: 5.2 sends updates between tool calls as progress-update thinking blocks. Under the default display: "omitted" those blocks are empty, so a client that renders only text shows nothing [3].
  • Fix: set thinking.display to "updates" (beta thinking-display-updates-2026-08-18) or "summarized", and render the non-empty thinking blocks. thinking.display isn't part of the prefix, so changing it doesn't trigger the 400.

Now the test that catches all ten.

How to Re-Test: A 5-Step Framework

Run these in order. Step 1 catches the 400s, Steps 3 and 4 catch the drift, and Step 5 covers the paths a normal test run never reaches.

Step 1. Run the prefix-check test on claude-fable-5-2

The beta header thinking-binding-controls-2026-08-01 plus prefix_mismatch_behavior: "drop_block" turns each failure into a logged entry instead of a 400. Every response then includes a top-level input_transformations array: [] when nothing was dropped, one entry per dropped block otherwise [6].

bash
curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2026-10-21" \
  -H "anthropic-beta: thinking-binding-controls-2026-08-01" \
  -H "content-type: application/json" \
  -d @request.json | jq '.input_transformations'
json
{
  "model": "claude-fable-5-2",
  "max_tokens": 16000,
  "thinking": {
    "type": "adaptive",
    "block_binding": { "prefix_mismatch_behavior": "drop_block" }
  },
  "system": "...the exact system prompt your app sends...",
  "messages": [ "...the exact history your app sends on this turn..." ]
}

Send the request bodies your app really builds, not hand-written ones. Capture them at the point where your code calls the API.

Prove the test can fail first

A clean result proves nothing if a proxy stripped the header or the session had no thinking blocks [5]. So break one conversation on purpose: replay a real turn with the first user message edited. You should get an entry like this:

json
[{ "type": "thinking_dropped", "path": "messages.2.content.0", "reason": "prefix_binding_mismatch" }]

If it comes back [], the check isn't running on your path. Fix that before you trust any other result.

Reading the result

reasonMeaningAction
prefix_binding_mismatchYour code changed the historyFind the edit (see the table in break 1) and make it append-only
model_binding_mismatchThe conversation moved to a model that can't read the blockExpected after a switch away from 5.2; decide if the cost is acceptable
organization_binding_mismatchThe block came from another accountReplay through the account that produced it

path indexes the messages array as you sent it, so messages.7.content.0 points at the block right after the edit. Cover the sessions that compact, add tools late, change instructions, switch models or resume from storage. Plain back-and-forth turns don't reach that code.

Step 2. Fix each edit, then go back to "error"

"drop_block" is a stopgap. Dropped blocks aren't billed, but the model can spend more output tokens working out again the reasoning it lost, and the drop invalidates the prompt cache from that point on. Anthropic gives no figure for the extra cost and says to run your own evals before relying on it [5].

Once Step 1 comes back clean, set production to "error" (the default) and alert on the 400 substring. Don't retry prefix errors: the same body fails the same way every time.

Message Batches drop blocks silently

A batch item with the setting unset never returns the 400. The API drops the blocks instead. Set "error" explicitly if you want batch items to fail [4].

Step 3. Remove 5.1-era prompt lines

Prompts tuned for 5.1 or Opus 5.5 carry lines that now cost you tokens or quality. Three to look for:

The code-ownership sentence. With “You are the owner and long-term maintainer of this codebase, and its design is up to you.”, Anthropic saw 5.2 merge repeated code in about three quarters of tries (under a tenth without), use 1.7 to 1.8 times the output tokens, and change an existing feature's behavior in one of every six to ten tries [3]. Keep it only where the agent should own the design, and review the diff, not the summary.

diff
- You are the owner and long-term maintainer of this codebase, and its design is up to you.
+ Make the requested change with the smallest diff. Report nearby problems; don't fix them.

Token budgets written into the prompt. Removing a large budget shown in the prompt lowered cost at equal performance in Anthropic's coding tests [3].

diff
- You have a budget of 200,000 tokens for this task. Track your usage.
+ (line removed: let effort control depth)

“Treat that answer as done” lines from the Opus 5.5 prompting guide. They cut follow-up thinking, but made the model “far less likely to point out mistakes in its earlier answers” [3].

diff
- Once you have answered, treat that answer as done and move on.
+ If you find a mistake in an earlier answer, say so and correct it.

Also check for “think less” lines (silent change 2), hard style rules like “one instruction per sentence, 20 words max”, and stale “never” notes in memory files. Make all prompt and tool changes in new conversations or as an appended system message. Editing system mid-conversation is itself a prefix edit.

Step 4. Re-run the effort sweep on your own evals

Set effort: "high" explicitly, then run the same task set at medium and xhigh [7]. A minimum regression suite for this migration records, per run:

MetricWhy it matters hereExample threshold
Pass rate on your task setQuality at each effort levelNo drop vs the 5.1 baseline
Output tokens per taskThinking and the prompt fixes add tokensWithin your cost budget (next section)
Latency per task5.2 claims up to 30% faster output; more thinking can offset itNo slower than 5.1 at p95
Unfinished-task rateSilent change 3Lower than or equal to 5.1
max_tokens stops with no textSilent change 2Zero
Subagent calls per taskSilent change 5Within budget

Add Anthropic's fixes one at a time and measure each one's token cost. Several of them raise output by 20% to 80%. For the wider method, see our guide on benchmarking a candidate model against your own workload.

Step 5. Check the UI and routing paths

  • Progress display: set thinking.display to "updates" or "summarized" and confirm the UI renders the non-empty thinking blocks.
  • Fallbacks and routers: confirm that every route from 5.2 to 5.1, Opus 5.5, Opus 4.8 or Opus 5 is acceptable without the earlier reasoning, and check first-turn cost after a switch.
  • Stored conversations: resume a few stored conversations after your prompt or tool changes. If system or tools changed, they'll hit the 400.
  • MCP: run Step 1 against 5.2 with a changing tool list, or pin the list.
  • Refusals: keep handling stop_reason: "refusal". With an explicit fallbacks list, 5.2 permits only claude-opus-4-8 and claude-opus-5 [2].

Tools for the re-test

ToolUse it for in this migration
thinking-binding-controls beta + input_transformationsFinding every history edit that trips the prefix check (Step 1)
/v1/messages/count_tokensA free first pass: it runs the same prefix check and returns the same 400 in "error" mode
response.usage logs or Anthropic's Usage and Cost APICost-per-task baseline, 5.1 vs 5.2
PromptfooRunning the same test set against both model IDs from a config file, in CI
DeepEvalpytest-style pass/fail assertions on outputs
BraintrustComparing experiment runs side by side to spot regressions
Langfuse or LangSmithTracing long agent runs to find early stops and subagent fan-out

The full checklist

Fable 5.1 to 5.2 re-test checklist. Returns a 400 or drops reasoning (4): prefix-check test passes on claude-fable-5-2 including MCP tool lists; every route away from 5.2 and every cross-account replay is checked; computer_20251124 replaced with computer_toolset_20260801; advisor set to a 5.2 model and no code reads the advice text. Passes and drifts (6): effort sweep re-baselined; think-less lines removed with no max_tokens stops without text; early stops checked; approval rules name exact actions; subagent count and cost checked at xhigh and max; progress updates render in the UI.
Four checks for the breaks, six for the drift.

Returns a 400 or drops reasoning (4)

  • Prefix-check test passes on claude-fable-5-2, including MCP tool lists, after proving it can fail.
  • Every route away from 5.2, and every cross-account replay, is checked and accepted.
  • computer_20251124 replaced with computer_toolset_20260801 (off Bedrock), in new conversations.
  • Advisor set to a 5.2 model, and no code reads the advice text.

Passes and drifts (6)

  • Effort sweep at medium / high / xhigh re-baselined.
  • “Think less” lines removed; no max_tokens stops without text.
  • Early stops checked on the longest tasks.
  • Approval rules name exact actions; stale “never” notes removed.
  • Subagent count and cost checked at xhigh / max.
  • Progress updates render in the UI.

Step 4 gives you token counts. Here's what they cost.

Fable 5.2 Costs Less per Token. Re-Test Cost per Task First

Fable 5.2 is 20% cheaper per token: $8 / $40 per million input and output tokens against 5.1's $10 / $50 [1]. That doesn't make each task 20% cheaper.

The break-even point is 25% more tokens

Because both prices fall by the same 20%, the math is simple: if a task uses 25% more tokens on 5.2 than on 5.1, it costs the same. Above 25% more, 5.2 costs more.

Several of Anthropic's own recommended fixes cross that line on output tokens alone [3]. The “Finishing work” text adds about 30%. The code-ownership sentence adds 70% to 80%. The opening and recap text for progress updates adds about 20%. "drop_block" adds an unmeasured amount on every turn it fires.

Bar chart of one example task with 40,000 input and 12,000 output tokens. Fable 5.1 costs $1.00. Fable 5.2 with the same tokens costs $0.80. Fable 5.2 with the Finishing work text (+30% output) costs $0.94. Fable 5.2 with the code-ownership sentence (+75% output) costs $1.16, past break-even.
Illustrative arithmetic at list prices, not a measurement. Your Step 4 numbers decide this.
Example task (illustrative)Input tokensOutput tokensCost
Fable 5.140,00012,000$1.00
Fable 5.2, same tokens40,00012,000$0.80
Fable 5.2 + “Finishing work” text (+30% output)40,00015,600$0.94
Fable 5.2 + code-ownership sentence (+75% output)40,00021,000$1.16

Where the extra tokens come from

  • Thinking on more turns. At high and above, 5.2 thinks before almost every reply.
  • Dropped blocks. After a fallback or a "drop_block" drop, the model works the reasoning out again.
  • Prompt fixes. The +20% to +80% figures above.
  • Subagents. More of them at xhigh and max.
  • Computer use. About 4,520 extra input tokens per request with the default toolset.

For context, Anthropic's launch post claims 5.2 at High effort roughly matched Opus 5.5 at Max on its FrontierCode benchmark “for roughly half the cost per task” [11]. That's a vendor benchmark, not your workload. Your Step 4 numbers decide this.

If the numbers pass, ship it without losing reasoning mid-conversation.

Rolling Out: Rate Limits, Canary and Rollback

Anthropic's migration guide doesn't cover rollout, so this section is our practice, not Anthropic guidance.

Check the separate rate-limit pool first

Fable 5.2 has its own rate limit, separate from the pool Fable 5.1 and Fable 5 share. The listed standard values match 5.1's: 4,000 RPM at the Start tier, 10,000 at Build, 13,000 at Scale [8]. Check your actual limits on the Console's Rate limits page. Ramp limits can also cap how fast usage on a model grows, returning a 429 with ramp_limit_exceeded. With a brand-new pool, moving all traffic at once is the easiest way to meet one.

Canary by new conversation, not by request

Move a share of new conversations to 5.2 and keep existing ones on 5.1 until they end. Splitting by request moves live conversations between models. A move up to 5.2 is fine, but a move back down drops 5.2's reasoning.

Rollback has a cost

You can switch back to 5.1 at any time. Conversations that started on 5.2 continue on 5.1 without 5.2's reasoning, so expect higher cost and latency on their next turn. Roll back new conversations first, and let in-flight 5.2 conversations finish where you can.

Eight ways teams get this wrong:

Mistakes to Avoid

01

Running the pre-switch test on 5.1

It won't catch MCP tool-list changes, which only Fable 5.2 treats as an edit.

02

Swapping the model ID and running only a smoke test

Plain turns don't reach compaction, resume or model-switch code.

03

Trusting a clean test you never proved can fail

A header stripped by a proxy looks exactly like a clean result.

04

Comparing cost per token instead of cost per task

Past 25% more tokens, Fable 5.2 costs more than 5.1.

05

Leaving drop_block on in production

It hides the bug and raises output tokens on every turn it fires.

06

Retrying prefix errors

The same request body fails the same way every time.

07

Stripping empty thinking blocks, or replaying through another account

Both drop reasoning. The first returns a 400, the second fails silently.

08

Cutting over before checking the rate-limit pool

Fable 5.2 has its own pool, and ramp limits cap how fast usage on it can grow.

So, switch or not?

Switch Now, Wait, or Choose Opus 5.5?

Anthropic's benchmarks show large gains on agentic coding, such as 49.1% vs 32.4% on FrontierCode 2.0 at xhigh [11], but we found no independent 5.1-vs-5.2 comparison yet. Let your own re-test decide.

Switch now

Your harness is already append-only, the prefix-check test comes back clean, and the effort sweep shows equal or better quality at a cost per task you accept.

Wait a sprint

The test found history edits, or you route between models or replay stored conversations. Fix those first, or you trade a working 5.1 setup for 400s and silent reasoning loss.

Choose Opus 5.5

Your cost-per-task test fails your budget on Fable 5.2 at every effort level that passes your quality bar. Opus 5.5 can't read 5.2's thinking blocks, so pick per new conversation, not per request.

If you'd rather have someone else run this re-test on your harness, our AI model migration service does exactly this.

Want the Fable 5.2 Re-Test Run on Your Harness?

Crescent AI runs the prefix-check test, the effort sweep and the cost-per-task comparison on your own traffic, then tells you whether to switch, wait or route.

Sources

  1. [1] What's new in Claude Fable 5.2 — Anthropic Platform Docs
  2. [2] Claude Fable 5.2 and Claude Mythos 5.2 migration guide — Anthropic Platform Docs
  3. [3] Prompting Claude Fable 5.2 — Anthropic Platform Docs
  4. [4] Prefix checks on thinking blocks — Anthropic Platform Docs
  5. [5] Fix a thinking block bound to a different conversation — Anthropic Platform Docs
  6. [6] Preserved thinking — Anthropic Platform Docs
  7. [7] Effort — Anthropic Platform Docs
  8. [8] Rate limits — Anthropic Platform Docs
  9. [9] Computer use tool: migrate from computer_20251124 — Anthropic Platform Docs
  10. [10] Claude Platform release notes — Anthropic, 2026
  11. [11] Introducing Claude Fable 5.2 and Claude Mythos 5.2 — Anthropic, November 2026
  12. [12] How is ChatGPT's behavior changing over time? — Chen, Zaharia & Zou, Stanford / UC Berkeley, arXiv 2023
  13. [13] State of Agent Engineering — LangChain, survey of 1,340 respondents, 2025

Frequently Asked Questions

On Anthropic's benchmarks, yes: for example 69.9% vs 56.3% on FrontierSWE v2 and 74.2% vs 65.6% on Humanity's Last Exam with tools. Those are vendor-run numbers at each model's highest effort, and no independent 5.1-vs-5.2 study existed when we checked. Run your own evals before you switch.
Often, yes. It thinks before almost every reply at high effort and above, and several of Anthropic's recommended prompt fixes add 20% to 80% output tokens. Because the price fell 20%, Fable 5.2 costs the same as 5.1 at 25% more tokens per task, and more beyond that.
It is if Claude Code, claude.ai, Managed Agents or the Agent SDK manages your conversation history and you don't use computer use or the advisor tool. If your code builds the messages array, run the prefix-check test first, because Fable 5.2 enforces it on every account.
On Fable 5.1, the prefix check was enforced by default only for accounts created on or after August 31, 2026, so older accounts could edit history with no error. On Fable 5.2 the check applies to every account, so the same edited history now returns a 400.
Your request sent back a thinking block whose prefix changed: the system prompt, the tools or an earlier message differs from when Claude wrote the block. Find the edit with the drop_block test and make your history append-only. Retrying the same request body won't help.
For the prefix check, no: they manage history for you. With the Agent SDK, keep the system prompt you pass in the same across a conversation. You should still re-check cost, rate limits and the six behavior changes, and update the advisor model if you use one.
Yes, the request succeeds. But Fable 5.1 can't read Fable 5.2's thinking blocks, so the API drops them and the next turn runs without that reasoning, at higher cost and latency. Roll back by new conversation where you can.
Run both on your own task set at the effort levels you'd use. Anthropic reports Fable 5.2 at high effort roughly matching Opus 5.5 at max on one coding benchmark at about half the cost per task. If Fable 5.2 fails your budget at every effort level that passes your quality bar, Opus 5.5 is the safer choice.

We use analytics cookies to understand how visitors use the site. No ads or retargeting. Learn more