Fable 5.2 vs Opus 5.5 in Claude Code: Plan With Fable, Build With Opus?

Fable 5.2 vs Opus 5.5 is the question in every Claude Code thread this week. Anthropic shipped Fable 5.2 on November 9, Claude Code made it the default Fable model the same day, and the most shared answer on X is a two-liner from Matt Shumer: Fable 5.2 for planning, Opus 5.5 for execution.

I like that split. It’s what I already do with Opus and Sonnet in my plan mode test. But “use Fable for planning” isn’t a setting you can click. There are three ways to do it in Claude Code, each with its own catch. So I built the same app from that test four times: Opus 5.5 alone, Fable 5.2 alone, Fable planning with Opus building, and Opus with a Fable advisor. Opus alone won: $3.58 and 9 minutes, against $6.61 to $9.33 for everything with Fable in it.

Quick answer: which model for what

• Opus 5.5 stays the daily driver. Anthropic says so itself: start with Opus 5.5 for most coding work and move up to Fable when the task is ambiguous, long or hard.
• Fable 5.2 is for the plan, the root cause and the architecture call. Those are the turns where a better model saves you a wasted build.
• The cleanest “Fable plans, Opus builds” setup is opusplan with two environment variables. The obvious version with one variable gives you Fable plans and Sonnet builds. Details below.
• On a clear spec, the split didn’t pay off. In my runs Opus 5.5 alone was the cheapest and fastest at $3.58. Fable planning plus Opus building cost $6.61, Fable alone $9.33.
• On Pro, Fable is only included until November 16, 2026, 11:59 pm PT. After that it runs on usage credits. On Max and Ultra it can use up to half of your weekly limit.

Short version for the impatient:

ANTHROPIC_DEFAULT_OPUS_MODEL=claude-fable-5-2 \
ANTHROPIC_DEFAULT_SONNET_MODEL=claude-opus-5-5 \
claude --model opusplan --permission-mode plan

What changed with Fable 5.2 in Claude Code

The Claude Code changelog for v2.1.321 says it in one line: Fable 5.2 (claude-fable-5-2) is now the default Fable model, with 1M context, $8/$40 per million tokens and $0.20 per million for cache reads. Three things follow from that, all from the model configuration docs:

1. The fable alias now means Fable 5.2. /model fable or claude --model fable gets you 5.2. You need v2.1.321 or later, so run claude update first.
2. A saved Fable 5.1 pick moved to 5.2. On Pro, Max and Ultra, if your user settings had claude-fable-5-1, it moved to the fable alias the first time you ran v2.1.321. The startup line can show (auto-updated) once. Want 5.1 back? /model claude-fable-5-1.
3. Fable is still never the default. No plan starts on Fable. You pick it, and picking it with /model saves it as your model for new sessions too.

Anthropic’s launch post also says Fable 5.2 generates output up to 30% faster than Fable 5.1, and that it’s cheaper than 5.1. The launch topped Hacker News in two threads, both above 900 points when I checked.

Fable 5.2 vs Opus 5.5: price, context, effort

Prices from Anthropic’s pricing page, per million tokens:

Fable costs twice as much per fresh token. But look at the cache read row: $0.20 per million on both. In a long Claude Code session most input tokens are cache reads, so a Fable session doesn’t automatically cost twice as much. The 2x hits output and cache writes.

Per token is also the wrong unit. Anthropic’s launch post claims Fable 5.2 at high effort scored about the same as Opus 5.5’s best score on FrontierCode 2.0 (45.3% vs 45.5%) “for roughly half the cost per task”. That’s their benchmark, not mine, but it matches the idea: a stronger model that needs fewer tokens to get there can be cheaper per task.

Anthropic’s own advice cuts the other way, though. The What’s new in Fable 5.2 page says to start with Opus and move to Fable 5.2 “when your evals on a Claude Opus model at higher effort still don’t meet your requirements”. The launch post calls Opus 5.5 “our strongest daily driver” and names two roles for Fable: advisor and orchestrator. That’s pretty much the split this post is about.

One effort detail: in Claude Code, Fable 5.2 and Opus 5.5 both start at medium. The API default for Fable 5.2 is high. If you compare Claude Code runs against API numbers, set the effort to the same level with /effort first.

Three ways to plan with Fable and build with Opus

Setup 1: switch by hand with /model

The simple way. Plan on Fable, approve, switch to Opus, build.

/model fable

Press Shift+Tab until you’re in plan mode, describe the task, and let Fable write the plan. When it’s done, don’t approve yet. Switch first:

/model

Pick Opus 5.5 in the picker and press s, not Enter. s switches for this session only. Enter, and typing /model opus directly, both save the model as your default for new sessions. Then approve the plan and Opus builds it.

The catch is caching. Each model has its own prompt cache, so the first Opus request after the switch reads the whole conversation with no cache hits. On a short planning session that’s cheap. On a long one with lots of files read, it isn’t. Claude Code asks you to confirm the switch while the cache is still warm, which is a good moment to ask yourself if the switch is worth it.

There’s a second, quieter cost. Per the What’s new page, Opus 5.5 can’t read Fable 5.2’s thinking blocks, so after the switch Opus sees the plan Fable wrote, not the reasoning behind it. A plan that spells out its decisions survives the handoff. A vague one doesn’t.

Setup 2: opusplan with Fable as the planner

opusplan is the built-in hybrid: opus in plan mode, sonnet everywhere else. The docs also say what controls those two phases:

• ANTHROPIC_DEFAULT_OPUS_MODEL sets the model “for opusplan when Plan Mode is active”
• ANTHROPIC_DEFAULT_SONNET_MODEL sets the model “for opusplan when Plan Mode is not active”

So the version going around, setting only the Opus variable to Fable, gives you Fable planning and Sonnet building. To get Opus as the builder you need both variables:

ANTHROPIC_DEFAULT_OPUS_MODEL=claude-fable-5-2 \
ANTHROPIC_DEFAULT_SONNET_MODEL=claude-opus-5-5 \
claude --model opusplan --permission-mode plan

I started that in an empty folder on Claude Code v2.1.323 to see whether it accepts it, without sending a prompt. It does. The header read Opus Plan with high effort · Claude Max (high because I’ve set it, the default is medium). The status line showed Fable 5.2 in plan mode, and after one Shift+Tab out of plan mode it switched to Opus 5.5.

Three side effects showed up in the same session, so keep these variables out of your global settings:

• The labels lie. The /model picker still describes opusplan as “Use Opus in plan mode, Sonnet otherwise”.
• Default moves to Fable. The picker’s Default row read Fable 5.2, because the Opus variable also sets which version the account default uses.
• Every opus becomes Fable. The /advisor picker listed Fable 5.2 twice, and any subagent defined with model: opus now runs on Fable at Fable prices.

Put the two variables in a shell alias or a one-off launch command, not in settings.json. And like the manual switch, every plan mode toggle in opusplan is a model switch, so it starts a fresh cache. The prompt caching docs say that explicitly for opusplan.

Setup 3: Opus 5.5 with a Fable advisor

The advisor tool flips the idea around. Opus 5.5 runs the whole session, and Claude calls Fable at decision points: before it commits to an approach, when an error keeps coming back, and before it says it’s done. Opus 5.5 as main model with a Fable advisor is an accepted pairing.

/model opus
/advisor fable

Or for a single session, without saving anything:

claude --model opus --advisor fable

The good part: toggling /advisor keeps your main model’s prompt cache, and Fable only runs when Claude decides it’s needed. The bad part: you can’t force or cap the calls, and each call reads the full conversation fresh, with no caching. A few Fable reads of a big transcript at $8 per million input tokens add up. Advisor tokens show up in /usage, so check it after your first real session.

The advisor is also experimental. It needs the Anthropic API or Claude Platform on AWS, so it won’t work on Bedrock, Google Cloud’s Agent Platform or Foundry.

Same app, four setups: cost, time, result

Same test as the plan mode post: the YouTube Thumbnail Previewer spec, word for word, as the only prompt. Vite, React, TypeScript, Tailwind, six features, no backend. Every run got its own empty folder and started in plan mode. I accepted every plan as it was and sent no follow-up prompts.

The four commands:

# Run 1: Opus 5.5 plans and builds
claude --model claude-opus-5-5 --effort high --permission-mode plan "$(cat SPEC.md)"

# Run 2: Fable 5.2 plans and builds
claude --model claude-fable-5-2 --effort high --permission-mode plan "$(cat SPEC.md)"

# Run 3: opusplan, Fable plans, Opus builds
ANTHROPIC_DEFAULT_OPUS_MODEL=claude-fable-5-2 \
ANTHROPIC_DEFAULT_SONNET_MODEL=claude-opus-5-5 \
claude --model opusplan --effort high --permission-mode plan "$(cat SPEC.md)"

# Run 4: Opus 5.5 with a Fable 5.2 advisor
claude --model claude-opus-5-5 --advisor fable --effort high --permission-mode plan "$(cat SPEC.md)"

Every number below comes from Claude Code’s session logs, priced at the API list prices from the table above. Cost is what the tokens would cost on the API. On my Max plan, the four runs together moved my weekly usage bar from 20% to 23%.

What stood out:

• Opus 5.5 alone was the cheapest and fastest. $3.58 in 9 minutes. In the plan mode post the same setup cost $3.20, so that’s in line.
• Fable 5.2 alone cost 2.6x as much. It wrote more (89K output tokens against 57K) and every one of those costs twice as much. It also took 6 minutes longer.
• The Fable plan itself was cheap. In run 3 the plan phase cost $1.27. The Opus build after it cost $5.34, though, more than the whole Opus-only run. It read 7.1M cached tokens against 3.9M for the Opus-only run, so it simply did more work.
• The advisor was called twice and cost $2.45. Two calls, 255K input tokens, all uncached, because each advisor call reads the whole transcript fresh. Without those two calls, run 4 would have cost $5.62.
• All four apps build. Each opens on a pre-filled YouTube feed with your card in it. Runs 2, 3 and 4 also drew the YouTube top bar and category chips around the cards. I checked the build and the first screen. The runs tested the six features themselves.

The fine print: one run per setup, so this is a data point, not a benchmark. All four ran in parallel on Claude Code v2.1.323, every one at high effort so the models compare fairly (Fable 5.2 defaults to medium). After the plan I picked “Yes, and use auto mode” instead of bypass permissions, so the build phase ran without prompts but with the auto mode classifier on.

Usage limits, usage credits and the consent prompt

How Fable bills depends on your plan. From Anthropic’s support pages on Fable models on your plan and the Fable 5.2 launch offers:

Max and Ultra also get one to three Fable limit resets depending on how long you’ve subscribed. They expire on March 8, 2027. A reset gives back the weekly usage you spent on Fable and refills your five-hour window.

When Fable would bill to usage credits, Claude Code shows a one-time consent prompt in interactive sessions. That prompt has two traps:

• Unattended sessions stall. With Remote Control connected, in a background session or an agent team teammate, Claude Code holds the prompt for the dialogExpiry deadline, five minutes by default. If nobody answers, it ends the turn without sending the request. Your remote agent just sits there.
• -p doesn’t ask at all. In non-interactive mode, Claude Code never shows the prompt. If a Fable request would bill to usage credits, it bills without asking. Watch your cron jobs and scripts.

The advisor follows the same rules. Until you’ve accepted the consent, /advisor fable won’t save and points you to /model fable instead, and claude --advisor fable exits at launch. Accepting it via /model fable also saves Fable as your model, so switch back to Opus afterwards.

Which setup I’d pick on Pro, Max and the API

My runs used a clear spec for a small app, and there Fable didn’t buy anything Opus couldn’t do for less. So my default is Opus 5.5, and Fable comes in when the task is unclear, not when it’s big:

• Pro: Stay on Opus 5.5 (or Sonnet). Try Fable this week while it’s included, until November 16. After that every Fable token is usage credits, so save it for the one plan or root-cause hunt that matters. Skip the advisor on long sessions, because its uncached reads go straight to credits.
• Max and Ultra: Opus 5.5 by default. For ambiguous work, setup 2: Fable plans, Opus builds. In my run the Fable plan phase was only $1.27 of $6.61, so the 50% Fable cap goes a long way.
• API: Same as Max, and watch output tokens. Fable alone wrote 56% more output than Opus alone, at twice the price per token.

It’s also the split I care about for my own AI Coding Orchestrator, where roadmap planning and task execution are separate steps anyway. These runs tell me to keep that split for big, unclear roadmaps and not for small builds.

Gotchas

• One env var isn’t enough. With only the Opus variable set, opusplan plans on Fable and builds on Sonnet.
• Your old Fable 5.1 pick is now 5.2. If you pinned 5.1 on purpose, set it again with /model claude-fable-5-1. Project, local and managed settings kept 5.1.
• Security and biology work falls back. Fable 5.2 and Opus 5.5 run safety classifiers. A flagged cybersecurity request re-runs on Opus 4.8, a flagged biology request on Opus 5, and the session stays on that model until you run /model. It can happen on the first request in a security-heavy repo, from CLAUDE.md alone. Set Switch models when a message is flagged to Ask each time in /config if you want a say.
• Medium effort can stop early. The What’s new page says Fable 5.2 sometimes ends a long task with a list of what’s left, more often at low and medium. For a big build, raise the effort with /effort.
• Accept the consent first. Do it once at the terminal before you start background or Remote Control sessions on Fable.

FAQ

Is Fable 5.2 better than Opus 5.5 for coding?

On Anthropic’s benchmarks, yes, a step above in most of them. Anthropic still recommends Opus 5.5 as the starting point for everyday coding and Fable for the hardest, most open-ended work.

Is Fable 5.2 twice as expensive as Opus 5.5?

Per input and output token, yes: $8/$40 against $4/$20. Cache reads cost $0.20 per million on both. In my run on the same app, Fable 5.2 alone cost $9.33 against $3.58 for Opus 5.5, 2.6x as much, because it also wrote more.

Can I use Fable 5.2 on the Pro plan?

Yes, with usage credits. During launch week it’s included in your weekly limits (up to 50%) until November 16, 2026, 11:59 pm PT.

Does opusplan use Fable 5.2?

Not by default. opusplan plans on opus and builds on sonnet. Set ANTHROPIC_DEFAULT_OPUS_MODEL=claude-fable-5-2 to plan on Fable, and ANTHROPIC_DEFAULT_SONNET_MODEL=claude-opus-5-5 to build on Opus.

Can Fable 5.2 be the advisor for Opus 5.5?

Yes. Opus 5 and Opus 5.5 accept Fable or Opus 5 and later as their advisor. The other way around doesn’t work: a Fable 5.2 main model only accepts Fable 5.2 as its advisor.

Related guides

• Claude Code Plan Mode vs One-Shot: Same App, 5 Ways, the opusplan baseline this post builds on
• AI Coding Workflow: Orchestrating Agents With Roadmaps
• Herdr: Run Claude Code Agents on Every Machine You Own
• Claude Code settings.local.json Secrets: Audit Your Repos, Rotate, and Stop the Leak
• Claude Custom Instructions: The 10-Line File That Kills Walls of Text
• How to Run Claude Code on a VPS, where unattended sessions meet the consent prompt
• Official docs: Model configuration and the advisor tool

Your turn

Did Fable earn its price in your sessions, or are you back on Opus too? Tell me your setup on X @StefanRows.