Haiku 4.5 and the collapsing cost of good-enough

Anthropic released Claude Haiku 4.5, a small fast model with coding performance in the neighborhood of the previous generation's mid-tier, at a fraction of the price and several times the speed.

The headline is not the benchmark. It is what the price-performance point makes economically viable.

the pattern across the industry#

Every major provider now ships roughly the same ladder:

The interesting fact is that the small tier's capability is rising faster than the frontier's. Today's small model is roughly where the frontier was eighteen months ago, and it costs about two percent as much.

For anyone doing volume work, that is the number that matters. Not "how smart is the best model" but "how cheap is the model that is good enough for this task."

what it enables#

Agent fleets. If a small model can handle subtasks reliably, an orchestrator using a frontier model can dispatch twenty parallel workers using a small one. Total cost stays reasonable; throughput multiplies. This architecture was uneconomic a year ago and is now obvious.

Real-time interaction. Latency matters more than capability for anything a human is waiting on. A fast model that is 90% as good and 5× faster wins on almost any interactive surface.

Processing everything instead of sampling. Classification, extraction, routing, and enrichment over an entire corpus rather than a sample. At small-model prices, "run it on all of it" becomes the default rather than a budget question.

Pipeline stages that were not worth it. Adding a model call to normalize an input, or to double-check an output, or to summarize an intermediate result — each of these was a cost decision at frontier prices and is now free enough to just do.

the routing architecture#

This is the shape that production systems are converging on:

request → cheap classifier → simple?  → small model → done
                           → complex? → frontier model → done
                           → ambiguous? → small model → verifier → escalate if low confidence

Most requests take the cheap path. The expensive model handles the tail. Overall cost is dominated by the common case, which is cheap.

Two implementation notes that matter:

The classifier can be the small model itself, or often a much simpler heuristic. Do not over-engineer the router — a regex and an input-length check gets you surprisingly far.

Instrument the escalation rate. If it is climbing, either your traffic mix changed or your small-model prompts have degraded. That metric is the health check for the whole architecture.

the caution#

Small models fail differently than large ones. They do not fail less on the tasks they handle — they fail more confidently on the ones just outside their envelope.

A large model asked something beyond its ability will often hedge. A small model will answer, fluently and wrongly.

So: verify the output of small models where correctness matters. A cheap verifier — schema validation, a test run, a range check, a second model asked to critique — costs almost nothing and catches the category of failure that will otherwise reach production silently.

The cost savings are real. They come with a verification obligation, and the teams that skip it will find out in a quarter.