Claude Fable 5.2: Release Date, $8/$40 Pricing and Breaking Changes

Claude Fable 5.2 was announced on 9 November 2026. It costs $8 per million input tokens and $40 per million output tokens, down from $10 and $50 for Fable 5.1. The API id is claude-fable-5-2. The headline change is a better score on Anthropic's own benchmarks at a lower price. Four breaking changes in the API mean the switch is not a pure drop-in.

Last verified 2026-11-11.

When was Claude Fable 5.2 released?

Anthropic announced Claude Fable 5.2 and Claude Mythos 5.2 together on 9 November 2026. Anthropic positions both models for demanding technical work. Anthropic says Fable 5.2 is available now on all platforms, including AWS, Google Cloud and Microsoft Azure. It also says output is up to 30% faster than Fable 5.1 and Mythos 5.1.

The models overview in the Claude docs lists the same id on several platforms. The Claude API, Claude Platform on AWS, Microsoft Foundry and Claude Models on Google Cloud use claude-fable-5-2. Amazon Bedrock uses anthropic.claude-fable-5-2. The docs give a retirement date of not sooner than 9 November 2027 for platforms Anthropic operates.

Core specs from the docs:

• A 1M token context window and up to 128K output tokens per request.
• Adaptive thinking that is always on. Both thinking: disabled and manual extended thinking return a 400 error.
• Five effort levels, with high as the API default (unchanged from 5.1). The announcement says Claude apps and Claude Code default to medium.
• A knowledge cutoff of June 2026.
• No support for Priority Tier.

Anthropic's advice on choosing is notable. Its announcement suggests starting most work on Opus 5.5, which it calls "our strongest daily driver". Then move up to Fable or Mythos, or down to Sonnet 5.5 or Haiku 5.5. The docs say to use Fable 5.2 for demanding reasoning and long-horizon agentic work, or when your evals on Opus 5.5 at higher effort still fall short. That is a vendor telling you not to default to its most expensive model.

How much does Claude Fable 5.2 cost?

Fable 5.2 costs $8 per million input tokens and $40 per million output tokens on the Claude API. Prompt cache reads cost $0.20 per million tokens. Five-minute cache writes cost $10, and one-hour cache writes cost $16.

All prices are US dollars per million tokens, from Anthropic's pricing page. Haiku 5.5 rises to $0.50 input and $2.50 output above 100,000 tokens of prompt, which we cover in our Haiku 5.5 routing post. Batch requests are 50% off, according to the docs.

Fast mode is a separate, premium option. Fable 5.2 fast mode costs $16 input and $80 output per million tokens. Anthropic says it generates tokens up to 2.5 times faster. For comparison, Opus 5.5 fast mode is $8 and $40. Fast mode pricing applies across the full context window, and caching multipliers stack on top of it.

One detail matters for cache-heavy workloads. Fable 5.2 cache reads are 2.5% of the input price. Opus 5.5 cache reads are 5% of its input price. Both land at $0.20 per million tokens, so for a cached prefix the gap between Fable 5.2 and Opus 5.5 narrows to nothing on that line. The input you do not cache is where Fable 5.2 costs twice as much. Our prompt caching comparison covers how the vendors differ.

Worked example: one agent turn

Take one agent turn with 40,000 input tokens and 4,000 output tokens, with no caching. These are our assumptions, not a measured workload.

• Fable 5.1: 40,000 input at $10 per million is $0.40. 4,000 output at $50 per million is $0.20. Total $0.60.
• Fable 5.2: 40,000 input at $8 per million is $0.32. 4,000 output at $40 per million is $0.16. Total $0.48.
• The saving is $0.12 a turn, or 20%. Over 10,000 turns that is $6,000 against $4,800.

Now assume 30,000 of those 40,000 input tokens are cache reads, and ignore cache writes.

• Fable 5.1: 10,000 at $10 per million is $0.10. 30,000 at $0.25 per million is $0.0075. Output is $0.20. Total $0.3075.
• Fable 5.2: 10,000 at $8 per million is $0.08. 30,000 at $0.20 per million is $0.006. Output is $0.16. Total $0.246.
• The saving is about 20% again.

The same uncached turn on other models, by our arithmetic: Opus 5.5 is 40,000 at $4 per million ($0.16) plus 4,000 at $20 per million ($0.08), so $0.24. Sonnet 5.5 is $0.08 plus $0.04, so $0.12. Haiku 5.5 is $0.004 plus $0.002, so $0.006.

Two caveats. First, thinking tokens count as output, so a model that thinks more costs more per turn at the same price. Second, Anthropic's migration guide says subagents can account for a large part of session cost, so watch usage at high effort. A 20% lower rate card does not guarantee a 20% lower bill.

What changed from Fable 5.1 to 5.2?

Four things changed: price, benchmark scores, speed and a short list of API behaviours. The first three are good news. The fourth needs a code review before you switch production traffic.

The benchmark numbers (vendor-reported)

The table below uses only figures from Anthropic's announcement page. They are vendor-reported and we have not reproduced them. Anthropic says every score uses the model's highest effort level unless marked, and that Fable 5.2, Fable 5.1 and Opus 5.5 were scored with safeguards on unless marked.

Two rows deserve a second look. On AutomationBench, the same page shows Gemini 4 Carbon ahead at 53.9%. On the AA-Briefcase Elo, Opus 5.5 at 1800 is higher than Fable 5.2 at 1785. Anthropic says as much itself: Fable 5.2 does not lead every row. A model that wins most rows can still lose the one that matches your workload. For independent comparisons across vendors, check our AI leaderboard and treat vendor tables as claims.

Anthropic also reports cost-efficiency results, which matter more to a budget than raw scores. On FrontierCode 2.0 at High effort, Fable 5.2 scores 45.3%, against 45.5% for Opus 5.5's best, at about half the cost per task. On Humanity's Last Exam at Low effort, it matches Opus 5.5's best score for under a tenth of the cost. These are vendor-reported and depend on how Anthropic defined cost per task. We could not find the full methodology on the page, so treat the ratios as directional.

The breaking changes

The migration guide says migration is mostly drop-in, then lists four changes that can break code.

1. The prefix check applies to every account. Each thinking block from Fable 5.2 is valid only against the system prompt, tools and history that preceded it. The guide says Fable 5.2 enforces this check on every account, which is the change from 5.1. If your code edits earlier turns and sends a thinking block back, you get a 400 error. Retrying the same body does not clear it. Nothing changes if Claude Code, claude.ai, Managed Agents or the Agent SDK manages your history.
2. Fable 5.1 cannot read Fable 5.2's thinking blocks. Fable 5.2 reads Fable 5.1's blocks, but not the other way round. If a router, a retry or a refusal fallback moves a conversation from 5.2 to 5.1, the API drops the blocks. The request succeeds and you are not billed for the dropped tokens, but the model works without that reasoning, which can raise cost and latency on the first turn after the switch.
3. The old computer use tool is rejected. A tool entry of type computer_20251124 returns a 400 error on every platform except Amazon Bedrock. Migrate to computer_toolset_20260801 using Anthropic's computer-use checklist: remove the old beta header and unsupported declaration fields, update action dispatch and results, and handle batched actions.
4. Advisor pairing is restricted. With the advisor tool, which is in beta, a Fable 5.2 executor accepts only Fable 5.2 or Mythos 5.2 as its advisor. Fable 5.1 as advisor returns a 400 error. Change the advisor model in a new conversation, because changing tools while replaying earlier thinking blocks can also return a 400.

Two further requirements carry over from 5.1. Both models need 30-day data retention and are not available under zero data retention arrangements unless Anthropic expressly authorises it. A request from a workspace without 30-day retention returns a 400 error. Forcing a tool call with tool_choice of type any or a named tool also returns a 400 error, and so does prefilling the assistant message. If your 5.1 integration already works around these, nothing new applies.

Fable 5.2 vs Mythos 5.2: what is the difference?

Anthropic's announcement says both names refer to the same underlying model. The difference is the safeguards and who can use it.

On the API, fallback is not automatic. Without it, a classifier decline returns a refusal. On the Claude API and Anthropic-managed Google Cloud, send fallbacks: "default" with the server-side-fallback-2026-07-01 beta header, or write a client-side retry.

The docs list Mythos 5.2 as limited availability. Anthropic also says Mythos 5.2 powers Claude Security for Claude Enterprise customers, including those outside the Cyber Verification Program. Mythos fast mode is limited to organisations in the Verification Programs.

For most teams the practical point is the classifier. In early testing across claude.ai, Claude Code and Cowork, Anthropic observed about 55% fewer blocks than with Fable 5.1: about 60% fewer in cyber and 40% fewer in biology. If your product does penetration testing, exploit work or biology research, Fable 5.2 may still decline requests, and on the API they only reach an older model if you configure a fallback. That is a workflow risk, not only a safety footnote. Plan for a refusal path.

Anthropic's cyber claims contain one inconsistency worth knowing. Its main text says Mythos 5.2 found 10.2% more vulnerabilities than Opus 5.5 in a CVE rediscovery run over 1,829 CVEs. A footnote on the same page says Anthropic's own evaluations put it roughly on par with Opus 5.5. We cannot tell which framing applies to your use case, so we do not rely on the cyber numbers here.

Anthropic also says it deliberately limited AI-research capabilities during training. It gives accelerator kernel optimisation and LLM architecture work as examples, held to about Opus 5.5's level. If your work is in those areas, test before you pay the premium.

Should you switch from Fable 5.1 or Opus 5.5?

From Fable 5.1, switch, after one check. The price is lower, Anthropic's reported scores are higher, and the API surface is largely the same. The check is whether your code builds the messages array itself and edits earlier turns, which the prefix check will punish. Run the migration guide's prefix check on your current model. If you use the MCP connector without a pinned tool list, also test on claude-fable-5-2, because a changing tool list can invalidate its thinking blocks. Then confirm that you have no computer_20251124 use outside Bedrock and no advisor pairing that uses 5.1.

From Opus 5.5, the answer depends on your evals, not on the leaderboard. Fable 5.2 costs twice as much per input token and per output token. The docs say to move up when your evals on Opus 5.5 at higher effort still fall short. Run a sample of real tasks on both and measure cost per accepted task, not price per million tokens. Anthropic's own FrontierCode result suggests Fable 5.2 can reach Opus 5.5's best score at lower cost when it runs at lower effort. That is a claim to test on your own tasks.

A practical rule:

• Default work goes to Opus 5.5, Sonnet 5.5 or Haiku 5.5, based on how hard the task is.
• Escalate to Fable 5.2 when a cheaper model fails an automated check.
• Use fast mode only where latency has a measurable value. At $16 and $80, it is double the standard rate.

For the earlier Fable 5 pricing story, see our Fable 5 against GPT-5.6 comparison. It covers why price per million tokens and cost per task can point in different directions.

What to do this week

A short migration list, drawn from Anthropic's checklist and our own judgement:

1. Confirm the workspace has 30-day data retention. If you rely on zero data retention, talk to your Anthropic account team first.
2. Search your code for computer_20251124, any advisor tool definition, and any place that rewrites earlier conversation turns.
3. Raise max_tokens. Thinking tokens count toward it, so a small limit can stop after a thinking block with no text.
4. Check subagent usage and lower the effort level where quality allows.
5. Replay a sample of production traffic on claude-fable-5-2 and compare cost per accepted task with your current model.
6. Keep a fallback path for classifier refusals and for rate limits on a new model.

Where Swfte sits

Swfte is not Anthropic, and we do not claim Fable 5.2 is in our catalogue. If you want to use it through Swfte Connect, the route is to bring your own Anthropic key.

Connect offers one OpenAI-compatible API across many providers, and you can bring your own provider keys. Workspaces can define routing rules with a mandatory fallback chain, so a request moves to another model when a provider fails, a rate limit is hit or funds run out. Usage caps can downgrade a workspace to a cheaper model once a limit is reached. That is a spending control, not a quality control, so it does not replace the cost-per-task test above.

The Fable 5.2 launch shows why a fallback matters. A conversation that moves from 5.2 to another model can lose its thinking blocks, and classifier refusals can hand work to an older model. Those are Anthropic's behaviours, described in Anthropic's docs, and not Swfte features. What a gateway gives you is one place to define which model comes next and what a cap does. You still need to test how your prompts behave after a switch. For the general case, see multi-provider routing with Swfte Connect and our guide to avoiding single-vendor lock-in.

The decision rule is plain. Treat Fable 5.2 as the escalation tier, measure cost per accepted task, and make sure your code survives the four breaking changes before you move production traffic.

---

Related: Claude Fable 5 vs GPT-5.6, Claude Haiku 5.5 pricing and routing, Prompt caching pricing compared, OpenAI API alternatives.

Sources: Anthropic, Claude Fable 5.2 and Claude Mythos 5.2, 9 November 2026 · Claude docs, Pricing · Claude docs, Models overview · Claude docs, Fable 5.2 and Mythos 5.2 migration guide · accessed 11 November 2026.

Benchmark and cost-efficiency figures are vendor-reported by Anthropic and not independently reproduced. Worked examples are our arithmetic on assumed token counts, with no thinking-token overhead modelled. We did not check third-party benchmark scores for Fable 5.2.