Fable 5.2 migration: what changes in the API and why you get 400 errors
Fable 5.2 migration from 5.1: model IDs by platform, four breaking changes, 400 errors and a developer checklist. Data as of 9 November 2026.

The Fable 5.2 migration starts with one line of code, the model ID, which moves from claude-fable-5-1 to the new claude-fable-5-2, and ends only once you have checked four points that can cause 400 errors. Claude Fable 5.2, released by Anthropic on 9 November 2026, has an API almost identical to 5.1's, but it changes how code can handle the conversation history. If Claude Code, claude.ai, Claude Managed Agents or the Agent SDK do the work for you, you do not need to act; if you build requests yourself, you need to run a test. The data comes from the “What's new” page of the documentation, read on 9 November 2026.
For the model overview (price, benchmarks, who it is for), see the article on Claude Fable 5.2; here we cover what breaks and how to fix it.
In summary
- The API ID is
claude-fable-5-2; on Amazon Bedrock it isanthropic.claude-fable-5-2(official page). - From Fable 5.1, four changes can break your code: the history prefix check, thinking blocks readable only by Fable 5.2 and Mythos 5.2, the old computer use tool, and an advisor that must be Fable 5.2 or Mythos 5.2 (documentation).
- Adaptive thinking cannot be turned off and forced
tool_choicereturns a 400 error, but if you are coming from Fable 5.1 or Opus 5.5 you do not need to change anything on these two points (documentation). - Compaction on demand and mid-conversation tool changes, both in beta, help keep the history append-only.
- The price goes down: $8 and $40 per million tokens against Fable 5.1's $10 and $50, according to the documentation.
- The safest entry points are a history test and a trial with real requests, before moving production traffic.
What actually changes when moving from Fable 5.1 to Fable 5.2?
Four things change that can make your code fail, according to the official documentation. The rest (1 million token context, 128K token maximum output, the tokenizer introduced with Claude Opus 4.7) is shared with the previous version or needs no action.
| Change from Fable 5.1 | What Happens | Where to fix it |
|---|---|---|
| Prefix check | Changing anything before a thinking block returns 400, on every account | Append-only history |
| Reading thinking blocks | Only Fable 5.2 and Mythos 5.2 read those of Fable 5.2 | Routers and fallbacks |
| Computer use | computer_20251124 returns 400 except on Amazon Bedrock |
Switch to computer_toolset_20260801 |
| Advisor | A Fable 5.2 executor accepts only Fable 5.2 or Mythos 5.2 as advisor | Tool definition |
Updating the ID is the last step, not the first: as long as your tests run on the old model, they tell you nothing about history compatibility.
Which model IDs should you use on each platform?
The ID changes depending on where you use the model. The official page and the “What's new” page list these values; Mythos 5.2 follows the same pattern.
| Platform | Fable 5.2 ID | Mythos 5.2 ID |
|---|---|---|
| Claude API | claude-fable-5-2 |
claude-mythos-5-2 |
| Amazon Bedrock | anthropic.claude-fable-5-2 |
anthropic.claude-mythos-5-2 |
| Claude Platform on AWS | claude-fable-5-2 |
not listed |
| Google Cloud (managed by Anthropic or by Google) | claude-fable-5-2 |
claude-mythos-5-2 |
| Microsoft Foundry | claude-fable-5-2 |
claude-mythos-5-2 |
On Microsoft Foundry, for deployments hosted by Anthropic, fast mode is a separate model: claude-fable-5-2-fast. Mythos 5.2 is instead reserved for verified organizations; the details are in Claude Mythos 5.2: what it is and who can use it.
The ID change is easy to see in code. This is the minimal change, the one the documentation shows for Python:
model = "claude-fable-5-1" # prima
model = "claude-fable-5-2" # dopo
Why does a request return the 400 error “The block is bound to a different conversation”?
Because your code changed something that comes before a thinking block produced by Fable 5.2. The API checks the history prefix: if the system prompt, the tools or an earlier message differ from when the model produced that block, the request is rejected with a 400 error whose text contains “The block is bound to a different conversation”. It applies to Fable 5.2 and Mythos 5.2 on any account, unless prefix_mismatch_behavior is set.
The surprising part is the age of the account. On Fable 5.1 the error only appears on accounts created from 31 August 2026 onwards, so code on an older account can work on 5.1 and break only after the switch.
The documentation says when nothing changes for you. All four of these conditions must hold:
- your code keeps
systemandtoolsunchanged throughout the conversation; - it only appends messages to
messages, never changing, reordering or removing earlier ones; - it sends each assistant turn back exactly as the API returned it, with every block and in the same order;
- it does none of the operations listed in the “What to check in your integration” section of the documentation.
The typical violation is code that “cleans up” the history: it shortens old messages, removes reasoning blocks, rewrites the system prompt on every turn.
How do you fix it, and what does “drop_block” do?
The real fix is to correct the change. As a fallback, the documentation describes a beta option: with the header thinking-binding-controls-2026-08-01 you assign the value "drop_block" to the field thinking.block_binding.prefix_mismatch_behavior. The API then discards the invalid blocks and carries on; the response lists each discarded block in the input_transformations. Anthropic warns that this is a stopgap, because dropping blocks can increase output tokens.
For the full test, the documentation points to the prefix check section of the migration guide from Claude Fable 5.1, cited on the “What's new” page. Price and benchmark differences are covered in Fable 5.2 vs Fable 5.1.
What happens to thinking blocks if I switch models mid-conversation?
Each thinking block records which model produced it, and a model reads only the blocks that are compatible with it. This is the behavior, according to the documentation for the Claude API and for Claude Models on Google Cloud managed by Google:
- Fable 5.2 and Mythos 5.2 read each other's blocks and those of Opus 5.5, Sonnet 5.5, Haiku 5.5, Fable 5.1, Mythos 5.1, Opus 5, Fable 5, Mythos 5 and earlier Opus, Sonnet and Haiku models.
- No other model reads Fable 5.2 blocks. Switching from Fable 5.2 to Opus 5.5, to Fable 5.1 or to the fallback models Opus 4.8 and Opus 5 loses the reasoning of the turns run on Fable 5.2.
- When a request carries a block that the model cannot read, the API discards it before the model sees it. The request succeeds and discarded blocks are not billed.
In addition, Fable 5.2 and Mythos 5.2 blocks work only in the account that produced them or in a linked account. If another account sends them, they are discarded; with the beta header mentioned earlier, input_transformations lists the reason organization_binding_mismatch.
With a router or an automatic fallback the consequence is practical: moving up to Mythos 5.2 preserves the reasoning, moving down to Opus 5.5 loses it. To work with several models in the same session, see Fable 5.2 as Advisor and Orchestrator.
How do you migrate computer use and the advisor?
These are two changes to make in the same pass as the ID change.
Computer use. Fable 5.1 accepts either the toolset computer_toolset_20260801 or, with the beta header computer-use-2025-11-24, the old tool computer_20251124. Fable 5.2 and Mythos 5.2 support only the toolset. A request that declares computer_20251124 receives a 400 invalid_request_error on every platform except Amazon Bedrock, where the old tool keeps working. The documentation's reference guide is called “Migrate from computer_20251124”. For what is worth automating and with which precautions, read Fable 5.2 and computer use and, for the test environment, Claude SDK with browser and computer use.
Advisor. With the advisor tool (in beta), the advisor must be at least as capable as the executor. A Fable 5.2 or Mythos 5.2 executor accepts only Fable 5.2 or Mythos 5.2 as advisor: any other, Fable 5.1 and Mythos 5.1 included, returns a 400 error invalid_request_error. If you move the executor, in the same change set the advisor to claude-fable-5-2 or claude-mythos-5-2. Changing the advisor is a change to tools: do it in new conversations, otherwise the prefix check triggers. The advice from a Fable 5.2 advisor arrives encrypted: if your code reads the advice text, see the “Result variants” section.
Thinking and tool_choice: when the error depends on where you start
Two rules apply to every request to Fable 5.2. If you start from Fable 5.1, Mythos 5.1 or Opus 5.5, there is nothing to change. Otherwise there is, and the documentation distinguishes by starting point:
| Starting model | Thinking always on | Forced tool_choice (any / tool) |
|---|---|---|
| Fable 5.1, Mythos 5.1, Opus 5.5 | already the case, no change | already the case, no change |
| Fable 5, Mythos 5 | already the case, no change | to change |
| Opus 5 and earlier Opus models | to change | to change |
The rules in practice:
- Adaptive thinking is always on. The
thinkingset withtype: "enabled"andbudget_tokens, or set withtype: "disabled", returns 400. Omitthinkingor send{"type": "adaptive"}, and control the depth witheffort. - Forced tool use is not supported. The
tool_choiceset withtype: "any"or withtype: "tool"returns a 400invalid_request_error. To get JSON that is valid against a schema, you leave the value{"type": "auto"}in the fieldtool_choiceand setstrict: true, or use JSON outputs. - Customer-managed encryption keys. In an organization that uses them, structured outputs are not available for Fable 5.2 and Mythos 5.2, neither with strict tool use nor with JSON outputs: remove
strictand validate the tool input in your own code.
To choose the effort level, which is the real cost dial after migration, see Fable 5.2: reasoning levels and effort.
Which beta features help avoid breaking the history?
Two beta features exist precisely to keep the history append-only, as the prefix check requires. The documentation presents them like this:
- Compaction on demand. With the header
compact-2026-09-04you decide when to replace the oldest turns with a summary, instead of trimming them by hand. - Mid-conversation tool changes. Add or remove tools with a
role: "system"message instead of editingtools. On the Claude API, on Claude Platform on AWS and on Claude Models on Google Cloud (managed by Anthropic) you need the headerinline-tools-2026-09-15; the headermid-conversation-tool-changes-2026-07-01applies to changes that name the tool by reference, on the platforms listed on the dedicated page.
Availability by model and platform must be checked on each feature's page. If you trim the history by hand today, compaction is the candidate to replace that logic.
How do costs and behavior change after migration?
The price goes down, but behaviour does not carry over: it has to be retested. Fable 5.2 costs $8 per million input tokens and $40 per million output tokens, against $10 and $50 for Fable 5.1 (source: official documentation, consulted on 9 November 2026). For the full calculation including caching, see Claude Fable 5.2 API pricing and real costs; for an estimation method that works for any model, AI API cost: how to calculate it.
The “What's new” page also points out behavior differences you see without changing the code:
- a prompt line such as “answer directly without deliberating” is not enough to stop thinking from medium effort upwards: at high effort or above, the model reasons before almost every reply;
- in long tasks a turn can end with a list of what remains or an offer to continue, more often at low and medium effort;
- a hard limit on sentence length can make prose choppy, and subagents can weigh on a session's cost.
These are the known limits we cover in Fable 5.2 known limitations and how to work around them. Before replacing Opus 5.5 with Fable 5.2, it is also worth rereading how to use Claude Opus 5.5: the documentation itself suggests starting from the latest Opus and moving to Fable when tests at higher effort are not enough.
An example: the in-house team of a software house integrating Claude into a CRM
An example, not a real case. A software house built for a client a CRM that calls Claude to summarize sales conversations and prepare email drafts. The service uses Fable 5.1 and, to keep cost down, trims the oldest messages on every turn and rewrites the system prompt with the client's updated data.
With Fable 5.2 this pattern produces 400 errors: the prefix changes on every turn. The team moves the client data into a new message, without touching the system prompt; replaces manual trimming with compaction on demand; removes every forced tool_choice used to obtain JSON, switching to strict: true and to the value auto for the field tool_choice. It then tests real requests in a separate environment and shifts traffic gradually.
Mistakes to avoid in the migration
- Changing only the ID and going to production. The history test is the essential part. An older account may never have seen the error on 5.1 and see it on the first day on 5.2.
- Using “drop_block” as the fix. It is a stopgap: it hides the change, does not remove it, and can increase output tokens.
- Switching between models mid-conversation without thinking about thinking blocks. Dropping down to Opus 5.5 loses the reasoning of the turns run on Fable 5.2.
- Forgetting the advisor. If the executor becomes Fable 5.2 and the advisor stays Fable 5.1, every request fails.
- Migrating prompts without rerunning the tests. “Don't think” lines or hard style limits behave differently on 5.2.
Migration checklist, in order
- Map where requests originate. Which parts use Claude Code, the Agent SDK or claude.ai (no action needed) and which ones build the history themselves in the array
messages. - Test the history. Run on your own code the prefix check test described in the migration guide, even if Fable 5.1 never raised an error.
- Check routers and fallbacks. Identify where a conversation can move to other models and what it loses.
- Move computer use to as
computer_toolset_20260801(except on Amazon Bedrock, if you want to keep the old tool). - Update the advisor: pick a
claude-fable-5-2orclaude-mythos-5-2model, in new conversations. - Remove forced
tool_choicesettings if you start from Fable 5, Mythos 5 or Opus 5 and earlier, andthinkingdisabled if you start from Opus 5 and earlier. - Rerun the tests with an effort sweep that starts from the level
high, the API default, and compare quality and cost with your baseline. - Change the ID and shift traffic gradually.
Where to start
The most useful move is just one: test the history with real requests, in a separate environment, before touching production. If your team does not have time to redo the tests, Giallo Studio can support it in reviewing the integration and in shifting traffic gradually.
Official pages change fast, and so do model versions: before acting, always check the up-to-date list of Claude models and the “What's new” page.
Giallo Studio guides: methodology and sources
Want to apply this to your business?In 30 minutes, free of charge: the first process to automate and its estimated return, in writing.
Book the free auditHow we apply it in the company
Related resources
Claude Fable 5.2: What It Is, What Changed and What It Costs
Fable 5.1 vs 5.2: what really changes and whether to upgrade
Claude computer use with Fable 5.2: letting the model operate a PC on its own
Claude Advisor Orchestrator: How to Use Fable 5.2 in AI Agents
Fable 5.2 effort levels: what they mean and how to choose
Claude Fable 5.2 limitations: the known ones and how to work around them
Claude Fable 5.2 Pricing: API Rates and Real Costs
Claude SDK browser and computer use classes: automating business softwareFAQ
Is changing the model ID enough to move from Fable 5.1 to Fable 5.2?
For the ID itself, yes: from claude-fable-5-1 to claude-fable-5-2. But the official documentation lists four changes that can make code written for 5.1 fail, including the check on earlier turns and the old computer use tool. If your code builds the messages array itself, test it before switching models.
Why does my request to Fable 5.2 return a 400 error?
The most frequent cause is a change to something that comes before a thinking block: the system prompt, the tools or an earlier message. In that case the error message says “The block is bound to a different conversation”. The other causes are disabled thinking, forced tool_choice, the computer_20251124 tool and an advisor other than Fable 5.2 or Mythos 5.2.
Can I turn off thinking on Fable 5.2?
No. Adaptive thinking is always on: thinking with type enabled or disabled returns a 400 error. Omit the parameter or send type adaptive, and control depth with the effort parameter. If you are coming from Fable 5.1, you do not need to change anything on this point.
What happens if I switch models mid-conversation?
The request works, but past reasoning may be lost. Fable 5.2 and Mythos 5.2 read each other's thinking blocks and those of many earlier models, while the other models, Opus 5.5 and Fable 5.1 included, discard those of Fable 5.2. Discarded blocks are not billed.
How do you use computer use with Fable 5.2?
Declare the computer_toolset_20260801 tool instead of computer_20251124. The old tool returns a 400 invalid_request_error on every platform except Amazon Bedrock. The official starting point is the “Migrate from computer_20251124” guide in the Anthropic documentation.
Which beta features help you migrate without breaking the history?
Two: compaction on demand, which lets you replace old turns with a summary when you decide, and mid-conversation tool changes through a message with role system. Both serve to keep the history append-only, as the prefix check requires. They are in beta and require dedicated headers.
Does the retirement of Fable 5.1 force me to migrate right away?
No. In the official pages consulted on 9 November 2026 there is no retirement date for Fable 5.1, so there is no deadline to cite. For Fable 5.2 the official page lists a retirement no earlier than 9 November 2027. It is worth testing the migration in a test environment, because the price of 5.2 is lower.