Anthropic shipped Claude Haiku 5.5 on October 7, 2026 and described it as the cheapest and fastest model it has released, designed for high-volume work, and a model that "pairs well with Opus 5.5 and Sonnet 5.5 as a subagent on coding work" (announcement).
Claude Code has supported per-subagent model selection for a while, so the interesting question is not whether you can use it. It is which tasks in your own workflow are worth routing down a tier, what that actually changes about your bill, and where the routing silently does not do what you think. This page answers that with the real pricing table, real subagent files, and the errors the documentation names.
Every price, benchmark and error string below was read from Anthropic's announcement or the Claude Code documentation on October 14, 2026.
A subagent is a markdown file in `.claude/agents/` with YAML frontmatter. The `model` field does the work:
--- name: repo-explorer description: Finds where a feature lives in this repository. Use for locating files, symbols and call sites before making changes. tools: Read, Glob, Grep model: haiku --- You search this repository and report what you found. You never edit files. For any question, return: - the files that matter, with paths - the function or symbol names involved - which call sites would need changing Keep the answer under 200 words and never guess a path you did not read.
Save it, then confirm Claude Code loaded it:
mkdir -p .claude/agents claude --version claude -p "list your available subagents and the model each one uses" --output-format text
Then run the cheap model as the lead only when the task is genuinely simple, which is how you find the boundary for your own work:
claude --model claude-haiku-5-5
Inside a session, the same switch is `/model claude-haiku-5-5`. That ID is the API model ID, and the announcement prints it as `claude-haiku-5-5`.
Anthropic's claim is that Haiku 5.5 is "the cheapest, fastest, and most capable small model we've ever released", aimed at "quick and repetitive workloads (like summaries, compactions, database queries, and classification requests)". Those parenthetical examples are the routing policy, written by the vendor.
The announcement publishes a comparison table. The agentic coding numbers are the ones that matter for a coding subagent, and they are vendor-reported rather than independently measured:
Read the gap between columns rather than the absolute scores. On Terminal-Bench, Haiku 5.5 sits at 39.2% against Sonnet 5.5 at 70.6%: less than two thirds of the capability for a twentieth of the input price below. That ratio is the argument for routing retrieval down a tier and against routing judgment there.
Prices are per million tokens, from the announcement. Haiku 5.5 has two columns because its price changes once a prompt passes 100,000 tokens.
Anthropic states that Haiku 5.5 "now costs around 75% less to run" on average than Haiku 4.5, and that it is good value "when used for tasks with prompts up to 100,000 tokens, which make up around 90% of requests". The same announcement cuts cache reads on Sonnet 5.5 from $0.20 to $0.10 per million.
The cliff is the detail that decides whether routing pays. A subagent whose prompt stays under 100,000 tokens runs at $0.10 per million input. Cross that line and the same tokens cost five times as much. A subagent that reads a whole repository into its prompt can therefore cost more than the model tier you were trying to avoid, and the way to prevent it is to keep the subagent's job narrow, which is also what makes a subagent useful.
Claude Code's own documentation records the window: on the Anthropic API, Haiku 5.5 runs with the 1M context window on every plan, with no `[1m]` suffix to select, and sessions auto-compact at roughly 967K tokens by default.
The documented order matters, because it explains why a setting you changed had no effect:
Aliases are not the same model everywhere. The model configuration page prints this table, and the provider column is where teams get surprised:
A subagent pinned to `model: haiku` on the Anthropic API runs Haiku 5.5. The same file behind the AWS platform alias resolves to Haiku 4.5, whose published scores in the table above are a fraction of the newer model's. If your routing decision depends on which model is actually behind the alias, pin the full ID instead of the alias, then verify.
The narrow job below is designed to stay under the price cliff: it classifies, it does not read the repository.
--- name: ticket-router description: Classifies an incoming support message by department and urgency. Use when a message needs routing, not answering. tools: Read model: haiku maxTurns: 3 --- You classify one support message. You never answer it and never edit files. Return exactly three lines: department: one of billing, technical, returns, sales urgency: one of low, normal, high reason: one sentence naming the words in the message that decided it If the message is ambiguous, set urgency to normal and say what was missing.
Test it headlessly, which is also how you find out whether the routing works before you wire it into anything:
claude -p "My card was charged twice for the same order and nobody has replied in four days." \ --append-subagent-system-prompt "Use the ticket-router subagent for this." \ --output-format text
`maxTurns: 3` is the guard rail that keeps a classifier from turning into a research project. The documented field stops the subagent after a set number of agentic turns, and Claude Code marks the output as partial so the parent can resume it if it needs more.
The pattern that survives contact with a real codebase keeps the expensive model in charge and gives it cheap hands for the parts that do not need judgment:
export CLAUDE_CODE_SUBAGENT_MODEL=claude-haiku-5-5 claude --model claude-opus-5-5 \ -p "Map every caller of the pricing function, then propose a safe rename plan. Do not edit anything yet."
That variable routes every subagent to Haiku 5.5 while the lead conversation stays on the model you chose, which is the configuration most teams actually want: expensive reasoning, cheap retrieval. To force one model onto subagents including the built-in ones, Claude Code documents the variable as the override, and the built-in `Explore` subagent can be replaced by defining your own with the same name and a `model` field.
For parallel work, the workflow variable pins every workflow agent to one model while other subagents keep theirs:
export CLAUDE_CODE_WORKFLOW_SUBAGENT_MODEL=claude-haiku-5-5
Both variables were named in the Claude Code changelog for v2.1.296, published October 9, 2026.
Verify the routing rather than trusting it:
claude --version claude -p "print the model you are running as, then list each subagent you can see and the model it will use" \ --output-format text
These strings are documented in Claude Code's error reference, read October 14, 2026.
A subagent whose `tools` list resolves to nothing. The message is `would be spawned with zero tools`, and the reference shows it ending in `refusing`, with the entries named:
would be spawned with zero tools
The fix is in the tools list. A typo in `tools: Read, Grep, Bash` is the usual cause, and the error names the entries that failed to resolve.
Descriptions that grow too large. Claude Code keeps every subagent description in context, so the reference documents a startup limit:
Agent descriptions are over the 15.0k-token limit
The fix is to shorten `description` fields and move detail into each subagent's system prompt, which only loads when that subagent runs. If you have many subagents, this is also a cost decision rather than only a context one.
A malformed `--agents` value. The reference documents three lines for this family, and the order of the checks matters because it stops at the first failure:
Error: Invalid --agents configuration:
Error: --agents file not found
Error: --agents takes a JSON object, or a file path only with --print (-p)
The second line of the first error is the parser's own message when the value begins with `{` but does not parse as JSON. The third error explains a limit people hit while scripting: a file path is accepted only with `--print`.
A session where the general agent is missing entirely:
subagent_type is required: the general-purpose agent is not available in this session
One more failure has no error at all. If you omit `model` and never set `CLAUDE_CODE_SUBAGENT_MODEL`, the subagent inherits the main conversation's model. You will see the expensive model in the billing and no message anywhere saying the routing did not apply.
The pricing table is the least interesting part of this change, and it is the part buyers ask about first. What changes operationally is that a two-tier setup makes the split between judgment and retrieval explicit. Once the cheap tier exists, every subagent you write answers one question: does this task need a model that can decide, or one that can fetch.
That question is the same one behind model and skill routing and the guardrails around risky tool calls. A cheap tier removes the excuse for letting one expensive model do everything, and it moves the review question from "which model ran" to "what was this agent allowed to do while it ran", which is what bounded permissions and human approval covers.
For the cost side in a business context rather than a per-token one, the honest framing is on what an AI engineer costs if you are buying the function, and in the install guide if you are setting up the tooling yourself. The complete Jev guide indexes the rest of this cluster.
If your team is standing up an agent layer and wants the routing and the review gates designed before the first workflow ships, that is the work we do: an embedded AI engineer inside your existing team, spec first, with the exit written down. Send a written intake or see what we do.
Is Haiku 5.5 good enough to write code?
Anthropic's own table puts it at 39.2% on Terminal-Bench 4.0 against Sonnet 5.5 at 70.6%. It is positioned as the model for summaries, compaction, classification and retrieval, and it pairs with a larger model as the subagent rather than replacing the lead.
Why is my Haiku 5.5 bill higher than Haiku 4.5 would have been?
Check the prompt length first. Above 100,000 tokens the input price goes from $0.10 to $0.50 per million and output from $0.50 to $2.50. A subagent that reads a whole repository can cross that line, which is why narrow jobs matter.
How do I know which model a subagent actually used?
A `model` field in frontmatter wins, then `CLAUDE_CODE_SUBAGENT_MODEL`, then the main conversation's model. If a subagent feels expensive, look for the missing `model` field before you look anywhere else.
Does `model: haiku` mean Haiku 5.5 everywhere?
No. On the Anthropic API the `haiku` alias is Haiku 5.5. On the Claude Platform on AWS the same alias resolves to Haiku 4.5. Pin the full model ID when the difference matters to your routing decision.
Can I stop a classifier from running long?
Yes, with `maxTurns` in the frontmatter. When the subagent reaches the limit, Claude Code returns its output marked as partial so the parent can resume it.
[1] Anthropic, Introducing Claude Haiku 5.5, October 7, 2026. The model ID, the positioning as a subagent for coding work, the benchmark comparison table, the pricing table with the 100k token split, the 75% average cost reduction against Haiku 4.5, and the Sonnet 5.5 cache read reduction.
[2] Claude Code, Create custom subagents, read October 14, 2026. The frontmatter fields including `name`, `description`, `tools`, `disallowedTools`, `model`, `permissionMode`, `maxTurns`, `skills` and `mcpServers`, the built-in `Explore` subagent and how to override its model, and the description token load.
[3] Claude Code, Model configuration, read October 14, 2026. The alias table including the Claude Platform on AWS resolution to Haiku 4.5 and Sonnet 4.6, the Haiku 5.5 1M context window and per-token change above 100k tokens, and the auto-compact behaviour.
[4] Claude Code, Errors, read October 14, 2026. Every error string quoted here: the zero-tools refusal, the 15.0k-token description limit, the three `--agents` errors and their check order, and the missing general-purpose agent.
[5] Claude Code, Manage costs, read October 14, 2026. The cost controls referenced for routing work down a tier.
[6] Anthropic, Pricing, read October 14, 2026. The platform pricing page the Claude Code documentation points to for both Haiku 5.5 rates.
[7] Anthropic, Claude Code changelog, v2.1.296 published October 9, 2026. The entries naming `CLAUDE_CODE_SUBAGENT_MODEL`, `CLAUDE_CODE_WORKFLOW_SUBAGENT_MODEL` and the per-subagent auto-compact window.
Maxpertise is an AI-native engineering company. We embed native AI engineers inside your team, live in about 10 days. Please enable JavaScript to view the site, or email contact@maxpertise.net.