Claude Platform Docs
Models & pricingClaude Fable 5.1

Claude Fable 5.1 and Claude Mythos 5.1 migration guide

Switch to Claude Fable 5.1 and Claude Mythos 5.1 from Claude Fable 5, Claude Mythos 5, Claude Opus 5, or Claude Opus 4.8 with this migration guide. The guidance to enable Claude Fable 5.1 and Claude Mythos 5.1 includes model IDs, breaking changes, and migration checklists.

Claude Code

Let Claude Code migrate your code for you

/claude-api migrate this project to claude-fable-5-1

Claude Fable 5.1 succeeds Claude Fable 5 at the same input and output prices, with cache reads at a quarter of the cost. It’s available on the Claude API, Amazon Bedrock, Claude Platform on AWS, Claude Models on Google Cloud (Anthropic managed), Claude Models on Google Cloud (Google managed), and Microsoft Foundry. Claude Fable 5.1 doesn’t require access approval. Claude Mythos 5.1 shares the same capabilities and is available only to organizations verified through Anthropic’s verification programs, such as the Cyber Verification Program. To request access, apply to the program that covers your use case or contact your Anthropic account team. For behavioral differences and prompting patterns, see Prompting Claude Fable 5.1.

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

  • Thinking: Adaptive thinking is always on, unchanged from Claude Fable 5. The model determines when and how much to think. No thinking configuration is required. Both thinking: {type: "disabled"} and manual extended thinking (thinking: {type: "enabled", budget_tokens: N}) return a 400 error.
  • Prefill: Prefilling the assistant message returns a 400 error, unchanged from Claude Fable 5. Use system prompt instructions instead.
  • 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. See Breaking changes.
  • Preserved thinking across models: Claude Fable 5.1 and Claude Mythos 5.1 read thinking blocks from Claude Opus 5, Claude Fable 5, Claude Mythos 5, and earlier Claude models. None of those models can read blocks from Claude Fable 5.1 or Claude Mythos 5.1. See Breaking changes.
  • Edits to earlier turns: A thinking block stays valid only while everything sent before it is unchanged, so keep the conversation history append-only. See Editing earlier turns invalidates thinking blocks.
  • Context window and output: Both models have a 1M token context window and return up to 128k output tokens for each request.
  • Pricing: $10 USD per million input tokens and $50 USD per million output tokens, the same as Claude Fable 5. Prompt cache reads are $0.25 USD per million tokens, a quarter of the Claude Fable 5 rate. See 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 and Claude Mythos 5. 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 for per-platform details.
  • Priority Tier: Neither model is supported on Priority Tier. Claude Fable 5 is.

Migrating to Claude Fable 5.1 from Claude Fable 5

Migration is mostly drop-in. The API surface, limits, per-token pricing, tokenizer, always-on adaptive thinking, refusal handling, and stop_details categories all match Claude Fable 5. The following changes apply:

  • A request that forces a tool call gets a 400 error.
  • Only Claude Fable 5.1 and Claude Mythos 5.1 read Claude Fable 5.1’s thinking blocks.
  • Editing earlier turns invalidates later thinking blocks.
  • Cache reads cost less.
  • The advisor tool (beta) accepts fewer advisors.
  • Agent-loop behavior differs in three ways.

Update your model name

model = "claude-fable-5"  # Before
model = "claude-fable-5-1"  # After

# Or, for Claude Mythos 5.1, which offers the same capabilities to verified organizations:
model = "claude-mythos-5-1"  # After

Breaking changes

  1. Forced tool choice is not supported: Claude Fable 5 accepts tool_choice auto, none, any, and tool. On claude-fable-5-1, {type: "any"} and {type: "tool", name: "..."} return a 400 invalid_request_error:

    tool_choice: type "tool" and "any" are not supported for this model.

    The check applies on the Messages API, the Message Batches API, and the token counting endpoint.

    Before (Claude Fable 5):

    client = anthropic.Anthropic()

record_summary_tool = {
    "name": "record_summary",
    "description": "Record the structured summary of the document.",
    "input_schema": {
        "type": "object",
        "properties": {"summary": {"type": "string"}},
        "required": ["summary"],
    },
}

response = client.messages.create(
    model="claude-fable-5",
    max_tokens=16000,
    tools=[record_summary_tool],
    tool_choice={"type": "tool", "name": "record_summary"},
    messages=[{"role": "user", "content": "Summarize: The meeting moved to Thursday."}],
)
print(response.content)

    After (Claude Fable 5.1): leave tool_choice at auto, name the tool in the instruction, and set strict: true so the call matches your schema. (In a CMEK organization, where structured outputs, including strict: true, are not available on Claude Fable models, rely on the instruction alone.) For example:

    client = anthropic.Anthropic()

record_summary_tool = {
    "name": "record_summary",
    "description": "Record the structured summary of the document.",
    "strict": True,
    "input_schema": {
        "type": "object",
        "properties": {"summary": {"type": "string"}},
        "required": ["summary"],
        "additionalProperties": False,
    },
}

response = client.messages.create(
    model="claude-fable-5-1",
    max_tokens=16000,
    tools=[record_summary_tool],
    tool_choice={"type": "auto"},
    messages=[
        {
            "role": "user",
            "content": "Summarize: The meeting moved to Thursday. Call the record_summary tool with your result.",
        }
    ],
)
print(response.content)

    See Strict tool use and Forcing tool use. If you forced a tool only to get schema-conformant JSON, use JSON outputs (output_config.format) instead.

    If your application, rather than the user, requires a specific tool call on the current turn of a multi-turn conversation, append a mid-conversation system message after the latest user turn. Name the tool, say the call is required for this turn, and tell Claude to open its response with it. Because the message is appended rather than written into the top-level system prompt, earlier turns stay byte-identical and keep their prompt cache hits:

    client = anthropic.Anthropic()

search_help_center_tool = {
    "name": "search_help_center",
    "description": "Search the help center for policy and troubleshooting articles.",
    "strict": True,
    "input_schema": {
        "type": "object",
        "properties": {"query": {"type": "string"}},
        "required": ["query"],
        "additionalProperties": False,
    },
}

response = client.messages.create(
    model="claude-fable-5-1",
    max_tokens=16000,
    system="You are a customer support assistant for an online electronics store.",
    tools=[search_help_center_tool],
    messages=[
        {
            "role": "user",
            "content": "My headphones from order A1234 arrived yesterday.",
        },
        {
            "role": "assistant",
            "content": "Thanks for confirming. How can I help with order A1234?",
        },
        {"role": "user", "content": "I opened the box. Can I still return them?"},
        # The application requires a help center lookup before any policy
        # answer. Appending the requirement as a system message leaves the
        # earlier turns unchanged.
        {
            "role": "system",
            "content": "Tool-use requirement for the current turn: the application requires a call to the search_help_center tool in your response to the user's latest message. Begin your response with the search_help_center tool call. Do not reply with text only.",
        },
    ],
)
print(response.content)

    Keep the role: "system" message in the history on later requests, as with any other turn. Mid-conversation system messages need no beta header. tool_choice: {"type": "none"} still works for a turn that must not call tools.

  2. Only Claude Fable 5.1 and Claude Mythos 5.1 read Claude Fable 5.1’s thinking blocks: Every thinking block records which model produced it. Claude Fable 5.1 reads its own blocks and those from Claude Mythos 5.1, Claude Opus 5, Claude Fable 5, Claude Mythos 5, and earlier Claude models. A conversation moving onto claude-fable-5-1 from any of those keeps its earlier reasoning. The condition is one-way: apart from Claude Mythos 5.1, none of those models can read Claude Fable 5.1’s blocks.

    A conversation that ran on Claude Fable 5.1 can land on another model, older or newer, through a router switch, a client-side retry, or a classifier refusal fallback, including a server-side fallback. The API removes the blocks that model can’t read before it receives them, the request succeeds, and you aren’t billed for the dropped input tokens. The target model re-plans without that reasoning, which can raise cost and latency on the first turn after the switch. To see what was dropped, send the thinking-binding-controls-2026-08-01 beta header: responses then carry an input_transformations array naming each dropped block with reason: "model_binding_mismatch". See Switching models mid-conversation.

  3. Editing earlier turns invalidates thinking blocks: On Claude Fable 5.1 and Claude Mythos 5.1, a thinking block you send back stays valid only while everything sent before it is unchanged: the system prompt, the tools, and the earlier messages. Claude Code, claude.ai, Claude Managed Agents, and the Claude Agent SDK keep that history intact for you. If your code builds the messages array itself, this item applies to you, and Preserved thinking is the full integration guide.

    The thinking.block_binding.prefix_mismatch_behavior field (beta header thinking-binding-controls-2026-08-01) sets what the API does with an invalid block. "error" rejects the request with a 400 error. "drop_block" drops the invalid block and every thinking block after it, and the request succeeds. When a request leaves the field unset, the outcome depends on the model and on when your account was created:

    ModelAccount created on or after August 31, 2026Account created before August 31, 2026
    Claude Fable 5.1400 errorNo error (failing blocks reach the model)
    Claude Mythos 5.1400 error400 error

    To see the 400 error from your own account, set the field to "error" on your test requests. Do this before you ship a tool that people run with their own API keys: their accounts can get the 400 error where yours doesn’t. The full table, with the platforms it applies to, is in When prefix_mismatch_behavior is unset.

    The 400 error looks like this:

    messages.5.content.0: Invalid `signature` in `thinking` block. The block is bound to a different conversation. Remove the block, or set `thinking.block_binding.prefix_mismatch_behavior` to "drop_block". That setting requires the `thinking-binding-controls-2026-08-01` value in the `anthropic-beta` header.

    The error comes back every time a request sends the invalid block, so a retry loop won’t clear it. To continue without the invalidated reasoning, strip the block the error names and every later thinking and redacted_thinking block, then retry once. Alternatively, send the thinking-binding-controls-2026-08-01 beta header and set prefix_mismatch_behavior to "drop_block" on every later request in the conversation. The response then reports each dropped block in its input_transformations array with reason: "prefix_binding_mismatch":

    client = anthropic.Anthropic()

response = client.beta.messages.create(
    model="claude-fable-5-1",
    max_tokens=16000,
    thinking={
        "type": "adaptive",
        "block_binding": {"prefix_mismatch_behavior": "drop_block"},
    },
    messages=[
        {
            "role": "user",
            "content": "What is the greatest common divisor of 1071 and 462?",
        }
    ],
    betas=["thinking-binding-controls-2026-08-01"],
)

for block in response.content:
    if block.type == "text":
        print(block.text)

print(f"Input transformations: {len(response.input_transformations or [])}")

    The token counting endpoint runs the same check. See Set the mismatch behavior and read input_transformations for the response shape and streaming placement.

    Patterns that invalidate later thinking blocks, and what to do instead:

    • Editing, reordering, or removing earlier turns. This includes deleting old tool results, snipping turns out of the middle of the transcript, and client-side compaction that keeps recent turns and their thinking blocks verbatim behind a summary (including background compaction that swaps its summary in a few turns later). Instead, use server-side compaction or context editing (tool result clearing for old tool results), or one of the client-side compaction shapes under Trim context on the server, or compact in a shape that carries no stale thinking.
    • Injecting content you don’t persist, for example a per-turn reminder appended after the tool_result blocks and removed on the next request. Instead, send the reminder as a turn-scoped system message and leave it in the history.
    • Rebuilding the top-level system prompt or the tools array between requests in the same conversation, for example to update the current date or to add or remove a tool. Instead, append a mid-conversation system message that carries the new instruction (“The current date is 2026-09-14.”) or tool_addition and tool_removal blocks. A tool that wasn’t declared in tools at the start can be defined inside the tool_addition block (beta header inline-tools-2026-09-15).
    • An image or document URL that serves different bytes on a later request. The prefix check covers the bytes, not the URL string, so a rotating signed URL for the same file is fine. For content you reference across turns, upload it once with the Files API and send the file_id, or send base64.

    Each replacement also keeps earlier turns byte-identical and preserves the prompt cache hits that editing the history, system prompt, or tools array would lose.

    Patterns that keep working:

    • Append-only histories: adding turns and passing earlier turns back exactly as sent and received, including appended role: "system" messages.
    • Removing the oldest thinking blocks (from the start of the history), the newest (from the end), or all of them.
    • Changing effort, max_tokens, or any other request parameter outside model, system, tools, and messages, and adding or moving cache_control markers.
    • Server-side compaction and context editing, including thinking block clearing. They don’t count as edits, because the check compares the conversation as you sent it.

    To check an existing integration:

    1. Capture the exact request bodies it sends over a few normal turns, including a compaction or a tool change if your product has them. For each pair of consecutive requests, compare the system prompt, the tools array, and the shared prefix of messages. They should be byte-identical up to the newly appended turns. An expected exception is a request that swaps in a signed compaction block from on-demand compaction: the block replaces the messages it summarizes at the front of messages, and everything after it should still match.
    2. Run a normal multi-turn session against claude-fable-5-1 with the thinking-binding-controls-2026-08-01 beta header and prefix_mismatch_behavior: "drop_block". Log input_transformations on every response. In a session whose responses include thinking blocks, an empty array on every turn means the history is intact. An entry with reason: "prefix_binding_mismatch" means something before the block at path changed since that block was produced. An entry with reason: "model_binding_mismatch" means the conversation switched models, which isn’t a bug in your code. Because every request sets the field, this test works from any account. In CI, set "error" instead so an edit fails the run.
    3. Choose a production setting and send it on every request. Use "error" if a prefix mismatch can only mean a bug in your code. Use "drop_block" if you’d rather drop the affected blocks than fail. Either way, monitor the 400 errors or the input_transformations entries.

    Dropping thinking blocks once, at a compaction boundary for example, has little effect. An integration that invalidates prior thinking on every request restarts the prompt cache each time, which can raise cost per task (see Keep the conversation history append-only).

  4. The advisor tool accepts fewer advisors: With the advisor tool (beta), the advisor must be at least as capable as the executor. With a claude-fable-5-1 executor, a less capable advisor, such as claude-fable-5 or claude-opus-5-5, returns a 400 invalid_request_error. Choose an advisor that Model compatibility lists for the executor.

Behavior changes

  1. Fewer parallel tool calls in long agent loops: In long-running loops where the next independent reads are only implied by the task (custom coding agents, bash-and-editor harnesses, computer use), Claude Fable 5.1 might issue one tool call in each turn. Each extra turn costs tokens, a round trip, and wall-clock time. Append a one-sentence batching instruction after each user message as a turn-scoped system message (clear_at: "next_user_message", beta), or, without the beta, in a text block after the tool_result blocks, and leave the earlier copies in the history on later requests. See Batch independent tool calls in agent loops.

  2. Fewer progress messages between tool calls: Claude Fable 5.1 writes fewer status updates during long tool sequences than Claude Fable 5, and its agentic coding summaries are shorter. If your interface renders those updates, set thinking.display to "updates" (beta) or "summarized" and prompt for them explicitly. See Progress updates between tool calls and Ask for user-facing progress updates.

  3. Fewer search and retrieval calls at low effort: At low effort Claude Fable 5.1 answers from memory more often than Claude Fable 5 instead of calling a search or retrieval tool. If your product relies on retrieval at low effort, raise effort for those requests or tell the model when to search. See Search triggering at low effort.

For the differences in prose density, chat formatting, quoting in summaries, and file edits, which don’t affect API integration, see Changed from Claude Fable 5.

These changes aren’t required, but each one lowers cost or latency or removes a failure mode:

  1. Change effort mid-conversation (beta): On Claude Fable 5, output_config.effort is request-level, and changing it between requests drops cached prefixes from earlier turns. On claude-fable-5-1, a role: "system" message carrying only output_config raises effort for a hard step or lowers it for routine ones without invalidating the prompt cache:

    client = anthropic.Anthropic()

response = client.beta.messages.create(
    model="claude-fable-5-1",
    max_tokens=4096,
    output_config={"effort": "high"},
    messages=[
        {
            "role": "user",
            "content": "Plan a migration from SQLite to PostgreSQL in three short steps.",
        },
        {
            "role": "assistant",
            "content": "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts.",
        },
        # Effort-only system message: the new level takes effect from the next user turn.
        {"role": "system", "content": [], "output_config": {"effort": "low"}},
        {"role": "user", "content": "Summarize the plan in one sentence."},
    ],
    betas=["mid-conversation-output-config-2026-07-01"],
)

for block in response.content:
    if block.type == "text":
        print(block.text)

    Placed between an assistant turn and the next user turn, as here, the message takes effect from that user turn. Placed directly after a user turn with new input, it sets the level for Claude’s reply to that turn. A user turn that holds only tool results doesn’t count as new input: the change waits for the next user turn with new input. The level then holds until another role: "system" message changes it. Only the named levels are accepted (low, medium, high, xhigh, max), and the mid-conversation-output-config-2026-07-01 beta header is required. See Per-message effort.

  2. Change instructions and tools with mid-conversation system messages: To change instructions or tools partway through a session, append a role: "system" message, with tool_addition and tool_removal blocks for tool changes. On the Claude API, Claude Platform on AWS, and Claude Models on Google Cloud (Anthropic managed), send the beta header inline-tools-2026-09-15 for tool changes. A tool_addition block can name a tool declared in tools at session start or carry the tool’s full definition, so a tool that is unknown at session start doesn’t need to be in tools. This preserves prompt cache hits on earlier turns and keeps the conversation history append-only. The mid-conversation-tool-changes-2026-07-01 header works for changes that name a tool by reference, on the Claude API, Amazon Bedrock, Claude Platform on AWS, Claude Models on Google Cloud (Anthropic managed), and Claude Models on Google Cloud (Google managed). The same message replaces forced tool_choice when a specific tool must run on the current turn (see Breaking changes). For a reminder that applies to one turn only, send it as a separate text-only role: "system" message with clear_at: "next_user_message" (turn-scoped system messages, beta header mid-conversation-system-clear-at-2026-08-21) and leave it in the history: it stops rendering after the next user message and costs no tokens once cleared. A message that carries tool_addition or tool_removal blocks can’t be turn-scoped.

  3. Use fallbacks: "default" for refusals: Keep handling stop_reason: "refusal" and reading stop_details.category before response content. To re-run refused requests on another model automatically, set fallbacks: "default" (beta, server-side-fallback-2026-07-01 header). "default" retries a declined request on the model Anthropic recommends for that category. The permitted fallback targets for Claude Fable 5.1 are Claude Opus 4.8 (claude-opus-4-8) and Claude Opus 5 (claude-opus-5). An explicit fallbacks list may name either. The fallback model doesn’t receive Claude Fable 5.1’s thinking blocks. The fallbacks parameter isn’t available on Amazon Bedrock, Claude Models on Google Cloud (Google managed), or Microsoft Foundry. On those platforms, use client-side fallback instead. If you build the retry yourself, fallback credit applies on the same terms as Claude Fable 5. See Refusals and fallback.

  4. Start at high effort and sweep: The effort parameter default is high, and all five levels are supported. Keep the Claude Fable 5 guidance: high for most work, and medium as a cost control worth testing. Claude Fable 5.1’s gains over Claude Fable 5 are largest at xhigh and max, but those levels also add thinking time and time-to-first-response, so step up to them for the most capability-sensitive tasks and where your evals show the gain. Run a fresh sweep on your own evals rather than carrying over a setting tuned for Claude Fable 5. See Recommended effort levels for Claude Fable 5.1.

  5. Trim context on the server, or compact in a shape that carries no stale thinking: If your code truncates or summarizes older turns on the client, the simplest fix is to move that work to server-side compaction or context editing. Neither counts as an edit: the prefix check compares the conversation as you sent it, so nothing they remove invalidates later thinking blocks. Compaction’s instructions parameter also accepts your own summarization prompt. If you keep recent turns verbatim behind the summary, or summarize in the background while the conversation continues, use on-demand compaction (beta header compact-2026-09-04) rather than a client-written summary. The API writes a signed summary block that you put in place of the messages it summarizes. The thinking blocks in the turns you keep can stay valid, under the conditions in Compaction and preserved thinking. If you keep compaction on the client, pick one of three shapes:

    • Simple compaction (recommended): replace the whole history with one summary message plus the new user turn and replay nothing else. No thinking blocks are carried over, so nothing fails. Claude models are trained on long-horizon tasks with this scheme, and it performs comparably to more elaborate ones for most workloads.
    • Keep-tail compaction: if you keep the most recent turns verbatim behind a summary, strip the thinking and redacted_thinking blocks from those turns (text and tool calls can stay), or set prefix_mismatch_behavior: "drop_block". Their thinking was produced against the full history and fails behind the summary otherwise.
    • Background compaction: if you build the summary off the critical path and swap it in later, every turn produced in the meantime carries thinking that predates the swap. Send "drop_block" on every request that still carries thinking blocks produced before the swap (or strip those blocks yourself; input_transformations on the first response after the swap lists exactly which ones), or compact synchronously.

    Don’t snip individual turns out of the middle of the transcript: that invalidates every later thinking block and no client-side shape avoids it. Use a mid-conversation system message for the instruction change you were making, or server-side context editing for selective removal. See Passing compaction blocks back.

Migration checklist

  • Update the model name from claude-fable-5 to claude-fable-5-1 (or claude-mythos-5 to claude-mythos-5-1).
  • Replace forced tool_choice ({type: "any"} or {type: "tool", ...}): a request that sets it gets a 400 error. Use {type: "auto"} with an explicit instruction and strict: true tools, or use JSON outputs. When your application requires the call, put the instruction in the user turn or in a mid-conversation role: "system" message.
  • If you use the advisor tool (beta), update the advisor model as well. An advisor less capable than Claude Fable 5.1, such as claude-fable-5 or claude-opus-5-5, returns a 400 error.
  • Keep passing thinking blocks back unchanged on every turn, including empty ones. Claude Fable 5.1 and Claude Mythos 5.1 read blocks from Claude Opus 5, Claude Fable 5, Claude Mythos 5, and earlier models. Moving a conversation from Claude Fable 5.1 to any model other than Claude Mythos 5.1 drops its blocks.
  • If your code builds the messages array itself, check whether it edits earlier turns: 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. model_binding_mismatch entries after a model switch are expected.
  • Keep conversation history append-only. Freeze system and tools at session start and move mid-session changes to role: "system" messages and tool_addition / tool_removal blocks. Send per-turn reminders as turn-scoped system messages you never remove. Trim context server-side or strip thinking blocks from any turns you carry across a client-side summary. Reference cross-turn files by file_id.
  • Set prefix_mismatch_behavior on every production request. "error" fails a request that sends back an invalid thinking block. "drop_block" drops the invalid blocks and lets the request succeed. Monitor the 400 errors or the input_transformations entries.
  • Review agent loops for one-tool-call-per-turn behavior and add the batching instruction.
  • If your interface renders progress text between tool calls, set thinking.display to "updates" (beta) or "summarized" and prompt for updates.
  • If you change effort between requests, move the change to a per-message effort role: "system" message (beta) to keep cache hits.
  • Handle stop_reason: "refusal" and read stop_details.category. Consider fallbacks: "default" (beta).
  • Re-evaluate effort with a fresh sweep, starting at high, and re-baseline cost and latency on your own workloads. The tokenizer is unchanged. Prompt cache reads cost a quarter of the Claude Fable 5 rate.
  • If you have a Priority Tier commitment for your current model, it doesn’t cover Claude Fable 5.1, which isn’t supported on Priority Tier.

Migrating to Claude Fable 5.1 from Claude Opus 5

Claude Fable 5.1 uses the same Messages API and tool use patterns as Claude Opus 5. It keeps the 1M token context window by default, 128k max output tokens, the 512-token prompt caching minimum, and mid-conversation system message support. The prefill restriction, the sampling-parameter restriction, and the "omitted" default for thinking.display also carry over. Apply everything in Migrating to Claude Fable 5.1 from Claude Fable 5, plus the following.

Update your model name

model = "claude-opus-5"  # Before
model = "claude-fable-5-1"  # After

# Or, for Claude Mythos 5.1, which offers the same capabilities to verified organizations:
model = "claude-mythos-5-1"  # After

What changed

  1. Thinking can’t be disabled: Claude Opus 5 accepts thinking: {type: "disabled"} at an effort level of high or lower. On claude-fable-5-1 and claude-mythos-5-1, adaptive thinking is always on, and thinking: {type: "disabled"} returns a 400 error at any effort level. Remove the field, control token spend with lower effort levels, and revisit max_tokens for workloads that ran with thinking disabled. Responses from those workloads can start with thinking blocks, so select content blocks by type instead of by position.

  2. Forced tool choice is not supported: Claude Opus 5 accepts tool_choice any and tool. claude-fable-5-1 and claude-mythos-5-1 return a 400 error. See Breaking changes.

  3. Preserved thinking across models: Claude Fable 5.1 and Claude Mythos 5.1 read Claude Opus 5’s thinking blocks: conversations moving from claude-opus-5 to claude-fable-5-1 or claude-mythos-5-1 keep their reasoning. Claude Opus 5 can’t read blocks from either model. See Breaking changes.

  4. Editing earlier turns invalidates thinking blocks: Claude Opus 5 doesn’t run the prefix check. On claude-fable-5-1 and claude-mythos-5-1, editing earlier messages, rebuilding system or tools, or compacting on the client between requests invalidates every later thinking block. Before you switch traffic, run the three-step check from the Claude Fable 5 section.

  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-1, as on Claude Fable 5, that narration comes back as progress-update thinking blocks, one before each tool call. Under the default thinking.display of "omitted", they carry no readable text. If your interface renders that narration, set thinking.display to "updates" (beta) to receive 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.

  6. Safety classifiers and fallback routing: Claude Fable 5.1 runs safety classifiers covering the same stop_details categories as Claude Fable 5, a broader set than Claude Opus 5’s classifiers. Expect additional stop_details.category values, such as "bio"; see the refusal category table for the full set. For fallbacks configuration and permitted targets, see Use fallbacks: "default" for refusals.

  7. Pricing: $10 USD per million input tokens and $50 USD per million output tokens, compared with $5 USD and $25 USD for Claude Opus 5. Prompt cache reads are $0.25 USD per million tokens, half the Claude Opus 5 rate. See Claude pricing.

  8. Data retention: Claude Fable 5.1 and Claude Mythos 5.1 require 30-day data retention, aren’t available under zero data retention (ZDR) arrangements unless expressly authorized by Anthropic, and are designated Covered Models. Claude Opus 5 is available under ZDR. See Model-specific data retention requirements.

Migration checklist

  • If your organization has a zero data retention (ZDR) arrangement, confirm eligibility first: these models aren’t available under ZDR unless expressly authorized by Anthropic. See Model-specific data retention requirements.
  • Update the model name from claude-opus-5 to claude-fable-5-1 (or claude-mythos-5-1).
  • Remove any thinking: {type: "disabled"} configuration: it returns a 400 error on claude-fable-5-1. Control token spend with lower effort levels, and revisit max_tokens.
  • If you removed thinking: {type: "disabled"}, update response parsing that reads content by position, such as content[0].text: a response can start with thinking blocks, so select content blocks by type instead.
  • Replace forced tool_choice (any or tool) with auto plus an explicit instruction (user turn or mid-conversation system message) and strict: true tools, or with JSON outputs.
  • If your interface renders text between tool calls, set display: "updates" (beta) or "summarized" and render the non-empty thinking blocks.
  • Apply the advisor, preserved-thinking, append-only, behavior, effort, and fallback items from the Claude Fable 5 checklist.
  • Re-baseline cost on your own workloads. The tokenizer is unchanged. Per-token pricing differs.

Migrating to Claude Fable 5.1 from Claude Opus 4.8 or earlier

Work through the following checklist. On Claude Opus 4.7 or earlier, start with the matching Claude Opus 5.5 migration guide section.

Update your model name

model = "claude-opus-4-8"  # Before
model = "claude-fable-5-1"  # After

# Or, for Claude Mythos 5.1, which offers the same capabilities to verified organizations:
model = "claude-mythos-5-1"  # After

Migration checklist

  • If your organization has a zero data retention (ZDR) arrangement, confirm eligibility first: these models aren’t available under ZDR unless expressly authorized by Anthropic. Claude Opus 4.8 is available under ZDR.
  • Update the model name from claude-opus-4-8 to claude-fable-5-1 (or claude-mythos-5-1).
  • Remove any thinking: {type: "disabled"} configuration and revisit max_tokens. Requests without a thinking field run with adaptive thinking.
  • Update response parsing that reads content by position, such as content[0].text: a response can start with thinking blocks, so select content blocks by type instead.
  • Replace forced tool_choice (any or tool) with auto plus an explicit instruction (user turn or mid-conversation system message) and strict: true tools, or with JSON outputs.
  • Pass thinking blocks back unchanged and treat their text as display-only. Claude Fable 5.1 and Claude Mythos 5.1 read Claude Opus 4.8’s thinking blocks: a conversation that moves onto claude-fable-5-1 or claude-mythos-5-1 keeps its earlier reasoning. Claude Opus 4.8 can’t read their blocks.
  • If your code builds the messages array itself, check whether it edits earlier turns. Integrations written for Claude Opus 4.8 and earlier often truncate old turns, strip or rebuild earlier messages, or refresh the system prompt each request, and Claude Opus 4.8 returns no error for any of them. On claude-fable-5-1 and claude-mythos-5-1, each of those invalidates later thinking blocks.
  • Handle stop_reason: "refusal", read stop_details.category, and consider fallbacks: "default" (beta).
  • Apply the advisor, Priority Tier, preserved-thinking, append-only, behavior, per-message effort, and progress-update items from the Claude Fable 5 checklist.
  • Re-evaluate effort (start at high), review prompts near the 512-token caching minimum (1,024 tokens on Claude Opus 4.8), and re-baseline cost and latency. Per-token pricing differs, and thinking tokens are billed as output tokens, so workloads that ran without thinking on Claude Opus 4.8 can produce more output tokens per request.

Migrating to Claude Mythos 5.1 from Claude Mythos 5

Claude Mythos 5.1 is the counterpart to Claude Fable 5.1 for organizations verified through Anthropic’s verification programs, such as the Cyber Verification Program. Confirm that your organization has access to Claude Mythos 5.1 before you switch model IDs.

Everything in Migrating to Claude Fable 5.1 from Claude Fable 5 applies, with claude-mythos-5 and claude-mythos-5-1 in place of the Claude Fable model IDs. Claude Mythos 5.1 reads Claude Mythos 5’s thinking blocks; Claude Mythos 5 can’t read Claude Mythos 5.1’s. On Claude Mythos 5.1, a request that sends back an invalid thinking block and leaves prefix_mismatch_behavior unset gets a 400 error (see When prefix_mismatch_behavior is unset).

Update your model name

model = "claude-mythos-5"  # Before
model = "claude-mythos-5-1"  # After

Migration checklist

  • Work through the Claude Fable 5 checklist with the Claude Mythos model IDs. Skip its Priority Tier item: Claude Mythos 5 isn’t supported on Priority Tier.
  • Run its check for edits to earlier turns before you switch: Claude Mythos 5 accepts those edits, but they invalidate Claude Mythos 5.1’s thinking blocks.

Was this page helpful?