Claude Haiku 5.5: Anthropic’s Cheapest Small Model Ships With Breaking API Changes

Anthropic released Claude Haiku 5.5 on 7 October 2026, and the headline number is easy to quote: $0.10 per million input tokens and $0.50 per million output tokens, in USD, down from Haiku 4.5’s $1.00 and $5.00. That is a 90% cut at list price. For teams running classification jobs or summarization pipelines at volume, it is a number worth checking carefully before it reaches a budget owner.

The engineering story is less tidy, and it is the actual news. Haiku 5.5 is not a drop-in replacement for Haiku 4.5. A new tokenizer inflates token counts by roughly 30%, three parameter classes now return errors instead of being silently ignored, and production code has to handle a refusal path that most integrations never wrote. The price cut is real. The migration bill is also real, and it arrives in the same release.

What Anthropic shipped

Haiku 5.5 carries the API model ID claude-haiku-5-5 and is available on the Claude Platform, Amazon Web Services, Google Cloud and Microsoft Azure. Anthropic calls it its cheapest, fastest and most capable small model, and positions it for high-volume, cost-sensitive work: summaries, context compaction, database queries and classification. It also slots in as a sub-agent beneath Opus 5.5 and Sonnet 5.5, a framing that matters more than the marketing suggests (more on that below).

Safety evaluations are documented in the system card, and the deprecation page lists the earliest retirement date as 7 October 2027, which gives migration projects a comfortable but not indefinite runway.

The breaking changes: delete, do not tune

These are the changes that will break a working integration on day one. Anthropic’s what’s-new page lists three hard breaks from Haiku 4.5, and all three fail loudly:

Old behavior (Haiku 4.5)	New behavior (Haiku 5.5)	Migration action
temperature, top_p or top_k accepted	Returns an error	Delete the parameters from every request
Assistant prefill accepted	Returns an error	Remove prefills; move the instruction into the system prompt
Manual thinking with budget_tokens accepted	Returns an error	Remove the budget; adaptive thinking is on by default
First content block assumed to be text	Response may begin with a thinking block	Make parsers scan blocks by type, not position
max_tokens budgeted for visible output only	Thinking tokens count toward max_tokens	Raise budgets and account for thinking overhead
Refusals surfaced as ordinary completions	stop_reason: "refusal" returned	Handle refusal as a normal branch, not an exception

For most codebases, migration means deleting parameters rather than adjusting them. That is a relief in one sense, since there is no silent behavior drift to debug, and an annoyance in another, since every wrapper, retry helper and prompt template that hardcoded a temperature of 0.2 now throws. Teams with a shared client library will want to grep for those three parameter names across the whole repository before the first deploy, not after.

Behavior changes that reach production code

Three behavioral shifts matter more than the parameter errors because they change what a response looks like.

First, adaptive thinking is on by default, so a response can begin with a thinking block. Any parser that assumes the first content block is text will break. Second, thinking tokens count toward max_tokens, which means a budget tuned for Haiku 4.5 output may now be consumed before the visible answer arrives. Third, safety classifiers can decline a request, so code must handle stop_reason: "refusal" as a normal branch rather than an exception.

That refusal path is worth treating as a first-class feature. A confident wrong answer and a silent refusal are different failure modes, and the second is easier to instrument. Anthropic’s broader work on agent reliability makes the same point: a refusal you can log and route is worth more than a plausible answer you cannot audit. Anthropic also states that Haiku 5.5’s cybersecurity safeguards are stricter than Haiku 4.5’s and block penetration testing. Security tooling vendors and internal red teams running this model for anything adjacent to offensive testing should expect refusals and should not treat them as bugs.

The 90% headline and the 75% reality

The list-price comparison is straightforward. Haiku 4.5 cost $1.00 per million input tokens and $5.00 per million output tokens. Haiku 5.5 costs $0.10 and $0.50 for prompts up to 100,000 tokens, where the threshold applies to the whole prompt, input and output combined. That is a 90% reduction on paper.

On paper is where it stays, partly. Haiku 5.5 uses a newer tokenizer, and the same text now counts as roughly 30% more tokens. Anthropic’s own estimate puts the average saving at around 75% once tokenizer inflation and the 10% of requests that exceed the 100K-token boundary are accounted for. That 10% figure matters because requests above the boundary fall outside the discounted tier and are billed at higher rates, which drags the blended average down. A 75% cut is still an excellent number, but it is not the number on the pricing page, and anyone quoting savings to a budget owner should run their own corpus through both tokenizers before signing off.

This is the sort of measurement gap that shows up repeatedly in production LLM work. The bill is set by what you measure, not what you assume.

New capabilities: adaptive thinking and a 1M-token window

Two additions stand out. Haiku 5.5 enables adaptive thinking by default, and it ships with a 1M-token context window. The context increase is meaningful for compaction workloads, where a cheap model summarizes older turns so a more expensive one can keep working. The adaptive thinking default is the change with sharper operational consequences, and it gets its own section above.

Anthropic’s sub-agent framing is the more interesting architectural claim. A small model that handles summaries, compaction, database queries and classification is not competing with Sonnet 5.5 or Opus 5.5. It is absorbing the high-frequency, low-difficulty calls that would otherwise burn frontier-model tokens.

Benchmarks, read carefully

Anthropic’s launch page includes benchmark results, and Sonnet 5.5 leads on all four rows, including 70.6% on Terminal-Bench 4.0. Haiku 5.5’s numbers should be read as a cost-per-quality trade rather than a frontier claim. That is not a criticism. A model at one-tenth the list price that lands within striking distance on classification and summarization is doing exactly what it was built for. It just should not be sold internally as a general-purpose replacement for a larger model without an evaluation set to back the claim.

Structured output and the Bedrock gap

JSON outputs constrain replies to a supplied schema and are guaranteed valid and schema-matching, which removes a whole class of defensive parsing. The catch is portability. JSON outputs are not available on Amazon Bedrock for Haiku 5.5, so deployments there must describe the format in the prompt and validate the result manually.

Forced tool calls add a second wrinkle: Haiku 5.5 accepts one, but Opus 5.5 rejects it with a 400 error. Across the three-model family, JSON outputs are the portable choice. Teams building a router that sends easy requests to Haiku 5.5 and hard ones to Opus 5.5 should standardize on JSON outputs now rather than discovering the split at integration time.

Getting started

You need Python 3.10 or newer, an API key from the Claude Console, and a recent Anthropic SDK, since the sample code uses the newer output_config parameter. The SDK reads ANTHROPIC_API_KEY automatically from the environment. Set it with export ANTHROPIC_API_KEY=... on macOS and Linux, or $env:ANTHROPIC_API_KEY=... on Windows PowerShell.

A sensible first task is not a benchmark. It is a tokenizer comparison on your own traffic, followed by a refusal-path test and a check that every response parser tolerates a leading thinking block.

What the ecosystem signal tells you about model pairing

Cognition reports using Haiku 5.5 as the sidekick in Devin Fusion, with Opus 5.5 as the lead. That is the clearest statement yet of a pattern worth copying: an expensive model for planning and hard reasoning, a cheap one for the routine calls around it. The economics only work if the cheap model’s token counts are measured honestly, which brings the discussion back to the tokenizer.

The teams that benefit most from Haiku 5.5 will be the ones that treat the release as an upgrade with a checklist, not a price cut with a changelog. Delete the sampling parameters, budget for 30% token inflation, handle refusals, standardize on JSON outputs, and let the sub-agent do the volume work. Anthropic has made the cheap model genuinely cheap. The rest is migration hygiene, and the engineers who own that work are increasingly visible in the market, a shift traced in Forward Deployed Engineer: The AI Job Title That Grew 5,230% in 15 Months. Haiku 5.5 is a good model. It is also a reminder that the hard part of shipping LLM features has moved from calling the API to keeping the integration honest as the API underneath it changes.