Sonnet 5, Opus 5 and Fable 5: which one I reach for, and what changing your mind costs

TL;DR My routing: Opus 5 at its default effort for almost everything, Fable 5 only when the territory is genuinely new, and Sonnet 5 living inside subagents, never as the main model. Plus the bit nobody mentions: switching models mid-session breaks your cache, and that turn reprocesses the whole conversation at full price. So the question isn't only which one you pick, it's when you switch.

Anthropic has its own guidance and the metaphor works: Fable is "a specialist who's seen problems almost no one else has", Opus is "the expert" for the genuinely hard stuff, and Sonnet is "a really good generalist" for routine work, because "there's no reason to pay for capability the task doesn't need".

That's a fine map. What it doesn't tell you is what happens when you change your mind mid-task, which is the decision you actually make several times a day. Here's how I do it, with the costs on the table.

Result (my routing, as it stands):

New task                  →  Opus 5, default effort
Unfamiliar territory      →  Fable 5 to open it up and scope it
   ...and on the way down →  /compact  and THEN  /model opus
Mechanical work           →  subagent with model: sonnet

1. Opus 5 at its default, and I leave effort alone

My daily driver is Opus 5 with effort exactly where it ships. I don't raise or lower it except in emergencies, and it turns out that's precisely what Anthropic recommends for Claude Code: "for most tasks you should use the model's default effort level", treating it as a general preference rather than a task-by-task decision.

Raise it when you have a concrete reason, and the docs name three: Claude skipped a file, didn't run the tests, or bailed on a refactor partway through. For me effort is a fire extinguisher, not a dial I fiddle with.

One detail to watch: Opus 5 doesn't reset your effort when you switch to it, unlike Fable 5 and the earlier Opus models. If you once dropped it, it's still dropped. Check it once with /effort and forget about it (the three ways to set it).

2. Fable only when the territory is genuinely new

I go to Fable 5 when the area is completely new to me, or when I'm combining areas I do know in a way I've never tried. I ask it to scope the problem and get started, then drop to Opus for the bulk of the work.

That lines up with its documentation: navigating ambiguity is its strong suit, and the guidance is to start at the top of your difficulty range, handing it something harder than you'd give an earlier model and letting it scope and execute.

What I don't do is use Fable for work a perfectly capable smaller model could handle. That's taking a Lamborghini to buy bread, and it eats your quota: Fable burns your limits around 2× faster than Opus. That said, the docs warn about the opposite too, so don't take it as a blind rule: on complex work a smaller model can burn iterations and end up costing you more than the big one getting it right first time.

3. Sonnet lives inside subagents

Sonnet 5 isn't my main model, it's my delegated one. Opus orchestrates with fresh context and hands the mechanical work to subagents running Sonnet.

The theory: once the domain-level decisions are settled upstream, the technical micro-decisions have enough context in the code itself for a smaller model to infer them. What can't be inferred from the codebase is what the human decides, and that happens first.

It isn't just a habit of mine: the effort docs describe low as suited to "simpler tasks that need the best speed and lowest costs, such as subagents".

And you don't do this by hand each time, you declare it on the agent:

---
name: refactor-worker
description: Mechanical changes where the design is already settled
model: sonnet
memory: project
---

About memory, which I had confused. Subagents do have persistent memory (user, project, or local) and later runs arrive knowing what they learned. But that isn't caching: the docs say a subagent gets a separate cache from your session, and enabling memory injects the first 200 lines or 25KB of its MEMORY.md into the system prompt. So the cold start becomes better informed and bigger, not cheaper. Two bonus traps: enabling memory hands Read, Write and Edit back to the subagent even if you'd restricted them, and none of it does anything if autoMemoryEnabled is off or CLAUDE_CODE_DISABLE_AUTO_MEMORY is set.

4. What changing your mind costs

Here's the part almost nobody accounts for. The model and the effort level are part of the cache key, they aren't just text. Change either one and you start a fresh cache from scratch, and that turn reprocesses the whole conversation at full price, roughly 10× more on input (the full detail).

Which is why, when I drop from Fable to Opus, the order matters:

/compact          # invalidates only the conversation layer
/model opus       # now the reprocess lands on an already-short history

Do it the other way round and you pay for reprocessing the long history. Same move, and one of the two orders is meaningfully cheaper.

Reference

If you're on a cloud provider, the "Sonnet" you're comparing isn't the one I'm using.

Where it fits

This doesn't replace how to choose the right model, which is about splitting by phase with opusplan (Opus plans, Sonnet executes) and still holds. That one answers "which model for which phase"; this one answers "which of the three above, and in what order". And if you're coming from Sonnet 5, you'll notice that what was the balanced model there is the delegated worker here, because Opus 5 brought the cost per task down and moved the line.

Official docs: Choosing a Claude model and effort level in Claude Code · Model configuration

Requirements

• Checked on Claude Code v2.1.220. Fable 5 needs v2.1.170, Sonnet 5 needs v2.1.197, and Opus 5 needs v2.1.219.