# Fable 5.1 vs 5.2: Cheaper at Medium, Costlier at High and Max

> Claude Fable 5.2 outscores 5.1 at every effort level. On Artificial Analysis's long tasks it costs 32% less per task at medium, but more at high and above.

- URL: https://blog.laozhang.ai/en/posts/claude-fable-5-1-vs-5-2
- 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 Fable 5.1, Model Comparison, Claude API, Claude Code

---
Claude Fable 5.2, released on November 9, 2026, is worth moving to from Fable 5.1, but the move only lowers your cost if you also pick the right effort level. Every token price fell 20% (input $10 → $8, output $50 → $40 per million tokens), and on Artificial Analysis's Intelligence Index v5.0.1, as of November 10, 2026, every Fable 5.2 effort level scores above every Fable 5.1 level. On that benchmark's long agentic tasks, Fable 5.2 also costs 31–32% less per task at `low` and `medium`, although on short one-shot API requests tested on November 10, 2026 it still wrote more output tokens at `medium` and the saving all but disappeared. At `high`, `xhigh` and `max` it writes 1.5 to 2.3 times as many output tokens, so the same level costs 20% to 104% more per task and takes longer, despite the lower price.

What to set depends on where you run it. In Claude Code, selecting `fable` (now Fable 5.2) starts sessions at `medium`, which in those numbers scores higher than Fable 5.1 at its old `high` default for half the cost per task, so keep `medium` and raise it only for the tasks that need more. On the API, both versions default to `high`, so changing `claude-fable-5-1` to `claude-fable-5-2` and nothing else buys a higher score at about 20% more per task; if Fable 5.1 at `high` already did the job, test `medium` first. If you ran Fable 5.1 at `xhigh` or `max`, Fable 5.2 at `low` already outscores it at under a third of the cost. In the Claude app, both versions start at Medium, the level where 5.2 scores higher and, on long tasks, costs less.

API code needs one test pass before traffic moves: Anthropic lists four changes that can break requests, the most likely being a stricter check on edited conversation history when your code builds its own `messages` array. Nothing changes when Claude Code, claude.ai or the Agent SDK manages the conversation. Fable 5.1 stays callable until at least September 1, 2027, so you can switch on your own schedule.

## What changed between Fable 5.1 and Fable 5.2, and what didn't

Fable 5.2 changes the price, a handful of API rules and one Claude Code default; the model's shape is the same. Anthropic's [Fable 5.2 migration guide](https://platform.claude.com/docs/en/models/fable-5-2/migration-guide) calls the move "mostly drop-in", and the [What's new in Claude Fable 5.2](https://platform.claude.com/docs/en/models/fable-5-2/whats-new-fable-5-2) page lists the differences below, as of November 10, 2026.

| | Fable 5.1 (`claude-fable-5-1`) | Fable 5.2 (`claude-fable-5-2`) |
| --- | --- | --- |
| Released / status | September 1, 2026 / Legacy | November 9, 2026 / current |
| Input / output per 1M tokens | $10 / $50 | $8 / $40 |
| Cache write 5 min / 1 hour, cache read | $12.50 / $20, $0.25 | $10 / $16, $0.20 |
| API rate limit | Shared with Fable 5 | Its own, separate limit |
| Prefix check on edited history | Default only for accounts created on or after August 31, 2026 | Every account |
| `computer_20251124` tool | Accepted | 400 except on Amazon Bedrock; use `computer_toolset_20260801` |
| Advisor tool (beta) | Accepts other advisors | Advisor must be Fable 5.2 or Mythos 5.2 |
| Fast mode | Not listed on the fast-mode page | `speed: "fast"`, up to 2.5x output speed, $16 / $80 |
| Claude Code default effort | `high` | `medium` |
| Unnecessary safety blocks | — | About 55% fewer than 5.1 in Anthropic's early testing |
| Context, max output, tokenizer | 1M, 128K, same tokenizer | Same |
| API default effort, effort levels | `high`; `low` to `max` | Same |

The rest of the request surface carries over unchanged: adaptive thinking is always on (disabling it or setting `budget_tokens` returns 400), assistant prefill and forced tool choice (`tool_choice` `any` or `tool`) still return 400, the reliable knowledge cutoff is June 2026, and both require 30-day data retention. Because the tokenizer is the same, the same prompt counts as the same number of tokens on both, so the 20% price cut is a real 20% on any fixed amount of text. Claude Mythos 5.2 (`claude-mythos-5-2`) is the same model with fewer safeguards for organizations verified through Anthropic's programs, and it follows the same rules. Posts from September 2026 about a "Fable 5.2" describe a rumored model; the November 9 release is the first official one.

## Fable 5.2 vs Fable 5.1 at the same effort: cheaper only at low and medium

On Artificial Analysis's long agentic tasks, Fable 5.2 costs less per task than Fable 5.1 at `low` and `medium` and more at `high`, `xhigh` and `max` at the same effort level, even though every token is 20% cheaper. The reason is volume: with prices 20% lower, Fable 5.2 breaks even with 5.1 when it uses 1.25 times the tokens (1 ÷ 0.8). It uses fewer at the two lower levels and far more than that at the three higher ones.

The table puts Artificial Analysis's same-effort rows for both versions side by side (Intelligence Index v5.0.1, as of November 10, 2026), with the changes recomputed from those rows on the same day. Cost per task is the cost of Artificial Analysis's own task mix at list prices, not a bill for your workload.

| Effort | Index, 5.1 → 5.2 | Cost per task, 5.1 → 5.2 | Output tokens per task, 5.1 → 5.2 | Time per task, 5.1 → 5.2 |
| --- | --- | --- | --- | --- |
| `low` | 39 → 54 | $4.47 → $3.10 (−31%) | 37.8k → 35.9k (0.95x) | 7.4 → 6.5 min (−12%) |
| `medium` | 43 → 56 | $5.56 → $3.80 (−32%) | 48.5k → 43.1k (0.89x) | 9.7 → 8.3 min (−14%) |
| `high` | 47 → 62 | $7.54 → $9.08 (+20%) | 66k → 97.8k (1.48x) | 13.2 → 17.7 min (+34%) |
| `xhigh` | 50 → 62 | $10.85 → $14.83 (+37%) | 97.1k → 162k (1.67x) | 19.2 → 26.3 min (+37%) |
| `max` | 49 → 65 | $12.99 → $26.54 (+104%) | 118k → 274k (2.32x) | 22.7 → 44.1 min (+94%) |

![Bar chart of cost per task for Fable 5.1 and Fable 5.2 at each effort level, cheaper for 5.2 at low and medium and costlier at high, xhigh and max](https://blog.laozhang.ai/posts/en/claude-fable-5-1-vs-5-2/img/cost-per-task-by-effort.webp)

The scores come from [Artificial Analysis's Fable 5.2 vs Fable 5.1 comparison](https://artificialanalysis.ai/models/comparisons/claude-fable-5-2-vs-claude-fable-5-1) and its per-effort pages; the index averages ten evaluations run in its own harness, and the site revises numbers without notice. The lowest Fable 5.2 score, 54 at `low`, is above the highest Fable 5.1 score, 50 at `xhigh`, which is why switching versions is an upgrade at any setting. The `medium` saving is the part that depends on your workload: in the November 10 API test of short single requests described below, Fable 5.2 at `medium` wrote 1.37 times the output tokens of 5.1, past the 1.25x break-even, and cost only about 5% less, while at `high` that test and Artificial Analysis point the same way. The "30% cheaper" figure that circulated on launch day mixes two numbers: the price cut is 20%, and 30% is Anthropic's "up to 30% faster" speed claim.

### Why Fable 5.2 `max` costs 79% more than `xhigh` for 3 more points

At `max`, Fable 5.2 spends 193k reasoning tokens per task against Fable 5.1's 71.4k, so its cost per task is $26.54, about twice Fable 5.1 `max` ($12.99, +104%). Within Fable 5.2, stepping from `xhigh` to `max` raises the index only from 62 to 65 while cost per task goes from $14.83 to $26.54 (about +79%) and time per task from 26.3 to 44.1 minutes. The top levels also stop paying off on individual tests. Fable 5.1 at `max` scores 49, below its own `xhigh` at 50. On FrontierCode 2.0 in Artificial Analysis's runs, Fable 5.2 peaks at `high` (49.1%) and then scores 47.6% at `xhigh` and 48.8% at `max`, so on that coding benchmark the two most expensive settings think longer and cost more for a lower result.

Anthropic's own guidance points the same way. Its [effort documentation for Fable 5.2](https://platform.claude.com/docs/en/build-with-claude/effort) says "most of the gain in capability is already present at `high`", suggests `xhigh` only for the hardest long-running coding and agentic work "where you've measured a gain", and says to "reserve `max` for measuring the model's ceiling and for the rare task where time and tokens don't matter." It also tells you to run an effort sweep on your own evals rather than carry settings over from Fable 5.1, which matters more than usual here because the same level now spends tokens differently.

## Which effort to run after switching: API, Claude Code, or the app

Pick your Fable 5.2 effort by the surface you use, because the default you land on differs. On the [Claude API](https://platform.claude.com/docs/en/build-with-claude/effort) both versions default to `high`. [Claude Code](https://code.claude.com/docs/en/model-config) defaults Fable 5.2 to `medium` but Fable 5.1 to `high`. In the Claude app, Anthropic calls Medium the default, and in a check on November 10, 2026 both Fable 5.1 and Fable 5.2 showed "Medium" when selected. The numbers below are the moves those defaults produce in Artificial Analysis's index, as of November 10, 2026.

| Where you run Fable | Default, 5.1 → 5.2 | What the default move does (index, cost per task, time) | Starting setting on 5.2 |
| --- | --- | --- | --- |
| Claude API | `high` → `high` | 47 → 62, +20% cost, +34% time | `medium` if 5.1 `high` was good enough; `high` if you need more than 5.1 gave you |
| Claude Code | `high` → `medium` | 47 → 56, −50% cost, −37% time | Keep `medium`; raise effort for a hard task, not for the whole session |
| Claude app | Medium → Medium | 43 → 56, −32% cost, −14% time | Keep Medium |
| You ran 5.1 at `xhigh` | — | 5.2 `low`: 50 → 54, −71% cost, −66% time | `low` or `medium` first; `high` (62) still costs 16% less than 5.1 `xhigh` |
| You ran 5.1 at `max` | — | 5.2 `low`: 49 → 54, −76% cost | Same as above; keep `max` only to measure the ceiling |

![Starting effort for Fable 5.2 on the Claude API, Claude Code and the Claude app, and for anyone who ran Fable 5.1 at xhigh or max](https://blog.laozhang.ai/posts/en/claude-fable-5-1-vs-5-2/img/effort-by-surface.webp)

On the API, the rule is to set `effort` explicitly rather than inherit `high`. If your Fable 5.1 integration ran at `high` and its output was acceptable, Fable 5.2 at `medium` is the obvious first candidate: it scores above 5.1 `high` in the index at about half the cost per task. On short single requests the gap is smaller; in the API test below, 5.2 `medium` cost 20% less than 5.1 `high` ($1.28 against $1.60) and passed 20 of 20 answers against 18 of 20. Stay at `high` when you moved to Fable for quality you didn't get before, and accept that the same level now costs more and runs longer.

In Claude Code, the lower default does most of the work for you, so the risk is the opposite one: a session that felt strong at Fable 5.1 `high` may now run at `medium`. Raise it for the tasks that need it rather than pinning `xhigh` or `max` for everything, since Anthropic also saw Fable 5.2 start subagents to review its own work at those levels, and subagents can account for a large part of what a session costs. How to set the level, and why a saved level may not stick, 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).

## Is Fable 5.2 faster? Faster tokens, longer tasks at high and above

Fable 5.2 generates tokens faster, but at `high` and above it takes longer per task, because it writes more of them. Anthropic says outputs are generated "up to 30% faster than Claude Fable 5.1" in its [Fable 5.2 announcement](https://www.anthropic.com/claude-fable-and-mythos-5-2); "up to" is a ceiling, not an average. Artificial Analysis measured output speed 4% to 23% higher depending on the level (for example 84 → 103 tokens per second at `xhigh`), as of November 10, 2026.

Time per task is what you actually wait for, and there the effort level decides again: 12–14% shorter at `low` and `medium`, 34–37% longer at `high` and `xhigh`, and 94% longer at `max`, where an Artificial Analysis task took 44.1 minutes against 22.7 on Fable 5.1. If speed is why you are switching, run 5.2 at `medium` or below on long tasks. Short requests behave differently: in the API test in the next section, Fable 5.2 streamed tokens faster at both `medium` and `high` but still took longer in total at both levels, because it wrote more tokens.

## Fable 5.1 vs 5.2 tested on November 10, 2026: Claude app and API

Two same-prompt tests on November 10, 2026, one in the Claude app and one through an API, found both versions about equally accurate on short, fully specified tasks, and on those tasks Fable 5.2 did not deliver the `medium` saving seen on long agentic work. Neither test is a benchmark of long agentic work, where the Artificial Analysis numbers above remain the better guide.

### Claude app at Medium: six prompts, 12 of 12 passed

In the Claude app, Fable 5.1 and Fable 5.2 at Medium both got everything right, and neither was clearly faster. Between about 08:20 and 08:50 (UTC+8), the same six prompts were sent once to each version on claude.ai, using incognito chats on one Ultra-plan account, with both models at the app's default Medium effort. Answers were graded against hidden tests and rule checks written before the run.

| Prompt | Fable 5.1 (Medium) | Fable 5.2 (Medium) | Result |
| --- | --- | --- | --- |
| Pricing word problem | 6.0 s | 4.5 s | Both correct |
| Digit-sum count without code | 11.4 s | 6.0 s | Both correct |
| Standard-library question with two made-up functions | 2.6 s | 1.6 s | Both said the functions don't exist |
| CSV line parser | 6.2 s | 3.8 s | Both 16/16 hidden tests |
| Expression evaluator | 10.0 s | 25.4 s | Both 25/25 hidden tests |
| Semver range matcher | 40.2 s | 35.0 s | Both 36/36 hidden tests |
| Total | 76.4 s | 76.3 s | 12 of 12 passed |

Times are wall time from pressing send to the end of streaming. Fable 5.2 finished sooner on five of the six prompts and later on the expression evaluator, where it wrote a 31% longer program (3,344 characters against 2,558); on the semver task its code was also 48% longer, with more comments and an extra helper. The totals came out the same.

Read this as a check that nothing regressed on everyday prompts, not as a speed benchmark. Each prompt ran once, on one account and one network, so a single timing can't separate the model from service load. The app shows no token counts, so the app test says nothing about cost; the API test below fills that gap. In the app's picker, Fable 5.2 sits in the main list and Fable 5.1 under "More models".

### API at `medium` and `high`: more output tokens, about the same cost

Through an API, Fable 5.2 wrote more output tokens than Fable 5.1 at both `medium` and `high` on short single requests, so its 20% lower price left the total cost about the same. Between 08:50 and 09:00 (UTC+8) on November 10, 2026, 11 standard prompts (the app's six plus five more, two of them with a long document of about 15,000 input tokens) were sent twice to each version at each level, through laozhang.ai's Anthropic Messages endpoint with a usage-billed key, not through Anthropic's API directly. Each was a single streamed request with no tools and no system prompt, `thinking: {"type": "adaptive"}`, `output_config.effort` set explicitly and `max_tokens: 32000`, and every response reported the requested model. The totals cover the 10 prompts both versions answered, 20 answers per cell, with cost computed from the returned token counts at list price ($10 / $50 per 1M tokens for 5.1, $8 / $40 for 5.2).

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

| Effort | Model | Passed | Output tokens | Cost at list price | Total request time |
| --- | --- | --- | --- | --- | --- |
| `medium` | Fable 5.1 | 20 of 20 | 13,898 | $1.35 | 209 s |
| `medium` | Fable 5.2 | 20 of 20 | 19,015 | $1.28 | 250 s |
| `high` | Fable 5.1 | 18 of 20 | 18,902 | $1.60 | 260 s |
| `high` | Fable 5.2 | 19 of 20 | 28,565 | $1.67 | 333 s |

At `medium`, Fable 5.2 used 1.37 times the output tokens and took 19% longer in total while streaming faster (66 → 76 tokens per second), and the price cut brought its cost to 5% below 5.1, not the 32% Artificial Analysis shows for long agentic tasks, where 5.2 at `medium` uses fewer tokens (0.89x). At `high`, the two sources agree in direction: 1.51x the output tokens here against 1.48x at Artificial Analysis, 4% more cost (26% more on the eight prompts without a long document, where output dominates the bill), and 28% more time. Fable 5.2 used fewer output tokens than 5.1 only on the counting problem solved without code, plus the long-document summary at `high`. If your traffic is short one-shot requests, budget for roughly the same cost at `medium`, not a third less.

Accuracy didn't separate the versions. The three failures were all at `high`: Fable 5.1 made an arithmetic slip on the pricing word problem ($46.00 for a combination that costs $41.50) and wrote a failing test of its own for an interval-merging function whose code passed the hidden tests, while Fable 5.2 returned the same function and its tests as two code blocks joined by a cross-file import that the single-file grader couldn't run.

One prompt behaved very differently on this route. Fable 5.1 refused the standard-library question (two real and two made-up Python functions) on 17 of 17 attempts, returning HTTP 200 with `stop_reason: "refusal"` and no output, while Fable 5.2 answered it correctly 5 of 5 times; in the Claude app, Fable 5.1 had answered the same question. That fits Anthropic's statement that Fable 5.2 produces about 55% fewer unnecessary blocks, but it is one prompt on one route on one day, not a refusal rate, and it was not checked against Anthropic's API.

The limits are narrow: one gateway route, one key, a ten-minute window, two samples per cell, four requests running in parallel, and request times that include network and gateway queueing. Output tokens include thinking, which wasn't streamed and can't be separated from the answer, and the costs are list-price equivalents of the token counts, not a bill. `low`, `xhigh`, `max`, fast mode, caching and the four breaking changes below were not part of the test.

## Fable 5.2 benchmark gains in Anthropic's launch table

Anthropic's launch table shows the biggest Fable 5.2 gains in agentic and coding work rather than in knowledge tests. In the [Fable and Mythos 5.2 announcement](https://www.anthropic.com/claude-fable-and-mythos-5-2), with each model at its highest available effort unless noted, FrontierCode 2.0 rises from 32.4% to 49.1% (both at `xhigh`), AutomationBench from 31.4% to 51.4%, Terminal-Bench-Science 0.1 from 52.6% to 74.6%, and Remote Labor Index from 17.9% to 41.3% (5.2 at `high`). Smaller steps appear on OSWorld 2.1 (83.5% to 89.3%) and Humanity's Last Exam with tools (65.6% to 74.2%). These are vendor-reported, launch-day numbers, and the cost table above is the better guide to what each point costs you.

## Before you swap the model ID in API code: what can break

If your API code builds its own `messages` array, run the checks below before moving production traffic from `claude-fable-5-1` to `claude-fable-5-2`; if Claude Code, claude.ai, Claude Managed Agents or the Claude Agent SDK builds the requests, Anthropic says nothing changes for you. The list follows the four breaking changes and the behavior notes in Anthropic's [Fable 5.2 migration guide](https://platform.claude.com/docs/en/models/fable-5-2/migration-guide) as of November 10, 2026; the API test above used single requests with no tools or conversation history, so it exercised none of them. In Claude Code, `/claude-api migrate this project to claude-fable-5-2` asks Claude to make the code changes for you.

- Run one session with the `thinking-binding-controls-2026-08-01` beta header and `thinking.block_binding.prefix_mismatch_behavior: "drop_block"`, log `input_transformations`, and fix every `prefix_binding_mismatch` entry. Fable 5.2 checks for edits to `system`, `tools` or earlier messages on every account, so code on an account created before August 31, 2026 can pass on 5.1 and fail on 5.2 with "Invalid `signature` in `thinking` block. The block is bound to a different conversation." Retrying the same body doesn't clear it, and `drop_block` is a stopgap that can raise output tokens.
- Find every router, retry or refusal fallback that can send a conversation from Fable 5.2 back to Fable 5.1. Fable 5.1 can't read 5.2's thinking blocks, so the API drops them: the request succeeds and the dropped tokens aren't billed, but the first turn after the switch runs without that reasoning.
- Replace `computer_20251124` with the `computer_toolset_20260801` toolset unless you run on Amazon Bedrock, and update the agent loop for it.
- If you use the advisor tool with Fable 5.2 as the executor, set the advisor's `model` to `claude-fable-5-2` or `claude-mythos-5-2`; a Fable 5.1 advisor returns 400.
- Look for prompt lines like "answer directly without deliberating" paired with a small `max_tokens`. At `medium` and above, Fable 5.2 thinks anyway, so the request can end with `stop_reason: "max_tokens"` before any text; raise `max_tokens` or lower effort.
- Check Fable 5.2's rate limit in your console, since it no longer shares the limit you sized for Fable 5.1 and Fable 5.
- Set `effort` explicitly, re-run your effort sweep, and re-measure cost per task and latency on your own evals instead of reusing 5.1's numbers.

Cache mechanics don't change between the versions: cache reads stay at 0.025 times the base input price, now $0.20 per million tokens. For how cache writes and reads are billed, see [Claude Prompt Caching: How It Works, Costs, 512-Token Minimum](https://blog.laozhang.ai/en/posts/claude-prompt-caching).

## Claude Code: what happens to a saved `claude-fable-5-1`

On Pro and Max plans, Claude Code moves a `claude-fable-5-1` model saved in your user settings to the `fable` alias, which now means Fable 5.2, the first time you run v2.1.321 or later, according to the [Claude Code model configuration docs](https://code.claude.com/docs/en/model-config) as of November 10, 2026. The terminal's startup model line can show `(auto-updated)` once. On Team and Enterprise plans the move waits for your organization's settings, so it may come later or not at all; run `/model` to see what you are on.

After the move, sessions start at Fable 5.2's default effort, `medium`, unless you have set a level for it. An older top-level `effortLevel` key in your user settings still applies to Fable 5.1 but not to models released after Opus 5.5, so a `high` you saved for 5.1 won't carry over. Console accounts, third-party providers, and project, local or managed settings keep `claude-fable-5-1` untouched. To go back to Fable 5.1, select it by ID with `/model claude-fable-5-1` or `claude --model claude-fable-5-1`; `/model fable` always picks Fable 5.2, except in Claude apps gateway sessions, where you use `/model claude-fable-5-2`.

## Do Pro, Max and Ultra plan limits treat Fable 5.2 differently?

No. Anthropic's Help Center article on [Fable models on your plan](https://support.claude.com/en/articles/15424964) says "Fable 5.2 and Fable 5.1 work the same way on these plans" as of November 10, 2026: Max and Ultra plans and premium Team or legacy Enterprise seats include Fable for up to 50% of the weekly usage limit, while Pro and standard Team seats pay for Fable with usage credits from the first request. The exception is launch week. From November 9 through November 16, 2026 at 11:59 pm PT, all Fable models are included on Pro and standard Team seats too, for up to 50% of weekly limits, with one Fable limit reset that expires at the same time. Anthropic does not say whether Fable 5.2 draws down a plan's limit faster or slower than 5.1. On Enterprise plans, Fable 5.2 stays off until an admin turns it on.

## Can you stay on Fable 5.1, and until when?

Yes. Fable 5.1 is labeled Legacy, not deprecated: its [model page](https://platform.claude.com/docs/en/models/fable-5-1/overview) says it "is still available" while suggesting the move, and the [model deprecations page](https://platform.claude.com/docs/en/about-claude/model-deprecations) sets its retirement no sooner than September 1, 2027, on the Claude API and the same cloud platforms that carry Fable 5.2. Staying makes sense while your API code fails one of the checks above, or when the provider you call doesn't serve Fable 5.2 yet. Gateways can add a new model later than Anthropic does: laozhang.ai added `claude-fable-5-2` on November 10, 2026, a day after the release (its model list didn't show it earlier that morning), at Anthropic's list price of $8 / $40 per 1M tokens with usage-based billing, so check your provider's model list before changing the ID. If the real question is whether you need Fable at all, Anthropic suggests starting most work on Opus 5.5 and moving up only when evals demand it; if you are moving to 5.2, that choice is covered in [Claude Fable 5.2 vs Opus 5.5: When Fable High Beats Opus Max](https://blog.laozhang.ai/en/posts/claude-fable-5-2-vs-opus-5-5), and if you are staying on 5.1, in [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).

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

## Sources

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

- [Fable 5.2 migration guide](https://platform.claude.com/docs/en/models/fable-5-2/migration-guide) (platform.claude.com)
- [What's new in Claude Fable 5.2](https://platform.claude.com/docs/en/models/fable-5-2/whats-new-fable-5-2) (platform.claude.com)
- [Artificial Analysis's Fable 5.2 vs Fable 5.1 comparison](https://artificialanalysis.ai/models/comparisons/claude-fable-5-2-vs-claude-fable-5-1) (artificialanalysis.ai)
- [effort documentation for Fable 5.2](https://platform.claude.com/docs/en/build-with-claude/effort) (platform.claude.com)
- [Claude Code](https://code.claude.com/docs/en/model-config) (code.claude.com)
- [Fable 5.2 announcement](https://www.anthropic.com/claude-fable-and-mythos-5-2) (anthropic.com)
- [Fable models on your plan](https://support.claude.com/en/articles/15424964) (support.claude.com)
- [model page](https://platform.claude.com/docs/en/models/fable-5-1/overview) (platform.claude.com)
- [model deprecations page](https://platform.claude.com/docs/en/about-claude/model-deprecations) (platform.claude.com)