Benefits of Claude Haiku 5.5 for Infrastructure Alert Triage

Your pager does not care that 400 of last night's infrastructure alerts were the same flapping disk check. Claude Haiku 5.5 alert triage puts a cheap, fast model between your monitoring stack and your humans: it classifies each alert, picks an owning team, writes a dedup key and adds a one-line summary. Anthropic shipped claude-haiku-5-5 on October 7, 2026 for high-volume classification, extraction and routing work.

Claude Haiku 5.5 alert triage in one API call

The call below is the whole pipeline: a cached routing prompt, low effort and a JSON schema the answer must match.

import json
import anthropic

client = anthropic.Anthropic()

TRIAGE_SCHEMA = {
    "type": "object",
    "properties": {
        "severity": {"type": "string", "enum": ["page", "ticket", "ignore"]},
        "team": {"type": "string", "enum": ["platform", "database", "network", "app", "unknown"]},
        "dedup_key": {"type": "string"},
        "summary": {"type": "string"},
    },
    "required": ["severity", "team", "dedup_key", "summary"],
    "additionalProperties": False,
}

# Service catalog, ownership map and severity policy (512+ tokens, or it won't cache)
ROUTING_RULES = open("routing_rules.md").read()


def triage(alert: dict) -> dict:
    response = client.messages.create(
        model="claude-haiku-5-5",
        max_tokens=1024,
        system=[
            {
                "type": "text",
                "text": ROUTING_RULES,
                "cache_control": {"type": "ephemeral"},
            }
        ],
        messages=[{"role": "user", "content": json.dumps(alert)}],
        output_config={
            "effort": "low",
            "format": {"type": "json_schema", "schema": TRIAGE_SCHEMA},
        },
    )
    if response.stop_reason == "refusal":
        # No server-side fallback on Haiku 5.5: hand it to a human
        return {"severity": "page", "team": "unknown", "dedup_key": "", "summary": "Model declined this alert"}
    text = next(block.text for block in response.content if block.type == "text")
    return json.loads(text)

Caching the system prompt means later alerts pay the cache-read rate. The max_tokens of 1024 leaves room for thinking, which counts toward that limit and bills as output.

Five benefits of Claude Haiku 5.5 for alert triage

1. Every alert gets read, not sampled. Haiku 5.5 lists at $0.10 per million input tokens and $0.50 per million output tokens for prompts up to 100,000 tokens, with cache reads at $0.01 per million, per the pricing page. Assume 1 million alerts a month, each with a 1,500-token cached routing prompt, a 300-token alert and a 100-token answer. My arithmetic gives about $95 a month with caching (cache writes extra but small) and $230 without. Haiku 4.5 listed at $1 and $5, so even after the new tokenizer's roughly 30% token inflation, the same text costs about 7 to 8 times less.

2. Fast enough to run before the page fires. Anthropic's models overview rates Haiku 5.5 the fastest model in the current lineup, and the effort guide calls low the fastest level. Triage can sit inline in the alert path instead of a morning digest, but time it on your own payloads.

3. Routing you can parse. Structured outputs work on claude-haiku-5-5, so severity and team come back as enum values from your schema. Your router becomes a dictionary lookup instead of a regex over prose.

4. One prompt can hold a whole alert storm. The context window is 1M tokens, but Haiku 5.5 is the exception to flat 1M pricing on Claude 4.6 and later: prompts over 100,000 tokens bill at $0.50 input and $2.50 output per million. About 300 alerts at 300 tokens each is roughly 90,000 tokens, so one call can cluster a storm into incidents and stay in the cheap tier.

5. Half-price review of the backlog. Not every alert needs an answer in seconds. The Message Batches API takes 50% off ($0.05 input and $0.25 output per million for prompts up to 100,000 tokens), and most batches finish within an hour. It suits the nightly pass that finds your noisiest alert rules.

import json
import anthropic
from anthropic.types.message_create_params import MessageCreateParamsNonStreaming
from anthropic.types.messages.batch_create_params import Request

client = anthropic.Anthropic()

# last_night_alerts: a list of alert dicts, each with an "id" field
batch = client.messages.batches.create(
    requests=[
        Request(
            custom_id=f"alert-{alert['id']}",
            params=MessageCreateParamsNonStreaming(
                model="claude-haiku-5-5",
                max_tokens=1024,
                system=ROUTING_RULES,
                messages=[{"role": "user", "content": json.dumps(alert)}],
                output_config={
                    "effort": "low",
                    "format": {"type": "json_schema", "schema": TRIAGE_SCHEMA},
                },
            ),
        )
        for alert in last_night_alerts
    ]
)
print(batch.id)

# Later, once the batch has ended:
for result in client.messages.batches.results(batch.id):
    outcome = result.result
    match outcome.type:
        case "succeeded":
            print(f"Triaged {result.custom_id}")
        case "errored":
            print(f"Failed {result.custom_id}")
        case "expired":
            print(f"Expired {result.custom_id}")

A custom_id must match ^[a-zA-Z0-9_-]{1,64}$, so build it from an alert ID, not a hostname with dots. Join answers back by custom_id, and resubmit anything that expires.

When Claude Haiku 5.5 is not worth it

Root-cause analysis across traces, logs and a week of deploys is reasoning work, not classification, so escalate those incidents to a bigger model. Sonnet 5.5 lists at $2 and $10 per million tokens, and Anthropic suggests comparing Haiku's xhigh and max effort against it on your own evals first.

It also isn't worth the plumbing if you see a few hundred alerts a day. A grouping rule in your alert manager does that job for free.

Claude Haiku 5.5 migration: what breaks from Haiku 4.5

Swapping the model ID is the easy part (claude-haiku-5-5, or anthropic.claude-haiku-5-5 on Amazon Bedrock). The migration guide lists the rest:

• thinking: {"type": "enabled", "budget_tokens": N} returns a 400. Leave thinking at its adaptive default and set output_config.effort.
• Omit temperature, top_p and top_k. Anything but temperature 1 or top_p 0.99 returns a 400, and so does any top_k.
• Assistant prefill returns a 400. Use structured outputs or a tool with enum fields instead.
• Safety classifiers can end a request with stop_reason: "refusal", with no server-side fallback. Watch security alerts for it.
• On Amazon Bedrock, structured outputs aren't available for Haiku 5.5, and neither is Priority Tier.

For anyone running AI in production, Haiku 5.5 makes reading every infrastructure alert affordable, as long as you keep it on triage and send the investigations to a bigger model.