Anthropic shipped Claude Haiku 5.5 on October 7 and described its job in one line: it “pairs well with Opus 5.5 and Sonnet 5.5 as a subagent on coding work.” The launch post lists it at $0.10 per million input tokens and $0.50 per million output for prompts up to 100K tokens, $0.50 and $2.50 above that. Two of the six customer quotes on the page describe the same shape: Rogo runs a Haiku 5.5 subagent that pulls a revenue line from a 10-K while a bigger model builds the deck, and Cognition runs it as the “sidekick” under Opus 5.5 in Devin Fusion.
That framing is about the model. For a team running several agents, the harder question is about the board. A subagent lives inside someone else’s run. It has no Task, no Assignee and no status of its own, so when it gets something wrong, the mistake arrives wearing the lead’s name. Cheap work is now cheap enough to do a lot of, and the real decision is where it should be visible.
TL;DR
Keep Haiku 5.5 as an in-run subagent when its output is consumed by the lead and checked there: lookups, summaries, exploration, compaction. Give it its own Agent and its own Task when its output ships, when someone has to accept it, or when it can fail on its own. In Claude Code, pin model: claude-haiku-5-5 in the subagent file rather than the haiku alias, and remember the built-in Explore subagent runs on the main conversation’s model, not Haiku. In Sharkly, a cheap Agent is a Custom arguments setting, so both lanes can share one Computer. Agents research, execute, test, and report. People set direction, grant authority, and accept the result.
A subagent is invisible from above
A subagent is a helper the lead agent spawns inside its own session, hands a narrow job to, and reads the answer from. That is the right design for many jobs, and it is also a boundary: everything the subagent does happens inside one run.
Seen from the board, the two placements differ on every question a manager asks.
| Question | Haiku 5.5 as an in-run subagent | Haiku 5.5 as its own Agent on a Task |
|---|---|---|
| Who owns the result? | The lead, implicitly | The Task’s Assignee, explicitly |
| Where does the work show up? | Inside the lead’s run and final response | Its own Task, run state and execution log |
| Who checks it? | The lead model, before it continues | A person, or a reviewer, before acceptance |
| What happens when it fails? | The lead absorbs it or carries it forward | The Task shows the failure on its own |
| Can a person answer it mid-run? | No, it talks to the lead | Yes, a question returns to the Task and the Inbox |
| What does it cost to set up? | A file in the repository | An Agent and a Task |
The Codex version of this problem is already on this blog: once a session fans out into many subagents, one consolidated reply becomes the only thing a reviewer sees. Haiku 5.5 makes the same trade more tempting, because Anthropic built and priced it for exactly that position. The Rogo shape works because the lead consumes the revenue line and it lands inside a deck, an artifact a person would review before it goes anywhere. The subagent’s error, if any, surfaces inside that review.
Now move the same model to a job whose output is the artifact: a migration, a config change, a data fix, a customer reply. As a subagent, that work reaches the board only as part of the lead’s summary. Nobody sees which part of the diff came from the cheap model, and a person approving the Task is approving work they cannot attribute.
The rule, written down
The Luna posts answered which work belongs on a cheap tier: route on checkability, not difficulty. Haiku 5.5 adds a second axis. Once work is cheap enough, decide where it lives by who consumes the output.
Haiku 5.5 placement rule
In-run subagent when ALL of these hold:
- the output is read by the lead agent, not shipped
- the lead checks or uses it before continuing
- a wrong answer shows up downstream, inside reviewed work
examples: file lookups, codebase exploration, log and doc summaries,
classification, pulling one fact from a long document
Own Agent and own Task when ANY of these hold:
- the output ships (a diff, a message, a record, a submitted form)
- a person has to accept it
- it can fail, stall, or need a human answer independently
- you want its acceptance rate measured separately from the lead's
Use a subagent when the work converges on one answer the lead needs. Use a separate Task when the work is something the team would put a name next to.
There is a middle option in Sharkly. In a Crew, the leader Agent mentions members for specific contributions, and those members run against the same Task and add their results to its chat. A Haiku 5.5 member is visible on the Task without needing a Task of its own. Use it when one person will accept the combined result. Split into separate Tasks when different people will review different pieces.
Setting up both lanes
Each lane has one setting that is easy to get wrong.
The subagent lane, in Claude Code. Claude Code needs v2.1.293 or later for Haiku 5.5. A subagent’s model field accepts sonnet, opus, haiku, fable, a full model id, or inherit, per the subagents docs. Pin the full id:
---
name: lookup
description: Find files, symbols and config values. Read-only.
model: claude-haiku-5-5
---
Answer with paths and line numbers. Do not edit files.
The alias is the trap. According to the model configuration docs, haiku resolves to Haiku 5.5 only on the Anthropic API. On Amazon Bedrock, Google Cloud, Microsoft Foundry and Claude Platform on AWS it still resolves to Haiku 4.5. A subagent file shared across Computers on different providers can run two different models under one name. ANTHROPIC_DEFAULT_HAIKU_MODEL sets what haiku means, and what Claude Code uses for background functionality, on each host.
The second surprise: the built-in Explore subagent uses the main conversation’s model, not Haiku. If the lead is on Opus 5.5, exploration runs on Opus 5.5. The docs’ own suggestion is a user or project subagent named Explore, which overrides the built-in, with model: haiku to run exploration on a lower-cost model. Give the file above that name and keep the full id.
The Agent lane, in Sharkly. Sharkly does not pick models. The Agents documentation says: “The Agent follows the Runtime’s default model. It does not promise or display a specific model name. To change models, specify one in Custom arguments on the Agent or Runtime.” There is no model dropdown and no thinking-depth control on the Agent. So the cheap Agent is a second Agent on the same Computer and the same Claude Code Runtime, with claude-haiku-5-5 specified in its Custom arguments, while the lead Agent keeps its default. The house setup guide, running Claude Haiku 5.5 agents in Sharkly, walks through it.
Because the Task does not display a model name, add one line to the cheap Agent’s instructions: report the model in the final response. In Claude Code, Haiku 5.5 defaults to medium effort and thinking cannot be turned off, so the effort you set there decides how much each run costs.
Where the 100K step lands
The placement decision also decides which price you pay. Haiku 5.5 is $0.10/$0.50 per million tokens only while the prompt stays at or under 100K tokens. Above that, the pricing is $0.50/$2.50, five times higher. Anthropic says about 90% of requests to Haiku 4.5 fell under the threshold.
A subagent call is the shape that stays under it: a narrow brief, a short read, one answer back. A standalone Agent working a long Task is the shape that crosses it. Claude Code compacts native-1M models like Haiku 5.5 at about 967K tokens by default, far past 100K, so a long Haiku 5.5 run can spend most of its later turns at the higher rate. The fix for a long Task is to split it, not to move it back inside a lead’s run.
That gives the decision pair a cost edge. Use the in-run subagent for short, read-heavy calls where the low rate is easy to keep. Use a separate Agent for work that ships, and size those Tasks so a run finishes before its context does.
Two things that did not change
Anthropic is direct about the ceiling. Sonnet 5.5 and Opus 5.5 “remain better choices for complex agentic coding tasks,” and the launch table has Haiku 5.5 at 39.2% on Terminal-Bench 4.0 against 70.6% for Sonnet 5.5, both at max effort. Haiku 5.5 is a worker or a helper, not a lead.
And a cheaper worker does not make acceptance cheaper. Whether Haiku 5.5 runs as a subagent or as its own Agent, someone still owns the result. The subagent lane hides that someone inside the lead’s run; the Agent lane puts a name and a status on it. For browser and desktop work, where a run can finish half done, that difference gets expensive fast, which is the subject of cheap browser agents and the review queue. Choosing between Haiku 5.5 and GPT-6 Luna at the same list price is a separate question, covered in two cheap Runtimes at the same price.
Write the placement rule down once, keep subagents for the lookups the lead checks, and give anything that ships its own Task. If you’re already running several agents, Sharkly gives you one place to manage their tasks and results.
