Claude Fable 5.1: What Changes for Developers

Fable 5.1 is Anthropic’s successor to Fable 5, aimed at agents that run for hours: code fixes, research passes, long knowledge work. It shipped on September 1, 2026 with the same $10 and $50 per million token list prices and one big change underneath: cache reads cost $0.25 instead of $1. This guide covers the developer impact and the migration path.

Fable 5.1: What You’ll Learn

Fable 5.1 keeps the input and output prices of Fable 5 while cutting the cost of the thing agent loops do most: re-reading cached context. The sections ahead cover the API behaviors that changed and the benchmark record, so you can decide whether your workload belongs on Fable 5.1, Opus 5, or Mythos 5.1.

What shipped on September 1

Anthropic announced the pair on September 1, 2026. Claude Fable 5.1 is generally available across the Claude API, Claude.ai, Claude Code, Amazon Bedrock, Google Cloud, Microsoft Foundry, and Claude Platform on AWS. The release notes describe it as “the successor to Claude Fable 5 for long-running agentic coding, knowledge work, and research.”

Claude Mythos 5.1 shipped the same day for Project Glasswing participants. It is the same model with lighter safeguards for verified cybersecurity and life-sciences organizations, gated behind Anthropic’s Cyber Verification Program and Life Sciences Verification Program, initially limited to US organizations. For everyone else, Fable 5.1 is the model you get.

The identifier is uniform across clouds, with one prefix exception worth memorizing. The Claude API takes claude-fable-5-1. Amazon Bedrock takes anthropic.claude-fable-5-1 plus the usual inference profile plumbing. Google Cloud and Microsoft Foundry both use the bare claude-fable-5-1. Claude Platform on AWS rounds out the list, so existing Bedrock shops do not need a new vendor relationship to try the model.

Both models carry a June 2026 knowledge cutoff, adaptive thinking that is always on, and a default effort level of high. The docs also flag slower comparative latency against the rest of the family. Interactive endpoints notice that before batch jobs do.

Cache reads at $0.25 are the real price change

Input stays $10 per million tokens and output stays $50. What changed is the cache read multiplier: 0.025x the base input price instead of the 0.1x other Claude models charge. At Fable 5.1’s list price that is $0.25 per million cached tokens, a 75% cut, while cache writes are unchanged.

Why this is the headline: long agents are cache-read machines. Every turn re-reads the system prompt, tool definitions, and the conversation so far, and that prefix usually dwarfs the fresh input. Anthropic estimates roughly 25% savings on typical workloads and up to about 45% on agentic ones.

You can sanity check the multiplier on your own traffic. Pull cache_read_input_tokens from the usage block of any response, multiply by your blended cache-read price, and compare against what the same session cost before. The walkthrough below does this arithmetic on a realistic loop.

How the cache discount actually works

Prompt caching on the Claude API is prefix caching. You mark a breakpoint with cache_control set to {"type": "ephemeral"}, and the cache covers everything before it in a fixed order: tools, then system, then messages. A hit requires the prefix to be 100% identical, text and images included, and editing your tool definitions invalidates the entire entry.

resp = client.messages.create(
    model="claude-fable-5-1",
    max_tokens=8192,
    system=[{
        "type": "text",
        "text": SYSTEM_PROMPT,
        "cache_control": {"type": "ephemeral"},  # breakpoint
    }],
    tools=tools,       # cached automatically ahead of system
    messages=messages,
)
print(resp.usage.cache_read_input_tokens)

The knobs worth knowing. Up to 4 breakpoints per request; the default cache lives 5 minutes and is refreshed for free on each use; an extended 1-hour TTL is available with "ttl": "1h". Cache writes cost 1.25x base input, so $12.50 per million tokens on a 5-minute entry, or 2x for the hour. Reads are where Fable 5.1 breaks from the family: 0.025x instead of 0.1x.

Breakpoint placement follows the loop. Mark the system prompt so tools and instructions cache once, let the conversation grow after it, and use the remaining slots sparingly: one on a stable summary block, one near the tail of a long session you expect to resume. Every edit before a breakpoint invalidates everything after it, so unstable content belongs at the end of the prefix.

One threshold matters for small prompts. Fable 5.1 caches prefixes of at least 512 tokens, where Sonnet 5 requires 1,024 and older Opus generations 4,096. Short tool-heavy loops that never qualified for caching before now do, which widens the savings beyond what the headline multiplier suggests.

The benchmark jumps, read in context

Anthropic’s own numbers show the largest gains on long-horizon terminal and computer work, the exact workloads Fable 5.1 targets. Treat them as vendor-reported until you reproduce them on your tasks.

Two footnotes from the same table. Mythos 5.1 scores 60.9% on Terminal-Bench 4.0, ahead of Fable 5.1’s 55.8%. Terminal-Bench 4.0 also lists GPT-5.6 Sol at 37.3%, well behind both.

On knowledge work, Fable 5.1 reports 60.9% on Humanity’s Last Exam without tools and 65.0% with tools. The pattern across the table is consistent: modest gains on short-horizon coding, large gains on anything that rewards patience.

Vendor numbers pick the races, so run your own before committing. A cheap protocol: take 20 real tasks from your backlog, the kind your agent already attempts weekly, replay them through Fable 5 and Fable 5.1 with identical prompts, and score both on your own definition of done plus invoice cost per success. Half a day of evals beats any benchmark table at predicting your outcome.

A 1M token window with 128k output

Both new models default to a 1M token context window and 128k max output tokens, per the models overview. Adaptive thinking is always on; there is no thinking toggle to budget for. If you were truncating large transcripts or sharding documents to fit earlier limits, that pressure drops.

Two caveats before you celebrate. First, a bigger window means bigger cache prefixes, so caching discipline matters even more at $0.25 per million. Second, the docs list slower comparative latency for Fable 5.1. Long-horizon work absorbs that; chat-adjacent endpoints may not.

Do the token arithmetic before you widen anything. A full 1M-token context read once at list price costs $10 in input; the same prefix on a cache hit costs $0.25. Output runs the other way: a maximal 128k-token answer bills $6.40 at $50 per million. Big windows are cheap to consult and expensive to fill, which is the shape agentic loops want.

Moving API calls from Fable 5 to Fable 5.1

The model identifier is claude-fable-5-1, and on Bedrock it is anthropic.claude-fable-5-1. Google Cloud and Microsoft Foundry use the bare identifier. The minimal migration is a one-line change:

from anthropic import Anthropic

client = Anthropic()

resp = client.messages.create(
    model="claude-fable-5-1",        # was: claude-fable-5
    max_tokens=8192,
    messages=[{"role": "user", "content": "Fix the failing test in utils"}],
)
print(resp.model)  # claude-fable-5-1
print(resp.usage.cache_read_input_tokens)

The raw HTTP call looks the same as always, which makes the identifier easy to pin in one place:

curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-fable-5-1",
    "max_tokens": 1024,
    "messages": [{"role": "user", "content": "Summarize this diff"}]
  }'

Transcript replay needs one check. A preserved thinking block now replays only on the exact model that generated it or on a newer model. Fable 5.1 accepts blocks from Opus 5, Fable 5, Mythos 5, and earlier, so replaying old sessions forward is safe. The reverse direction is not: replay a Fable 5.1 transcript into an older model and the blocks drop.

For API accounts first opened on August 31, 2026 or later, replaying a thinking block once the system prompt, tools, or earlier messages have changed fails with a 400 instead of a silent drop. Developers who want visibility can send the thinking-binding-controls-2026-08-01 beta header: it lists every dropped block under input_transformations in the response. What happens when anything before a replayed block has changed is yours to decide with thinking.block_binding.prefix_mismatch_behavior: reject the whole request, or drop only the stale block.

tool_choice any and tool now fail with a 400

This is the one breaking change. On Fable 5.1 and Mythos 5.1, tool_choice of type any or tool is unsupported and returns a 400 error. The auto and none types behave exactly as before.

What you are giving up: any forced the model to call some tool before answering, and tool forced one named tool. Neither survives. Note also that changing tool_choice mid-conversation invalidates the cached messages, though the tools and system portions stay cached, so toggling it per turn still carried a quieter cost than it looked.

# raises anthropic.BadRequestError on Fable 5.1
client.messages.create(
    model="claude-fable-5-1",
    tool_choice={"type": "any"},   # no longer supported
    tools=tools,
    messages=messages,
)

The release notes offer two migration paths: strict tool use, where the tool schema itself forces the shape you wanted any to guarantee, or structured outputs for constrained response formats. Audit every call site that pins tool_choice before you flip the identifier, because this failure is loud in production and silent in code review.

Three smaller API notes from the same entry. Per-message effort is in beta via a role: "system" message carrying output_config.effort, behind the mid-conversation-output-config-2026-07-01 header. Behind mid-conversation-system-clear-at-2026-08-21, system messages scoped to a single turn ship in beta. And thinking.display accepts "updates" to stream progress between tool calls, behind thinking-display-updates-2026-08-18.

Retention, watermarks, and safeguards

Fable 5.1 requires 30-day data retention, and zero data retention is not available unless authorized. If your compliance posture depends on ZDR, this model is not on your menu yet. Anthropic’s Enterprise Frontier Safeguards program, a zero-retention-like arrangement with customer-controlled cloud storage, begins phasing in during the fall.

Until then, the practical move is a split: keep the regulated slice of traffic on a model that supports your retention terms, and route the engineering workloads, which rarely contain the data your lawyers worry about, to Fable 5.1 where the cache savings live. If you think you qualify for an authorized exception or the EFS preview, that conversation goes through your Anthropic account contact, not the API console.

Text output ships with the Anthropic watermark, and files that come out of code execution include C2PA Content Credentials once you fetch them through the Files API, with no changes needed in your requests. A detection API for the watermark is in private preview as part of EU AI Act compliance. Practical upshot for app builders: content your users export from Claude-generated flows is detectable as model output downstream, which is either a compliance feature or a leak risk depending on your threat model, and it is worth a policy line either way.

Safeguards changed in ways developers will feel. Cyber filters report 60% fewer false positives, and Fable 5.1 may now find vulnerabilities, though writing exploits remains off-limits. On the biology side, false interventions on legitimate requests drop 85%, and life-science queries still route to Opus. One more anti-distillation shift: new API accounts can no longer edit prior context while keeping Claude’s thinking transcript attached.

Running Fable 5.1 in Claude Code

Claude Code picked the model up in version 2.1.257. The fable alias resolves to Fable 5.1 in most sessions, so /model fable from inside a session is the fast path. In Claude apps gateway sessions, where fable still resolves to Fable 5, use the full identifier: /model claude-fable-5-1.

Per the Claude Code model configuration docs, you can also set the model at startup with claude --model claude-fable-5-1, pin it with the ANTHROPIC_MODEL environment variable, or set the model field in settings for every new session.

Effort defaults to high in Claude Code, versus medium on Claude.ai and Claude Cowork. For repo-scale refactors and long debug sessions, high effort plus $0.25 cache reads is the combination the pricing change was designed for: each additional turn over a growing context costs far less to serve.

The session shape where the savings compound is the multi-hour one: a branch refactor that touches forty files, a flaky test hunt that reads half a repository. Those sessions re-read their whole prefix every turn and previously accumulated most of their cost in cache reads at $1. The same sessions at $0.25 behave like a different product at budget-review time.

When to stay on Opus 5 or reach for Mythos 5.1

Three cases argue against switching. Latency-sensitive endpoints pay for Fable 5.1’s slower comparative latency in user perception. Deep life-sciences queries route to Opus regardless of what you send. And exploit development stays blocked on Fable 5.1; verification work is fine, weaponized output is not.

The rest of the family did not move. Opus 5 remains the general-purpose flagship, Sonnet 5 the balanced mid-tier, and Haiku 4.5 the fast lane. If a workload already meets its quality bar on Sonnet 5, the cheapest optimization is still staying there; Fable 5.1 earns its slot when sessions run long and stall on stamina, not when they are short and fast.

Mythos 5.1 exists for that last gap, but only for organizations that clear Anthropic’s Cyber Verification Program or the US-government-partnered Life Sciences Verification Program. It posts 60.9% on Terminal-Bench 4.0 with the same $10/$50 pricing. If you are not already in Project Glasswing, plan around Fable 5.1.

For everyone else the question is simpler. If your sessions run long, loop over tools, and re-read the same context, the cache arithmetic from the next section usually settles it.

A Worked Example

Picture a repo-fixing agent that runs 40 turns per session against a growing context: a system prompt and tool definitions around 50k tokens, then conversation that grows past 100k. Suppose the average cached prefix across the session is 120k tokens. On Fable 5, every turn after the first re-reads that prefix at $1 per million cached tokens.

The arithmetic at list prices: 40 turns times 120k cached tokens is 4.8 million cache-read tokens per session. At Fable 5’s $1 that line item costs $4.80. At Fable 5.1’s $0.25 it costs $1.20. Same session, same turns, $3.60 less, and the cache write you pay once at the start is unchanged. Run 500 such sessions a month and the delta is $1,800 monthly before you touch a single prompt.

Migrating the agent itself takes an afternoon. First, swap the identifier to claude-fable-5-1 in exactly one place, the model configuration, not at every call site. Second, grep the codebase for tool_choice. This agent forced a linter tool with {"type": "tool"}, which now returns a 400; the fix is a strict schema so the model cannot misuse the tool, with auto retained elsewhere. Third, log usage.cache_read_input_tokens for a week and confirm the expected multiplier lands on the invoice.

Add an eval gate before cutover. Replay 20 finished sessions from the archive through the new model with unchanged prompts, then compare three numbers: tasks completed, turns needed, tokens burned. A switch that needs a prompt rewrite to perform is not a drop-in migration, and you want to know that before the identifier flips everywhere. Your replay results are the only ones that appear on your invoice.

One replay check closes it out. The agent stores transcripts with preserved thinking blocks for audit. Those replay into Fable 5.1 cleanly, since it accepts blocks from Fable 5 and earlier. Nobody on the team edited old transcripts, so the new prefix-mismatch 400 never fires. If your tooling does mutate history, that is the bug to fix before, not after, the model flip.

Fable 5.1: Common Mistakes to Avoid

Even careful teams trip over the same four issues in the first week after switching.

• Treating the identifier swap as the whole migration, then learning about the tool_choice 400 from a production alert instead of a staging test.
• Assuming zero data retention is available. It is not, unless authorized, and Enterprise Frontier Safeguards is still rolling out.
• Quoting vendor benchmarks to leadership without running your own evals. The deltas are large, but the harnesses are Anthropic’s.
• Pointing latency-sensitive endpoints at a model the docs describe as having slower comparative latency, then wondering why time-to-first-token regressed.

Fable 5.1: Best Practices

• Pin the model identifier in configuration, never at call sites, so the next identifier change stays a one-line edit.
• Test every tool_choice surface against the new model in staging; any and tool fail loudly, not gracefully.
• Measure cache_read_input_tokens before and after the switch; the savings live in that counter, not in the input price.
• Replay a few archived transcripts with preserved thinking blocks before cutover, especially if any tooling edits conversation history.
• Keep Opus 5 or Sonnet 5 on interactive paths that are sensitive to latency, and let Fable 5.1 own the long-horizon loops.

Fable 5.1: Frequently Asked Questions

Is Fable 5.1 a drop-in replacement for Fable 5?

Almost. The identifier changes, and tool_choice types any and tool return a 400. Everything else about the request shape, including auto and none, behaves as before.

How much cheaper is it really?

Cache reads drop 75%, from $1 to $0.25 per million tokens. Anthropic estimates roughly 25% off typical bills and up to about 45% on agentic workloads. Input and output prices are unchanged.

Can I run it under zero data retention?

No. Fable 5.1 requires 30-day retention, with ZDR only where authorized. Enterprise Frontier Safeguards, which behaves like zero retention with customer-controlled storage, begins phasing in later this fall.

Why did my thinking replay start returning 400?

Strict checking applies to API accounts opened on August 31, 2026 or later: a preserved thinking block replayed against a changed prefix is rejected. Use the thinking-binding-controls-2026-08-01 header to see dropped blocks and control the behavior.

What is Mythos 5.1, and can I get it?

Same weights as Fable 5.1 with lighter safeguards for cybersecurity and life sciences, available to Project Glasswing participants through Anthropic’s verification programs, initially US organizations. Everyone else uses Fable 5.1.

Fable 5.1 is a pricing and stamina upgrade for long-horizon agents: cache reads at $0.25 per million, a 1M token window, and large gains on terminal and computer-use benchmarks. Migrate the identifier, fix tool_choice, keep ZDR workloads and latency-sensitive endpoints elsewhere, and let the cache counter prove the savings.