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

Anthropic released Claude Haiku 5.5 on October 7, 2026, and the headline
number is hard to ignore: $0.10 per million input tokens, a tenth of Sonnet
5.5 and a fortieth of Opus 5.5. The real question for anyone running Claude
Code daily is not the price, though. It is which jobs a $0.10 model can take
away from a $2 model without your pull requests noticing. I dug through the
launch benchmarks, the independent coding tests, and the pricing fine print
so you can route your work before your next invoice surprises you.

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:

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.

Benchmark figures in this post come from Anthropic's launch materials
(vendor-reported, not independently reproduced) and from Bito's October
2026 coding benchmark, which ran fresh sessions on its own task battery.
Pricing was cross-checked against Anthropic's pricing page as reported on
October 11, 2026. Treat vendor benchmarks as directional, not gospel.

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:

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:

- Subagent lookups: search, read, summarize for an orchestrator - Classification, routing, extraction, tagging - Summaries, changelogs, context compaction - One-shot fixes with an existing test suite - Boilerplate generation you will diff anyway - Anything with a cheap oracle: tests, types, schemas - Open-ended feature builds and architecture calls - Multi-step shell and refactor work (the 39.2 vs 70.6 gap) - Debugging across an unfamiliar codebase - Anything where a wrong answer is expensive - Long-horizon autonomous agent runs - Tasks with no acceptance test you trust

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

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.


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.


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.


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.


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:

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

{/* MONETIZATION NOTE (not rendered): the links below are official product
pages. If Anthropic or a benchmark provider opens an affiliate program,
swap in affiliate links here and update the disclosure. Never claim
affiliate status before it exists. */}

The links above are plain official links, not affiliate links. If that
changes I will say so on the page, same policy as every post here.

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.