AIDiveIntro: the cheap worker nobody calls
Claude Code's subagents skip Haiku 5.5 until two files say otherwise. That is the whole finding, and the rest of this article is the measurement behind it: seven everyday tasks on a real repository, with Haiku 5.5, Sonnet 5.5 and Opus 5.5 each taking the worker role, and the plan meter read after every block of runs.
Haiku 5.5 shipped on October 7, 2026, pitched by Anthropic as the subagent model, at a tenth of the old Haiku's price per token. A month of logs from one account tells the other half of the story: 2,631 subagent runs, 42 of them on Haiku, because every subagent inherits the main model. Flipping every subagent to Haiku raises an obvious question, which is what the plan meter actually gives back. Two files put the Explore agent on Haiku, and the setting most people reach for does nothing on its own. The usage breakdown panel, the one everyone trusts, is computed from four numbers baked into the binary.
What one task costs on each model
Haiku 5.5 costs $0.10 per million input tokens and $0.50 per million output tokens, against $1 and $5 for Haiku 4.5. That price holds for prompts up to 100,000 tokens; above that line the whole request is priced five times higher. Anthropic's "90%" figure is not a discount: it is the share of requests to the previous Haiku that stayed under that line.
| Model | Input per 1M tokens | Output per 1M tokens |
|---|---|---|
| Haiku 5.5 (prompt up to 100k) | $0.10 | $0.50 |
| Haiku 5.5 (prompt over 100k) | $0.50 | $2.50 |
| Haiku 4.5 | $1.00 | $5.00 |
| Sonnet 5.5 | $2.00 | $10.00 |
| Opus 5.5 | $4.00 | $20.00 |
Two more catches came from the field. The new tokenizer counts the same text as about 30% more tokens than Haiku 4.5. And at max effort, an independent run measured about 162,000 output tokens per task, around three times a rival model. Anthropic's own line is careful: Sonnet and Opus remain the better choices for complex agentic coding. On Terminal-Bench 4.0, Haiku 5.5 scores 39.2% against Sonnet 5.5's 70.6%.
The test covers the tasks a subagent actually gets. One real repository, tinydb, with 226 tests in its suite. Seven task types: explore the code, fix a failing test, clean lint errors, write a commit message, add a small feature, review a diff, summarize the architecture. Four workers: Haiku 5.5 at medium effort, Haiku 5.5 at low effort, Sonnet 5.5, Opus 5.5. 182 runs in all, every one checked by a hidden test or a fixed rule, never by eye.
| Configuration | Runs | Accepted | Small feature, list price | Small feature, wall time |
|---|---|---|---|---|
| Haiku 5.5, low effort | 70 | 70 | $0.0052 | 17.1 s |
| Haiku 5.5, medium effort | 70 | 70 | $0.0078 | 26.3 s |
| Sonnet 5.5 | 21 | 21 | $0.1050 | 30.3 s |
| Opus 5.5 | 21 | 21 | $0.1675 | 30.3 s |
Exploring the codebase cost $0.0035 on Haiku low and $0.1454 on Opus, about forty times more. Haiku was never slower: seven tasks, all accepted, at a fraction of the price, as fast or faster.
Why nothing runs on Haiku by default
Nothing goes to Haiku on its own, and that is by design. Since release 2.1.198 the built-in Explore agent inherits the main session's model, capped at Opus; before that release it ran on Haiku. Every custom subagent does the same. The documentation gives the resolution order: the model named at launch, then the model in the agent file, then the CLAUDE_CODE_SUBAGENT_MODEL variable, and only after those the main model.
There is a trap in that list, and the docs say it plainly: setting the subagent model variable by itself does not change the model the built-in Explore and Plan agents run on. Two headless runs confirm both claims. With the main session on the Fable model and one question (use the Explore agent to find where the query cache is cleared), the tool result names the model that actually ran: Opus 5.5. The same run with the subagent model variable set to Haiku 5.5 and nothing else: Opus 5.5 again.
That is why a month of logs looks the way it does. Across 2,631 subagent runs, 42 went to Haiku. Subagents took 48.1% of every token on the account, and Haiku's share of the weighted cost was 0.27%. The default is a defensible choice: an explorer on your main model reads code as well as the main model does. What nobody prints is what it costs.
The two files
Two files fix it, and you can take either one or both. The small one is a single agent file in your project: create .claude/agents/Explore.md, name it Explore, give it a description, set the model to claude-haiku-5-5 with the full id, set the effort to low, and limit the tools to Read, Glob, Grep and Bash. Claude Code treats your file as the Explore agent from then on, and the docs say it in so many words: define a project subagent named Explore and give it the Haiku model. The same headless run then reports resolvedModel: claude-haiku-5-5.
The second file is your settings. An env block in .claude/settings.json with two variables: CLAUDE_CODE_SUBAGENT_MODEL set to claude-haiku-5-5, and CLAUDE_CODE_SUBAGENT_MODEL_FORCE set to 1. Force is the part people miss. Since release 2.1.257, that flag applies the subagent model to every subagent, ignoring the overrides set at launch or in an agent file. The same run with those two variables in the environment and no agent file reads Haiku 5.5 again.
| You want | Use | Side effect |
|---|---|---|
| Every subagent cheap | The settings env block with the force flag | Your deliberately Opus agents drop to Haiku too |
| Only the explorer cheap | The Explore agent file | The other agents keep their own models |
Pin the full model id. The haiku alias means Haiku 5.5 only on the Anthropic API; on Bedrock, Vertex and Foundry it still means Haiku 4.5. An open issue on the Claude Code repository reports 1,149 subagents out of 1,371 running on the parent's Opus model with the file saying otherwise, intermittent across a dozen builds (2.1.277 to 2.1.290), with no reply from Anthropic. On the current build, 2.1.293, every one of the 182 runs carried the configured model. Still, check: the /tasks command shows the model each subagent ran on, and a headless run's tool result carries it too. Effort is the lever that remains, since thinking cannot be turned off on these models; low effort in the Explore file is a deliberate choice, and what it buys is measured below.
What the real meter saw
Every headless run with streaming output emits one rate_limit_event. Inside it sit two fractions, the five-hour window and the seven-day window, with two decimals each. They come straight from the response headers Anthropic sends with every reply, at one point of resolution and nothing finer. The four workers ran as four blocks, one after another, with nothing else touching the account.
| Block | Runs | Five-hour window before | Five-hour window after | Weekly window |
|---|---|---|---|---|
| Haiku 5.5, low effort | 70 | 21% | 21% | 67% |
| Haiku 5.5, medium effort | 70 | 21% | 21% | 67% |
| Sonnet 5.5 | 21 | 21% | 22% | 67% |
| Opus 5.5 | 21 | 22% | 23% | 67% |
In list price the whole matrix cost $4.09. On the meter, it cost two points of a five-hour window and zero points of the week. The Haiku half cost $0.54 and moved nothing: one point of this account's window is worth more than 140 of these tasks on Haiku.
Anthropic publishes one sentence on model weight: Opus costs several times more per turn than Sonnet, and Sonnet more than Haiku. Several. No number anywhere. The windows are one pool for every model, so switching models in the middle of a session restores nothing. Each block carries up to a point of rounding, which means Sonnet's one point and Opus's one point cannot be told apart. What the meter proves for sure is that a scoped task on any of these models is invisible at this resolution. The weight of each model has to be read somewhere else.
The /usage breakdown is a guess
Open the /usage panel and you get a breakdown: percentages attributed to skills, subagents, plugins and MCP servers. It looks like server data. It is not. The documentation says the figures are approximate and computed from local session history on this machine, so the formula lives in the binary. Run strings on the executable and two functions fall out.
| Factor | Weight |
|---|---|
| Model tier: Fable | 10 |
| Model tier: Opus | 5 |
| Model tier: Haiku | 1 |
| Model tier: anything else | 3 |
| Cached tokens | 1 |
| Fresh input tokens | 10 |
| Cache writes | 12.5 |
| Output tokens | 50 |
The record weight is the token sum times the model tier. These are the client's attribution weights, not proof of how the server bills your quota, and the gap shows. Run the formula on the blocks above: 70 Haiku medium runs score 29.5 units, 21 Opus runs score 27.3. The panel would rank the Haiku block above the Opus block; the real meter said zero points against one.
There is a second flaw underneath. An open issue reports that subagent transcripts record the usage of the first streaming chunk: one run logged 461 output tokens where the same run headless logged 15,575. A transcript on this machine shows 16 output tokens on every assistant entry. The formula multiplies that undercounted figure by 50, so subagents that write a lot vanish from the panel. Use it for what it is: which skill or agent eats your local history, with the day and week keys. For the weight of a model in your real quota, it is a guess.
Where a day's quota really goes
The scale the meter can see is a day. Andrea Grandi published his numbers the day Haiku 5.5 shipped, on a Pro plan. His main session runs Opus 5.5 at medium effort; an implementer agent on Sonnet 5.5 writes the code; two Haiku 5.5 agents do the rest, a scoper in plan mode with no edit tools and at most twelve turns, and a shipper at low effort that commits, pushes and opens the PR.
| Measure | Value |
|---|---|
| Pull requests over sessions | 13 over 10 |
| Five-hour window per PR | about 6% |
| Weekly counter per single-PR session | about 1% |
| Estimated cost per PR with subagents | $2.31 |
| Estimated cost per PR on Opus alone | $3.59 |
| Requests per session, before and after | 75 to 54 |
| Tokens per request, before and after | 119,000 to 107,000 |
His own sentence is the point: if he prices the subagents' tokens at Opus rates, the ten sessions only get 5% more expensive. The saving came from the main context staying small. A month of logs says the same from the other side: subagents took 48.1% of the tokens, and 96% of all tokens were cache reads. Every subagent starts with a launch prompt; on this account the median is 47,000 tokens, and it is the same stack whether the worker is Opus, Sonnet or Haiku. The model switch does not shrink it.
Effort does change the appetite. On the small feature, Haiku at medium effort read 233,000 tokens over 14 turns; Haiku at low effort read 140,000 over 8 turns for the same accepted result; Opus needed 88,000. An independent run measured the same curve higher up: 55,000 output tokens per task at high effort, 162,000 at max. Cheap per token, hungrier per task, and the dial is yours. Two caveats: Grandi's dollars are an estimate on a Pro plan, and the matrix here is one small repository. Neither is a week on a Max plan.
The routing table, the limits, the pack
The routing table: explore the code, fix a failing test, clean the lint, write the commit message, add a small feature, review a diff, summarize the architecture. All seven go to Haiku 5.5 at low effort, with 70 runs out of 70 accepted on each, at low and at medium. Per task that is between a fifth of a cent and half a cent in list price, against six to seventeen cents on Opus. What stays on Sonnet or Opus is complex agentic coding, in Anthropic's own words, where Terminal-Bench puts Haiku at 39.2 against 70.6; the one tested review of the launch closed on the same line, stay on Sonnet for hard coding.
The two files sit beside the table: the Explore agent file with the full Haiku model id and low effort, and the settings env block with the subagent model and the force flag. The check is the /tasks command, which shows the model each subagent ran on. Trust that line, never the file.
Back to the question from the start. Flip every subagent to Haiku, and what does the meter give back? For a scoped task, less than a point on any model. The whole matrix of 182 runs moved the five-hour window two points and the week zero. The real week comes back from the main context and from the launch prompt every subagent carries. The model switch is the cheap part, and it is free to take.
| Limit | Detail |
|---|---|
| Repository | One small repo, tinydb, 226 tests |
| Task size | Seven scoped tasks under a minute each, not a day of agentic coding |
| Meter | One point of resolution, plus or minus a point per block |
| Multiplier | None published by Anthropic per model |
| Version | Claude Code 2.1.293 on October 8, 2026; earlier builds ignored the agent file's model (open issue) |
The free pack holds the routing table, the two files, and the harness that measured it: the seven prompts, the checks and the runner.
