One read of Claude Developer Platformapi-20261109T190724Z

build-with-claude/fallback-credit Changed · +8 / -6 lines

build-with-claude/fast-mode Changed · +16 / -10 lines

build-with-claude/mid-conversation-system-messages Changed · +12 / -10 lines

build-with-claude/multilingual-support Changed · +17 / -15 lines

build-with-claude/preserved-thinking Changed · +139 / -116 lines

### When `prefix_mismatch_behavior` is unset ### What to check in your integration #### What else happens when `prefix_mismatch_behavior` is unset ### Resume a saved session ### Which model switches keep the reasoning on the Claude API #### Earlier models ### See which blocks were dropped #### When `prefix_mismatch_behavior` is unset

build-with-claude/prompt-caching Changed · +8 / -4 lines

build-with-claude/prompt-engineering/claude-prompting-best-practices Changed · +24 / -8 lines

build-with-claude/prompt-engineering/prompting-claude-fable-5-1 Changed · +6 / -6 lines

build-with-claude/prompt-engineering/prompting-claude-fable-5-2 New page · 210 lines, new page

## Calibrate effort ## Finish the whole task ### Approvals ## Say who owns the code ## Keep users informed during long turns ## Set expectations for subagents ## Keep caution from piling up ## Review instructions written for earlier models ## Make reports easy to follow ## Safeguard refusals ## Where to start

A whole new page. There's nothing to diff it against, so here is what it says.

---
title: Prompting Claude Fable 5.2
url: https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5-2
description: "Prompting patterns specific to Claude Fable 5.2 and Claude Mythos 5.2: effort, early stopping, approvals, code ownership, progress updates, subagents, caution that builds up, instructions written for earlier models, final reports, and refusals."
---

This guide covers the prompting patterns specific to Claude Fable 5.2. For the model’s capabilities and API changes, see [What’s new in Claude Fable 5.2](https://platform.claude.com/docs/en/models/fable-5-2/whats-new-fable-5-2). For techniques that apply across all current Claude models, see [Prompting best practices](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/claude-prompting-best-practices).

Claude Fable 5.2 behaves differently from earlier models in a few ways. Start with the section that matches what you observe:

* Unsure which effort level to run, or easy requests take too long: [Calibrate effort](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5-2#calibrate-effort)
* A turn ends before the work is done: [Finish the whole task](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5-2#finish-the-whole-task)
* You approve steps as the agent works, or your system prompt has approval rules: [Approvals](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5-2#approvals)
* A coding agent repeats existing code instead of merging it, or reports nearby problems without fixing them: [Say who owns the code](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5-2#say-who-owns-the-code)
* Long agentic turns look silent: [Keep users informed during long turns](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5-2#keep-users-informed-during-long-turns)
* Agent sessions start more subagents than the task needs: [Set expectations for subagents](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5-2#set-expectations-for-subagents)
* Agents ask for approvals they don’t need, or hold back routine work: [Keep caution from piling up](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5-2#keep-caution-from-piling-up)
* You carry over a system prompt, skills, or a harness written for Claude Fable 5.1 or Claude Opus 5.5: [Review instructions written for earlier models](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5-2#review-instructions-written-for-earlier-models)
* Your users read final reports or handoffs after long tasks: [Make reports easy to follow](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5-2#make-reports-easy-to-follow)
* Requests return `stop_reason: "refusal"`: [Safeguard refusals](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5-2#safeguard-refusals)

<Note>
  For the API changes when you migrate from an earlier model, see the [Claude Fable 5.2 and Claude Mythos 5.2 migration guide](https://platform.claude.com/docs/en/models/fable-5-2/migration-guide). For the order in which to apply this guidance when you migrate, see [Where to start](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5-2#where-to-start).

  Several sections on this page suggest text to add to your system prompt, lines to remove from it or from the notes and rules your agents carry, or changes to a tool description. Make these changes in new conversations only. On Claude Fable 5.2, the API enforces the [prefix check](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#prefix-check) for every account. A request that sends thinking blocks back after `system`, `tools`, or an earlier message changed can return a 400 error, so a stored conversation resumed with the new text can fail. To change instructions partway through a conversation, [put them in the newest turn](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#changing-context). Where [mid-conversation system messages](https://platform.claude.com/docs/en/build-with-claude/mid-conversation-system-messages) are available, you can instead [append a system message to the conversation](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#new-instructions).
</Note>

## Calibrate effort

Start at `high`, the default on the Claude API. If your use case calls for it, move effort up or down, and test each change against your own evals. The [effort](https://platform.claude.com/docs/en/build-with-claude/effort) level sets how much Claude Fable 5.2 thinks, how long a turn takes, and how many tokens it uses. Tune effort alongside your prompt, because the level also changes the way the model thinks and how many tool calls it makes.

In general, effort levels run in the same order across Claude models, but the amount of thinking behind each level can differ from model to model. So rerun your effort sweep instead of carrying over a setting you tuned on Claude Fable 5.1 or Claude Opus 5.5.

Choose a level by the kind of work:

* `low` suits quick back-and-forth, well-specified tasks, and high-volume workloads, such as fast, intelligent subagents. In Anthropic’s testing, the model’s scores at `low` sat close to Claude Fable 5.1’s scores at higher effort levels.
* `medium` suits interactive coding, chat, and everyday knowledge work.
* `high` suits hard coding, research, agentic work, and long unattended runs. Turns take noticeably longer to finish than at `medium`.
* `xhigh` is for your hardest long-running coding and agentic work, where you’ve measured a gain. On Anthropic’s internal coding evaluations, it raised scores slightly and used many more tokens.
* `max` is for measuring the model’s ceiling, or for the rare task where time and tokens don’t matter. It best suits open-ended problems, such as scientific discovery and mathematics. Turns are slow and use many more tokens than at `xhigh`.

Most of the gain in capability is already present at `high`. The step from `medium` to `high` raised scores on most of the coding and knowledge-work evaluations that Anthropic tracks. That step also uses more tokens and more time, so move down to `medium` wherever your evals show that quality holds. Above `high`, gains are uneven and depend on the task.

When you choose a level, note three behaviors:

* The model is more likely to stop early at lower effort levels. For agentic work at `low` or `medium`, add the text in [Finish the whole task](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5-2#finish-the-whole-task).
* At `high` and above, the model thinks before almost every reply, including a reply to a greeting. If easy requests take too long or cost too much, use a lower effort level for those turns. In Anthropic’s testing, an instruction to answer directly without deliberating didn’t stop the model from thinking at `medium` and above.
* Effort barely changes how long the model’s replies are. To change the length and tone of a reply, use your prompt.

You can also mix levels in one workflow. For example, you might plan and iterate with the model at `medium`, then raise effort for the long, unattended part. To change levels within a conversation and keep the prompt cache, use a [per-message effort change](https://platform.claude.com/docs/en/build-with-claude/effort#change-effort-mid-conversation-beta) (beta, `mid-conversation-output-config-2026-07-01` header); that section lists the platforms where it’s available. A change holds until another one replaces it. Where per-message effort isn’t available, set a new top-level `effort` value on the next request, which starts the cache over.

## Finish the whole task

On long, multistep tasks, Claude Fable 5.2 sometimes ends a turn before the work is done. The turn closes with a list of what remains, an offer to continue, or a stop at an ordinary obstacle such as a timeout. This occurs more often at `low` and `medium` effort.

If you see these stops in your agent, add text like this to your system prompt:

```text wrap
# Finishing work
Please avoid stopping while you still owe work the user asked for. Be persistent and do not stop unless needed.

While status notes are welcome, as is clarifying with the user on open decisions, carry on with work that does not depend on the user's answer without unnecessary stops.

If you notice yourself inviting the user to redirect you or offering to wait, instead proceed on the next part of the task. You may meet ordinary obstacles like errors, timeouts, locked files, empty results or failing tools. Diagnose them first, and when they are not real blockers, work through them with the access you have (wait and retry, fix the request, use another tool or source) rather than stopping unnecessarily.

If someone clearly decided something is a hard blocker, such as a file marked not to be touched, access that was intentionally withheld, or a safety guardrail, leave it alone, say plainly what you found, and look for another safe way to finish the task. Stopping before the task is complete is very rarely merited, as in when the task can't move forward without user input, or where the blocker is deliberate and should not be worked past. This does not override the need for confirmation on risky or destructive actions.
```

This text separates two kinds of obstacle. It tells the model to diagnose and work through ordinary obstacles, such as errors, timeouts, and failing tools. It tells the model to leave deliberate blockers alone, such as a file marked not to be touched, and to report them. Treat the text as a starting point, and keep that distinction when you adapt it to your application.

Anthropic replayed recorded sessions from an agentic coding product at `medium` effort. With a version of this text, about half as many sessions ended with doable work left. The text removed most endings that ask permission or offer to continue, but not endings that list what remains and then stop. Output tokens rose by about 30 percent.

Because the model asks less often with this text, keep your own confirmation step for risky or irreversible actions.

### Approvals

When you tell the model to keep going, say clearly what you want from it instead of sending a bare “continue.” For example, reply “Yes, run the migration on the staging database” where you might have sent “go” or a thumbs-up.

If your system prompt has approval rules, name the exact actions they cover, because the model applies them as written. In Anthropic’s testing on simulated tasks with nobody there to approve, one rule listed “sending messages to people outside this conversation” among the steps that need approval. With that rule, the model held back roughly half of its routine requests to colleagues and other teams.

## Say who owns the code

Claude Fable 5.2 responds closely to what the prompt says about who owns the code it works on. In Anthropic’s testing on small coding tasks, when a prompt said nothing about ownership or presented the code base as someone else’s, the model tended to add to the existing structure, even when that repeated existing code. It also tended to report nearby problems instead of fixing them. When the prompt says the code base is the model’s own, the model often merges repeated code and makes related fixes without being asked.

If you want the model to improve the structure as it works, say that the code is its own:

```text wrap
This codebase is yours: what it's for and how it's built are your call, and you'll keep building on it.
```

In Anthropic’s testing on small coding tasks, the model merged repeated code in about half of the tries with this sentence, and in under a tenth of the tries without it. The rate varied by task. The result held when the sentence stood inside a long system prompt. The requested feature worked in nearly every try either way.

In the same testing, the model also used about 1.5 times the output tokens with the sentence and made several changes that nobody had asked for, many of them new tests and documentation. Apart from bug fixes, it changed how an existing feature behaves in one try in six to ten, and more often at higher effort. Its closing summary named the larger changes but often left out small ones, so review the diff and not only the summary.

Leave the ownership sentence out where the user owns the code and wants it changed as little as possible. A rule elsewhere in the prompt that limits scope doesn’t cancel the ownership sentence. In Anthropic’s testing, with “No drive-by refactors, renames or cleanups” earlier in the same prompt, the model still merged repeated code in about a third of the tries.

## Keep users informed during long turns

Claude Fable 5.2 sometimes writes little user-facing text during long runs of tool calls. The model might also make its first tool call without saying what it’s about to do.

First, check that your client receives the model’s updates. On Claude Fable 5.2, the updates the model writes between tool calls come back as [progress-update `thinking` blocks](https://platform.claude.com/docs/en/build-with-claude/thinking#progress-updates). These updates say what the model found and what it’s doing next. Their text is empty at the default `thinking.display` of `"omitted"`. So a client that renders only `text` blocks can look silent during a long agentic turn. Set `display: "updates"` (beta, `thinking-display-updates-2026-08-18` header) to receive a short summary of each update, or `"summarized"` to receive the updates along with summarized reasoning. Then render the non-empty `thinking` blocks between tool calls.

Frequent updates matter most when a user watches the work in real time, as in interactive coding. If your users watch the work and still get too few updates, use one or more of these options.

If you can change your harness, an effective option is to have it count consecutive tool-calling steps that give the user nothing to read: no `text` block and no `thinking` block with text. Count with `display` set to `"updates"` or `"summarized"`, because at `"omitted"` every `thinking` block is empty. This option works where your platform supports [mid-conversation system messages](https://platform.claude.com/docs/en/build-with-claude/mid-conversation-system-messages). After several such steps in a row, have the harness append this reminder after the latest tool results as a [turn-scoped system message](https://platform.claude.com/docs/en/build-with-claude/mid-conversation-system-messages#turn-scoped-system-messages) (`clear_at: "next_user_message"`, beta, `mid-conversation-system-clear-at-2026-08-21` header):

```text wrap
The user hasn't heard from you in a while: say in a few words what you're doing, then continue.
```

In Anthropic’s testing on multi-turn coding tasks, the reminder roughly halved the longest silent stretch, with no noticeable increase in tokens or time.

Leave each reminder in `messages` on later requests. Removing or rewording one edits an earlier turn, which invalidates the thinking blocks after it. See [Send per-turn reminders as turn-scoped system messages](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#per-turn-reminders).

To also get an opening line before the first tool call, brief updates, and a closing recap, add this text to your system prompt:

```text wrap
Before you start, say in a line what you're about to do; brief updates while you work help the user follow along. Close with a short recap that stands on its own (what you found, what you did, and what's next), so a reader who only sees the last message has the full picture.
```

In Anthropic’s testing on coding tasks, the model spoke before its first tool call every time with this text. The text also raised output tokens per task by roughly 20 percent. Use this text where a human is directly in the loop. To get the most updates, pair it with the reminder that your harness appends.

If you can’t change the harness, or your platform has no mid-conversation system messages, add this sentence to your system prompt:

```text wrap
Every few tool calls, give the user a one-line update on where things stand.
```

In Anthropic’s testing on workflow automation tasks, this sentence cut most long silent stretches.

Even with the reminder and the opening and recap text together, expect runs of several tool calls between updates. Claude Fable 5.2 works well on long-running asynchronous tasks, where the user comes back for the result instead of watching each step. Gaps between updates matter less there.

## Set expectations for subagents

How much work Claude Fable 5.2 delegates to subagents depends on your harness and tasks. In Anthropic’s testing on short tasks with a minimal tool for starting subagents, it rarely started one. In an agentic coding product whose prompts invite delegation, it delegates readily.

If your system prompt, skills, or agent files tell the model to delegate, review those lines first. Change the description of the tool that starts subagents only if Claude Fable 5.2 still starts more subagents than your tasks need. If the tool has a plain description and nothing else in your prompts asks for delegation, you likely don’t need a new description.

In the new description, state what a subagent adds to the cost of a session, say when delegation is worth it and when it isn’t, and tell the model how to brief a subagent that it starts. The description that Anthropic tested does these three things and puts cost first. A description of this kind is most useful when your harness already invites delegation and subagents make up a large share of your token usage.

In Anthropic’s testing on short tasks, the model delegated about a third less often with the tested description than with one that mostly listed reasons to delegate. Task success was the same.

In the tested description, the opening sentences on cost hold delegation back. Say less about cost if the model delegates too little. If it still delegates too much, say more about what a subagent costs in your harness, and test the change.

Anthropic also observed Claude Fable 5.2 using subagents to review its own work in an agentic coding product at higher effort levels, such as `xhigh` and `max`. Claude Fable 5.1 didn’t do this on the same tasks. Early testers had good results with Claude Fable 5.2 as the planner and orchestrator for other models. Delegation can speed up work that runs well in parallel. However, subagents can account for a large part of what a session costs, so check which model your harness runs subagents on by default.

## Keep caution from piling up

Cautious instructions build up wherever context carries over: memory, notes, instruction files, and messages between agents. Claude Fable 5.2 follows these instructions closely, so it might ask for approvals it doesn’t need or hold back routine work. A few early testers saw this behavior, mostly where several agents work together. Earlier models follow such instructions too, but in one of the setups described here only Claude Fable 5.2 held back.

If you see this behavior, clean up what your agents carry:

* **Remove notes you no longer need.** In Anthropic’s testing on simulated tasks, one of a dozen notes from earlier sessions said never to retry. With those notes in context, and with nothing in the prompt that allowed retries, the model retried after a tool was busy in about four in ten tries, down from nearly all without those notes.
* **Name the steps that need no approval.** In Anthropic’s testing on simulated tasks, the context held “never” rules, notes, and a reviewer’s conditions. A line at the end of the rules that listed retries among the steps that need no approval raised retries from almost none to about half of the tries. In the same setup, a general instruction to act more freely changed nothing. Name retries only for calls that are safe to repeat.
* **Check what reviewer agents attach.** In Anthropic’s testing on simulated tasks, one setup had a line in the prompt that listed retries among the steps that need no approval, and a reviewer’s “stop at the first error” in context. Claude Fable 5.2 didn’t retry in about a third of the tries. Claude Fable 5.1 and Claude Opus 5.5 retried.
* **Write the exception into the rule.** In Anthropic’s testing on simulated tasks, the person in charge had approved a step. Under a “never” rule, the model took that step in about one try in ten. A separate line that said an approved step has its go-ahead didn’t change that rate much. When the rule itself said to get a go-ahead first, the model took the step in about nine tries in ten. See [Approvals](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5-2#approvals).

Also keep your own confirmation step for risky or irreversible actions.

## Review instructions written for earlier models

When you migrate to Claude Fable 5.2, review your prompts. In Anthropic’s testing, some instructions written for earlier models raised cost, caused side effects, or no longer had an effect. Reconsider these instructions:

* **Standing instructions to delegate:** Lines that push work to subagents can sit in system prompts, skills, and agent files. Read those files before you migrate. If, in your tests, the model starts more subagents than your tasks need, remove the lines you no longer need. See [Set expectations for subagents](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5-2#set-expectations-for-subagents).
* **A token budget that your harness writes into the prompt:** Some harnesses tell the model in the prompt how many tokens the task may use and how many are left. The size of that budget changes how much Claude Fable 5.2 spends. In Anthropic’s testing on coding tasks at `high` and `xhigh` effort, removing a large budget lowered cost, with equivalent performance. Test your tasks without the budget. This finding is about text in the prompt, not the API’s [task budgets](https://platform.claude.com/docs/en/build-with-claude/task-budgets), a beta feature that the testing didn’t cover.
* **Harness code that edits earlier turns:** If your harness changes the system prompt, the tools, or an earlier message between requests, the thinking blocks that follow the changed point in the history become invalid. By default, the Messages API then rejects the request, and the Message Batches API drops those blocks. To have the Messages API drop them too, set `thinking.block_binding.prefix_mismatch_behavior` to `"drop_block"` (beta, `thinking-binding-controls-2026-08-01` header). In Anthropic’s testing, when earlier thinking was dropped on every turn, the model thought again and used more output tokens. That is the worst case, and the increase depends on how often your harness edits earlier turns. Keep the history append-only, so that no thinking is dropped, and measure output tokens on your own tasks before you rely on `"drop_block"`. See [What the API does with an invalid block](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#mismatch-behavior) and [Make changes without editing the prefix](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#replace-prefix-edits).
* **The “treat that answer as done” lines:** [Prompting Claude Opus 5.5](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-opus-5-5#thinking-instructions-in-chat-system-prompts) offers two sentences for chat system prompts. They tell the model to treat an earlier answer as done and to focus its thinking on the new message. In Anthropic’s testing at `high` effort, these sentences reduced Claude Fable 5.2’s thinking on follow-up questions, but the model also became far less likely to point out mistakes in its earlier answers. Leave these lines out where you want the model to keep re-examining its earlier answers. Elsewhere, test whether the model still points out its own mistakes before you adopt the lines.
* **Instructions to think less:** Claude Fable 5.1 usually follows a line such as “answer directly without deliberating.” In Anthropic’s testing, such a line didn’t stop Claude Fable 5.2 from thinking at `medium` and above. Remove these lines and lower the effort level, as described in [Calibrate effort](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5-2#calibrate-effort).
* **Style rules for writing:** Claude Fable 5.2 follows style rules closely, so a hard limit such as “one instruction per sentence, in 20 words or fewer” can make its prose choppy. Remove the rules you no longer need before you add the text in [Make reports easy to follow](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5-2#make-reports-easy-to-follow).
* **Rules, notes, and memories that have built up:** Memory files, notes, and instruction files collect cautions over time, and the model might have written some of them itself. Before you migrate, delete the cautions whose reason no longer holds, and rewrite absolute rules so that they state their scope and reason. If a system is already stuck, consider restarting it with its memory and notes trimmed, and keep a copy of the originals. See [Keep caution from piling up](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5-2#keep-caution-from-piling-up).

## Make reports easy to follow

After long agentic work, the people who read Claude Fable 5.2’s final report usually haven’t seen the tool calls or files behind it. The report needs to make sense on its own.

If you ask Claude Fable 5.2 to write final reports or handoffs, add this text to your system prompt, and adjust it to your readers and your product:

```text wrap
# Communicating clearly
Write for an intelligent but low-context reader. The person reading has not seen your tool calls, your reasoning or the files you opened, and may be switching in from other work. Messages should generally be self-contained: the reader should understand what you mean without having to dig for other context. Put the key points in the first few sentences. Practice progressive disclosure in your sentence order, and do not use undefined references and ideas in line 1 that won't make sense until the reader reaches line 12.

Use plain words, and write in clear, understandable full sentences. Do not use a term or abbreviation that you made up during the work. Say what the thing is in a way any reader would understand. Write mostly in the style of ASD-STE100 Simplified Technical English: short sentences, one idea per sentence, active voice, and consistently using the same word for the same thing. Use a paragraph of flowing prose where ideas connect, and keep bullets for lists of separate items. Leave out unnecessary details unless the reader asks and practice concision, but do ensure that your messages have the key context. Aim to make your user-facing text as human-readable and clear as possible.
```

In Anthropic’s testing on agentic tasks, this text made final reports less dense, with fewer semicolons. On workflow automation tasks, it also made sentences shorter. You might also add instructions about length or ask the model to include specific details.

## Safeguard refusals

Claude Fable 5.2 runs safety classifiers that can decline a request. A declined request returns `stop_reason: "refusal"`, and `stop_details.category` names the [refusal category](https://platform.claude.com/docs/en/build-with-claude/refusals-and-fallback#refusal-response):

* `cyber`: the request could enable cyber harm, such as malware or exploit development.
* `bio`: the request could enable biological harm, such as dangerous lab methods.
* `frontier_llm`: the request could help with the development of competing AI models.
* `reasoning_extraction`: the request asks the model to reproduce its internal reasoning in the response text.
* `general_harms`: the request falls under another usage-policy area.

Benign cybersecurity and life sciences work can also trigger the `cyber` and `bio` classifiers. If they block your organization’s legitimate work, see Anthropic’s [Cyber Verification Program](https://support.claude.com/en/articles/14604842) and [Life Sciences Verification Program](https://www.anthropic.com/news/life-sciences-verification-program). [Claude Mythos 5.2](https://platform.claude.com/docs/en/models/mythos-5-2/overview) offers the same capabilities as Claude Fable 5.2 only to organizations verified through these programs.

If your prompts, skills, or tool descriptions ask the model to write its reasoning in the response, remove those instructions. To see how the model reasoned, set `display: "summarized"` and read the thinking blocks. See [Keep reasoning in thinking blocks](https://platform.claude.com/docs/en/build-with-claude/refusals-and-fallback#keep-reasoning-in-thinking-blocks).

To retry a declined request on another model, see [Refusals, fallback, and billing](https://platform.claude.com/docs/en/models/fable-5-2/whats-new-fable-5-2#refusals-fallback-and-billing).

## Where to start

When you migrate, work through these steps in order:

1. Set `effort` to `high` explicitly, then run your evals at `medium` and `xhigh` as well.
2. Read the system prompts, skills, agent files, memory files, notes, and harness text you carry over. Remove or test the instructions listed in [Review instructions written for earlier models](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5-2#review-instructions-written-for-earlier-models).
3. Run your longest agentic tasks. Note where the model stops early, asks for approvals it doesn’t need, goes quiet, delegates more than the task needs, or adds to existing code where you wanted it restructured.
4. Apply the guidance for each behavior you observed, one at a time, and measure its effect and its token cost on your own tasks.

build-with-claude/refusals-and-fallback Changed · +15 / -13 lines

build-with-claude/task-budgets Changed · +7 / -3 lines

build-with-claude/thinking Changed · +21 / -15 lines

build-with-claude/thinking-troubleshooting Changed · +5 / -3 lines

build-with-claude/token-counting Changed · +4 / -2 lines

claude_api_primer Changed · +4 / -2 lines

cli-sdks-libraries/libraries/openai-sdk Changed · +30 / -28 lines

cli-sdks-libraries/overview Changed · +7 / -7 lines

cli-sdks-libraries/sdks/java Changed · +6 / -6 lines

manage-claude/data-residency Changed · +11 / -9 lines

manage-claude/opentelemetry/sdk Changed · +4 / -2 lines

managed-agents/quickstart Changed · +4 / -2 lines

models/fable-5-1/migration-guide Page removed · 1616 lines, page removed

## Migrating to Claude Fable 5.1 from Claude Fable 5 ### Update your model name ### Breaking changes ### Behavior changes ### Recommended changes ### Migration checklist ## Migrating to Claude Fable 5.1 from Claude Opus 5 ### Update your model name ### What changed ### Migration checklist ## Migrating to Claude Fable 5.1 from Claude Opus 4.8 or earlier ### Update your model name ### Migration checklist ## Migrating to Claude Mythos 5.1 from Claude Mythos 5 ### Update your model name ### Migration checklist

The page is gone upstream. What it last said is kept here.

models/fable-5-1/overview Changed · +23 / -39 lines

## How it compares to the current lineup ## Overview ## How it compares

models/fable-5-1/whats-new-fable-5-1 Page removed · 521 lines, page removed

## Models ## Breaking changes ### Forced tool use is not supported ### Only Claude Fable 5.1 and Claude Mythos 5.1 read Claude Fable 5.1 thinking blocks ### Editing earlier turns invalidates thinking blocks ### Some advisor tool pairings are not supported ## New features ### Change effort mid-conversation (beta) ### Turn-scoped system messages (beta) ### Progress updates between tool calls (beta) ### Content provenance ## Behavior differences ### Changed from Claude Fable 5 ### Unchanged from Claude Fable 5 ## Capability improvements ## Refusals, fallback, and billing ## Pricing ## Availability ## Migrate from Claude Fable 5 ## Next steps

The page is gone upstream. What it last said is kept here.

models/fable-5-2/migration-guide New page · 370 lines, new page

## Migrating to Claude Fable 5.2 from Claude Fable 5.1 ### Update your model name ### Breaking changes ### Behavior changes ### Migration checklist ## Migrating to Claude Mythos 5.2 from Claude Mythos 5.1 ### Update your model name ### Migration checklist ## Migrating to Claude Fable 5.2 from Claude Opus 5.5 ### Update your model name ### What changes ### Migration checklist ## Migrating to Claude Fable 5.2 from Claude Fable 5 ### Update your model name ### Breaking changes ### Other changes ### Migration checklist ## Migrating to Claude Mythos 5.2 from Claude Mythos 5 ### Update your model name ### Migration checklist ## Migrating to Claude Fable 5.2 from Claude Opus 5 ### Update your model name ### What changes ### Migration checklist ## Migrating to Claude Fable 5.2 from Claude Opus 4.8 or earlier ### What changes ### Migration checklist

A whole new page. There's nothing to diff it against, so here is what it says.

---
title: Claude Fable 5.2 and Claude Mythos 5.2 migration guide
url: https://platform.claude.com/docs/en/models/fable-5-2/migration-guide
description: Switch to Claude Fable 5.2 and Claude Mythos 5.2 from Claude Fable 5.1, Claude Mythos 5.1, Claude Opus 5.5, or an earlier Claude Fable, Claude Mythos, or Claude Opus model with this migration guide. The guidance to enable Claude Fable 5.2 and Claude Mythos 5.2 includes model IDs, breaking changes, and migration checklists.
---

<Note>
  This guide covers migrating [Messages API](https://platform.claude.com/docs/en/build-with-claude/working-with-messages) code. If you use [Claude Managed Agents](https://platform.claude.com/docs/en/managed-agents/overview), no changes beyond updating the model name are required.
</Note>

Let Claude Code migrate your code for you

```text
/claude-api migrate this project to claude-fable-5-2
```

If your Claude Managed Agents agent has an advisor, the advisor’s `model` is a second model name to update: set it to `claude-fable-5-2` or `claude-mythos-5-2` when you change the agent’s model. See [A Claude Fable 5.2 executor needs a Claude Fable 5.2 or Claude Mythos 5.2 advisor](https://platform.claude.com/docs/en/models/fable-5-2/migration-guide#fable-5-2-advisor-pairs).

The following sections cover moving to Claude Fable 5.2, or to Claude Mythos 5.2, from Claude Fable 5.1, Claude Mythos 5.1, Claude Opus 5.5, or an earlier Claude Fable, Claude Mythos, or Claude Opus model. For the changes themselves, see [What’s new in Claude Fable 5.2](https://platform.claude.com/docs/en/models/fable-5-2/whats-new-fable-5-2). For behavioral differences and model-specific prompting patterns, see [Prompting Claude Fable 5.2](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5-2).

Claude Fable 5.2 is available on the Claude API, [Claude Platform on AWS](https://platform.claude.com/docs/en/build-with-claude/claude-platform-on-aws), and [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/en/build-with-claude/claude-models-on-google-cloud/anthropic-managed). It’s also available on [Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/en/build-with-claude/claude-models-on-google-cloud/google-managed). [Claude Mythos 5.2](https://platform.claude.com/docs/en/models/mythos-5-2/overview) has the same capabilities and is available only to organizations verified through Anthropic’s verification programs, such as the [Cyber Verification Program](https://support.claude.com/en/articles/14604842).

The baseline settings shared by `claude-fable-5-2` and `claude-mythos-5-2`:

* **Thinking:** [Adaptive thinking](https://platform.claude.com/docs/en/build-with-claude/thinking) is always on, unchanged from Claude Fable 5.1. The model determines when and how much to think, and the [effort](https://platform.claude.com/docs/en/build-with-claude/effort) parameter controls how deeply. Both `thinking: {type: "disabled"}` and manual extended thinking (`thinking: {type: "enabled", budget_tokens: N}`) return a 400 error.
* **Effort:** All five [effort](https://platform.claude.com/docs/en/build-with-claude/effort) levels are supported, and the default is `high`, unchanged from Claude Fable 5.1. See [Recommended effort levels for Claude Fable 5.2](https://platform.claude.com/docs/en/build-with-claude/effort#recommended-effort-levels-for-claude-fable-5-2).
* **Prefill:** Prefilling the assistant message returns a 400 error, unchanged from Claude Fable 5.1. Use system prompt instructions instead.
* **Sampling parameters:** Omit `temperature`, `top_p`, and `top_k`, as on Claude Fable 5.1. See [Sampling parameters](https://platform.claude.com/docs/en/build-with-claude/thinking#sampling-parameters) for the values that return a 400 error.
* **Tool choice:** `{type: "auto"}` (the default) and `{type: "none"}` are supported. Forcing a tool call with `{type: "any"}` or `{type: "tool", name: "..."}` returns a 400 error, unchanged from Claude Fable 5.1.
* **Structured outputs:** In an organization with [customer-managed encryption keys](https://platform.claude.com/docs/en/manage-claude/cmek) (CMEK), [structured outputs](https://platform.claude.com/docs/en/build-with-claude/structured-outputs) aren’t available for either model, as for Claude Fable 5.1. That covers both strict tool use and JSON outputs. If your requests set `strict: true` or `output_config.format` there, remove them and validate the output in your code.
* **Preserved thinking across models:** On the Claude API and Claude Models on Google Cloud (Google managed), Claude Fable 5.2 and Claude Mythos 5.2 read each other’s thinking blocks and those from other models, including Claude Opus 5.5, Claude Sonnet 5.5, and Claude Haiku 5.5. No other model reads their blocks. See [Switching models mid-conversation](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#switching-models) for the list.
* **Account-bound thinking:** Thinking blocks from Claude Fable 5.2 and Claude Mythos 5.2 work only in the account that produced them, or in an account linked to it. When another account sends one of these blocks, the API drops the block before the model receives it, and the request succeeds. On the Claude API and Claude Models on Google Cloud (Google managed), with the `thinking-binding-controls-2026-08-01` beta header, the response lists each dropped block in `input_transformations` with `reason: "organization_binding_mismatch"`. See [Thinking blocks stay with the account that produced them](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#account-bound-thinking).
* **Context window and output:** A [1M token context window](https://platform.claude.com/docs/en/build-with-claude/context-windows) by default, and up to 128k output tokens for each request.
* **Pricing:** $8 USD per million input tokens and $40 USD per million output tokens, compared with $10 USD and $50 USD on Claude Fable 5.1 and Claude Mythos 5.1. Prompt cache reads are $0.20 USD per million tokens, compared with $0.25 USD on those models. See [Pricing](https://platform.claude.com/docs/en/about-claude/pricing).
* **Data retention:** Both models require 30-day data retention, aren’t available under zero data retention (ZDR) arrangements unless expressly authorized by Anthropic, and are designated Covered Models, the same as Claude Fable 5.1 and Claude Mythos 5.1. On the Claude API, a request from an organization or workspace without 30-day retention returns a 400 `invalid_request_error`. Organizations with a ZDR arrangement should contact their Anthropic account team, or configure retention for individual workspaces. See [Model-specific data retention requirements](https://platform.claude.com/docs/en/manage-claude/api-and-data-retention#model-specific-data-retention-requirements) for per-platform details.
* **Priority Tier:** Neither model is supported on [Priority Tier](https://platform.claude.com/docs/en/api/service-tiers#supported-models).
* **Fast mode:** Both models support [fast mode](https://platform.claude.com/docs/en/build-with-claude/fast-mode) in Messages API requests. [Availability of fast mode](https://platform.claude.com/docs/en/build-with-claude/fast-mode#feature-availability) lists each model’s platforms.

Where the two models diverge:

* **Availability:** On the Claude API, Claude Fable 5.2 doesn’t require access approval. Claude Mythos 5.2 is available only to organizations verified through Anthropic’s verification programs, such as the [Cyber Verification Program](https://support.claude.com/en/articles/14604842). To request access, apply to the program that covers your use case, or contact your Anthropic account team.
* **Rate limits:** Claude Fable 5.2 has its own rate limit, separate from the combined limit that Claude Fable 5.1 and Claude Fable 5 share. Claude Mythos 5.2 shares one combined limit with Claude Mythos 5.1 and Claude Mythos 5. See [Rate limits](https://platform.claude.com/docs/en/api/rate-limits#rate-limits).

## Migrating to Claude Fable 5.2 from Claude Fable 5.1

Migration is mostly drop-in. The API surface, always-on adaptive thinking, the forced tool choice restriction, refusal handling, `stop_details` categories, and the data retention requirement all match Claude Fable 5.1. Claude Fable 5.2 costs less: $8 USD per million input tokens and $40 USD per million output tokens, compared with $10 USD and $50 USD on Claude Fable 5.1. Four changes can break your code. The [prefix check](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#prefix-check), which catches edits to earlier turns, applies to every account. Claude Fable 5.1 can’t read Claude Fable 5.2’s thinking blocks. The earlier computer use tool, `computer_20251124`, returns a 400 error. With the advisor tool, a Claude Fable 5.2 executor accepts only Claude Fable 5.2 or Claude Mythos 5.2 as its advisor.

### Update your model name

```python
model = "claude-fable-5-1"  # Before
model = "claude-fable-5-2"  # After
```

The model ID is `claude-fable-5-2` on every platform. For each platform’s ID, see the [Claude Fable 5.2](https://platform.claude.com/docs/en/models/fable-5-2/overview) model page.

### Breaking changes

1. **The prefix check applies to every account:** Each `thinking` block from Claude Fable 5.2 is valid only against the `system` prompt, `tools`, and conversation history that preceded it, as on Claude Fable 5.1. Claude Fable 5.2 enforces this [prefix check](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#prefix-check) for every account, whatever its age. Claude Fable 5.1 enforces it by default for accounts created on or after August 31, 2026. So on an older account, requests that pass on Claude Fable 5.1 can fail on Claude Fable 5.2.

   Nothing changes for you if Claude Code, claude.ai, [Claude Managed Agents](https://platform.claude.com/docs/en/managed-agents/overview), or the [Claude Agent SDK](https://code.claude.com/docs/en/agent-sdk/overview) manages your conversation history. If your code builds the `messages` array itself, compare what it does between requests with the list in [Who the prefix check affects](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#who-is-affected). A request that sends a thinking block back after one of those edits returns a 400 error:

   ```text wrap
   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 request body doesn’t clear the error. To find these edits before you switch production traffic, run the check in [Check whether your code edits the prefix](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#how-to-tell-whether-your-integration-is-impacted) against the model you use now, Claude Fable 5.1 or Claude Opus 5.5. It works from any account, because setting `prefix_mismatch_behavior` opts the request into the check. [Preserved thinking](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking) gives the fix for each pattern.

   In production, leave `prefix_mismatch_behavior` at its default, `"error"`, if a mismatch can only mean a bug in your code. To drop the affected blocks and continue without that reasoning while you fix the edit, set it to `"drop_block"`. Treat that as a stopgap, not a long-term setting: [dropping blocks can raise output tokens](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#drop-block-cost).

2. **Claude Fable 5.1 can’t read Claude Fable 5.2’s thinking blocks:** On the Claude API and Claude Models on Google Cloud (Google managed), Claude Fable 5.2 reads Claude Fable 5.1’s blocks, so a conversation that moves from `claude-fable-5-1` onto `claude-fable-5-2` keeps its earlier reasoning. In the other direction, Claude Fable 5.1 can’t read Claude Fable 5.2’s blocks. If a router switch, a client-side retry, or a [classifier refusal fallback](https://platform.claude.com/docs/en/build-with-claude/refusals-and-fallback) moves a conversation from Claude Fable 5.2 to another model, Claude Fable 5.1 included, the API drops the blocks that model can’t read. The request succeeds, and you aren’t billed for the dropped input tokens. The model then works without that reasoning, which can raise cost and latency on the first turn after the switch. With the `thinking-binding-controls-2026-08-01` beta header, `input_transformations` lists each dropped block with `reason: "model_binding_mismatch"`. See [Switching models mid-conversation](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#switching-models).

3. **Use the computer use toolset instead of `computer_20251124`:** A `tools` entry of type `computer_20251124` returns a 400 error. Declare the `computer_toolset_20260801` toolset instead: drop the beta header and send the entry with no `name` or display dimensions. Then update your agent loop for the toolset, as [Migrate from `computer_20251124`](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool#migrate-from-computer-20251124) describes.

4. **A Claude Fable 5.2 executor needs a Claude Fable 5.2 or Claude Mythos 5.2 advisor:** With the [advisor tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/advisor-tool), which is in beta, the advisor must be at least as capable as the executor. A Claude Fable 5.2 or Claude Mythos 5.2 executor accepts only Claude Fable 5.2 or Claude Mythos 5.2 as its advisor, and any other advisor, including Claude Fable 5.1 and Claude Mythos 5.1, returns a 400 `invalid_request_error`. When you change the executor’s model ID, set the `model` in the advisor tool definition to `claude-fable-5-2` or `claude-mythos-5-2`. Changing the advisor’s `model` is an edit to `tools`, so make the change in new conversations. A request that sends earlier thinking blocks back after the change fails the prefix check (see [The prefix check applies to every account](https://platform.claude.com/docs/en/models/fable-5-2/migration-guide#fable-5-2-preserved-thinking)) and returns a 400 error, unless you set `prefix_mismatch_behavior` to `"drop_block"`. To keep your current executor and change only the advisor, set the advisor’s `model` to `claude-fable-5-2`: every executor model accepts it. A Claude Fable 5.2 advisor returns its advice encrypted, so if your code reads the advice text, see [Result variants](https://platform.claude.com/docs/en/agents-and-tools/tool-use/advisor-tool#result-variants). The same pairs apply to the advisor of a [Claude Managed Agents](https://platform.claude.com/docs/en/managed-agents/overview) agent, so set that advisor’s `model` to one of these two models when you change the agent’s. See [Model compatibility](https://platform.claude.com/docs/en/agents-and-tools/tool-use/advisor-tool#model-compatibility) and [Give the session an advisor](https://platform.claude.com/docs/en/managed-agents/multiagent-orchestration#give-the-session-an-advisor).

### Behavior changes

1. **Prompt lines that ask for less thinking don’t stop the model from thinking at `medium` effort and above:** Claude Fable 5.1 usually follows a line such as “answer directly without deliberating.” In Anthropic’s testing, such a line didn’t stop Claude Fable 5.2 from thinking at `medium` and above. Remove these lines and lower the effort level. See [Calibrate effort](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5-2#calibrate-effort).
2. **The model can start subagents to review its own work at higher effort:** In an agentic coding product at higher effort levels, such as `xhigh` and `max`, Anthropic observed Claude Fable 5.2 using subagents to review its own work. Claude Fable 5.1 didn’t do this on the same tasks. Subagents can account for a large part of what a session costs. See [Set expectations for subagents](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5-2#set-expectations-for-subagents).
3. **A small `max_tokens` can leave no room for text:** Thinking tokens count toward `max_tokens`, so a request with a small `max_tokens` can stop with `stop_reason: "max_tokens"` after a `thinking` block and before any text. A prompt line that usually keeps Claude Fable 5.1 from thinking doesn’t keep Claude Fable 5.2 from thinking at `medium` effort and above. So a request that relied on such a line to fit a small `max_tokens` on Claude Fable 5.1 can run out of tokens before any text on Claude Fable 5.2. Raise `max_tokens` to leave room for thinking, or choose a lower [effort](https://platform.claude.com/docs/en/build-with-claude/effort) level.

For the other behaviors to check when you carry prompts over, see [Behavior differences](https://platform.claude.com/docs/en/models/fable-5-2/whats-new-fable-5-2#behavior-differences).

### Migration checklist

* Update the model name from `claude-fable-5-1` to `claude-fable-5-2`.
* Check your [rate limits](https://platform.claude.com/docs/en/api/rate-limits#rate-limits) before you move production traffic. Claude Fable 5.2 has its own rate limit, separate from the one Claude Fable 5.1 and Claude Fable 5 share.
* If you use computer use through `computer_20251124`, Claude Fable 5.2 returns a 400 error for that tool. Declare `computer_toolset_20260801` instead and update your agent loop for the toolset.
* If you use the advisor tool with Claude Fable 5.2 as the executor, set the advisor’s `model` to `claude-fable-5-2` or `claude-mythos-5-2`.
* If your code builds the `messages` array itself, run a session with the `thinking-binding-controls-2026-08-01` beta header and `prefix_mismatch_behavior: "drop_block"`, log `input_transformations`, and fix every `prefix_binding_mismatch` entry. Do this even if your account never hit the check on Claude Fable 5.1.
* Pick a production `prefix_mismatch_behavior`: `"error"` (the default), or `"drop_block"` as a stopgap while you fix the edits, because [dropping blocks can raise output tokens](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#drop-block-cost). Monitor the 400 errors or the `input_transformations` entries.
* Keep passing `thinking` blocks back unchanged on every turn, including empty ones. If a router or fallback can move a conversation from Claude Fable 5.2 to Claude Fable 5.1, expect Claude Fable 5.1 to run without Claude Fable 5.2’s blocks.
* If you replay stored conversations through a different account, replay each one through the account that produced it, or an account linked to it. The API drops Claude Fable 5.2 thinking blocks that another account produced. See [Thinking blocks stay with the account that produced them](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#account-bound-thinking).
* Re-run your [effort sweep](https://platform.claude.com/docs/en/build-with-claude/effort#recommended-effort-levels-for-claude-fable-5-2) on your own evals, and re-baseline cost and latency.
* Check the system prompts, skills, and other instructions you carry over against [Review instructions written for earlier models](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5-2#review-instructions-written-for-earlier-models).

## Migrating to Claude Mythos 5.2 from Claude Mythos 5.1

[Claude Mythos 5.2](https://platform.claude.com/docs/en/models/mythos-5-2/overview) is the counterpart to Claude Fable 5.2 for organizations verified through Anthropic’s verification programs, such as the [Cyber Verification Program](https://support.claude.com/en/articles/14604842). Confirm that your organization has access to Claude Mythos 5.2 before you switch model IDs.

Claude Mythos 5.2 enforces the [prefix check](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#prefix-check) for every account, as Claude Fable 5.2 does. [When `prefix_mismatch_behavior` is unset](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#enforcement) shows where Claude Mythos 5.1 already returns the error. If your code edits earlier turns, see [Editing earlier turns invalidates thinking blocks](https://platform.claude.com/docs/en/models/fable-5-2/migration-guide#fable-5-2-edited-history) for what to change and how to test, and run the test against `claude-mythos-5-2`.

On the Claude API and Claude Models on Google Cloud (Google managed), Claude Mythos 5.2 reads Claude Mythos 5.1’s thinking blocks, so a conversation that moves from `claude-mythos-5-1` onto `claude-mythos-5-2` keeps its earlier reasoning. In the other direction, Claude Mythos 5.1 can’t read Claude Mythos 5.2’s blocks: the API drops them, and the request succeeds. See [Switching models mid-conversation](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#switching-models).

With the [advisor tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/advisor-tool), which is in beta, a Claude Mythos 5.2 executor accepts only Claude Mythos 5.2 or Claude Fable 5.2 as its advisor. A Claude Mythos 5.1 or Claude Fable 5.1 advisor returns a 400 error. See [A Claude Fable 5.2 executor needs a Claude Fable 5.2 or Claude Mythos 5.2 advisor](https://platform.claude.com/docs/en/models/fable-5-2/migration-guide#fable-5-2-advisor-pairs).

Claude Mythos 5.2 supports computer use through the `computer_toolset_20260801` toolset. A `tools` entry of type `computer_20251124` returns a 400 error. See [Use the computer use toolset instead of `computer_20251124`](https://platform.claude.com/docs/en/models/fable-5-2/migration-guide#fable-5-2-computer-use).

Claude Mythos 5.2 costs $8 USD per million input tokens and $40 USD per million output tokens, compared with $10 USD and $50 USD on Claude Mythos 5.1. Prompt cache reads are $0.20 USD per million tokens, compared with $0.25 USD.

### Update your model name

```python
model = "claude-mythos-5-1"  # Before
model = "claude-mythos-5-2"  # After
```

### Migration checklist

* Update the model name from `claude-mythos-5-1` to `claude-mythos-5-2`.
* If you use computer use through `computer_20251124`, Claude Mythos 5.2 returns a 400 error for that tool. Declare `computer_toolset_20260801` instead and update your agent loop for the toolset.
* If you use the advisor tool with Claude Mythos 5.2 as the executor, set the advisor’s `model` to `claude-mythos-5-2` or `claude-fable-5-2`.
* Keep passing `thinking` blocks back unchanged on every turn, including empty ones.
* If you replay stored conversations through a different account, replay each one through the account that produced it, or an account linked to it. The API drops Claude Mythos 5.2 thinking blocks that another account produced. See [Thinking blocks stay with the account that produced them](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#account-bound-thinking).
* If your code builds the `messages` array itself, run the check in [Editing earlier turns invalidates thinking blocks](https://platform.claude.com/docs/en/models/fable-5-2/migration-guide#fable-5-2-edited-history) against `claude-mythos-5-2`, fix every `prefix_binding_mismatch` entry, and keep conversation history append-only (see [What counts as an edit](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#what-counts-as-an-edit)). An append-only history also keeps the prompt cache warm.
* Handle `stop_reason: "refusal"` and read `stop_details.category` before response content. See [Refusals and fallback](https://platform.claude.com/docs/en/build-with-claude/refusals-and-fallback).
* Re-run your effort sweep, and re-baseline cost and latency.
* Check the system prompts, skills, and other instructions you carry over against [Review instructions written for earlier models](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5-2#review-instructions-written-for-earlier-models).

## Migrating to Claude Fable 5.2 from Claude Opus 5.5

Claude Fable 5.2 uses the same Messages API and tool use patterns as [Claude Opus 5.5](https://platform.claude.com/docs/en/models/opus-5-5/overview). Both models always think adaptively and return a 400 error for forced tool choice, so those parts of your requests carry over. The following differences apply when you move traffic, or a fallback path, onto Claude Fable 5.2.

### Update your model name

```python
model = "claude-opus-5-5"  # Before
model = "claude-fable-5-2"  # After
```

### What changes

1. **Data retention is required:** Claude Fable 5.2 requires 30-day data retention and isn’t available under a zero data retention (ZDR) arrangement unless expressly authorized by Anthropic. If your organization or workspace runs Claude Opus 5.5 under ZDR, enable 30-day retention for a workspace or contact your Anthropic account team before you switch. Otherwise, on the Claude API, every request to Claude Fable 5.2 returns a 400 `invalid_request_error`. See [Model-specific data retention requirements](https://platform.claude.com/docs/en/manage-claude/api-and-data-retention#model-specific-data-retention-requirements).

2. **The prefix check applies to every account:** Claude Opus 5.5 enforces the prefix check by default for accounts created on or after August 31, 2026. Claude Fable 5.2 enforces it for every account, whatever its age. If your account is older and your code edits earlier turns, requests that work on Claude Opus 5.5 fail on Claude Fable 5.2. To test before you switch, see [The prefix check applies to every account](https://platform.claude.com/docs/en/models/fable-5-2/migration-guide#fable-5-2-preserved-thinking).

3. **Claude Opus 5.5 can’t read Claude Fable 5.2’s thinking blocks:** A conversation that moves from Claude Fable 5.2 to Claude Opus 5.5 keeps its text and tool calls, but the turns after the switch run without Claude Fable 5.2’s reasoning. The API drops those blocks before the model receives them, the request succeeds, and the dropped blocks aren’t billed. Expect higher cost and latency on the first turn after the switch. In the other direction, on the Claude API and Claude Models on Google Cloud (Google managed), Claude Fable 5.2 reads Claude Opus 5.5’s thinking blocks, so a conversation that moves from `claude-opus-5-5` onto `claude-fable-5-2` keeps its earlier reasoning.

4. **Safety classifiers and fallback:** Claude Fable 5.2 runs safety classifiers covering the same `stop_details` categories as Claude Fable 5.1. Handle every category in the [refusal category table](https://platform.claude.com/docs/en/build-with-claude/refusals-and-fallback#refusal-response), not only the ones you’ve seen from Claude Opus 5.5. To re-run declined requests on another model, set `fallbacks: "default"`, which retries on the model Anthropic recommends for that category, or build your own retry. That parameter is in beta on the Claude API and Claude Models on Google Cloud (Anthropic managed), and needs the `server-side-fallback-2026-07-01` beta header. The permitted fallback targets for Claude Fable 5.2 are Claude Opus 4.8 (`claude-opus-4-8`) and Claude Opus 5 (`claude-opus-5`). Server-side fallback doesn’t retry a request declined with `"reasoning_extraction"`. That refusal comes back to you. The fallback model doesn’t receive Claude Fable 5.2’s thinking blocks. See [Refusals and fallback](https://platform.claude.com/docs/en/build-with-claude/refusals-and-fallback).

5. **Pricing:** Claude Fable 5.2 costs $8 USD per million input tokens and $40 USD per million output tokens, compared with $4 USD and $20 USD for Claude Opus 5.5. Prompt cache reads are $0.20 USD per million tokens on both models. See [Pricing](https://platform.claude.com/docs/en/about-claude/pricing).

6. **Fast mode:** Claude Fable 5.2 supports [fast mode](https://platform.claude.com/docs/en/build-with-claude/fast-mode) (`speed: "fast"`) in Messages API requests on the Claude API, as Claude Opus 5.5 does. Fast mode for Claude Fable 5.2 costs $16 USD per million input tokens and $80 USD per million output tokens, compared with $8 USD and $40 USD for Claude Opus 5.5 in fast mode. See [Fast mode pricing](https://platform.claude.com/docs/en/about-claude/pricing#fast-mode-pricing).

   Claude Fable 5.2 also supports fast mode on [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/en/build-with-claude/claude-models-on-google-cloud/anthropic-managed), with the same `speed: "fast"` setting.

   Claude Fable 5.2 also supports fast mode on [Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/en/build-with-claude/claude-models-on-google-cloud/google-managed), with the same `speed: "fast"` setting. Google Cloud sets its prices there. See [Cloud platform pricing](https://platform.claude.com/docs/en/about-claude/pricing#cloud-platform-pricing).

   Claude Mythos 5.2 also supports fast mode in Messages API requests on the Claude API, at Claude Fable 5.2’s fast mode prices. [Availability of fast mode](https://platform.claude.com/docs/en/build-with-claude/fast-mode#feature-availability) lists every platform where Claude Mythos 5.2 has fast mode.

   Remove `speed: "fast"` in Claude Managed Agents. Also remove it on any platform or hosting option where [Availability of fast mode](https://platform.claude.com/docs/en/build-with-claude/fast-mode#feature-availability) doesn’t list the model you move to.

7. **Structured outputs in CMEK organizations:** In an organization with [customer-managed encryption keys](https://platform.claude.com/docs/en/manage-claude/cmek), Claude Opus 5.5 supports [structured outputs](https://platform.claude.com/docs/en/build-with-claude/structured-outputs) and Claude Fable 5.2 doesn’t. Remove `strict: true` and `output_config.format` from requests you move, and validate the output in your code.

8. **The default effort is `high`:** Claude Opus 5.5 defaults to `medium`, so a request that omits `effort` runs one level higher on Claude Fable 5.2. The request succeeds, and the change shows up only as different cost, latency, and results. Set `effort` explicitly, then re-run your [effort sweep](https://platform.claude.com/docs/en/build-with-claude/effort#recommended-effort-levels-for-claude-fable-5-2) on your own evals.

9. **A Claude Fable 5.2 executor needs a Claude Fable 5.2 or Claude Mythos 5.2 advisor:** With the [advisor tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/advisor-tool), which is in beta, a Claude Opus 5.5 executor accepts several advisors, Claude Opus 5.5 and Claude Fable 5.1 among them. A Claude Fable 5.2 executor accepts only Claude Fable 5.2 or Claude Mythos 5.2, and any other advisor returns a 400 error. Set the advisor’s `model` to `claude-fable-5-2` or `claude-mythos-5-2` when you change the executor’s. See [A Claude Fable 5.2 executor needs a Claude Fable 5.2 or Claude Mythos 5.2 advisor](https://platform.claude.com/docs/en/models/fable-5-2/migration-guide#fable-5-2-advisor-pairs).

### Migration checklist

* If your organization has a ZDR arrangement, enable 30-day retention for the workspace, or confirm eligibility with your Anthropic account team, before anything else.
* Update the model ID from `claude-opus-5-5` to `claude-fable-5-2`.
* Check your [rate limits](https://platform.claude.com/docs/en/api/rate-limits#rate-limits) before you move production traffic. Claude Fable 5.2’s rate limit is separate from Claude Opus 5.5’s, with lower token limits at each tier.
* If your code builds the `messages` array itself, run the test in [The prefix check applies to every account](https://platform.claude.com/docs/en/models/fable-5-2/migration-guide#fable-5-2-preserved-thinking), even if your account never hit the check on Claude Opus 5.5.
* Handle every `stop_details.category`. If you set an explicit `fallbacks` list, name only Claude Fable 5.2’s permitted targets.
* If a router or fallback moves conversations from Claude Fable 5.2 to Claude Opus 5.5, expect the turns after the switch to run without Claude Fable 5.2’s thinking blocks.
* If you replay stored conversations through a different account, replay each one through the account that produced it, or an account linked to it. The API drops Claude Fable 5.2 thinking blocks that another account produced. See [Thinking blocks stay with the account that produced them](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#account-bound-thinking).
* If you use fast mode in Messages API requests, keep `speed: "fast"` only on a platform or hosting option where [Availability of fast mode](https://platform.claude.com/docs/en/build-with-claude/fast-mode#feature-availability) lists the model you move to. On those platforms and hosting options, re-baseline cost against the [fast mode prices](https://platform.claude.com/docs/en/about-claude/pricing#fast-mode-pricing). On every other platform or hosting option, and in Claude Managed Agents, remove `speed: "fast"`. You don’t need the `fast-mode-2026-02-01` beta header. On the Claude API, requests that send it keep working.
* If you use the advisor tool with Claude Fable 5.2 as the executor, set the advisor’s `model` to `claude-fable-5-2` or `claude-mythos-5-2`.
* In an organization with [customer-managed encryption keys](https://platform.claude.com/docs/en/manage-claude/cmek), remove `strict: true` and `output_config.format`, and validate the output in your code.
* Set `effort` explicitly: Claude Fable 5.2’s default is `high`, where Claude Opus 5.5’s is `medium`, so a request that omits it runs one level higher. Then re-run your [effort sweep](https://platform.claude.com/docs/en/build-with-claude/effort#recommended-effort-levels-for-claude-fable-5-2) on your own evals, and re-baseline cost and latency.
* Check the system prompts, skills, and other instructions you carry over against [Review instructions written for earlier models](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5-2#review-instructions-written-for-earlier-models).

## Migrating to Claude Fable 5.2 from Claude Fable 5

The API surface, context window and output limits, tokenizer, always-on adaptive thinking, and refusal handling all match Claude Fable 5. Some of the following changes also apply when you move from Claude Mythos 5 to Claude Mythos 5.2. [Migrating to Claude Mythos 5.2 from Claude Mythos 5](https://platform.claude.com/docs/en/models/fable-5-2/migration-guide#migrating-from-claude-mythos-5-to-claude-mythos-5-2) says which ones.

### Update your model name

```python
model = "claude-fable-5"  # Before
model = "claude-fable-5-2"  # After
```

### Breaking changes

1. **Forced tool choice returns a 400 error:** Claude Fable 5 accepts `tool_choice` `auto`, `none`, `any`, and `tool`. On `claude-fable-5-2`, `{type: "any"}` and `{type: "tool", name: "..."}` return a 400 `invalid_request_error`, and so does the [token counting](https://platform.claude.com/docs/en/build-with-claude/token-counting) endpoint. See [Forced tool use not supported](https://platform.claude.com/docs/en/api/errors#forced-tool-use-not-supported) for the error message.

   To get the tool call without forcing it, leave `tool_choice` at `auto` and name the tool in your instruction. Set `strict: true` on the tool so the call matches your schema. See [Strict tool use](https://platform.claude.com/docs/en/agents-and-tools/tool-use/strict-tool-use). If you forced a tool only to get schema-valid JSON, use [JSON outputs](https://platform.claude.com/docs/en/build-with-claude/structured-outputs#usage) instead. In an organization with [customer-managed encryption keys](https://platform.claude.com/docs/en/manage-claude/cmek), [structured outputs](https://platform.claude.com/docs/en/build-with-claude/structured-outputs) aren’t available for Claude Fable 5.2 or Claude Mythos 5.2. That covers both strict tool use and JSON outputs. There, keep `auto` and the instruction, leave out `strict`, and validate the tool input in your code.

   If your application requires a specific tool call on the current turn, append a [mid-conversation system message](https://platform.claude.com/docs/en/build-with-claude/mid-conversation-system-messages) after the latest `user` turn. Name the tool, say that the call is required for this turn, and tell Claude to open its response with it. Earlier turns stay unchanged, so their prompt cache hits and thinking blocks stay valid. [Mid-conversation system messages](https://platform.claude.com/docs/en/build-with-claude/mid-conversation-system-messages) lists the platforms where they’re available. For a turn that must not call tools, `tool_choice: {"type": "none"}` still works. See [Forcing tool use](https://platform.claude.com/docs/en/agents-and-tools/tool-use/define-tools#forcing-tool-use).

2. **Editing earlier turns invalidates thinking blocks, on every account:** Claude Fable 5 doesn’t check whether earlier turns changed. On Claude Fable 5.2, each `thinking` block is valid only against the `system` prompt, `tools`, and messages that came before it. Claude Fable 5.2 enforces this [prefix check](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#prefix-check) for every account. A request that sends a thinking block back after any of those changed returns a 400 error, and retrying the same request body doesn’t clear it.

   Nothing changes for you if Claude Code, claude.ai, [Claude Managed Agents](https://platform.claude.com/docs/en/managed-agents/overview), or the [Claude Agent SDK](https://code.claude.com/docs/en/agent-sdk/overview) manages your conversation history. If your code builds the `messages` array itself, keep the history append-only. Freeze `system` and `tools` for the session. Make instruction and tool changes with [mid-conversation system messages](https://platform.claude.com/docs/en/build-with-claude/mid-conversation-system-messages), and trim context with server-side [compaction](https://platform.claude.com/docs/en/build-with-claude/compaction) or [context editing](https://platform.claude.com/docs/en/build-with-claude/context-editing). [Mid-conversation system messages](https://platform.claude.com/docs/en/build-with-claude/mid-conversation-system-messages) lists the platforms where they’re available. [Make changes without editing the prefix](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#replace-prefix-edits) gives the replacement for each common edit.

   To find these edits before you switch production traffic, run the check in [Check whether your code edits the prefix](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#how-to-tell-whether-your-integration-is-impacted) against `claude-fable-5-2`. In production, leave `prefix_mismatch_behavior` at its default, `"error"`, if a mismatch can only mean a bug in your code. To drop the affected blocks and continue without that reasoning while you fix the edit, set it to `"drop_block"` with the `thinking-binding-controls-2026-08-01` beta header. Treat that as a stopgap, not a long-term setting: [dropping blocks can raise output tokens](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#drop-block-cost).

3. **Claude Fable 5 can’t read Claude Fable 5.2’s thinking blocks:** On the Claude API and Claude Models on Google Cloud (Google managed), Claude Fable 5.2 reads Claude Fable 5’s blocks, so a conversation that moves from `claude-fable-5` onto `claude-fable-5-2` keeps its earlier reasoning. In the other direction, Claude Fable 5 can’t read Claude Fable 5.2’s blocks. If a router switch, a client-side retry, or a [classifier refusal fallback](https://platform.claude.com/docs/en/build-with-claude/refusals-and-fallback) moves a conversation from Claude Fable 5.2 to another model, Claude Fable 5 included, the API drops the blocks that model can’t read. The request succeeds, and you aren’t billed for the dropped input tokens. With the `thinking-binding-controls-2026-08-01` beta header, `input_transformations` lists each dropped block with `reason: "model_binding_mismatch"`. See [Switching models mid-conversation](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#switching-models).

4. **Use the computer use toolset instead of `computer_20251124`:** On Claude Fable 5.2, a `tools` entry of type `computer_20251124` returns a 400 error. Claude Fable 5 accepts it with its beta header. Declare the `computer_toolset_20260801` toolset instead, as [Use the computer use toolset instead of `computer_20251124`](https://platform.claude.com/docs/en/models/fable-5-2/migration-guide#fable-5-2-computer-use) describes.

5. **A Claude Fable 5.2 executor needs a Claude Fable 5.2 or Claude Mythos 5.2 advisor:** With the [advisor tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/advisor-tool), which is in beta, a Claude Fable 5.2 executor accepts only Claude Fable 5.2 or Claude Mythos 5.2 as its advisor. The other advisors a Claude Fable 5 executor accepts, such as Claude Fable 5 and Claude Opus 5.5, return a 400 error. Set the advisor’s `model` to `claude-fable-5-2` or `claude-mythos-5-2` when you change the executor’s. See [A Claude Fable 5.2 executor needs a Claude Fable 5.2 or Claude Mythos 5.2 advisor](https://platform.claude.com/docs/en/models/fable-5-2/migration-guide#fable-5-2-advisor-pairs).

### Other changes

* **Pricing:** $8 USD per million input tokens and $40 USD per million output tokens, compared with $10 USD and $50 USD on Claude Fable 5. Prompt cache reads are $0.20 USD per million tokens, compared with $1 USD. See [Pricing](https://platform.claude.com/docs/en/about-claude/pricing).
* **Priority Tier:** Claude Fable 5.2 isn’t supported on [Priority Tier](https://platform.claude.com/docs/en/api/service-tiers#supported-models). Claude Fable 5 is. If your organization has a Priority Tier commitment, plan capacity separately.
* **Per-message effort (beta):** To change effort partway through a conversation without losing prompt cache hits, send a [per-message effort](https://platform.claude.com/docs/en/build-with-claude/effort#change-effort-mid-conversation-beta) `role: "system"` message instead of changing `output_config.effort` between requests. That section lists the platforms where it’s available.

### Migration checklist

* Update the model name from `claude-fable-5` to `claude-fable-5-2`.
* Check your [rate limits](https://platform.claude.com/docs/en/api/rate-limits#rate-limits) before you move production traffic. Claude Fable 5.2 has its own rate limit, separate from the one Claude Fable 5.1 and Claude Fable 5 share.
* Replace forced `tool_choice` (`{type: "any"}` or `{type: "tool", ...}`) with `{type: "auto"}` plus an explicit instruction and `strict: true` tools, or with JSON outputs. Put the instruction in the `user` turn. When your application requires the call, put it in a mid-conversation `role: "system"` message instead, on the platforms that [Mid-conversation system messages](https://platform.claude.com/docs/en/build-with-claude/mid-conversation-system-messages) lists. In an organization with [customer-managed encryption keys](https://platform.claude.com/docs/en/manage-claude/cmek), strict tool use and JSON outputs aren’t available for Claude Fable 5.2. There, keep `{type: "auto"}` and the instruction, and validate the tool input in your code.
* If your code builds the `messages` array itself, run a session with the `thinking-binding-controls-2026-08-01` beta header and `prefix_mismatch_behavior: "drop_block"`, log `input_transformations`, and fix every `prefix_binding_mismatch` entry. `model_binding_mismatch` entries after a model switch are expected.
* Keep the history append-only: freeze `system` and `tools` at session start, make mid-session changes with `role: "system"` messages, and trim context on the server. [Mid-conversation system messages](https://platform.claude.com/docs/en/build-with-claude/mid-conversation-system-messages) lists the platforms where they’re available.
* Pick a production `prefix_mismatch_behavior`: `"error"` (the default), or `"drop_block"` as a stopgap while you fix the edits, because [dropping blocks can raise output tokens](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#drop-block-cost). Monitor the 400 errors or the `input_transformations` entries.
* Keep passing `thinking` blocks back unchanged on every turn, including empty ones. If a router or fallback can move a conversation from Claude Fable 5.2 to Claude Fable 5, expect Claude Fable 5 to run without Claude Fable 5.2’s blocks.
* If you replay stored conversations through a different account, replay each one through the account that produced it, or an account linked to it. The API drops Claude Fable 5.2 thinking blocks that another account produced. See [Thinking blocks stay with the account that produced them](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#account-bound-thinking).
* If you use computer use through `computer_20251124`, Claude Fable 5.2 returns a 400 error for that tool. Declare `computer_toolset_20260801` instead and update your agent loop for the toolset.
* If you use the advisor tool with Claude Fable 5.2 as the executor, set the advisor’s `model` to `claude-fable-5-2` or `claude-mythos-5-2`.
* If you change effort between requests, move the change to a per-message effort `role: "system"` message, which is in beta, where your platform supports it.
* If your organization has a Priority Tier commitment, plan capacity separately.
* Handle `stop_reason: "refusal"` and read `stop_details.category`. Consider `fallbacks: "default"`, in beta on the Claude API and Claude Models on Google Cloud (Anthropic managed).
* Re-run your [effort sweep](https://platform.claude.com/docs/en/build-with-claude/effort#recommended-effort-levels-for-claude-fable-5-2) on your own evals, and re-baseline cost and latency.
* Check the system prompts, skills, and other instructions you carry over against [Review instructions written for earlier models](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5-2#review-instructions-written-for-earlier-models).

## Migrating to Claude Mythos 5.2 from Claude Mythos 5

[Claude Mythos 5.2](https://platform.claude.com/docs/en/models/mythos-5-2/overview) is the counterpart to Claude Fable 5.2 for organizations verified through Anthropic’s verification programs, such as the [Cyber Verification Program](https://support.claude.com/en/articles/14604842). Confirm that your organization has access to Claude Mythos 5.2 before you switch model IDs.

Four of the changes in [Migrating to Claude Fable 5.2 from Claude Fable 5](https://platform.claude.com/docs/en/models/fable-5-2/migration-guide#migrating-from-claude-fable-5-to-claude-fable-5-2) apply as written:

* [Forced tool choice returns a 400 error](https://platform.claude.com/docs/en/models/fable-5-2/migration-guide#fable-5-2-forced-tool-choice).
* [Editing earlier turns invalidates thinking blocks](https://platform.claude.com/docs/en/models/fable-5-2/migration-guide#fable-5-2-edited-history) (for every account).
* [Use the computer use toolset instead of `computer_20251124`](https://platform.claude.com/docs/en/models/fable-5-2/migration-guide#fable-5-2-computer-use).
* A Claude Fable 5.2 or Claude Mythos 5.2 executor [needs one of those two models as its advisor](https://platform.claude.com/docs/en/models/fable-5-2/migration-guide#fable-5-2-advisor-pairs).

On the Claude API and Claude Models on Google Cloud (Google managed), Claude Mythos 5.2 reads Claude Mythos 5’s thinking blocks, so a conversation that moves from `claude-mythos-5` onto `claude-mythos-5-2` keeps its earlier reasoning. In the other direction, Claude Mythos 5 can’t read Claude Mythos 5.2’s blocks: the API drops them, and the request succeeds. See [Switching models mid-conversation](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#switching-models). Claude Mythos 5.2 costs $8 USD per million input tokens and $40 USD per million output tokens, compared with $10 USD and $50 USD on Claude Mythos 5. Prompt cache reads are $0.20 USD per million tokens, compared with $1 USD.

### Update your model name

```python
model = "claude-mythos-5"  # Before
model = "claude-mythos-5-2"  # After
```

### Migration checklist

* Update the model name from `claude-mythos-5` to `claude-mythos-5-2`.
* Replace forced `tool_choice` (`any` or `tool`) with `auto` plus an explicit instruction and `strict: true` tools, or with JSON outputs. In an organization with [customer-managed encryption keys](https://platform.claude.com/docs/en/manage-claude/cmek), strict tool use and JSON outputs aren’t available for Claude Mythos 5.2. There, keep `auto` and the instruction, and validate the tool input in your code.
* If you use computer use through `computer_20251124`, Claude Mythos 5.2 returns a 400 error for that tool. Declare `computer_toolset_20260801` instead and update your agent loop for the toolset.
* If you use the advisor tool with Claude Mythos 5.2 as the executor, set the advisor’s `model` to `claude-mythos-5-2` or `claude-fable-5-2`.
* Keep passing `thinking` blocks back unchanged on every turn, including empty ones.
* If you replay stored conversations through a different account, replay each one through the account that produced it, or an account linked to it. The API drops Claude Mythos 5.2 thinking blocks that another account produced. See [Thinking blocks stay with the account that produced them](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#account-bound-thinking).
* If your code builds the `messages` array itself, run the check in [Editing earlier turns invalidates thinking blocks](https://platform.claude.com/docs/en/models/fable-5-2/migration-guide#fable-5-2-edited-history) against `claude-mythos-5-2`, fix every `prefix_binding_mismatch` entry, and keep conversation history append-only (see [What counts as an edit](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#what-counts-as-an-edit)). An append-only history also keeps the prompt cache warm.
* Handle `stop_reason: "refusal"` and read `stop_details.category` before response content. See [Refusals and fallback](https://platform.claude.com/docs/en/build-with-claude/refusals-and-fallback).
* Re-run your effort sweep, and re-baseline cost and latency.
* Check the system prompts, skills, and other instructions you carry over against [Review instructions written for earlier models](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5-2#review-instructions-written-for-earlier-models).

## Migrating to Claude Fable 5.2 from Claude Opus 5

Claude Fable 5.2 uses the same [Messages API](https://platform.claude.com/docs/en/build-with-claude/working-with-messages) and [tool use](https://platform.claude.com/docs/en/agents-and-tools/tool-use/overview) patterns as [Claude Opus 5](https://platform.claude.com/docs/en/models/opus-5/overview). The 1M token context window, 128k max output tokens, the 512-token prompt caching minimum, and [mid-conversation system messages](https://platform.claude.com/docs/en/build-with-claude/mid-conversation-system-messages) carry over. So do the restrictions on prefill and sampling parameters. The following differences apply when you move traffic, or a fallback path, onto Claude Fable 5.2.

### Update your model name

```python
model = "claude-opus-5"  # Before
model = "claude-fable-5-2"  # After
```

### What changes

1. **Thinking can’t be disabled:** Claude Opus 5 accepts `thinking: {type: "disabled"}` at an [effort](https://platform.claude.com/docs/en/build-with-claude/effort) level of `high` or lower. On Claude Fable 5.2, [adaptive thinking](https://platform.claude.com/docs/en/build-with-claude/thinking) is always on, and `thinking: {type: "disabled"}` returns a 400 error at any effort level. Remove the field, and control token spend with lower effort levels. For workloads that ran with thinking disabled, revisit `max_tokens`, which covers thinking plus response text. If that code reads content by position, such as `content[0].text`, select content blocks by `type` instead, because `thinking` blocks come first.

2. **Forced tool choice returns a 400 error:** Claude Opus 5 accepts `tool_choice` `any` and `tool`. Claude Fable 5.2 rejects both. See [Forced tool choice returns a 400 error](https://platform.claude.com/docs/en/models/fable-5-2/migration-guide#fable-5-2-forced-tool-choice) for what to send instead.

3. **Editing earlier turns invalidates thinking blocks, on every account:** Claude Opus 5 doesn’t check whether earlier turns changed. Claude Fable 5.2 does, for every account. If your code edits earlier messages, rebuilds `system` or `tools`, or compacts on the client between requests, Claude Fable 5.2 rejects the request or drops the invalid thinking blocks. See [Editing earlier turns invalidates thinking blocks](https://platform.claude.com/docs/en/models/fable-5-2/migration-guide#fable-5-2-edited-history) for what to change and how to test.

4. **Claude Opus 5 can’t read Claude Fable 5.2’s thinking blocks:** On the Claude API and Claude Models on Google Cloud (Google managed), Claude Fable 5.2 reads Claude Opus 5’s blocks, so a conversation that moves from `claude-opus-5` onto `claude-fable-5-2` keeps its earlier reasoning. In the other direction, Claude Opus 5 can’t read Claude Fable 5.2’s blocks. A conversation that moves from Claude Fable 5.2 to Claude Opus 5 runs the turns after the switch without Claude Fable 5.2’s reasoning. The API drops those blocks before the model receives them, the request succeeds, and the dropped blocks aren’t billed. See [Switching models mid-conversation](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#switching-models).

5. **Text between tool calls is returned in thinking blocks:** On Claude Opus 5, text the model writes between tool calls comes back as `text` blocks. On Claude Fable 5.2, that narration comes back as progress-update `thinking` blocks, at most one before each tool call. If your interface renders that narration, set `thinking.display` to `"updates"`, which is in beta, to receive the progress updates as text while reasoning stays hidden, or to `"summarized"` to receive both. Then render the non-empty `thinking` blocks between `tool_use` blocks. See [Progress updates between tool calls](https://platform.claude.com/docs/en/build-with-claude/thinking#progress-updates).

6. **Use the computer use toolset instead of `computer_20251124`:** Claude Opus 5 accepts the earlier `computer_20251124` tool with its beta header. Claude Fable 5.2 returns a 400 error for it. See [Use the computer use toolset instead of `computer_20251124`](https://platform.claude.com/docs/en/models/fable-5-2/migration-guide#fable-5-2-computer-use).

7. **Safety classifiers and fallback:** Claude Fable 5.2’s safety classifiers cover a broader set of `stop_details` categories than Claude Opus 5’s classifiers. Expect additional `stop_details.category` values, such as `"bio"`. Handle every category in the [refusal category table](https://platform.claude.com/docs/en/build-with-claude/refusals-and-fallback#refusal-response). To re-run declined requests on another model, set `fallbacks: "default"` or build your own retry. That parameter is in beta on the Claude API and Claude Models on Google Cloud (Anthropic managed), and needs the `server-side-fallback-2026-07-01` beta header. [Refusals, fallback, and billing](https://platform.claude.com/docs/en/models/fable-5-2/whats-new-fable-5-2#refusals-fallback-and-billing) lists the permitted fallback targets.

8. **Pricing:** Claude Fable 5.2 costs $8 USD per million input tokens and $40 USD per million output tokens, compared with $5 USD and $25 USD for Claude Opus 5. Prompt cache reads are $0.20 USD per million tokens, compared with $0.50 USD. See [Pricing](https://platform.claude.com/docs/en/about-claude/pricing).

Cut at 300 lines. The page has the rest.