Claude Haiku 5.5: The Cheap Worker That Becomes Your Default Sub-Agent
AI News11 min readOctober 19, 2026

Claude Haiku 5.5: The Cheap Worker That Becomes Your Default Sub-Agent

Haiku 5.5 costs just $0.10 input / $0.50 output per million tokens (up to 100K), and finally gets an "effort" setting. In a 200-file scan test, it beat Opus 5.5 while cutting the bill roughly 10x.

Yuval Avidani

Yuval Avidani

Author

Meet Claude Haiku 5.5, Anthropic's small and fast model that dropped on October 7th. In my eyes it's not just "another cheap model" but the hard-working employee every agentic system has been waiting for. It costs 10 cents per million input tokens and 50 cents per million output tokens, it's the first Haiku ever to get an effort knob, and on Hacker News the launch post climbed to 1,049 points and 489 comments. Let's break down why this matters specifically if you're building agents, and how to wire it into Claude Code and the API today.

We'll carry one example through the whole piece: say we have a repo with 200 Python files, and we need to find, in every single one, calls to an old internal library called legacy_client and suggest a fix. Boring, long, and completely parallelizable. Exactly the kind of thing agents are supposed to do for us.

The situation: all our agents are running on the most expensive model

Anyone working with Claude Code or the API today knows the pattern: you open a session with the strong model, and it does everything. Plans, reads files, searches, summarizes, writes code. It works great, but it's like sending the company's chief architect to count bolts in the warehouse. He'll count them correctly, except every bolt now costs you an architect's hourly rate.

In our example, most of the work is reading: open a file, scan it, log findings. Only the last part, merging 200 findings into a risk-sorted migration plan, actually needs the judgment of a big model. And yet most of us default to running the whole chain on the same model anyway.

The fix: a conductor and an orchestra

The pattern that solves this is called orchestrator/worker — in plain terms, a conductor and musicians. Orchestrator/worker is a work pattern where a big model plans and splits up tasks, and a fleet of small, cheap models executes them in parallel — relevant for anyone running agentic work at scale. The conductor doesn't play an instrument. He decides who plays what, listens to the result, and stitches it all into one piece.

A subagent is exactly that musician: a separate model instance, with its own context window (how much text the model "sees" at once), a limited toolset, and one clear instruction. It gets a task, works on it quietly, and hands the conductor back a short summary. Turns out this saves twice over: once in money, because the musician runs on a cheap model, and once in context, because all the noisy file-reading stays with the musician instead of cluttering the conductor's head.

In our example it looks like this: the conductor, Opus 5.5, takes the task, splits the 200 files into 50 batches of four files each, and sends each batch to Haiku 5.5. Each Haiku returns a short list of problem lines and a suggested fix, and Opus merges it all into one plan.

The obstacle: why this hasn't worked well until now

The idea isn't new. The problem was that the workers were too weak. The previous model, Haiku 4.5, was relatively cheap, but on real agentic tasks it fell apart. According to the table Anthropic published, Haiku 4.5 scored 0% on Terminal-Bench 4.0 (a benchmark for independent terminal work) and 15.7% on OSWorld 2.1 (using a computer like a human). When Haiku 5.5 gets 39.2% and 72.4% on those same tests, that's not a small upgrade — that's a different category of worker.

To be fair, let's put the other side of the table on display too: Sonnet 5.5, which launched a few days earlier, scores 70.6% on Terminal-Bench and 83.9% on OSWorld. In other words, Haiku 5.5 doesn't replace the big models on hard coding tasks, and it doesn't pretend to. Anthropic themselves write that it "pairs well with Opus 5.5 and Sonnet 5.5 as a subagent in coding work." Bottom line: a great musician, not a conductor.

Two more things worth knowing before you jump in:

  • Same text, more tokens. The model moved to a new-generation tokenizer (the tool that chops text into units the model counts and bills you for), and according to the official docs the same text comes out at roughly 30% more tokens than with Haiku 4.5. Against Opus 5.5 and Sonnet 5 the comparison is fair, since they're all on the same tokenizer.
  • Thinking is on by default. The response can start with a thinking block, and thinking counts toward max_tokens. Old code that reads the first block as "the answer," or that sets a very small max_tokens, might get back an empty response.

The cool part: effort, and the 100K trap

According to Anthropic, this is "the first Haiku model with a tunable effort setting." Effort is a parameter that controls how much work the model puts into its answer — including how much it thinks and how many tool calls it makes. Think of it like an AC dial: Low, Medium, High, plus two more modes, xhigh and max. The default in Haiku 5.5 is medium.

The docs' recommendation is clear: medium for most work, including agentic coding. low for short, simple, high-volume tasks. high for knowledge work, long agentic tasks, and strict instruction-following. But there's a warning worth reading: at low, on long agentic prompts, the model is more prone to skip searching, stop early, or skip verification. In our example, a Haiku that reads one file and returns a list is a perfect candidate for low. A Haiku that roams around the repo with tools and searches on its own is better off at medium.

And now the trap. Haiku 5.5's pricing is tiered by prompt length: up to 100,000 tokens per request, it's $0.10 input and $0.50 output per million. Above 100,000, the entire request costs five times as much: $0.50 and $2.50. And it's not just the input: the output of that same request is priced at the higher rate too, and even tokens read from cache count toward the prompt length. The pricing page is explicit that every single request is priced on its own — so in an agentic loop, where history gets resent every round, your agent can cross that line mid-task without you noticing.

The chart shows official output prices per million tokens. Below 100K, Haiku 5.5 costs $0.50 — 20x less than Sonnet 5 ($10) and 40x less than Opus 5.5 ($20). Above 100K it jumps to $2.50 — still cheaper than Haiku 4.5 ($5), but a 5x gap within the same model.

Let's do the math: what our example actually costs

Let's assume, purely for the sake of calculation, that each of the 50 tasks consumes a total of 40,000 input tokens and 4,000 output tokens (including thinking), and every single request stays under 100K. On top of that, the conductor on Opus 5.5 reads all the summaries and writes the plan: say 150,000 input tokens and 20,000 output. These are illustrative assumptions, not measurements — your real numbers will vary by codebase, effort level, and number of rounds. The math itself is based on official pricing:

  • Everything on Opus 5.5: the workers consume 2 million input tokens times $4, plus 200,000 output tokens times $20 — that's $12, plus $1 for the conductor. Total: about $13.
  • Workers on Sonnet 5, conductor on Opus 5.5: $4 plus $2 for the workers, plus $1. Total: about $7.
  • Workers on Haiku 5.5, conductor on Opus 5.5: $0.20 plus $0.10 for the workers, plus $1. Total: about $1.30.

For the exact same job, swapping the workers to Haiku 5.5 cuts the bill by roughly 10x, and most of what's left is the conductor. Now let's look at the 100K trap in numbers: if we gave each worker one giant batch of 120,000 tokens per request, 50 such requests would cost about $3.50. If we split each batch into two requests of 60,000 instead, that same amount of input costs about $0.80. The lesson: small batches, not one worker swallowing everything whole.

You can play with your own project's numbers in the calculator:

How to wire this in today: Claude Code and the API

In Claude Code, a subagent is a Markdown file in the .claude/agents/ folder in your project (or ~/.claude/agents/ for all projects), with a YAML header. According to the official docs, the model field accepts an alias like haiku or a full identifier, and the effort field accepts the five levels. Note one small but important detail: the haiku alias points to Haiku 5.5 only when you're connecting through Anthropic's own API. Through Bedrock, Google Cloud, Foundry, or Claude Platform on AWS, it still points to Haiku 4.5. So here, we'll write out the full identifier:

Once the file is in the folder, the conductor in your main session can delegate work to it based on the description you wrote, or you can explicitly ask it to use it. And if you want all your subagents to default to Haiku, the docs mention the environment variable CLAUDE_CODE_SUBAGENT_MODEL. A setting inside the agent's own file still takes priority over it.

On the API it's the same pattern, except we write the loop ourselves. The code below scans every file with Haiku 5.5 at low effort, in parallel, checks with count_tokens that the request doesn't cross the 100K line, and then passes all the reports to Opus 5.5 to merge into one plan:

Three things in the code worth paying attention to: output_config={"effort": "low"} is where you set effort — it's not a separate parameter. The response is collected by block type, not by position, since it might start with a thinking block. And there's no temperature in the code, because according to the migration guide, sampling parameters like temperature can return an error on Haiku 5.5.

Bottom line: when to reach for Haiku, and when not to

In my eyes, Haiku 5.5 is the moment "a big model plans, lots of small models execute" turned from a nice idea in conference talks into an economic default. The musician is finally good enough, and cheap enough, that we can run dozens of them without thinking twice. Anthropic's own customers are reporting this in their own words too: Asana talks about up to 2.5x faster speed per agent turn, and Box reports an 11-point higher score than Haiku 4.5 in roughly half the response time. These are customer reports, not independent benchmarks.

But there are limits. The model is still far behind Sonnet 5.5 on hard, long coding tasks, so the big decisions, the architecture, and the final merge stay with the conductor. It's worth measuring effort on your own real tasks before dropping to low. You must keep every request under 100K, or the savings shrink fast. And one more note for anyone working through Bedrock: per the docs, structured outputs aren't available there for Haiku 5.5.

Bottom line: in our example, the same scan of 200 files dropped from about $13 to about $1.30, and the big model got freed up to do what it's actually good at.

Want to take this further?

I break down all this work with subagents, effort, and splitting between conductor and workers in depth in the Claude Code Mastery course, in English. If you prefer Hebrew, and want to start from Claude Desktop, MCP, Skills, agents and automations, check out Practical AI with Claude.

I post these demos and experiments on YouTube and LinkedIn, with regular updates on X, Instagram, and TikTok. My code is open on GitHub.

And I'm curious to hear: which task in your project would you hand off first to a fleet of Haiku agents — and which one would you never let it touch?

Comments