Anthropic's new guide says to start most work on Opus 5.5 at medium effort. On list prices Fable 5.2 costs twice as much as Opus, and Haiku 5.5 a fortieth. So I took every Opus turn my server ran last week, 29,515 of them, and priced the same tokens on each model. Fable came out at 1.53 times Opus. Haiku at 0.17, not 0.025. The difference is the context Claude Code sends every turn, and that's the part you can change.
I pay a subscription, not the API. Every dollar on this page is the Claude API list price applied to my token counts, so read it as a way to compare models, not as my bill. Measured 10 November 2026, 04:36 UTC, over the previous seven days on one server. Sources at the bottom.
The guide came out on 9 November, the same day as Claude Fable 5.2. It's written by Addy Osmani and it's a good one. The short version is a ladder. Start on Opus 5.5 at its default effort, medium. Go down when the work is simple and easy to check, and go up only when Opus at high still falls short.
All four have a 1M-token context window and 128K max output. The input and output prices tell you Fable is exactly twice Opus, Opus twice Sonnet. That's true per token. It's not true per task, and Anthropic says so in the same post: on long, cache-heavy runs the gap between Fable and Opus "comes down to uncached input and output". I wanted to know how big that effect is on real work.
My server runs Claude Code all day: my own sessions, scheduled routines and helper sessions. Every turn lands in a transcript under ~/.claude/projects/ with its token counts. Last week that was 29,515 Opus 5.5 turns, 5,135 on Sonnet 5.5 and 222 on Haiku 5.5. No Fable yet.
Then I took the exact same token counts, turn by turn, and priced them on the other three models. Haiku gets its long-prompt price on every turn over 100,000 tokens, the way the pricing page says.
| Same 29,515 turns on | List price | Against Opus |
|---|---|---|
| Fable 5.2 | $3,387 | 1.53x |
| Opus 5.5 | $2,208 | 1x |
| Sonnet 5.5 | $1,104 | 0.50x |
| Haiku 5.5 | $368 | 0.17x |
Fable isn't double because a Fable cache read costs the same $0.20 as an Opus cache read. Almost half my spend was reads, and that part doesn't change. Sonnet is a clean 0.50x because every Sonnet price, reads included, is half of Opus.
Haiku is the surprise. On paper its input price is a fortieth of Opus. On my turns it's a sixth, because 90% of them were over 100,000 tokens. Above that line Haiku charges five times its short-prompt price, on the whole prompt, cache reads included.
One thing this table can't tell you is quality. These are Opus's tokens. Fable might finish the same job in fewer turns, Haiku might fail it and need three tries. All I'm showing is how the price of a turn moves when the context is this large. Anthropic's own advice is the same: compare cost per finished task, on your own work.
Before you type anything, Claude Code sends its system prompt, the tool definitions, the instructions of every MCP server you connected, your skills list, your CLAUDE.md files and your memory index. On my server the first turn of a session had a median of 82,331 tokens on Opus and 67,584 on Haiku. The Haiku sessions are helpers I start for bulk reading, and they load the same instruction files.
That's on me. My CLAUDE.md files and memory index add up to 74KB, because they route a whole portfolio of sites. At roughly 3.5 bytes a token that's about 20,000 tokens, a quarter of the start. The rest is tools, MCP servers and skills I connected over time. Together it means a Haiku helper on my box starts at two thirds of its cheap tier. Read three or four files and it's over. Last week 55 of my 222 Haiku turns crossed 100,000 tokens and paid the five-times price.
Anthropic writes that Haiku "pays off most on short prompts, where it costs a twentieth of Sonnet 5.5's input price". Short is the key word. A Claude Code session isn't short. I've written before about compacting at 300k because rereading context ate most of my weekly limit. The same context decides how cheap Haiku really is.
Set the shape of one task: how much context it starts with, how many turns it takes, and how much each turn adds and writes. The calculator prices every turn on every model at list price, with cache reads, cache writes and Haiku's 100K line. The first preset is a session shaped like mine. With it, the calculator lands close to my measured week: about 0.50x for Sonnet, 1.57x for Fable and 0.15x for Haiku.
Runs in your browser, nothing is sent anywhere. It counts tokens, not effort: higher effort shows up as more output and more turns, so raise those to see it. Prices from Anthropic's pricing page, checked 10 November 2026.
Try the classification preset and Haiku really is a fortieth of Opus. Then go back to the session preset. Same models, same price list, and Haiku is suddenly worth a sixth. Before you move a task to a cheaper model, check which of the two your task looks like.
The prompt cache belongs to the model that wrote it. Switch with /model halfway through a session and the next turn pays a cache write on everything, at the new model's price. At my median context of 168,840 tokens that one turn costs $1.35 on Opus and $2.70 on Fable, with Claude Code's one-hour cache. An average Opus turn on my box costs 7.5 cents. So one switch to Fable costs as much as 36 normal Opus turns.
Anthropic's fix is in the guide: run /compact first, or start a fresh session with a short written plan. Going down a tier has a second cost. A smaller model can't read the thinking blocks of a bigger one, so the earlier reasoning is dropped. A move away from Fable 5.2 to any other model drops its reasoning too.
The switch field in the calculator shows this. Put in the turn where you'd switch and each model gets the extra cost of that first turn.
The most useful part of the guide isn't about models at all. Anthropic says: before you move up a model, check that Claude can verify its own work, then raise effort one level, and only then switch. These are their numbers for Opus 5.5 on SWE-bench Pro, against the high setting:
| Opus 5.5 effort | Score against high | Cost against high |
|---|---|---|
| low | about 8 points lower | about a third |
| medium (default) | about 2.5 points lower | about 70% |
| xhigh | about 1.4 points higher | 2.5 times |
| low, rerun failures at high | about 97% passed, against 95.3% | about $0.17 a task, against $0.29 |
That last row is the one I'd steal. It only works if you can check the outcome automatically, with a test, a build or a script. Most of my scheduled routines can. My long interactive sessions can't, and there I stay on Opus at medium.
On the hardest work the price gap closes from the other side. On FrontierCode 2.0, Fable 5.2 at high scored about level with Opus 5.5 at max, 45.3% against 45.5%, for roughly half the cost per task. So if you catch yourself setting Opus to max, try Fable at high first.
One line in the guide changes a default you might not have noticed. Claude Code's built-in Explore subagent, the one Claude sends to search a codebase, now runs on your session's model instead of always on Haiku. On a subscription with Fable as the main model it runs on Opus. The fix in the docs is to define your own subagent named Explore. It overrides the built-in one and keeps its own model.
---
name: Explore
description: Searches and reads the codebase to answer a question. Never edits files.
tools: Read, Grep, Glob, Bash
model: haiku
omitClaudeMd: true
---
Find what the main conversation asked for. Report file paths, line numbers
and the shortest excerpt that answers the question. Don't edit anything.I added omitClaudeMd: true on purpose. The built-in Explore already starts without your CLAUDE.md files, but a custom subagent loads them unless you set that field, which needs Claude Code 2.1.271 or later. By my byte count my CLAUDE.md files are about a quarter of the 67,000 tokens my Haiku helpers start with, so leaving them out helps but doesn't solve it alone. I haven't measured how low a Haiku Explore starts without them, so check your own first turn with the script below.
Fair warning about my own setup: Explore ran zero times on my server last week. I send bulk reading to Haiku helpers on purpose, so the change didn't cost me anything. It will cost you if you lean on Explore and run Fable or Opus as your main model. Anthropic's rule for what goes to a small model is a good one: work where a mistake is cheap to spot, like finding files, running tests and reading logs. Code edits and judgment calls stay on the main model.
Anthropic's post on X had 8,800 likes and around 200 replies when I read it, seven hours in. The most repeated request was some version of "let the model pick for me". Others were about weekly limits after the Fable launch, not about model choice. The sharpest reply I saw came from someone who had read their own transcripts: 59% of their spend was "the main thread rereading its own context". My number is 47%. Same story.
An automatic router would help people who don't want to think about models. It wouldn't fix the bigger lever. On my box the choice between Opus and Sonnet halves the bill. A start context of 82,000 tokens is in every turn on every model, and a router doesn't shrink it.
Anthropic's guide has a weak spot too. Its prices and examples are clean API calls. It says Haiku "pays off most on short prompts", but a Claude Code helper isn't a short prompt unless you make it one. If you take the ladder from the guide and drop your subagents to Haiku without checking their start context, you can end up paying the long-prompt price on most turns and wonder why the savings are smaller than the price list promised.
This prints, per model family, how many turns you ran in the last seven days, the share of input that came from cache, the list-price split, the median context per turn and the first-turn size. For Haiku it also counts turns over 100K. It only reads your transcripts. It writes nothing and sends nothing.
python3 - <<'EOF'
import json, glob, os, time, statistics as st
P = {"fable": (8, 10, 16, .20, 40), "opus": (4, 5, 8, .20, 20), "sonnet": (2, 2.5, 4, .10, 10),
"haiku": (.10, .125, .20, .01, .50), "haiku>100k": (.50, .625, 1, .05, 2.50)}
cut, seen, S = time.time() - 7 * 86400, set(), {}
for f in glob.glob(os.path.expanduser("~/.claude/projects/**/*.jsonl"), recursive=True):
if os.path.getmtime(f) < cut: continue
first = True
for line in open(f, errors="ignore"):
try: d = json.loads(line)
except ValueError: continue
m = d.get("message") or {}
if d.get("type") != "assistant" or m.get("id") in seen: continue
fam = next((k for k in ("fable", "opus", "sonnet", "haiku") if k in m.get("model", "")), None)
if not fam: continue
seen.add(m["id"]); u = m.get("usage") or {}; cc = u.get("cache_creation") or {}
w1 = cc.get("ephemeral_1h_input_tokens", 0); w5 = (u.get("cache_creation_input_tokens") or 0) - w1
i, r, o = u.get("input_tokens") or 0, u.get("cache_read_input_tokens") or 0, u.get("output_tokens") or 0
prompt = i + w5 + w1 + r
big = fam == "haiku" and prompt > 100_000; p = P["haiku>100k" if big else fam]
s = S.setdefault(fam, {"turns": 0, "read": 0, "prompt": 0, "big": 0, "first": [], "all": [], "$": [0, 0, 0, 0]})
s["turns"] += 1; s["read"] += r; s["prompt"] += prompt; s["big"] += big
s["all"].append(prompt)
if first: s["first"].append(prompt); first = False
for k, v in enumerate((i * p[0], w5 * p[1] + w1 * p[2], r * p[3], o * p[4])): s["$"][k] += v / 1e6
for fam, s in S.items():
tot = sum(s["$"]) or 1
print(f"{fam:7} {s['turns']:6} turns | cache reads {s['read'] / max(s['prompt'], 1):.0%} of input tokens"
f" | list price ${tot:,.2f}: writes {s['$'][1] / tot:.0%}, reads {s['$'][2] / tot:.0%}, output {s['$'][3] / tot:.0%}"
f" | context per turn median {st.median(s['all']):,.0f}"
f" | first turn median {st.median(s['first']) if s['first'] else 0:,.0f} tokens"
+ (f" | {s['big']} turns over 100K" if fam == "haiku" else ""))
EOFMine printed this, on 10 November at 04:36 UTC:
haiku 222 turns | cache reads 55% of input tokens | list price $4.18: writes 53%, reads 11%, output 36% | context per turn median 71,300 | first turn median 67,584 tokens | 55 turns over 100K
sonnet 5135 turns | cache reads 98% of input tokens | list price $197.82: writes 42%, reads 43%, output 15% | context per turn median 166,833 | first turn median 77,014 tokens
opus 29513 turns | cache reads 98% of input tokens | list price $2,207.36: writes 39%, reads 47%, output 15% | context per turn median 168,840 | first turn median 82,331 tokens| If your output shows | Mine | Look at this first |
|---|---|---|
| First turn median above 60,000 | 82,331 | Your CLAUDE.md files, MCP servers and skills, before any model change |
| Haiku turns over 100K | 55 of 222 | That's the saving the price list promised and you didn't get |
| Reads near half of the Opus bill | 47% | Sonnet halves that part, Fable doesn't double it |
If your Opus line looks like mine, Opus at medium is probably the right default, as Anthropic says. The cheaper move is a shorter start, not a smaller model.
The next thing that could change this is Haiku's pricing. A Haiku without the 100K line would make the ladder in the guide work for Claude Code helpers too. Until then, the line decides more than the model name does.
Same server, same habit of publishing the numbers that embarrass me.
75.6 percent of my week went to Claude rereading old context. The one-line compact fix and a daily pace check.
Read the guide // claude codeClaude Code loads 25KB of MEMORY.md. Mine was 38,855 bytes, so the last 63 lines never loaded. A checker for yours.
Read the guideStart context, model per task and the subagents that should run on Haiku, checked on your own server with the script on this page.