Claude Haiku 5.5: The $0.10 Small Model That Makes Subagents Affordable

On October 7, 2026 Anthropic released Claude Haiku 5.5, which it calls the cheapest, fastest and most capable small model it has ever shipped. For prompts up to 100,000 tokens it costs $0.10 per million input tokens and $0.50 per million output tokens, rising to $0.50 and $2.50 above that threshold. The footnote is more useful than the headline: around 90% of requests to Haiku 4.5 fell under 100k tokens, so for most traffic the input price dropped tenfold rather than twofold, and Anthropic's all-in average is roughly 75% cheaper once changes in token consumption are counted. The same day brought a halved Sonnet 5.5 cache-read price, monthly API credits for Max and Team subscribers, and beta computer-use and browser-use support in the Python and TypeScript SDKs.

The small-model price war has converged on one number: $0.10 / $0.50

The price table, read carefully

Put the published price tables side by side and the change stops looking incremental. Haiku 5.5 is $0.10 in and $0.50 out under 100k tokens; Haiku 4.5 was $1.00 and $5.00. Cache writes fall from $1.25 to $0.125. In other words, if your traffic already sat in the short-prompt band — which Anthropic says was nine out of ten requests — you are paying an order of magnitude less. The detail people skip is the second footnote: Haiku 5.5 uses a newer tokenizer, shared with Sonnet 5.5 and Opus 5.5, so the same task consumes slightly more tokens than it used to. Budget against a measured token count, never against last quarter's average multiplied by the new sticker price.

# Anthropic's published price table, per 1M tokens.
# The first number is for prompts up to 100k; the second for over 100k.
PRICES = {
    "claude-haiku-5-5": {
        "cache_read":   (0.01,  0.05),
        "cache_write":  (0.125, 0.625),
        "input":        (0.10,  0.50),
        "output":       (0.50,  2.50),
    },
    "claude-haiku-4-5": {          # what you were paying
        "cache_read":   (0.10,  0.10),
        "cache_write":  (1.25,  1.25),
        "input":        (1.00,  1.00),
        "output":       (5.00,  5.00),
    },
    "claude-sonnet-5-5": {
        "cache_read":   (0.10,  0.10),   # halved from $0.20 this week
        "input":        (2.00,  2.00),
        "output":       (10.00, 10.00),
    },
}

# Anthropic's own footnote matters: 90% of Haiku 4.5 requests fell under
# 100k tokens. So for most traffic, the input price fell 10x, not 2x.
# The catch is the new tokenizer - Haiku 5.5 spends more tokens per task.

Read the benchmarks together, not one at a time

Launch posts tend to quote the best number. Line the benchmarks up instead and the model's job description writes itself. On OSWorld 2.1, which measures operating a real computer to finish long multi-step tasks, Haiku 5.5 scores 72.4% against 15.7% for Haiku 4.5 — that is the genuine jump, and it is what makes browser and desktop agents viable at this price. On Terminal-Bench 4.0, the agentic coding benchmark, it manages 39.2% while Sonnet 5.5 reaches 70.6% and Haiku 4.5 scored 0.0%. On Humanity's Last Exam without tools it is 45.9% versus 10.2%, and on GDPval-AA v2.1 it is 1620 versus 735. The read is simple: use it for work that reads a lot and decides a little, and keep the expensive model in front on long coding chains.

# Do not read one benchmark in isolation. Read them together and the
# model's job description writes itself.
SCORES = {
    #                        Haiku 5.5   Haiku 4.5   Sonnet 5.5
    "OSWorld 2.1":            (72.4,      15.7,       83.9),   # computer use
    "Terminal-Bench 4.0":     (39.2,       0.0,       70.6),   # agentic coding
    "FrontierCode 1.1":       (46.4,      None,       52.1),
    "Humanity's Last Exam":   (45.9,      10.2,       56.9),   # no tools
    "GDPval-AA v2.1":         (1620,       735,       1840),
}

def where_it_fits(scores):
    # A 4.6x jump on OSWorld says: browser and computer use, yes.
    # 39.2 vs 70.6 on Terminal-Bench says: not your lead agent on hard
    # multi-step coding. Put it behind a bigger model, not in front.
    return {
        "good": ["browser_use", "triage", "summarisation", "compaction", "extraction"],
        "bad":  ["long_horizon_coding", "architecture_decisions"],
    }

Effort settings on one model: accuracy against cost

The first Haiku with an effort dial

The more practical addition is the effort setting. Haiku 5.5 is the first Haiku-class model with an adjustable effort control, which turns 'which model' from a binary choice into two dials on one model. Low effort belongs on classification, routing and field extraction. Medium covers summarisation, compaction and most subagent calls. High belongs only on the step where a wrong answer means a rerun. Anthropic published accuracy-versus-cost charts on three benchmarks to show the tradeoff. The real value is not that high effort is stronger — that part is obvious — it is that you now have a documented knob to point at when someone asks why inference costs dropped.

# Haiku 5.5 is the first Haiku-class model with an adjustable effort
# setting. That turns "which model" into two dials you can tune per
# call instead of one binary choice.
def call(system, user, effort="medium"):
    """
    effort trades cost for intelligence on the same model.
    low    - classification, routing, field extraction
    medium - summaries, compaction, most subagent work
    high   - the step where a wrong answer costs you a rerun
    """
    return client.messages.create(
        model="claude-haiku-5-5",
        max_tokens=2048,
        thinking={"effort": effort},
        system=system,
        messages=[{"role": "user", "content": user}],
    )

# The point is not that high effort is better. It is that you now have
# a documented knob to defend when someone asks why inference got cheaper.

The subagent pattern: expensive model plans, cheap model reads

The pattern that actually clears the invoice is subagents. Let a frontier model plan and sign off, and let Haiku 5.5 do the high-volume reading and screening, and your cost structure becomes dominated by the reader — which just got an order of magnitude cheaper. The customer quotes in Anthropic's post are exactly this shape. Rogo describes a Haiku 5.5 subagent going into a 10-K to pull the segment revenue line while a larger model builds the deck. Cognition ships it as the sidekick in Devin Fusion, holding a top-tier FrontierCode score of 66.2 while cutting cost and latency. HubSpot reports the best score it has seen on its CRM simulation at 92.8% averaged over three runs. AlphaSense ran 400 queries and measured a statistically significant improvement, 0.84 versus 0.76. Asana reports over 30% lower latency for task completions and up to 2.5x faster inference per agent turn.

# The pattern that pays for itself: a frontier model plans, Haiku 5.5
# does the high-volume reading. Cost is dominated by the reader.
from dataclasses import dataclass

@dataclass
class Subagent:
    name: str
    model: str = "claude-haiku-5-5"
    effort: str = "low"

def review_pull_request(diff_files, lead_model="claude-opus-5-5"):
    # Lead model: reads the change once, decides what deserves a look.
    plan = lead(lead_model).plan(diff_files)

    # Reader subagents: one per file, cheap, parallel, disposable.
    findings = []
    for f in plan.files_to_check:
        out = Subagent("file-scout").run(
            task=f"flag real bugs in {f.path}; quote the exact line",
            content=f.content,
        )
        findings.append(out)

    # Only the surviving findings go back to the expensive model.
    return lead(lead_model).summarise(findings)

# Anthropic's own customer quotes in the launch post are this pattern.
# Rogo: a Haiku 5.5 subagent pulls the segment revenue line out of a
# 10-K while a larger model builds the deck. Cognition ships it as the
# Devin Fusion sidekick, holding a FrontierCode score of 66.2.

Do not miss the Sonnet price cut that shipped alongside it

One line in the same announcement is easy to skim past: Anthropic halved Sonnet 5.5's cache-read price from $0.20 to $0.10 per million tokens. Because cache reads are a large share of token consumption, that cuts the cost of most agentic Sonnet work by around 20%. What does it mean for your stack? If you already run stable Sonnet 5.5 workloads, check the arithmetic before swapping in the shiny new cheap model — the Sonnet saving may beat the migration, because you would otherwise pay in rewritten prompts, re-evaluated output quality and rerun benchmarks. It is also worth naming the context: at $0.10 and $0.50 under 100k tokens, Haiku 5.5 lands on exactly the same numbers as OpenAI's GPT-6 Luna. The small-model price war has converged on a single price point, so differentiation now has to come from capability, effort control and ecosystem.

# Do the arithmetic before you celebrate, because the tokenizer moved.
def monthly_cost(requests, tokens_in, tokens_out, cache_hit_rate, model):
    """requests/month, mean token counts, share served from cache."""
    read, write, pin, pout = PRICES[model]["cache_read"][0], \
        PRICES[model]["cache_write"][0], \
        PRICES[model]["input"][0], \
        PRICES[model]["output"][0]

    billed_in = tokens_in * (1 - cache_hit_rate)
    cost = requests * (
        billed_in / 1e6 * pin
        + tokens_in * cache_hit_rate / 1e6 * read
        + tokens_in * 0.2 / 1e6 * write   # assume 20% of context is written
        + tokens_out / 1e6 * pout
    )
    return cost

# Two hidden line items people miss:
#   1. Haiku 5.5 uses a newer tokenizer, so the same task can bill more
#      tokens than it did on 4.5. Measure, do not assume.
#   2. Sonnet 5.5 cache reads halved to $0.10/M, cutting most agentic
#      Sonnet work by about 20% - sometimes the better lever is the
#      bigger model you already trust, not the cheaper new one.

Measure tokens before celebrating savings: the new tokenizer moves the ledger

The sentence the marketing skipped

Two sentences from the developer discussion deserve to be written down. The good one: Haiku 5.5 improves on Haiku 4.5 across almost all of Anthropic's alignment evaluations, and its cybersecurity safeguards are more restrictive than 4.5's while remaining somewhat looser than Sonnet 5.5's — permitting a wider range of defensive tasks, still blocking penetration testing and techniques more likely to be used by attackers. The cautionary one: some builders flag quiet failure modes on complex edits and question whether part of the benchmark jump reflects changes in how evaluations are run. That scepticism is healthy. The sensible path is to deploy it first in low-risk, verifiable pipelines — summaries, extraction, classification, where a wrong answer is immediately visible — run it on real traffic for a couple of weeks, and only then move it closer to the decisions that matter.