Claude Haiku vs Opus: When the Cheaper Model Is Enough

Claude Opus 5.5 and Claude Haiku 5.5 sit at opposite ends of Anthropic’s 5.5 lineup. Opus is the largest model in the family. Anthropic positions it for complex implementation, audits and long agent runs where the model has to hold a plan together over many steps. Haiku is the smallest and newest. Anthropic describes it as built for summaries, compaction, database queries and classification, and as a subagent working under a larger model on coding tasks. Sonnet 5.5 sits between them. Both ends share a 1-million-token context window, and all three models were released within about two weeks of each other, between September 22 and October 7, 2026.

That timing explains why the choice between the two is hard to make from experience. Few teams have run Haiku 5.5 long enough to know where it holds up, and most still treat Opus as the model that handles anything. The public evidence is recent and spread across several sources: Anthropic’s launch benchmarks, which compare Haiku with Sonnet rather than Opus, and three October tests from OpenRouter, Bito and MindStudio. Between them they cover hidden-test coding, quick code questions, long Claude Code sessions, customer-service tasks, document analysis and visual builds. They use different graders and sometimes disagree on the numbers. All three third parties also sell products that benefit from multi-model setups, so each result needs a note on how far it can be trusted.

This guide puts those sources side by side and sorts tasks by which of the two models they suit, with a rating of how much evidence sits behind each call. It then covers the list prices, including the billing rules that change what a session costs, and works through a cost example with break-even figures for when Opus pays for itself. The last sections give a test you can run on 50 to 100 of your own requests and show how to assign different models to different roles in Claude Code and agent stacks.

Claude Haiku vs Opus in short: which model gets which task

Send short, well-specified, checkable work to Haiku 5.5. That covers classification, extraction, code lookups, document questions with verifiable answers, routine code edits and sub-agent tasks. Keep Opus 5.5 for long sessions where the model has to implement a change and then audit its own work, and for output where visual polish is the product.

Sonnet 5.5 sits between them. If you want one default and have no routing logic, it is the safer pick, and OpenRouter’s own comparison lands in the same place.

The evidence comes from Anthropic’s own launch benchmarks and three October tests: OpenRouter’s hidden-test and Claude Code runs, Bito’s coding benchmark, and MindStudio’s side-by-side builds. They disagree on some numbers and agree on the shape of the answer. Not every source deserves equal weight, so a section after the price table rates each one.

Claude Haiku 5.5, Sonnet 5.5 and Opus 5.5 pricing compared

All three models have a 1-million-token context window, and Anthropic released them within about two weeks of each other. The rates below are list prices per million tokens as of October 30, 2026. The Haiku 5.5 and Sonnet 5.5 figures match Anthropic’s Haiku 5.5 launch page, and the Opus 5.5 figures come from OpenRouter’s October 21 snapshot.

Haiku’s rates apply to prompts up to 100,000 tokens. Above that line, every token in the request is billed at $0.50 input and $2.50 output.

Opus costs 40 times what Haiku does on both input and output, and 20 times on cache reads. Sonnet is 20 times Haiku. For short prompts, Haiku 5.5 also costs a tenth of Haiku 4.5’s $1 and $5 rates. Sonnet’s cache-read price was cut from $0.20 to $0.10 the same day Haiku launched, which matters because agents re-read the same context on every turn.

Per-token billing is one of the agent pricing models we think buyers should forecast before comparing headline rates, so run your own volume through these numbers before you choose a default.

How much to trust the Haiku vs Opus tests

Four sources carry this guide, and they are not equally strong. Each one can show some things and not others.

Three consequences follow. Most of the hard numbers describe coding, so the decision table later in this guide marks its non-coding rows as weaker evidence. We did not run any of these tests, and this guide reports and weighs other people’s results without claiming its own. Finally, the three third-party sources all sell something that benefits from multi-model setups. That does not make their results wrong, but it is a reason to trust findings that more than one source reaches independently.

Where Claude Haiku 5.5 matches Opus

Haiku 5.5 held its own against Opus wherever the task was short, well specified and easy to check: hidden-test coding, quick code questions and structured document analysis. The subsections below go through each result, then cover what Anthropic’s own benchmarks add for non-coding work.

Short coding tasks: every model passed, Haiku up to 30 times cheaper

OpenRouter gave all three models 11 Python tasks with hidden tests. They ranged from parsing durations and merging intervals to a regex engine written without the standard library and free calendar slots across daylight-saving changes. Every model passed all 25 of its attempts. Haiku cost $0.0007 per everyday task against $0.0211 for Opus, and $0.0027 per hard task against $0.0739. That is roughly 30 and 27 times cheaper.

A separate run had Claude Code fix three bugs in a small invoicing library. All three models fixed all three bugs in all three runs, at a median of $0.0052 per session on Haiku and $0.098 on Opus, about 19 times less. On τ-bench airline, a multi-turn customer-service benchmark, Haiku scored 76.0% to Opus’s 75.5%. OpenRouter ran 100 to 200 tasks per model and warns that gaps of a few points may be noise.

Sonnet landed between the two, at roughly half of Opus’s cost to just under two thirds of it.

Quick code questions: Haiku scored 87% against Opus’s 90%

Bito ran Haiku on launch day through the same battery of real coding work it uses for every model. On one-shot asks, such as explaining how a config system resolves a setting, finding where a flag is used or fixing a small bug, Haiku at high effort scored 87% against Opus’s 90%. The session cost $0.014 against $0.32, about 23 times less for three points.

The effort setting mattered more than model size here. One task hid a quoted empty token in a config file that lets requests through with an empty Authorization header. Haiku at medium effort missed it and scored 59%. At high effort it caught the problem and scored 84%, and the session cost rose from $0.009 to $0.014. Haiku at medium also swung about three times more between sessions than at high. Bito’s advice is to run Haiku at high effort on small tasks, and at that price the advice is easy to follow.

Bito discloses that its grader was Opus 5.5, scores against answer keys checked against the code, and treats gaps of 1 to 2 points as ties. Read its numbers with that in mind.

Document analysis: all three models found 8 of 8 planted frauds

In MindStudio’s hands-on comparison, one creator planted eight fraud instances across several schemes in a retailer’s financial data and asked each model to act as a forensic accountant. Haiku, Sonnet and Opus all found all eight. Opus formatted its report more cleanly and cost roughly four to five times more. This is one person’s test and not a controlled benchmark, so treat it as a signal that structured analysis with verifiable answers suits the cheap tier, not as a guarantee.

Non-coding work: what Anthropic’s own benchmarks show

Anthropic describes Haiku 5.5 as built for summaries, compaction, database queries and classification, and as a subagent under Opus 5.5 or Sonnet 5.5 on coding work. Its benchmark table compares Haiku with Sonnet 5.5 and not with Opus, so read it as the cheap tier against the middle tier:

Haiku reaches about 81% of Sonnet’s score on Humanity’s Last Exam and 86% on OSWorld, but only about 56% on Terminal-Bench. That matches the third-party tests. The gap is modest on scoped work and large on long agentic coding, and Anthropic itself names Sonnet 5.5 and Opus 5.5 as the better choices for complex agentic coding.

Anthropic also quotes customers. HubSpot reports that Haiku 5.5 scored 92.8% on its simulated CRM-task suite, the best result it has seen on that suite, and was fastest with the lowest false-positive rate on a stale-record audit. AlphaSense measured 0.84 against 0.76 for Haiku 4.5 on 400 document-question queries. Rogo trusts it as a subagent for pulling a revenue line from a 10-K. None of these compares Haiku with Opus, and Anthropic chose them, so they show that Haiku is good enough for those jobs and not that it matches Opus on them.

Where Claude Opus 5.5 still earns its price

Opus pulls ahead when the work is long, hard to verify, or judged on polish: implementing and auditing fixes across a long session, and visual output where fidelity is the product. The subsections below show where the gap opens, and where Sonnet is enough instead.

Long coding sessions: Opus leads on implementing and auditing fixes

Bito’s long sessions are 15 to 20 minute Claude Code conversations on a real service: trace the relevant code, analyse a failure, plan a fix, implement it, audit the result. Haiku at high effort held up through the first half. On the failure-analysis turn it scored 87%, ahead of Sonnet at high effort (76%) and about level with Opus. The back half looked different. On the implementation turn Haiku scored 78% against Opus’s 85%, and on the final audit 71% against 82%.

Blended across Bito’s six main tasks, the cheaper setups score lower, but by far less than their price gaps:

The gap between Opus and Haiku widened with the complexity of the work: about 3 points on one-shot asks, 7 on the blended benchmark, and 8 to 10 on the implement-and-audit turns. Our reading is that the gap follows two things, how long the model has to keep a plan coherent and how much a wrong turn costs. Explaining existing code is cheap to verify. Implementing a fix in tangled code and then auditing it is not. Bito’s own advice is to keep Opus for implementing fixes in hairy code, auditing a change and reviewing a design, where it measured gaps of 7 to 11 points, well past its roughly 3-point noise.

Visual polish: Opus raises the ceiling

In MindStudio’s tests, Haiku built a 3D watch launch page for about $30. Opus cost close to $55 and produced the most polished result, an animated scroll experience that breaks the watch into its mechanical parts. Opus also led on character and face fidelity in the generated games. The same tester still judged Haiku’s page better than the median site live on the internet, and preferred Haiku’s narrative game because the larger models buried theirs in unskippable cutscenes. Opus raises the ceiling on visual work, and Haiku’s floor is already respectable.

Opus vs Sonnet: where the middle model fits

OpenRouter found Sonnet 5.5 scored higher than Opus 5.5 on its GPQA Diamond run (92.4% against 90.4%) and on τ-bench airline (78.7% against 75.5%), while passing every coding test at about half the per-token price. Opus led by 1.6 points on the Artificial Analysis Intelligence Index (57.6 against 56.0), and Haiku scored 43.4.

Bito’s coding benchmark points the other way, with Opus at 85% and Sonnet at high effort at 82%. The two sets of tests disagree, and the disagreement is useful. Short, bounded benchmarks do not show an Opus advantage, and long coding sessions do. If your work looks like the first, Sonnet or Haiku is probably enough. If it looks like the second, put Opus in your test.

Hidden costs of Claude Haiku 5.5

Haiku’s list price is only part of the bill. Long prompts, extra turns and misleading cost reports can all change what a session really costs, so check these three before you budget.

The 100K-token pricing cliff

Haiku’s $0.10 rate applies to prompts up to 100,000 tokens. Above that, every token in the request costs five times as much: $0.50 input and $2.50 output. Agents carry their history forward, so they cross the line far more often than one-off calls do. In Bito’s long build sessions about 70% of Haiku’s requests crossed it, which is why a long session at default effort cost $0.69 and not the rounding error the headline rate suggests. Our Claude Code review lists rising costs on very large context tasks as a trade-off for the same reason.

Even above the line Haiku costs a quarter of Sonnet and an eighth of Opus. The cliff changes your budget. It does not erase the savings.

More turns, and speed that varies by task

Bito found that Haiku needs more requests than the larger models to finish the same work. At matched quality it was slower, about 13 minutes against Sonnet medium’s 7 on long sessions. OpenRouter’s Claude Code bug-fix test shows the same tendency in miniature: Haiku took 6 to 8 turns where Opus and Sonnet took 5, though wall-clock time landed in the same range (22 to 31 seconds against 24 to 30 for Opus).

On OpenRouter’s hard function tasks the result flipped. Haiku finished fastest, at 22.6 seconds against 32.1 for Opus, even after spending more reasoning tokens. Speed varies with the task, so time your own workload if a person is waiting on the answer.

Cost reporting that can mislead

OpenRouter found that Claude Code’s built-in cost field did not recognize its Haiku model name when routed through a gateway. It reported $0.16 to $0.31 per session against a computed median of $0.0052. If you run Claude Code through a gateway, compare its reported cost with the gateway’s own usage page before you trust either number.

Worked example: 50,000 support tickets a month on Haiku, Sonnet or Opus

This is a hypothetical calculation from the list prices above, not a measured result. Assume each triage call sends 3,000 input tokens and returns 400 output tokens, prompts stay under 100,000 tokens, and nothing is cached.

In the cascade, Haiku answers every ticket and 15% of them (7,500) go to Opus afterwards. That is $25 plus 7,500 times $0.02, or $175, which is 82.5% less than running Opus on everything.

Haiku answers everything, the check decides what escalates, and only those tickets pay Opus rates.

The break-even point is extreme. A Haiku-first cascade stays cheaper than Opus-only until you reject about 97.5% of Haiku’s answers, because Haiku’s cost per request is 1/40 of Opus’s. Price almost never decides this. Detection does. A cascade only works if something tells you Haiku’s answer was wrong: a unit test, a schema validator, a confidence check, or a rule that sends refund requests straight to a person. If nothing can catch the failure, the cheap answer is not cheap, because the cost lands on the customer and not on the invoice.

Support is the category where autonomous agents reached production first and hurt fastest when wrong, which is why the escalation rule matters most there. We cover that market in the state of autonomous customer support. The numbers above also exclude engineering time, retries after errors and the cost of a wrong answer, so treat them as a floor.

The break-even math: when Opus’s extra cost is worth paying

Price per request is half the comparison. Opus pays for itself when its extra cost per task is smaller than the error-rate gap times what one error costs. The cases below are hypothetical and use prices from earlier in this guide.

When an error is cheap to catch and redo, even a large quality gap does not justify Opus. When a miss costs a person’s time, a gap of a few points can. Bito measured a 3-point gap on one-shot code questions, which is more than the 2 points a $15 error would justify. Score points are not error rates, so treat that as a prompt to find your own numbers and not as a verdict.

Scale matters too. At 50,000 requests a month the whole difference in the triage example is $975, an amount a team might reasonably spend to avoid even occasional costly errors. That is the case for a cascade over either extreme: Haiku answers everything, and a check sends the doubtful answers to Opus.

Decision table: which Claude model for which task

This table is editorial judgment built from the sources above. Start each task type in the tier shown and move up only when your own test shows failures. The last column rates how strong the evidence is: strong means more than one source agrees, moderate means one source or vendor guidance, weak means anecdote or a gap within noise.

Treat the first question as a gate. If nothing can catch a bad answer, the price gap stops mattering.

How to test Haiku vs Opus on your own workload

Published tests show the shape of the gap. Only your workload shows where you sit on it, and an afternoon of testing can save months of paying for the wrong default.

1. Pull 50 to 100 real requests from your logs and strip anything sensitive. Include the awkward ones, not only the typical ones.

2. Write a pass check for each: a unit test, an answer key, a schema validator or a short rubric. If you cannot define a pass, you cannot compare tiers.

3. Run every tier on identical prompts, several times each. Bito saw about 3 points of session-to-session noise, so treat gaps of 1 to 2 points as ties.

4. Record cost, wall-clock time, number of turns and failures, not only accuracy. Run Haiku at high effort as well as at its default.

5. Group the failures by type. If Haiku fails on a pattern, such as multi-step planning, route that pattern up a tier and keep the rest cheap.

6. Rerun the test when a new model ships. Bito’s own run scored Haiku 4.5 at 46% and Haiku 5.5 at 76% on the same blended benchmark, so a judgment formed on the old model is already out of date.

Whether you run this in a spreadsheet or in dedicated tooling, the starting point matters. Tracing-first or evaluation-first tooling suits different teams. LangSmith fits if your problem is that you cannot see what happened in production, and Braintrust fits if you already know and need a quality gate before the next prompt change ships.

How to route between Haiku and Opus in Claude Code and agent stacks

Once a test tells you where to draw the line, the cheapest way to enforce it is to set a model per role instead of one model for everything.

In Claude Code, OpenRouter’s guide shows the pieces. The /model opusplan command plans with Opus and writes code with Sonnet, and the CLAUDE_CODE_SUBAGENT_MODEL variable sets the model for sub-agents that do not name their own. Pointing sub-agents at Haiku keeps self-contained exploration cheap while the main thread keeps a stronger model. Check your Claude Code version’s documentation before relying on either setting, since both were described for a specific release.

Anthropic describes the same pattern, with Haiku 5.5 as a subagent beside Opus 5.5 or Sonnet 5.5 on coding work. Cognition, which makes Devin, told Anthropic that Haiku as the sidekick with Opus 5.5 leading kept a top-tier FrontierCode score of 66.2 while cutting cost and latency. That is a vendor-selected testimonial, so treat it as an example of the pattern and not as proof.

One default is worth checking today. OpenRouter reports that Claude Code uses Opus 5.5 on most plans unless you change it, so if you have never touched the model setting, Opus is probably what you are running. If you have not yet chosen the agent that calls these models, our comparison of Cursor and Claude Code sets an AI-native editor against a terminal agent.

Outside coding, the same logic applies to any multi-step agent. The AI Agent Hub stack we recommend pairs LangGraph with LangSmith, Braintrust, Modal and Relevance AI so you can replay a bad run instead of arguing about it. That replay data is also what shows you which step needed the expensive model and which never did.

Conclusion

The 40 times price gap only holds for short prompts, and short prompts are also where Haiku is closest to Opus on quality. Once a session gets long, both advantages shrink. Past 100,000 tokens Haiku costs 8 times less than Opus, not 40, and in Bito’s long build sessions about 70% of Haiku’s requests got there. Quality slips over the same stretch: 3 points behind on one-shot questions, 8 to 10 behind on the implement-and-audit turns. Add it up and Haiku at high effort came out 4.4 times cheaper per session ($0.62 against $2.71). That is still a good saving, just far smaller than the headline suggests.

Sonnet deserves a second look for long coding work. In Bito’s table, going from Haiku to Sonnet at high effort gets you 3 more points for 57 cents a session. Going from Sonnet to Opus gets you another 3 for $1.52. Bito’s own run-to-run noise is about 3 points, so we wouldn’t treat that as a ranking, but it does show that the last few points cost the most.

These numbers will also date quickly. Haiku 4.5 scored 46% on Bito’s benchmark and Haiku 5.5 scored 76%, so whatever you read here will be stale by the next release. What you keep is the set of real requests and pass checks you built to test with. They let you run a cascade, they make retesting an afternoon’s work, and they give you something to track in production: the share of requests that escalate. A rising rate means your traffic or the model changed. A falling one probably means you’re paying for a tier you don’t need anymore.

Before you pick a default, work out what a wrong answer costs you and what would catch one. Those two answers settle most of the model choice, and the benchmarks above are only useful once you have them.