Haiku 5.5 In-Depth Review: Anthropic Finally Has a Small Model Worth Using

Anthropic's Small Model Problem Is Finally Solved

For a long time, Anthropic has been a powerhouse in the large model space — from the early days of Sonnet 3.5 establishing the engineering paradigm for tool calls, to the Opus series, and now the latest Opus 5.5 and Sonnet 5.5. But there has always been one obvious weak spot in its product line: small models.

The previous generation Haiku 4.5 had some appeal when it first launched, but quickly came to feel both overpriced and underperforming. One YouTube creator admitted he had gone so far as to rework all his toolchains, agent configurations, and Claude MD files to explicitly tell every agent to "avoid Haiku 4.5 at all costs." His reasoning was blunt: the model was "practically useless," and to save money, he'd rather train his Claude to call Sol (OpenAI's model) than trust Haiku 4.5.

That painful experience led him to publicly complain a few weeks ago that Anthropic didn't have a single small model worth using. Haiku 5.5's release is a direct answer to that "biggest missing piece."

Haiku 5.5's Pricing Is the Real Killer Feature

According to Anthropic's official positioning, Haiku 5.5 is "the cheapest, fastest, and most capable small model we've ever released," designed for high-frequency, cost-sensitive tasks — summarization, compression, database queries, classification requests, and so on. On average, it costs roughly 75% less to run than Haiku 4.5.

The price breakdown is interesting:

• Cache reads: $0.01 per million tokens — one-tenth the cost of Haiku 4.5
• Cache writes: $0.125 per million tokens
• Standard input: $0.10 per million tokens
• Output: $0.50 per million tokens (vs. $5.00 per million for the previous generation — roughly 20× cheaper)

But there's a critical threshold: the prices above only apply to contexts under 100K tokens. Once you exceed 100K tokens, the price doesn't double — it jumps 5× — output goes from $0.50 to $2.50 per million, and input from $0.10 to $0.50 per million.

The creator's read on this is spot-on: Anthropic is deliberately steering user behavior. The ultra-cheap pricing below 100K makes it hard to justify calling any other API (like GPT's small models), since you can "just toss it to Haiku." The steep premium on long contexts, meanwhile, discourages users from burning through tokens indiscriminately in Claude Code, protecting Anthropic's margins.

Anthropic employee Lydia has publicly suggested: if you want to control your bill, manually set Haiku 5.5's auto-compact window to 100K — that keeps you in the cheap tier at all times, and since the setting is saved per model, it only affects Haiku (and its sub-agents).

Cache Reads are a frequently overlooked but critically important cost factor in LLM API pricing. When the same context (such as a system prompt, codebase prefix, or long document) is repeatedly sent to the model, the provider can cache it server-side, so subsequent requests only pay the "cache read" rate rather than the full "standard input" rate for reprocessing all those tokens. In agentic workflows, the main agent's system prompt and tool definitions often run tens of thousands of tokens, and every subtask carries that same context — meaning cache reads can far outnumber standard inputs and easily account for 30–50% of the total bill. This is precisely why the cache read price cut on Sonnet 5.5 has the creator so excited: for high-frequency workloads, this single pricing change can have a larger real-world impact on spending than changes to standard input/output prices.

A Major Change Everyone Missed: Sonnet Gets Cheaper

Midway through his video, the creator had a moment of genuine surprise — he realized this release quietly buried a big piece of news: Sonnet 5.5's cache read price was cut in half, dropping from $0.20 to $0.10 per million tokens.

This was exactly the pain point he had railed against in his earlier Sonnet 5.5 review. Sonnet's cache read pricing had been the same as Opus — and since cache reads typically make up 30–50% of the total bill, the real-world price difference between Sonnet and Opus in agentic workflows was surprisingly small. That made Sonnet far less competitive against OpenAI's GPT-6.1 Sol.

With the price cut, Sonnet's cache read rate is now on par with GPT-6.1 Sol, and the whole product line's logic suddenly makes sense. He even admitted this might be his favorite part of the entire release.

Performance: Doubled Gains and Real Limitations

In the creator's custom benchmark suite, Haiku 5.5 scored more than double Haiku 4.5 on the vast majority of tests. A few notable numbers:

• Terminal Bench: Up from 0% on Haiku 4.5 to nearly 40%
• Coding ability: More than twice as high as GPT-6 Luna (16.4%)
• Computer Use: Surprisingly strong — about 40% higher than 6 Luna, a notable result in an area where OpenAI has long led

On speed, Haiku 5.5 can hit 100–200 TPS across different providers; the creator's own Claude Code testing consistently showed around 180 TPS.

There's a dissenting voice, though. Developer Prime reported that when he turned off reasoning and tried to use Haiku 5.5 as a drop-in replacement for Luna on automation tasks, the pass rate was worse, failure rate was higher, and it was slower. The creator wasn't surprised — OpenAI's models are specifically trained to excel in "no-reasoning" mode, while Anthropic's models are the opposite. Opus and Sonnet 5.5 have removed the no-reasoning option entirely; Haiku retains it, but clearly doesn't perform well in that mode. The takeaway: Haiku with reasoning on is excellent; Haiku with reasoning off, you're better off with GPT's Jev or Luna.

The Reasoning mode mentioned throughout refers to letting the model output an internal chain-of-thought before giving a final answer, which improves accuracy on complex tasks. Anthropic's Opus and Sonnet 5.5 have made reasoning the default and non-disableable; Haiku 5.5 retains a toggle but is clearly optimized for the reasoning-on scenario. OpenAI's small models (such as Luna and Jev), by contrast, are deliberately trained to work efficiently in "direct response" mode without outputting a reasoning chain — suitable for latency-critical, cost-constrained classification and routing tasks. This philosophical difference in training means both companies' models at similar price points each excel at different workloads, directly informing which is the better substitution choice. TPS (Tokens Per Second) is a standard metric for model inference speed, representing the number of tokens generated per second. Haiku 5.5 can reach 180 TPS on some providers, meaning latency remains manageable even with reasoning enabled.

Haiku's Real Value: As a Sub-Agent, Not a Primary Model

The creator repeatedly hammers one core point: Haiku 5.5's best use case isn't manually selecting it in a UI to write code — it's having your agents and applications call it.

He pushes back sharply on the idea of using a cheap model to write code: coding itself isn't what makes LLMs expensive. Once context is loaded into the model and cached, generating the correct code file is actually quite cheap. What burns money is everything else — gathering context, verifying correctness, writing extensive tests, regenerating an eighth time because the first seven were wrong.

"Those 500 output tokens, once input is cached, aren't expensive at all. I don't understand why everyone's looking for a dumber model to do the actual code-writing part."

Anthropic's official demo illustrates Haiku's value as a sub-agent perfectly. They had Opus 5.5 solo complete an "egg drop" simulation task, then had Opus 5.5 orchestrate 10 Haiku 5.5 sub-agents on the same task:

• Opus solo: 3.5 minutes, 25 attempts, cost $0.47
• Opus + 10 Haiku: Under 1 minute, 86 attempts, cost only $0.14

For tasks where "most answers are wrong and you need lots of trial and error" — like finding a specific file in a massive codebase — Haiku's speed and low cost let you run many parallel attempts without a shocking bill. The creator's conclusion: When more attempts beats smarter attempts, Haiku 5.5 dominates.

Multi-agent architecture refers to a system design where a "main agent" (orchestrator) handles planning and decision-making, and dynamically calls one or more "sub-agents" for specific subtasks. The main agent typically uses a more capable, more expensive model (like Opus), while sub-agents handle concurrent, repetitive, or low-complexity work (such as file search, document reading, API calls, or running tests) — and can therefore use cheaper, faster small models. This division of labor dramatically reduces both total task time and cost: in the official demo, Opus completing a task solo cost $0.47, while Opus orchestrating 10 Haiku sub-agents cost only $0.14 and finished more than 3× faster. This is exactly where Haiku 5.5's value lies: it doesn't need to be the "smartest" at every step — it just needs to be fast and cheap enough to let the main agent cast a wide net and explore multiple paths in parallel.

Frontend Design and Surprising Demo Moments

A few community demos genuinely impressed the creator. Community member Arsh generated video content using Haiku that looked "embarrassingly good" for the price — completed in 20 minutes at just $0.60 in API costs. The creator believes Anthropic's models have an innate "sense of taste" for design, likely due to high-quality design material in the training data.

With the Design Skill enabled, Haiku's frontend design ability easily outpaced Grok 4.7. But turning off Design Skill immediately dropped it back to generic "classic LLM design" mediocrity — suggesting this skill provides a massive boost to Claude models specifically.

In the creator's signature "fish slop" mini-game test, however, Haiku 5.5 showed its limits: no mouse movement, no sound, buggy corner logic, and wrong timing on the second wave of alien attacks. His assessment was precise: "Its floor isn't as low as Astra's, but its ceiling is only one-tenth of Astra's." The build cost about $1.00.

Should You Use Haiku? Should You Skip Sonnet?

Looking at Artificial Analysis's cost-vs-intelligence chart with full data included, Haiku 5.5 is nearly neck-and-neck with GPT-6 Luna. A few of the creator's judgments are worth noting:

• If you're purely optimizing for "intelligence per dollar," the best combination is GPT-6 Luna, GPT-6.1 Sol, and Opus 5.5, plus the underrated open-source model Mimo V26 Pro
• But if you want to stay within a single provider ecosystem (like using only Anthropic's API or Claude Code subscription), the Opus + Haiku combination is very strong — you can almost entirely skip Sonnet
• Sonnet's real value isn't "filling the gap between Haiku and Opus" — it's a "different family's perspective." Like asking a friend who works at a different company. The creator specifically recommends using GPT-6.1 Sol for code review: have Opus write the code, Sol review it, and PR merge speed improves dramatically

You might not realize it, but the price gap between Opus 5 low and Haiku 5.5 max isn't actually that wide ($0.20 vs. $0.55). And the creator learned this the hard way: when Haiku gets stuck in a loop, unable to complete a task while burning through tokens, it ends up costing more than just using Opus directly. When he used Haiku to audit 1,500 PRs, he hit GitHub rate limits and Haiku got itself stuck — whereas switching to Opus, the model was "smart enough" to work around the rate limits and sensibly batch its sub-agent calls.

Hidden Perks for Subscribers

This release also includes a developer-friendly change: users subscribed to the Claude 20X plan ($200/month) now receive an additional $200 in API credits per month; 5X users get $100. This means you can use those credits to vibe-code an app with built-in Haiku or Sonnet and share it with friends.

The creator mentioned he had spoken with Anthropic multiple times about this type of integration design, and praised them for "actually listening" — something that could have been a bad decision ended up becoming a genuinely cool feature. Anthropic also updated its Python and TypeScript SDKs to add support for computer use and browser use.

Conclusion

Circling back to the creator's original complaint — "Anthropic doesn't have a single small model worth using" — his wording has now shifted to: "Anthropic now has a small model that is sometimes worth using."

That's a measured but genuine endorsement. Haiku 5.5 won't be the model you manually reach for to write code or build frontend. But as a tool your agents can call — to gather data, read documents, do classification, run parallel trial-and-error — it's an extremely cost-effective complement. Combined with the Sonnet price cut, the entire Anthropic 5.5 product line's pricing logic has finally been sorted out. The creator signed off with a parting shot: if he were OpenAI right now, he'd be "very scared," and hoping the next generation of Astra's training brings a real breakthrough.