TL;DR For well-scoped work, stay on Opus 5.5 at
medium, your Default: it passed 12 out of 12 for $1.91, the cheapest of the five configurations. When you were about to raise Opus tomax, start the session withclaude --model fable --effort highinstead: the same 12 out of 12 for $4.56 rather than $15.09, and 33 seconds of API time per task rather than 283.
Fable 5.2 costs twice as much as Opus 5.5 per token ($8/$40 against $4/$20 per MTok), and Anthropic's announcement says that at high it scores level with Opus 5.5 at max for roughly half the cost per task. I measured that inside Claude Code, with the same harness I used for Sonnet 5.5 against Opus 5.5: five configurations, four tasks, 60 runs. Fable on high didn't cost half of Opus on max. It cost a third, and finished eight times faster.
What Anthropic claims
On FrontierCode 2.0, which measures whether open source maintainers would merge the model's changes, Fable 5.2 at high scores 45.3% and Opus 5.5 at its best level, max, scores 45.5%. According to the announcement, for roughly half the cost per task. The same announcement recommends starting most coding work on Opus 5.5 and moving up to Fable only when the work calls for it.
Why twice the price per token isn't always twice the price per task:
| Per million tokens | Opus 5.5 | Fable 5.2 | Fable 5.1 |
|---|---|---|---|
| Input | $4 | $8 | $10 |
| Output (thinking included) | $20 | $40 | $50 |
| Cache write (1 h) | $8 | $16 | $20 |
| Cache read | $0.20 | $0.20 | $0.25 |
Cache reads cost the same on both models. In a Claude Code session they're most of what each turn reads, so on the same tokens Fable comes out at a bit under double.
What I measured
The same 11-file PHP repo and the four tasks from the Sonnet 5.5 benchmark, unchanged: fix a rounding bug, rename a class across 5 files, write a script that prices a JSONL of usage, and pull duplicated validation out of three controllers. Each has its own automated check. Three repetitions, four runs in parallel, Claude Code v2.1.325. Every run starts from a clean copy:
claude -p "<task prompt>" --model <model> --effort <level> \
--setting-sources project --strict-mcp-config \
--no-session-persistence --dangerously-skip-permissions \
--output-format json
Cost is the total_cost_usd the CLI itself returns. Before the grid I checked each configuration's real effort with the probe from the effort chain: Fable 5.2 and Opus 5.5 at medium (both start there) and with --effort high and --effort max; Fable 5.1 with no flag, at its default high. The harness is the one in this zip with three more configurations. Total spend: $33.09.
Results
Medians per run, plus the total across each configuration's 12:
| Configuration | Done | Cost | API time | Turns | Thinking | Total |
|---|---|---|---|---|---|---|
Opus 5.5 (medium, Default) |
12/12 | $0.157 | 18.7 s | 4.5 | 308 tokens | $1.91 |
Fable 5.2 (medium) |
12/12 | $0.284 | 22.7 s | 4 | 242 tokens | $3.49 |
Fable 5.2 (high) |
12/12 | $0.351 | 32.8 s | 5 | 1,070 tokens | $4.56 |
Fable 5.1 (high) |
12/12 | $0.509 | 78.7 s | 5.5 | 610 tokens | $8.04 |
Opus 5.5 (max) |
12/12 | $1.137 | 282.7 s | 14 | 20,227 tokens | $15.09 |
All 60 runs passed their check. What sets the five apart is what you pay and how long you wait. Opus 5.5 at medium reproduced the Sonnet 5.5 benchmark: $1.91 in total both times.
Fable on high against Opus on max, task by task
| Task | Fable 5.2 high |
Opus 5.5 max |
Fable / Opus | API time |
|---|---|---|---|---|
| Rounding bug | $0.256 | $0.906 | 28% | 17 s against 219 s |
| Class rename | $0.321 | $0.631 | 51% | 31 s against 157 s |
| Pricing script | $0.502 | $2.164 | 23% | 54 s against 615 s |
| Validation refactor | $0.360 | $1.289 | 28% | 34 s against 320 s |
Anthropic's half only shows up on the rename. On the other three, Fable on high cost between a quarter and a third. Overall, 31% of Opus on max's median ($0.351 against $1.137) and 8.6 times less API time.
Where Opus on max spends the money
- Thinking. About 20,000 tokens per run, billed as output at $20 per million: some $0.40 of the $1.14 median.
- Turns. A median of 14 on tasks
mediumfinishes in 4 or 5, and every turn re-reads the context (why that adds up).
The effort docs warn about it: max may show diminishing returns and is prone to overthinking, so test it before adopting it broadly. On these tasks, Opus 5.5 at max cost 7.2 times what it did at medium and took 15 times as long, for the same 12 out of 12.
At the same effort, Fable costs almost double
At medium, where both start, Fable 5.2 cost 1.8 times what Opus 5.5 did ($0.284 against $0.157) and was a little slower (22.7 s against 18.7 s). That fits the price list: double on everything except cache reads.
Against its predecessor, Fable 5.2 at high cost 31% less than Fable 5.1 at high and took 58% less time. That's more than the 20% rate cut Fable 5.2 brought accounts for.
When to use which
| Configuration | Reach for it when |
|---|---|
Opus 5.5 at medium (Default) |
You know what has to change and how to check it. Here it was the cheapest and the fastest |
Fable 5.2 at high |
You were about to go to max, or the work is long and open-ended, where Anthropic places Fable |
Fable 5.2 at medium |
You're already on Fable: here it passed the same as Opus at medium for almost double |
Opus 5.5 at max |
Nothing in these tasks justifies it. If you use it, measure first on a task of yours |
For well-scoped tasks, Sonnet 5.5 is cheaper still. And how I split the models day to day is in which one I use and when.
Switch to Fable on high
1. Start the session with model and effort
claude --model fable --effort high
--effort applies to that session and leaves your saved level alone. In a session that's already open, run /model fable, then /effort, pick high and press s so it applies to that session only. Pick at the start: switching models mid-session re-reads the whole conversation without the cache.
2. Check the level
$ claude -p "/effort status" --model fable --effort high
Current effort level: high (Comprehensive implementation with extensive testing and documentation)
3. Check how your plan bills it
On Pro, Fable 5.2 bills usage credits from the first request. On Max and Ultra it's included for up to 50% of your weekly limit. On the API, you pay the rates above.
If you already use max on Opus, remember it isn't saved: it lasts the session unless you pin it with CLAUDE_CODE_EFFORT_LEVEL. To keep one level per model, set effort per model. And what Fable 5.2 gains between medium, high and xhigh on tasks with hidden edge cases is in which effort to use with Fable 5.2.
Official docs: Model configuration: Adjust effort level · Claude Fable 5.2 and Mythos 5.2 · Pricing
What this doesn't measure
- Which one reasons better. All five configurations passed everything, so this measures cost and time at an equal pass rate. The hard work where
maxmight pay off isn't in these four PHP tasks with one right answer each. - Scale. 60 runs, three per task and configuration, one day.
- API dollars. On a subscription you feel it in your limit and in the wait, and in credits if your plan bills Fable separately.
Requirements
- Claude Code v2.1.321 or later for
fableto be Fable 5.2 (claude update). Every figure comes from v2.1.325, on November 17, 2026.