Which Claude model to use: Haiku, Sonnet, Opus or Fable (a start-here routine)

Pick the cheapest Claude model that passes your own test set, then spend extra only where a measured gap forces you to. In Anthropic's current lineup that usually means trying Haiku 5.5 first for volume work, Sonnet 5.5 for everyday coding and agents, Opus 5.5 for long-running agentic work, and Fable 5.1 only when Opus at high effort still falls short.

One caveat on whose advice this is: Anthropic's overview page says that if you are unsure, you should start with Opus 5.5 for most workloads. The routine below is the cost-first variant of that advice, and it is the better fit when volume is high. If a single failed run is expensive, Anthropic's capability-first path is reasonable.

This post gives you the prices (read on Anthropic's pages on 2026-10-09), a table of which model fits which job, a cost-per-task script I ran, and a "start here, move up only if" routine. It does not contain benchmark scores. For model-specific prompting, see the Opus 5.5 guide and the Fable 5 guide; for cross-vendor price mechanics, AI model pricing in 2026.

What is in the current Claude lineup?

From Anthropic's models overview and pricing page:

A related model, Claude Mythos 5.1, has the same capabilities as Fable 5.1 but is offered only to organisations verified through Anthropic's programmes, so it is not part of this decision for most readers. Older models (Opus 5, Sonnet 5, Sonnet 4.6 and earlier) remain on the pricing page; the older Sonnet 4.6 guide on this site describes a previous generation.

What do the price modifiers do?

The headline price is the start. From the pricing page:

• Prompt caching. A 5-minute cache write costs 1.25x the base input price and a 1-hour write costs 2x. A cache read costs 0.1x, except 0.05x on Opus 5.5 and Sonnet 5.5 and 0.025x on Fable 5.1. For Fable 5.1 that is $0.25 per million tokens, for Opus 5.5 $0.20, Sonnet 5.5 $0.10, Haiku 5.5 $0.01.
• Batch API. 50% off input and output for work that can wait (Anthropic's cost guide says up to 24 hours). That makes Sonnet 5.5 batch $1 / $5 and Haiku 5.5 batch $0.05 / $0.25 for prompts up to 100k.
• Long prompts. Fable, Opus and Sonnet include the full 1M window at standard pricing. Haiku 5.5 is priced by prompt length: over 100,000 tokens, the higher rates apply to the whole request, cache reads and writes included in the count.
• Fast mode. In research preview for Opus 5.5, at $8 / $40 per million tokens. Anthropic says it delivers up to 2.5x higher output speed. It is not available with the Batch API.
• US-only inference. The inference_geo: "us" setting applies a 1.1x multiplier on all token categories.
• Tokenizer. Models from 4.7 onward use a tokenizer that produces roughly 30% more tokens for the same text than Sonnet 4.6 and earlier, per the pricing page. If you compare to an old bill, count tokens, not words.

How much does a task cost on each model?

List price per token is not cost per task. I wrote a small script (Python, standard library) that holds the per-million prices from Anthropic's, OpenAI's and Google's pages and multiplies them by token counts for three task profiles. The profiles are my assumptions, chosen to show the arithmetic. Replace them with the usage numbers from your own logs.

# (fresh input, cache read, cache write, output) USD per 1M tokens, read 2026-10-09
PRICES = {
    "Claude Fable 5.1": (10.00, 0.25, 12.50, 50.00),
    "Claude Opus 5.5": (4.00, 0.20, 5.00, 20.00),
    "Claude Sonnet 5.5": (2.00, 0.10, 2.50, 10.00),
    "Claude Haiku 5.5 (prompt <=100k)": (0.10, 0.01, 0.125, 0.50),
}

def cost(model, tokens):
    p_in, p_read, p_write, p_out = PRICES[model]
    t_in, t_read, t_write, t_out = tokens
    return (t_in * p_in + t_read * p_read + t_write * p_write + t_out * p_out) / 1_000_000

Output of the full script, filtered to Claude, run on 2026-10-09:

Ticket classification (1.2k in, 60 out)
model                                         $/task  $/1,000 tasks
Claude Haiku 5.5 (prompt <=100k)              0.0001           0.15
Claude Sonnet 5.5                             0.0030           3.00
Claude Opus 5.5                               0.0060           6.00
Claude Fable 5.1                              0.0150          15.00

RAG answer (6k fresh + 4k cached prefix, 700 out)
Claude Haiku 5.5 (prompt <=100k)              0.0010           0.99
Claude Sonnet 5.5                             0.0194          19.40
Claude Opus 5.5                               0.0388          38.80
Claude Fable 5.1                              0.0960          96.00

Agent coding task (30k fresh, 400k cache read, 40k cache write, 25k out)
Claude Haiku 5.5 (prompt <=100k)              0.0245          24.50
Claude Sonnet 5.5                             0.4500         450.00
Claude Opus 5.5                               0.9000         900.00
Claude Fable 5.1                              2.1500        2150.00

Read it as ratios, not forecasts. Across these profiles Fable 5.1 costs about 2.4 to 2.5 times Opus 5.5 per task, and Opus costs 2 times Sonnet. Those ratios follow directly from the list prices, since every profile uses the same token mix for each model. The agent profile sums tokens over many requests; in a real run each request's prompt length decides whether Haiku's over-100k rates apply. Output tokens include thinking, so a higher effort setting raises the output column even when the price per token is unchanged.

The same script prices the other vendors. On the same profiles, Sonnet 5.5 and OpenAI's GPT-6.1 Sol have identical list prices ($2 / $10), and Haiku 5.5 up to 100k matches GPT-6 Luna ($0.10 / $0.50). List price equality says nothing about quality or token usage; for the other vendors' tiers see the GPT-6 prompting guide and the Gemini 3.8 prompting guide, and for turning this into a bill, LLM API cost per 1,000 requests.

Which model fits which job?

Anthropic's selection matrix is the base; the "my call" column is judgement, not vendor guidance.

The "start here, move up only if" routine

Anthropic's own advice is that a good evaluation set is the most important step. So build one before you pick.

1. Write 20 to 50 real tasks with a pass or fail check you can automate (a unit test, a schema check, an exact-match field, a rubric you have applied to a small sample by hand).
2. Run Haiku 5.5 at its default effort (medium). Record pass rate, tokens and cost per task.
3. Read the failures before changing the model. Instruction misses and format slips often fix with a clearer prompt or one effort notch up. Anthropic recommends high on Haiku for knowledge work, longer agent tasks and strict instruction following, and warns that at low it is more likely to skip a search, stop early or skip a check on long agent prompts.
4. Move to Sonnet 5.5 if failures are about reasoning depth or multi-step tool use. Anthropic suggests medium for well-specified agentic coding and high for harder or longer tasks.
5. Move to Opus 5.5 if Sonnet at high still misses. Sweep its effort rather than copying the setting from another model; Anthropic says to run a fresh sweep.
6. Move to Fable 5.1 only if Opus 5.5 at xhigh or max still falls short on demanding reasoning or long-horizon agentic work (Anthropic's wording).
7. Stop at the first rung that clears your bar on cost per solved task, then try one effort level lower on that rung.

Cost per solved task is cost per task divided by pass rate, if you retry failures until one passes. Here is the function and a run with pass rates that I invented to show the arithmetic. They are not measurements of these models:

def cost_per_solved(model, tokens, pass_rate):
    return cost(model, tokens) / pass_rate

Cost per solved task, agent profile, with HYPOTHETICAL pass rates (not measurements)
Claude Haiku 5.5 (prompt <=100k)           pass  55%  per task   0.025  per solved   0.045
Claude Sonnet 5.5                          pass  80%  per task   0.450  per solved   0.562
Claude Opus 5.5                            pass  88%  per task   0.900  per solved   1.023

With these made-up rates the cheaper model wins even at 55% passing, because the price gap is bigger than the pass-rate gap. With your numbers it may not. Retries are not free in wall-clock time either, so add a latency column if users wait.

Two shortcuts Anthropic describes, both from its own measurements which I have not reproduced: if you can verify outputs automatically, run everything at low effort and re-run failures at high; and put a frontier model in an advisor or orchestrator role over cheaper workers. See Anthropic's cost and intelligence guide for its numbers and caveats, and cut your Claude API bill for the caching and batching side.

What breaks when you switch models?

Changing rungs is not always a one-line edit. From Anthropic's effort and choosing pages:

• Different defaults. Opus 5.5 and Haiku 5.5 default to medium; Fable 5.1 and Sonnet 5.5 to high. Omitting effort on a swapped model changes behaviour and cost. Setting a model's default explicitly equals omitting it.
• Thinking switches differ. On Opus 5.5, adaptive thinking is always on, and thinking: {"type": "disabled"} returns a 400 at every effort level. Haiku 5.5 accepts disabled at high effort or below but returns a 400 at xhigh or max. Sonnet 5.5 uses {"type": "between_tools"} as its lowest setting, and that errors at xhigh and max.
• Forced tool use. Anthropic's choosing page warns that integrations forcing tool use with a tool_choice of type any or tool need to read the breaking changes before switching to Opus 5.5.
• Effort levels. All four support low to max including xhigh, but Anthropic notes that Sonnet 5.5 levels are recalibrated, so a level does not mean the same amount of thinking as on Sonnet 5.
• Cache. Assume a cold cache on a new model (I did not find an explicit statement on the pages I read, so check the caching docs). Changing effort or thinking config mid-session invalidates it unless you use per-message effort (beta; requires a beta header). A broken cache on Fable 5.1 re-writes at 1.25x instead of reading at 0.025x, a 50x gap per Anthropic's guide.
• max_tokens. Thinking counts toward it. Anthropic suggests starting at 64k for xhigh or max and, for Sonnet 5.5 agentic coding, 128,000 with streaming.

How do I check the lineup before I hard-code anything?

Ask the Models API instead of trusting a blog, including this one. Anthropic says it returns max_input_tokens, max_tokens and a capabilities object per model. Unrun, because I used no API key:

curl https://api.anthropic.com/v1/models \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01"

Pin the model ID in config, not in code, and log the model, effort and token usage on every call so the routine above is something you can rerun when the lineup changes. For automated routing between vendors, see AI model routing with LiteLLM and OpenRouter, and for the framework that does not depend on names, which AI model should I use.

What I could not verify

I did not run any Claude model for this post, so all quality claims are Anthropic's, and any pass rate in the text is labelled as invented. Prices and defaults come from pages fetched with curl and converted to plain text, so a footnote could be missing; Anthropic's pricing page points to claude.com/pricing for the most current figures. The profile token counts in the script are my assumptions. Consumer plan limits (Claude apps, Max, Pro) are a different topic and are not covered.