Claude Sonnet vs Haiku vs Opus: When to Pick Which
A practical decision rubric for the Anthropic Claude tiers: per-tier cost, speed, capability, and a 7-row table mapping everyday tasks to the right model.
The three tiers, in one sentence
Haiku is the cheap-and-fast tier for high-volume low-stakes work. Sonnet is the balanced tier for everyday reasoning. Opus is the heaviest tier for reasoning that has to be right.
Three tiers, three jobs. The mistake most operators make is treating the three like a ladder they must climb — start at the bottom, upgrade if needed. The Anthropic Claude lineup is not a ladder. It is three parallel tools with different cost and capability profiles, and the right one depends entirely on the call you are about to make.
The decision rubric
This is the table to bookmark. Read the “task” column on the left, pick the tier on the right, and stop second-guessing.
| Task | Pick | Why |
|---|---|---|
| One-line reply, classification, JSON extraction | Haiku 4.5 | Cheapest; near-frontier quality on short structured prompts |
| High-volume categorization (triage, tagging, routing) | Haiku 4.5 | Cost-per-call dominates; capability is plenty |
| Single-file code edit with clear diff in mind | Sonnet 5 | Right balance of context grasp and latency |
| Multi-file analysis or refactor across modules | Sonnet 5 | Better instruction-following than Haiku; cheaper than Opus |
| Long-context summarization (200k–1M tokens) | Opus 4.8 or Sonnet 5 | Sonnet for routine summarization; Opus when the summary drives a decision |
| Code review where missed bugs are expensive | Opus 4.8 | Highest code-correctness ceiling in the lineup |
| Math / proof verification / multi-step reasoning chains | Opus 4.8 | Heavyweight reasoning is what the tier exists for |
If a task fits two rows, pick the cheaper tier first. Promote only after the cheaper tier demonstrably fails on the operator’s downstream.
Cost per million tokens (snapshot)
Live prices from the Anthropic pricing page, captured 2026-07-14. All figures are USD per million tokens (MTok), input / output.
| Model | Input | Output | Context window |
|---|---|---|---|
| Claude Haiku 4.5 | $1 | $5 | 200k |
| Claude Sonnet 5 (intro through 2026-08-31) | $2 | $10 | 1M |
| Claude Sonnet 5 (standard from 2026-09-01) | $3 | $15 | 1M |
| Claude Opus 4.8 | $5 | $25 | 1M |
Output tokens cost 5x as much as input tokens across the lineup. That is why long-winded system prompts matter more than people think: a 1k-token system prompt is cheap (input); a 1k-token opus response with the same content is a five-times costlier line on the bill.
The intro pricing on Sonnet 5 expires on 2026-08-31. Do not bake the $2/$10 figure into any long-lived automation or budget forecast without a refresh date in the comment.
The four capability axes
A useful way to compare three tiers without drowning in benchmark graphs: pick four axes that map to operator outcomes.
- Reasoning depth — Haiku solid, Sonnet stronger, Opus strongest on multi-step chains. The gap between Sonnet and Opus widens noticeably on multi-hop problems.
- Speed floor — Haiku fastest on short prompts, Sonnet close behind on most calls, Opus noticeably slower because more compute is spent per token.
- Instruction-following — Sonnet and Opus both hold complex, layered system prompts reliably; Haiku can drift on long or contradictory instruction sets.
- Code-correctness — All three tiers can write code; Sonnet is the everyday workhorse; Opus is the model to reach for when a missed edge case is a real cost.
The Anthropic model cards document these axes formally with test methodology; the operator takeaway above is the gut version distilled from running them.
When to override the rubric
Sometimes a task that “should” be Sonnet keeps failing three times in a row. Promote to Opus. Sometimes a task that “should” be Opus lands clean on the first call with Sonnet. Demote and bank the savings.
The rule of thumb is short: move up a tier when the output is unfit for the operator’s downstream; move down when the output is fine and the cost is obvious. The rubric is a starting bias, not a law. Each call is one data point; a small personal log of “task → tier → result → retry count” quickly becomes the most valuable piece of operational metadata in the whole stack.
Use Haiku for:
- Quick one-liner replies
- High-volume categorization
- Tiny summarization (≤ 500 tokens of input)
- Cheap shell-out layers in multi-agent systems
Use Sonnet for:
- Mid-depth reasoning and most everyday reasoning tasks
- Code generation across single files or a small set
- Multi-step instructions with several constraints
- The default fallback when the task is not obviously tiered
Use Opus for:
- Long-context tasks with downstream consequences
- Math or proof verification
- Architecture-level design across many components
- Reasoning chains where two-strikes-out means the project failed
Common failure modes
| Mistake | What it costs |
|---|---|
| Defaulting every call to Opus | Burns 5x the input budget on trivially easy tasks; Sonnet would have shipped faster and cheaper |
| Routing Opus-grade tasks to Haiku to save money | The output is rejected, retried, or quietly shipped wrong — the “savings” turn into rework cost |
| Locking an app to one tier forever | A new Anthropic release shifts the cost/quality curve; the app’s worst task suddenly becomes its most expensive line item |
| Benchmarking on a single test prompt | Every call is one data point — pick the tier on five diverse tasks before committing |
| Confusing the legacy and current aliases | claude-3-5-sonnet-*, claude-3-7-sonnet-*, claude-sonnet-4-*, and claude-sonnet-5 are four different models with different prices |
What not to do
- Don’t lock your app to a single tier. Compose a routing layer: cheap tier first, expensive tier on failure.
- Don’t pick Opus by reflex. Operators fresh out of a benchmark high are the most expensive users Anthropic has.
- Don’t write a benchmark of one — every call is one data point. Test on five diverse tasks before committing to a tier assignment.
- Don’t confuse model family generations. 3.5 Sonnet, 3.7 Sonnet, Sonnet 4.5, Sonnet 4.6, and Sonnet 5 are different models with different prices and capability ceilings.
- Don’t quote input pricing while ignoring output — output is 5x input on every tier.
Verification checklist
Three commands to confirm what is actually happening on a real call.
- Which model is loaded? Inspect the API request payload or the Hermes config layer:
cat ~/.hermes/config.yaml | grep -A2 'models:'. Thedefault:and the alias on the active provider must match the tier you intended to call. - How many tokens moved? Capture the response
usageblock (input_tokens,output_tokens,cache_read_input_tokens). On the Claude API this is part of every Messages response; on Hermes it surfaces in the run log. - What did that call cost? Multiply:
(input × tier.input_price) + (output × tier.output_price). Pre-compute it as a one-liner so cost is visible before the next call, not after the bill.
Sources
Last verified: 2026-07-14.
Sources
Submit a take
Have a different read on this? Drop a comment below — your email isn't published, and I read every one. Nothing leaves the site until I approve it.