// guide · claude models

Which Claude model? I priced my Claude Code week on all four

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.

Anthropic's answer: Opus 5.5 at medium, then move

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.

Fable 5.2
Major refactors and migrations, architecture, leading many subagents, deep research. Also when Opus at high falls short, and for long unattended runs. $8 / $40 per million tokens.
Opus 5.5
Everyday engineering and debugging, computer use, and anything you're unsure about. The Claude Code default. $4 / $20.
Sonnet 5.5
Well-scoped coding against a spec, chat, documents and slides, agent tasks you repeat. $2 / $10.
Haiku 5.5
Classification, routing, extraction, and subagents that search files or read logs. $0.10 / $0.50 up to 100K tokens per prompt, $0.50 / $2.50 above.

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 week of Opus turns, priced on every model

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.

98%
of all Opus input tokens were cache reads. Claude Code resends the whole conversation every turn, and almost all of it comes from cache.
168,840
tokens of context in the median Opus turn. At $0.20 per million, that's 3.4 cents of reading before Claude writes a word.
15%
of the list-price total was output. Reading the cache was 47%, writing it 39%. What Claude writes is the small part.

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 onList priceAgainst Opus
Fable 5.2$3,3871.53x
Opus 5.5$2,2081x
Sonnet 5.5$1,1040.50x
Haiku 5.5$3680.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.

Claude Code starts at 82,000 tokens on my box

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.

Price one task on all four models

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.

A model switch rewrites your whole cache

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.

Four panels for one online coffee shop project: Fable 5.2 moves the store from JavaScript to TypeScript with 19 of 19 files moved, Opus 5.5 builds a monthly subscription with 40 of 63 tests passing, Sonnet 5.5 writes 24 of 24 product pages, and Haiku 5.5 sorts 480 of 480 customer messages.
Anthropic's picture of mixing models: each one gets its own kind of work, and Opus starts its feature after Fable's migration is in. Every handover is a natural break, not a switch in the middle of a long session. Still from a demo by Dan Fein in Anthropic's model guide.

Turn effort first, and rerun only what fails

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 effortScore against highCost against high
lowabout 8 points lowerabout a third
medium (default)about 2.5 points lowerabout 70%
xhighabout 1.4 points higher2.5 times
low, rerun failures at highabout 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.

Explore no longer runs on Haiku by default

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.

.claude/agents/explore.md
---
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.

"Make it an automatic decision" misses the context part

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.

Four portfolio homepages built from the same prompt: Lumen Atlas by Fable with a large serif title and a yellow halftone sun, Parcel and Co by Opus with blue and red halftone, Ostinato by Sonnet reading Crafting interfaces with a pulse, and Almanac by Haiku with a plain serif title.
The same portfolio site built by Fable 5.2, Opus 5.5, Sonnet 5.5 and Haiku 5.5. A nice picture of quality differences, and the part my token table can't show. Demo by Addy Osmani in Anthropic's model guide.

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.

Measure your own week before you switch anything

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.

terminal · python 3
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 ""))
EOF

Mine printed this, on 10 November at 04:36 UTC:

my output
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 showsMineLook at this first
First turn median above 60,00082,331Your CLAUDE.md files, MCP servers and skills, before any model change
Haiku turns over 100K55 of 222That's the saving the price list promised and you didn't get
Reads near half of the Opus bill47%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.

// more from the same box

The other Claude Code guides

Same server, same habit of publishing the numbers that embarrass me.

Sources, checked 10 November 2026

  • Anthropic, "Which Claude model should you build with? Fable, Opus, Sonnet, or Haiku", Addy Osmani, claude.dev blog, 9 November 2026: the task table, the start on Opus 5.5 at medium, cache reads at $0.20 on Fable 5.2 and Opus 5.5, the SWE-bench Pro effort numbers, the low-then-high rerun (about 97% for about $0.17 against 95.3% for $0.29), FrontierCode 2.0 (45.3% against 45.5%), model switches and thinking blocks, Explore on the session model. Both figures on this page come from its demos, with credit.
  • Claude Platform docs, "Pricing", platform.claude.com/docs/en/about-claude/pricing: base input, 5-minute and 1-hour cache writes, cache hits and output for all four models; Haiku 5.5 long-prompt prices over 100,000 tokens, counted on all input including cache reads and writes.
  • Claude Code docs, "Subagents", code.claude.com/docs/en/sub-agents: Explore runs on the main conversation's model, Explore and Plan start without CLAUDE.md, a user or project subagent named Explore overrides the built-in, omitClaudeMd in subagent frontmatter.
  • @ClaudeDevs on X, 9 November 2026, and its replies, read about seven hours after posting: 8,800 likes, around 200 replies. Read as a picture of that thread, not a poll.
  • My own measurement: all Claude Code transcripts on my server modified in the seven days before 10 November 2026, 04:36 UTC. 29,513 Opus turns in the summary, 29,515 in the repricing run a minute later. The script above is the one I ran. Subscription use, priced at API list prices for comparison only.

Want your Claude Code setup measured?

Start context, model per task and the subagents that should run on Haiku, checked on your own server with the script on this page.