# Claude Fable 5.2 vs Opus 5.5: When Fable High Beats Opus Max

> Keep Opus 5.5 as the default and switch a task to Fable 5.2 at high effort only when Opus at xhigh or max fails it. On routine coding, Fable costs about double.

- URL: https://blog.laozhang.ai/en/posts/claude-fable-5-2-vs-opus-5-5
- Published: 2026-11-10
- Updated: 2026-11-10
- Author: LaoZhang AI Team (https://blog.laozhang.ai/en/about)
- Topic: Claude Code
- Tags: Claude Fable 5.2, Claude Opus 5.5, Model Comparison, Claude Code, Claude API

---
**Keep Claude Opus 5.5 as your default and move a task to Claude Fable 5.2 only after Opus at `xhigh` or `max` has failed it. When you do switch, run Fable at `high`, not `max`.** Anthropic released Fable 5.2 on November 9, 2026 at $8 per million input tokens and $40 per million output tokens, twice Opus 5.5's $4 and $20, and its own [Claude model selection guide](https://platform.claude.com/docs/en/about-claude/models/choosing-a-model) still starts most workloads on Opus 5.5. The case for switching sits where Opus runs out of headroom: on the [Artificial Analysis comparison of Opus 5.5 and Fable 5.2](https://artificialanalysis.ai/models/releases/comparisons/claude-opus-5-5-vs-claude-fable-5-2) (Intelligence Index v5.0.1, as of November 10, 2026), Fable 5.2 at `high` scores 62 against 59 for Opus 5.5 at `max`, for $9.08 instead of $10.04 per task.

On well-specified coding the comparison flips. In Anthropic's own cost guide, Opus 5.5 at `xhigh` solved as many SWE-bench Pro problems as Fable 5.2 at `high` for a little over half the cost per solved task. In a November 10, 2026 run of the same 11 small tasks through Claude Code, both models at `high` passed every graded answer, and Fable 5.2 cost 1.86 times as much at list price and took 1.27 times as long. Cybersecurity and research-biology requests are blocked on Fable 5.2 and answered by older Opus models, so those stay on Opus 5.5 as well.

In Claude Code, select Fable 5.2 with `/model fable`; in the Claude apps, pick it in the model picker. Both models start at `medium` effort in Claude Code, while the API defaults Fable 5.2 to `high` and Opus 5.5 to `medium`. Max and Ultra plans can spend up to half of their weekly limit on Fable models. Pro plans and standard Team seats get Fable included only through November 16, 2026, 11:59 pm PT, and pay usage credits for it after that.

## Fable 5.2 high vs Opus 5.5 xhigh: which effort levels match on score

Fable 5.2 at `high` beats Opus 5.5 at `xhigh` on the Artificial Analysis index, 62 to 57, but it costs 1.5 times as much per task ($9.08 against $6.05), so it is not the like-for-like pairing. The Fable level that matches Opus `xhigh` is `medium`: 56 points, one under, for $3.80 instead of $6.05 and in about half the time. The table lines up each Opus 5.5 level with the cheapest Fable 5.2 level that reaches about the same score, using Artificial Analysis' index, cost per task and time per task at API list prices as of November 10, 2026.

| Opus 5.5 at | Index · cost · time per task | Fable 5.2 level at about the same score | Index · cost · time per task |
| --- | --- | --- | --- |
| `max` | 59 · $10.04 · 25.1 min | `high` | 62 · $9.08 · 17.7 min |
| `xhigh` | 57 · $6.05 · 16.3 min | `medium` (one point lower) | 56 · $3.80 · 8.3 min |
| `high` | 52 · $3.46 · 9.5 min | `low` | 54 · $3.10 · 6.5 min |
| `medium` | 48 · $2.45 · 7.1 min | none; Fable's cheapest level is `low` at $3.10 | — |
| `low` | 35 · $0.98 · 3.0 min | none | — |

From Opus `high` upward, Fable 5.2 has a level that scores about the same or higher for less money and less time: about 10% cheaper in 30% less time against Opus `max`, and 37% cheaper in about half the time against Opus `xhigh`. Below that, Opus 5.5 is the only cheap option, because Fable's lowest setting already costs more than Opus at `medium`. Comparing the same named level is what makes Fable look expensive: at each label it costs 1.55 times (`medium`) to 3.16 times (`low`) as much as Opus for 5 to 19 more index points, so "Fable high vs Opus high" measures two different amounts of capability.

![Each Opus 5.5 effort level paired with the Fable 5.2 level that reaches about the same Artificial Analysis score, with cost and time per task](https://blog.laozhang.ai/posts/en/claude-fable-5-2-vs-opus-5-5/img/effort-score-pairing.webp)

Above Opus 5.5's ceiling, Fable 5.2 at `xhigh` scores the same 62 as at `high` for $14.83, and `max` reaches 65 for $26.54 and 44.1 minutes, 2.9 times the cost of `high` for three points. That matches Anthropic's [effort guidance for Fable 5.2](https://platform.claude.com/docs/en/build-with-claude/effort): "most of the gain in capability is already present at `high`", and `max` costs more than `xhigh` "often for only a small gain". The index averages many evaluations, Artificial Analysis labels these runs "Default Fallback", and it was read one day after launch, so treat a one-point gap as a tie and expect the numbers to be revised.

Anthropic's [Fable 5.2 launch post](https://www.anthropic.com/claude-fable-and-mythos-5-2) points the same way with vendor-reported results that pit a lower Fable level against Opus 5.5's best. On FrontierCode 2.0, Fable 5.2 at `high` scored 45.3% against Opus 5.5's 45.5% at `max` for roughly half the cost per task. On the WANDR search benchmark, Fable at `medium` matched Opus' top score for about 40% of the cost, and on Chartography, Fable at `medium` scored 66.4% against 64.4% for Opus at `max` for less than a tenth of the cost.

## Does Fable 5.2 win on everyday coding? Anthropic's cost guide says no

On routine, well-specified coding, Anthropic's own measurements put Opus 5.5 level with Fable 5.2 for about half the money. In the [Anthropic guide to optimizing for cost and intelligence](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence), on 463 problems of a SWE-bench Pro subset, Fable 5.2 at `high` solved 96.3% for $1.39 per solved task and at `low` 94.6% for $0.39. Opus 5.5 solved 93.1% at its default `medium` for $0.22, 95.5% at `high` for $0.30, and 96.5% at `xhigh` for $0.75, which the guide calls "level with Fable 5.2 at high for a little over half the cost". Even Fable's cheapest run, at `low`, cost more per solved task than Opus at `high` and solved fewer.

Two more results in the same guide lean toward Opus. On 44 DeepResearch Bench II tasks at each model's default effort on the Messages API, which means Fable at `high` and Opus at `medium`, Fable 5.2 cost 2.9 times as much as Opus 5.5 for a score 1.9 points lower. On Anthropic's internal agentic-coding benchmark, both at `medium`, Opus 5.5 scored 86.6% at $0.84 per attempt and Fable 5.2 scored 88.9% in a single run at $1.34, about 2 points more for 1.6 times the cost.

Both sets of numbers come from Anthropic, and they disagree because they measure different work. The launch benchmarks are tasks where Opus 5.5 at `max` still falls short, so a cheaper Fable level overtakes it. The guide notes that Opus 5.5 and Fable 5.1 "largely saturate" the SWE-bench Pro subset, so on those problems both models succeed and the one with half the token price wins. The more of your tasks Opus already passes, the less Fable 5.2 can save, which is why the guide tells you to compare on cost per completed task, start with Opus 5.5 at its default, and also price "the frontier model at reduced effort".

## Where Opus 5.5 still ties or beats Fable 5.2

Opus 5.5 holds its ground on document-style knowledge work, on one terminal benchmark, and on every topic Fable 5.2's safeguards block. In the Artificial Analysis sub-scores as of November 10, 2026, Opus 5.5 at `max` rates 1800 Elo on AA-Briefcase v1.1 against 1785 for Fable at `max`, and Opus' best GDP.pdf score, 28.8% at `high`, is above every Fable 5.2 level (21.4% to 26.8%). On Terminal-Bench 4.0, Opus at `xhigh` and `max` scores 59.6%, the same as Fable at `high` and `max`. Fable's biggest leads are on knowledge recall and hard reasoning instead: 64 to 67 on AA-Omniscience v1.1 at `high` to `max` against 42 to 48 for Opus at the same levels, and 80.2% against 67.9% on HLE-Diamond at `max`.

Fable 5.2's safety classifiers block high-risk cybersecurity work, including penetration testing, exploit generation and binary vulnerability work, and most research-biology tasks. A blocked query is answered by Opus 4.8 for cybersecurity or Opus 5 for biology, so on those topics choosing Fable 5.2 gets you an older model's answer. Anthropic reports about 55% fewer blocks than Fable 5.1 in early testing, and Opus 5.5 has safeguards too: the cost guide notes they nearly always stopped it on four biology tasks. In AI research areas such as accelerator kernel optimization, Anthropic limited the model during training so that Fable 5.2 performs "at about the level of Opus 5.5", which leaves no reason to pay double there. Claude Mythos 5.2 is the same model with fewer safeguards, open only to organizations verified through Anthropic's programs.

## Fable 5.2 vs Opus 5.5 in Claude Code: November 10, 2026 test on 11 tasks

On November 10, 2026, the same 11 tasks went to Claude Code subagents running Fable 5.2 and Opus 5.5, two runs per model, every request at `high` effort. All 44 graded answers passed, so the test did not separate the models on quality; it shows what the same passing work cost. The tasks were a pricing word problem, three small Python functions, a five-bullet summary of a 6,723-word article, an expression evaluator, a CSV line parser, a counting problem solved without running code, a semver range matcher, arithmetic from three notes buried in a long document, and a standard-library question that included two made-up functions. Code was graded with hidden tests written before any model answered, and the transcripts confirm that `claude-fable-5-2` and `claude-opus-5-5` produced the answers.

| Mean per run (2 runs each, effort `high`) | Fable 5.2 | Opus 5.5 | Fable ÷ Opus |
| --- | --- | --- | --- |
| Graded answers passed | 11 of 11 | 11 of 11 | same |
| API round trips | 8 | 15 | 0.53x |
| Output tokens (of which thinking) | 24,052 (8,426) | 17,826 (4,684) | 1.35x (1.80x) |
| Wall time | 221.8 s | 174.9 s | 1.27x |
| Output cost at list price | $0.96 | $0.36 | 2.70x |
| Context cost: input, cache reads and writes | $1.19 | $0.80 | 1.49x |
| Total at list price | $2.15 | $1.16 | 1.86x |

Fable 5.2 wrote 1.35 times the output tokens for the same answers, most of the extra being thinking (1.80 times the thinking tokens), and each output token costs twice as much, so its output cost was 2.70 times Opus'. It also batched more tool calls per turn and finished in about half as many API round trips. Every round trip re-read 85,000 to 125,000 tokens of session context from the cache, and cache reads cost the same on both models, so fewer trips held Fable's context cost to 1.49 times and the total under 2 times. A setup with less session context would push the total toward the 2.70 output ratio; a heavier one toward parity. The individual runs were consistent: Fable cost $2.35 and $1.96 at 224 and 220 seconds, Opus $1.23 and $1.09 at 189 and 161 seconds.

![Claude Code test cost split: Fable 5.2 output cost 2.70x and context cost 1.49x that of Opus 5.5, for a total of 1.86x](https://blog.laozhang.ai/posts/en/claude-fable-5-2-vs-opus-5-5/img/claude-code-cost-split.webp)

The limits matter as much as the result. These were small, fully specified tasks on one subscription account, on one day, with two samples per model and the four runs going in parallel, using the Claude Code bundled with the macOS desktop app. The dollar figures are the API list-price value of the tokens used, not a bill, because the runs drew on a subscription. Other effort levels, fast mode, the direct API, multi-hour sessions and fallback on blocked topics were not part of the run, so equal pass counts here say nothing about long-horizon or ambiguous work, where the vendor and Artificial Analysis figures above are the reference.

## Fable 5.2 vs Opus 5.5 pricing: 2x per token, except cache reads

Every Fable 5.2 token price is double Opus 5.5's except one: cache reads cost $0.20 per million tokens on both models, according to [Anthropic's Claude API pricing page](https://platform.claude.com/docs/en/about-claude/pricing) as of November 10, 2026.

| Claude API list price per 1M tokens (USD) | Fable 5.2 | Opus 5.5 | Fable ÷ Opus |
| --- | --- | --- | --- |
| Input | $8 | $4 | 2x |
| Output | $40 | $20 | 2x |
| Cache write, 5 minutes | $10 | $5 | 2x |
| Cache write, 1 hour | $16 | $8 | 2x |
| Cache read | $0.20 | $0.20 | 1x |
| Batch API, input / output | $4 / $20 | $2 / $10 | 2x |
| Fast mode, input / output | $16 / $80 | $8 / $40 | 2x |

Both models share the tokenizer introduced with Opus 4.7, so the same text counts as the same number of tokens and the gap stays at 2x per token. Per task is a different number, because the two models spend different amounts of tokens on the same work: in the November 10 test Fable wrote 1.35 times Opus' output tokens at the same effort level, while in Artificial Analysis' runs Fable at `high` spent less in total than Opus at `max`. The equal cache-read price is the one place the gap narrows: agent sessions that re-read a large cached context on every call pay the same for that part on either model. [Claude Prompt Caching: How It Works, Costs, 512-Token Minimum](https://blog.laozhang.ai/en/posts/claude-prompt-caching) explains the write and read mechanics. Both models have a 1M-token context window and 128K maximum output, and Fable 5.2 is 20% cheaper per token than Fable 5.1 was at $10 and $50.

## Is Fable 5.2 faster than Opus 5.5? Not at the same effort level

No. At the same effort level Opus 5.5 finishes sooner; Fable 5.2 is faster only when it replaces a higher Opus level. The "up to 30% faster" in Anthropic's launch post compares Fable 5.2 with Fable 5.1, not with Opus. In Artificial Analysis' time per task, Opus is quicker at all five levels, 9.5 against 17.7 minutes at `high`, and its output speed is 103 to 115 tokens per second against 87 to 103 for Fable. The November 10 Claude Code run agrees: both Opus runs finished before either Fable run.

At equal score the order reverses. Fable at `high` finished its average task in 17.7 minutes against 25.1 for Opus at `max`, and Fable at `medium` in 8.3 against 16.3 for Opus at `xhigh`. If raw speed matters more than cost, both models offer [fast mode](https://platform.claude.com/docs/en/build-with-claude/fast-mode) (`speed: "fast"`), up to 2.5 times the output speed at double the standard price, which makes Opus 5.5 in fast mode cost the same as standard Fable 5.2. Fast mode for Fable 5.2 is available in Claude Code, on the Claude API, on Google Cloud, and on Microsoft Foundry deployments hosted by Anthropic.

## Fable 5.2 on Pro, Max and Ultra plans: this week and after November 16

What Fable 5.2 costs you on a subscription depends on the plan, and this week is an exception. On Max and Ultra plans, premium Team seats and premium seats on legacy seat-based Enterprise plans, Fable models are included, but at most 50% of the weekly limit can go to them and they use up those limits faster than other Claude models, according to Anthropic's help article on [Claude Fable models on your plan](https://support.claude.com/en/articles/15424964) as of November 10, 2026. Past that point you continue on usage credits or switch models. Anthropic publishes no token or message count for these limits. Opus 5.5, by contrast, is part of the normal limits on every paid plan.

On Pro plans and standard Team seats, Fable is normally not included and runs on pay-as-you-go usage credits from the first request. The [Claude Fable 5.2 launch offers](https://support.claude.com/en/articles/17506494) change that for one week: all Fable models are included up to 50% of the weekly limit through November 16, 2026, 11:59 pm PT, plus one Fable limit reset that expires at the same moment. After that, Claude Code shows "Requires usage credits" on the Fable row of the `/model` picker and asks for consent in interactive sessions, but a `claude -p` run "bills it without asking", so a script pinned to Fable starts spending credits silently.

Max, Ultra and premium seats get one to three Fable limit resets instead, by subscription length: one under six months, two for six to 12 months, three after 12 months, all expiring March 8, 2027, 11:59 pm PT. Resets go only to accounts that had paid billing in place before November 9, 2026, 10:00 am PT. A Fable reset gives back the weekly usage spent on Fable models and refills the five-hour window, and you claim it under **Settings > Usage**. How limit resets work on Opus 5.5 is covered in [Claude Opus 5.5 Pricing and Limit Reset: What Each One Changes](https://blog.laozhang.ai/en/posts/claude-opus-5-5-pricing-limit-reset). Fable is not on the Free plan, and on Enterprise, Fable 5.2 stays off until an admin enables it; seven days after launch it is added to roles that already have a Fable model unless the admin opts out.

## How to switch to Fable 5.2 in Claude Code and pick its effort

Switching takes a model command and an effort setting, and the effort matters because Claude Code starts Fable 5.2 at `medium`, one level below the `high` that Anthropic recommends as its starting point. The commands below come from the [Claude Code model configuration docs](https://code.claude.com/docs/en/model-config) as of November 10, 2026.

1. Run `claude update`. Anthropic lists Claude Code v2.1.321 or later as the requirement for Fable 5.2.
2. Run `/model fable`, or start the session with `claude --model fable`. In Claude apps gateway sessions the `fable` alias resolves to Fable 5, so run `/model claude-fable-5-2` there. If the Fable row says "Requires usage credits", Fable bills credits on your plan.
3. Run `/effort high`. A level typed after `/effort` is saved as that model's default for later sessions; pressing `s` in the `/effort` slider applies it to the current session only.

`high` is the level to start on, because at `low` and `medium` Fable 5.2 more often ends a long task's turn early with a list of what remains, according to Anthropic's [notes on what's new in Fable 5.2](https://platform.claude.com/docs/en/models/fable-5-2/whats-new-fable-5-2). A line in your prompt asking it to think less doesn't stop it from thinking at `medium` and above, so lower the effort level instead when easy turns cost too much. Fable also delegates readily in harnesses that invite it, and subagents "can account for a large part of what a session costs", so check which model your subagents run on. In the November 10 test, the subagents inherited the parent session's effort level. Why a saved level sometimes doesn't apply is covered in [Claude Code Effort Level: Model Defaults and Why It Won't Stick](https://blog.laozhang.ai/en/posts/claude-code-effort-level).

## Moving API traffic from claude-opus-5-5 to claude-fable-5-2

The request shape carries over, but several account and request settings that work on Opus 5.5 fail or behave differently on Fable 5.2. Both models use the same Messages API, think adaptively on every request and return a 400 error for forced tool choice, so those parts need no change. Anthropic's [Fable 5.2 migration guide](https://platform.claude.com/docs/en/models/fable-5-2/migration-guide) lists the rest; as of November 10, 2026, these are the checks before you move traffic or a fallback path:

- If your organization runs under zero data retention, enable 30-day retention for the workspace or get Anthropic's authorization first, because otherwise every Fable 5.2 request returns a 400 `invalid_request_error`.
- Set `effort` explicitly. A request that omits it runs at `high` on Fable 5.2 instead of `medium` on Opus 5.5, succeeds, and shows up only as different cost and latency.
- Check rate limits. Fable 5.2 has its own, with lower token limits at each tier than Opus 5.5.
- Test any code that edits `system`, `tools` or earlier messages between requests. Fable 5.2 applies the prefix check to every account, while Opus 5.5 applies it only to accounts created on or after August 31, 2026, so an older account can start getting a 400 that says `The block is bound to a different conversation`.
- Handle `stop_reason: "refusal"`, which arrives with HTTP 200, and read `stop_details.category`. With `fallbacks: "default"` (beta, `server-side-fallback-2026-07-01` header) the request retries on Opus 4.8 or Opus 5, the only permitted targets.
- Expect higher cost and latency on the first turn when a router moves a conversation from Fable 5.2 back to Opus 5.5. Opus can't read Fable's thinking blocks, so the turns after the switch keep text and tool calls but lose that reasoning; moving from Opus to Fable keeps it.
- In organizations with customer-managed encryption keys, remove `strict: true` and `output_config.format`, because structured outputs are unavailable on Fable 5.2 there, and validate the output in code.
- With the advisor tool, set the advisor's `model` to `claude-fable-5-2` or `claude-mythos-5-2`. A Fable 5.2 executor rejects any other advisor with a 400.
- Replace the earlier `computer_20251124` tool with the `computer_toolset_20260801` toolset. The old tool returns a 400 on every platform except Amazon Bedrock.

If you reach Claude through a third-party gateway, check its model list before switching, because a gateway that doesn't serve `claude-fable-5-2` rejects requests for it. On November 10, 2026 (UTC+8), `GET /v1/models` on laozhang.ai's gateway did not list `claude-fable-5-2` at 07:31, and a second call at 08:53 did, one day after Anthropic's release; a gateway can lag a release by a day like this, so check its model list on the day you switch.

*Disclosure: [laozhang.ai is our own service](https://blog.laozhang.ai/en/about#laozhang). Its prices are platform pricing, not an independent comparison.*

## How to test Fable 5.2 against Opus 5.5 on your own work

The rule at the top is a starting point; your own pass rate and cost per completed task decide it. Start with the tasks Opus 5.5 fails at `xhigh` or `max`, plus the hardest tenth of your usual work, because Anthropic's cost guide says to price the tail, not the median: failed tasks and their retries are where the bill goes. Write the pass check before running anything, whether that is tests, a review rubric or numbers that must trace to a source, so neither model's output can move the bar. Then run Opus 5.5 at its default and at `xhigh`, and Fable 5.2 at `medium` and `high`, each in a separate session, since changing the top-level effort mid-session invalidates the prompt cache and distorts the cost. Finally, divide each setting's total spend, failed attempts included, by the number of tasks it passed.

Move a class of work to Fable 5.2 when it passes tasks Opus 5.5 fails, or passes the same share for less per completed task. When results are checkable, the cheaper policy is often not a fixed choice at all: run everything on Opus 5.5 and send only the failures to Fable 5.2 at `high`. That applies the guide's advice to re-run failures at a higher setting, with Fable as the higher setting, and spends frontier prices only on the tail. If Opus 5.5 is already more than your work needs, [Claude Sonnet 5.5 vs Opus 5.5: When Half the Price Really Saves](https://blog.laozhang.ai/en/posts/claude-sonnet-5-5-vs-opus-5-5) covers the step down. If you still run Fable 5.1, which Anthropic now lists as a legacy model, [Claude Fable 5.1 vs Opus 5.5: Which Should You Use?](https://blog.laozhang.ai/en/posts/claude-fable-5-1-vs-opus-5-5) covers that pairing.

## Sources

External pages this guide links to, in the order they appear. Last updated 2026-11-10.

- [Claude model selection guide](https://platform.claude.com/docs/en/about-claude/models/choosing-a-model) (platform.claude.com)
- [Artificial Analysis comparison of Opus 5.5 and Fable 5.2](https://artificialanalysis.ai/models/releases/comparisons/claude-opus-5-5-vs-claude-fable-5-2) (artificialanalysis.ai)
- [effort guidance for Fable 5.2](https://platform.claude.com/docs/en/build-with-claude/effort) (platform.claude.com)
- [Fable 5.2 launch post](https://www.anthropic.com/claude-fable-and-mythos-5-2) (anthropic.com)
- [Anthropic guide to optimizing for cost and intelligence](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence) (platform.claude.com)
- [Anthropic's Claude API pricing page](https://platform.claude.com/docs/en/about-claude/pricing) (platform.claude.com)
- [fast mode](https://platform.claude.com/docs/en/build-with-claude/fast-mode) (platform.claude.com)
- [Claude Fable models on your plan](https://support.claude.com/en/articles/15424964) (support.claude.com)
- [Claude Fable 5.2 launch offers](https://support.claude.com/en/articles/17506494) (support.claude.com)
- [Claude Code model configuration docs](https://code.claude.com/docs/en/model-config) (code.claude.com)
- [notes on what's new in Fable 5.2](https://platform.claude.com/docs/en/models/fable-5-2/whats-new-fable-5-2) (platform.claude.com)
- [Fable 5.2 migration guide](https://platform.claude.com/docs/en/models/fable-5-2/migration-guide) (platform.claude.com)