Why Leaders Should Send Routine Work to Claude Haiku 5.5

Your most expensive model is probably doing your cheapest work. Someone picked it for the demo, it worked, and now it sorts support tickets at Sonnet or Opus prices. Claude Haiku 5.5, released on October 7, 2026, is built for exactly that kind of high-volume work: classification, routing, extraction and subagent tasks. Make the cheapest tier that passes your evals the default, and make every step up to Sonnet 5.5 or Opus 5.5 a decision that needs evidence.

Claude Haiku 5.5 pricing next to Sonnet 5.5 and Opus 5.5

List prices per million tokens, from the Anthropic pricing page:

| Model | Input / output | | --- | --- | | Claude Haiku 5.5 | $0.10 / $0.50 (prompts up to 100K tokens) | | Claude Sonnet 5.5 | $2 / $10 | | Claude Opus 5.5 | $4 / $20 |

For prompts up to 100,000 tokens, Sonnet 5.5 costs 20 times as much as Haiku 5.5 and Opus 5.5 costs 40 times as much. Take a hypothetical routing service handling 10 million requests a month at 1,500 input and 200 output tokens each. That is $2,500 a month on Haiku, $50,000 on Sonnet and $100,000 on Opus, before batch discounts, caching and thinking tokens. If all three pass your eval, the extra $47,500 buys nothing you can measure.

Why the cheapest tier that passes should be the default

Quality belongs to a task, not a tier. A four-label ticket classifier has a right answer, and a bigger model returns the same label at a much higher price.

A default is the one lever a leader holds across dozens of teams. If the default is the biggest model, every team overspends quietly. If it is the cheapest model that passes, overspending needs a written reason, and that reason is a failed eval.

The objection: cheap models fail where it counts

Sometimes they do, and Anthropic says so. Its announcement states that Sonnet 5.5 and Opus 5.5 remain better choices for complex agentic coding tasks like those measured by Terminal-Bench 4.0, where it lists Haiku 5.5 at 39.2% and Sonnet 5.5 at 70.6%. Haiku 5.5 is for narrowly scoped work.

So the policy is not 'use Haiku everywhere.' It is 'prove you need more.' A failed eval is the best budget request an engineer can bring you: the task, the pass rate on each tier, and the monthly difference.

You can also keep the cheap tier in front and send only the cases that fail validation, such as a malformed output or a low-confidence label, to the next tier. Then you pay Sonnet prices for the hard tail, not the whole stream.

Run the tier test on your own tickets

This script tries the tiers cheapest first and stops at the first one that clears your bar. It reads a JSONL file with a ticket and a label on each line.

import json

import anthropic

client = anthropic.Anthropic()

# (model, input $/MTok, output $/MTok), cheapest first.
# List prices for prompts up to 100K tokens.
TIERS = [
    ('claude-haiku-5-5', 0.10, 0.50),
    ('claude-sonnet-5-5', 2.00, 10.00),
    ('claude-opus-5-5', 4.00, 20.00),
]
PASS_RATE = 0.95  # agree this number with the business before you run, not after
SYSTEM = 'Classify the support ticket as billing, outage, access or other. Reply with the label only.'


def evaluate(model, in_price, out_price, cases):
    correct, cost = 0, 0.0
    for case in cases:
        response = client.messages.create(
            model=model,
            max_tokens=2048,  # thinking tokens count toward this, so leave room
            system=SYSTEM,
            output_config={'effort': 'low'},
            messages=[{'role': 'user', 'content': case['ticket']}],
        )
        answer = ''.join(b.text for b in response.content if b.type == 'text').strip().lower()
        correct += answer == case['label']
        cost += (response.usage.input_tokens * in_price + response.usage.output_tokens * out_price) / 1_000_000
    return correct / len(cases), cost


with open('evals/ticket_routing.jsonl') as f:
    cases = [json.loads(line) for line in f]

for model, in_price, out_price in TIERS:
    rate, cost = evaluate(model, in_price, out_price, cases)
    print(f'{model}: {rate:.1%} correct, ${cost:.4f} for {len(cases)} cases')
    if rate >= PASS_RATE:
        print(f'Default for this task: {model}')
        break
else:
    print('No tier passed. Fix the prompt or the eval before paying for a bigger model.')

The effort setting controls how much the model thinks. low is the level the Haiku 5.5 docs suggest for simple, high-volume requests, so try medium if the cheap tier misses. Thinking is on by default and counts toward max_tokens, which is why the script leaves 2,048 tokens of room.

Gotchas

• Long prompts shrink the gap. Over 100,000 tokens Haiku 5.5 costs $0.50 input and $2.50 output, so Sonnet 5.5's premium falls to 4 times.
• Recount your tokens. The same text counts as roughly 30% more tokens than on Haiku 4.5, so budgets built from old counts run low.
• Handle refusals. Haiku 5.5 runs safety classifiers that can return a refusal stop reason, with no server-side fallback, so your client has to handle it.
• Check old request code. Sampling parameters and assistant prefill can return 400 errors, and Priority Tier is not supported. The migration guide lists each change.

Start with Claude Haiku 5.5 on your next eval run

Pick one production workload that already has labeled examples and run it on Haiku 5.5 before anything else. Write down the pass rate and the monthly cost next to the current model's. If it clears the bar, you found savings. If it does not, you hold the evidence for the upgrade.

In production, volume multiplies every per-token decision, so the default tier for routine calls matters more than the model you pick for the hard cases.