Claude Haiku 5.5 in Claude Code: Cut AI Coding Costs 20x

The short answer

Claude Haiku 5.5 is Anthropic's cheapest, fastest model, and the first Haiku that can survive an agent loop: 1M-token context, adaptive thinking with adjustable effort, and agent-benchmark scores several times higher than Haiku 4.5. Route narrow, verifiable work (subagent lookups, extraction, summaries, one-shot fixes with tests) to Haiku at $0.10/$0.50 per million tokens, keep Sonnet 5.5 as your default coder, and watch the 100K-token price cliff that re-prices the whole request 5x when you cross it.

The price, verified

Every number below is per million tokens, in USD, from Anthropic's own pricing for the Claude 5.5 family. I am leading with the vendor's table because every independent benchmark prices against it:

Model	Input / output (per 1M)	Cache read	Context
Haiku 4.5	$1 / $5	$0.10	200K
Haiku 5.5 (up to 100K prompt tokens)	$0.10 / $0.50	$0.01	1M
Haiku 5.5 (over 100K prompt tokens)	$0.50 / $2.50	$0.05	1M
Sonnet 5.5	$2 / $10	$0.10	1M
Opus 5.5	$4 / $20	$0.20	1M

Two things jump out. First, the gaps are clean multiples: Haiku is 20x under Sonnet and 40x under Opus on every token class. Second, Haiku 5.5 is the only model in the lineup with two price tiers, and the tier boundary is a cliff, not a slope.

Anthropic itself puts the average saving at about 75%, not the 90% the headline implies - the gap closes once long prompts, the new tokenizer, and output tokens enter the math. That is still a big number. It is just not the number on the poster.

What it can actually do now

The reason this Haiku matters is the capability jump, not the price cut. On Anthropic's own table, Haiku 5.5 beats Haiku 4.5 on every row where both have a score, and the deltas on agentic benchmarks are the story:

Benchmark	Haiku 4.5	Haiku 5.5
OSWorld 2.1 (computer use)	15.7%	72.4%
Terminal-Bench 4.0 (shell tasks)	0.0%	39.2%
GDPval-AA v2.1 (professional tasks, Elo)	735	1620
Humanity's Last Exam, no tools	10.2%	45.9%

The honest reading: this is a genuinely capable small model for structured agent work, and it is still not a frontier coder. The hardest line in the whole table is Terminal-Bench: 39.2% against Sonnet's 70.6%. Multi-step shell work, large refactors, debugging across a codebase - Anthropic itself points those at Sonnet 5.5 and Opus 5.5. Haiku 5.5 takes narrow, well-scoped edits. It does not take open-ended engineering.

The more practical evidence comes from Bito's benchmark, which ran real coding sessions the week of launch. On one-shot asks, Haiku 5.5 at high effort scored 87% at $0.014 per session against Opus 5.5 at 90% for $0.32 - three points of quality for roughly 1/23rd of the cost. On long build sessions the gap widens: Haiku at high effort hit 82% for $1.35 while Opus took 85% for $5.42. That is the shape of this model. The simpler and more checkable the job, the more of the price gap you keep.

The 100K-token cliff nobody reads

Here is the pricing detail that will actually change your bill. Haiku 5.5's $0.10/$0.50 rate applies to prompts of 100,000 tokens or fewer. Cross that line and the entire request reprices at $0.50/$2.50 - not just the tokens above the line, the whole thing, cache reads and cache writes included. Each request is priced on its own.

Work the example: an agent session with 120,000 input tokens does not cost the cheap rate for the first 100K and the expensive rate for the last 20K. It costs the expensive rate for all 120K. At $0.50 input per million, that is $0.06 instead of $0.012 - a 5x jump from a 20% overage. Agent loops that keep stuffing conversation history back into the prompt cross this line quietly, session after session.

Two defenses. First, context discipline: compact or summarize history before it approaches 100K, and keep the system prompt lean. Second, the new tokenizer counts roughly 30% more tokens for the same text than Haiku 4.5's did (Simon Willison measured about 1.25x on a long test prompt with his token counter), so a prompt that fit comfortably under the old model may not fit under the new one. Run your own prompts through a counter before planning a migration.

The Checkability Rule: a routing framework

Forget "big model good, small model bad." The routing question has a precise form, and I am going to name it because it is the decision rule I actually use:

The Checkability Rule: route a task to Haiku 5.5 when you can verify its output for less than the price gap between the models. Route to Sonnet or Opus when you cannot.

Verification is the whole game. A test suite, a type checker, a linter, a schema validator, a human glance at a diff - these are all cheap oracles. When the oracle is cheaper than the price gap, the small model's mistakes are free: you catch them and retry, and you are still ahead. When there is no oracle - ambiguous product decisions, novel architecture, judgment calls - the price gap buys you nothing and the failure costs you hours.

In practice this produces a stable split:

I write my acceptance checks as typed contracts - Zod schemas as the contract between the agent and me - because a check you can run in CI is a check you can route against. The sharper your oracles, the more work clears the bar for Haiku.

One more routing lever: effort. Haiku 5.5 ships with adaptive thinking and five effort levels, defaulting to medium. Use low for routing and simple labels, medium for most extraction, and high for multi-step checks where a wrong call is expensive. Bito's numbers show effort is real money: Haiku at high effort beat Sonnet's default on every task set they measured, at roughly half the session cost.

Setup in Claude Code

1. Check your Claude Code version

   Haiku 5.5 needs Claude Code v2.1.293 or later for full support. Run claude --version and update if you are behind. Older versions may not list the model or may mishandle its thinking configuration.

2. Switch models mid-session

   Inside any session, run /model claude-haiku-5-5 to switch the current session to Haiku. The model ID is claude-haiku-5-5 everywhere - the API, Amazon Bedrock (anthropic.claude-haiku-5-5), Google Cloud, and Microsoft Foundry all use the same string.

3. Start sessions on Haiku when the job fits

   For sessions you know are narrow - triage, exploration, bulk labeling - launch directly with claude --model claude-haiku-5-5. Starting on Haiku beats switching later, because the model never pays the orchestrator's context prices for the opening turns.

4. Set the orchestrator/subagent pattern

   Keep your main session on Sonnet (or Opus for hard jobs) and let it spawn Haiku subagents for the lookup and verification work. Measured spawn costs make the case: a fresh subagent prefix costs roughly $0.005-0.011 on Haiku 5.5 against about $0.17 on Sonnet 5.5. That is the cheapest architectural change in this whole post.

5. Tune effort per task

   Start at the medium default, drop to low for routing and labeling where speed matters most, and raise to high for the multi-step checks where a wrong call is expensive. Effort is the second pricing lever after model choice, and it costs nothing to experiment with.

Where Haiku still loses: the honest list

A cheap model you trust blindly is worse than an expensive one, so here is everything that tempers the headline:

• The coding gap is real. 39.2% vs 70.6% on Terminal-Bench is not a matter of degree. Open-ended engineering belongs to Sonnet and Opus, and Anthropic says so on its own launch page.
• The 100K cliff. Covered above, but it bears repeating: one long context window wipes out the per-token savings for the whole request.
• The tokenizer tax. About 30% more tokens for the same text than Haiku 4.5, measured independently. Your old cost math needs re-running.
• Not a drop-in replacement. Manual budget_tokens thinking, non-default sampling parameters, and assistant prefill now return errors. Computer use needs a new toolset version. Budget migration time for anything built on Haiku 4.5's quirks.
• Effort at max writes more. Independent analysis notes Haiku 5.5 at max effort emits roughly 3x the output tokens per task as its closest competitor, which eats into the per-token price advantage on output-heavy work.
• Vendor benchmarks are marketing. Anthropic's table compares against competitors' reported figures; the methodology details live in a system card most people will not read. Independent coverage is still thin - this model is six days old. Expect the numbers to move.

What this does to your bill

Take Bito's one-shot numbers as a worked example, since they are the closest thing to a real workload. Suppose your week holds 200 one-shot coding asks:

Setup	Score	Cost per ask	Weekly cost
Opus 5.5 default	90%	$0.32	$64.00
Haiku 5.5 high effort	87%	$0.014	$2.80

Same week, same asks: $64 becomes $2.80 for three points of benchmark score, provided every ask is checkable. That "provided" is doing all the work, which is why the Checkability Rule is the post and the table is just illustration. Anthropic's own guidance lands in the same place: they quote roughly 75% average savings in practice, not 90%.

The compounding win is the orchestrator pattern. A Sonnet session that spawns ten Haiku subagents a day for lookups, each costing about a cent instead of $0.17, saves roughly $1.60 a day on spawns alone - before any of the per-token math. Small numbers, every day, automatic.

Tools for the routing workflow

Tool	What it does	Why it matters here
Claude Code	Anthropic's agentic coding CLI	Where you run /model and the orchestrator pattern
Anthropic API	Usage-based API access	Direct per-token billing when subscriptions don't fit
Artificial Analysis	Independent model benchmarks	Tracks whether Haiku's scores hold as tests mature

FAQ

What is Claude Haiku 5.5 and when was it released?

Claude Haiku 5.5 is Anthropic's small, fast, cheap model in the Claude 5.5 family, released October 7, 2026. It brings a 1M-token context window, adaptive thinking with effort levels, and benchmark scores that beat Haiku 4.5 by wide margins on agentic tasks.

How much does Haiku 5.5 cost in Claude Code?

Through the API it costs $0.10 per million input tokens and $0.50 per million output tokens for prompts up to 100,000 tokens, jumping to $0.50/$2.50 above that line. In Claude Code subscription plans, model choice does not change the subscription price, but routing work to Haiku keeps you under usage caps and stretches rate limits further.

How do I use Haiku 5.5 in Claude Code?

Inside a session, run /model claude-haiku-5-5 to switch models. To start a session on Haiku directly, launch with claude --model claude-haiku-5-5. You will need Claude Code v2.1.293 or later for full support. The model ID is claude-haiku-5-5 everywhere: API, Bedrock, and Vertex.

Is Haiku 5.5 good enough for coding agents?

For narrow, checkable coding jobs, yes - independent benchmarks put Haiku 5.5 at high effort within a few points of Opus 5.5 on one-shot asks at about 1/23rd the cost. For open-ended multi-step engineering it still lags: Anthropic's own figures show 39.2% vs 70.6% on Terminal-Bench 4.0, which is why Sonnet stays the default for everyday coding.

What is the 100K-token price cliff?

Haiku 5.5's headline price only applies to prompts of 100,000 tokens or fewer. Cross that line and the whole request - input, cache reads, everything - reprices at $0.50/$2.50 per million tokens, five times higher. Long agent histories and repo-wide context cross the line easily, so keep prompts compact or pay the second tier.

Should I switch from Sonnet 5.5 to Haiku 5.5?

Not wholesale. Use Sonnet as your orchestrator and default coder, and route narrow, verifiable work - classification, extraction, summaries, subagent lookups - to Haiku. That hybrid setup is where the savings live. Switch the default only for workloads where Haiku's scores already clear your acceptance bar.

Cut your agent bill on purpose

I help teams and founders set up exactly this: agent workflows where the model routing, the acceptance checks, and the cost monitoring are designed together instead of discovered in the invoice. If your Claude Code or API bill is growing faster than your output, that is a solvable problem, and it is usually a week of work, not a rewrite. Details are on my about page.

“

Route by checkability: if you can verify it cheaply, Haiku does it. If you cannot, that is what Sonnet is for.

”