{"slug": "claude-haiku-5-5-whats-new-and-how-to-use-it-for-fast-cheap-ai-workflows", "title": "Claude Haiku 5.5: What’s New and How to Use It for Fast, Cheap AI Workflows", "summary": "Anthropic released Claude Haiku 5.5 on October 7, 2026, with list prices of $0.10 per million input tokens and $0.50 per million output tokens for prompts up to 100,000 tokens, a 90% cut from Haiku 4.5's $1.00/$5.00. The model adds a 1M-token context window, 128K max output, and adaptive thinking with an effort setting, and Anthropic reports benchmark gains including 72.4% on OSWorld 2.1's offline subset (up from 15.7%) and 39.2% on Terminal-Bench 4.0 (up from 0.0%). Anthropic says the newer tokenizer counts the same text as roughly 30% more tokens, putting the average saving at around 75%, and three changes break Haiku 4.5 code: sending temperature, top_p or top_k, assistant prefill, and manual budget_tokens thinking all return errors.", "body_md": "# Claude Haiku 5.5: What’s New and How to Use It for Fast, Cheap AI Workflows\n\nClaude Haiku 5.5 cuts list prices by 90% and adds adaptive thinking and a 1M token context window. Learn what broke from Haiku 4.5, and build classification, extraction, and sub-agent workflows in Python using the new API.\n\nAnthropic released **[Claude Haiku 5.5](https://www.anthropic.com/claude-haiku-5-5)** on October 7, 2026, and calls it its cheapest, fastest, and most capable small model. The API model ID is `claude-haiku-5-5`, and prompts up to 100,000 tokens cost \\$0.10 per million input tokens and \\$0.50 per million output tokens. This article covers what changed since Haiku 4.5, how to build fast, cheap AI workflows with it in Python (classification, extraction, and sub-agents), and when a bigger Claude model is still the better pick.\n\n## Haiku 5.5\n\nAnthropic positions Haiku 5.5 for [high-volume, cost-sensitive work](https://www.anthropic.com/claude-haiku-5-5) such as summaries, compaction, database queries, and classification, and as a subagent alongside Opus 5.5 and Sonnet 5.5. It is available on the Claude Platform, **[Amazon Web Services](https://aws.amazon.com/blogs/machine-learning/introducing-claude-haiku-5-5-on-aws/)**, Google Cloud, and Microsoft Azure. Its safety evaluations are documented in the [system card](https://www.anthropic.com/claude-haiku-5-5-system-card). [Anthropic's deprecation page](https://platform.claude.com/docs/en/about-claude/model-deprecations) lists the earliest retirement date as October 7, 2027.\n\n## What's New Compared With Haiku 4.5?\n\n| Feature | Haiku 4.5 | Haiku 5.5 | \n|---|---|---|\n| Context window | 200K tokens | [1M tokens](https://platform.claude.com/docs/en/models/haiku-5-5/whats-new-haiku-5-5) | \n| Max output | 64K tokens | [128K tokens](https://platform.claude.com/docs/en/models/haiku-5-5/whats-new-haiku-5-5) | \n| Thinking control | Manual thinking budget | [Adaptive thinking with an effort setting, a first for a Haiku](https://www.anthropic.com/claude-haiku-5-5) | \n| Price per million tokens, prompts up to 100K (input / output) | \\$1.00 / \\$5.00 | [\\$0.10 / \\$0.50](https://www.anthropic.com/claude-haiku-5-5) | \n| Price over 100K | \\$1.00 / \\$5.00 | [\\$0.50 / \\$2.50](https://www.anthropic.com/claude-haiku-5-5) | \n| Smallest cacheable prompt | 4,096 tokens | [512 tokens](https://platform.claude.com/docs/en/models/haiku-5-5/whats-new-haiku-5-5) | \n| GDPval-AA (knowledge work) | 735 | [1620](https://www.anthropic.com/claude-haiku-5-5) | \n| OSWorld 2.1, offline subset (computer use) | 15.7% | [72.4%](https://www.anthropic.com/claude-haiku-5-5) | \n| Humanity's Last Exam, no tools | 10.2% | [45.9%](https://www.anthropic.com/claude-haiku-5-5) | \n| Terminal-Bench 4.0 (agentic coding) | 0.0% | [39.2%](https://www.anthropic.com/claude-haiku-5-5) | \n\nThe benchmark rows are Anthropic's own results, and the [launch page](https://www.anthropic.com/claude-haiku-5-5) shows Sonnet 5.5 ahead on all four (for example, 70.6% on Terminal-Bench 4.0). The price cut is also smaller in practice than the list prices suggest. Haiku 5.5 uses a newer tokenizer, so the same text counts as [roughly 30% more tokens](https://platform.claude.com/docs/en/models/haiku-5-5/whats-new-haiku-5-5). Anthropic puts the average saving at [around 75%](https://www.anthropic.com/claude-haiku-5-5), after accounting for the tokenizer and for the 10% of requests that run over 100K tokens.\n\nThree changes can break existing Haiku 4.5 code. The [what's-new page](https://platform.claude.com/docs/en/models/haiku-5-5/whats-new-haiku-5-5) lists them as breaking: sending `temperature`, `top_p`, or `top_k` returns an error, ending the messages with an assistant prefill returns an error, and manual thinking with `budget_tokens` returns an error. Two behavior changes matter as well. Adaptive thinking is on by default, so a response can start with a thinking block, and thinking tokens count toward `max_tokens`. Safety classifiers can also decline a request, so your code must handle `stop_reason: \"refusal\"`. On safety, Anthropic says Haiku 5.5's [cybersecurity safeguards](https://www.anthropic.com/claude-haiku-5-5) are stricter than Haiku 4.5's and block penetration testing.\n\n## Using Haiku 5.5 for Fast, Cheap Workflows\n\nYou need Python 3.10 or newer, an API key from the Claude Console, and a recent Anthropic SDK, since the code below uses the newer `output_config` parameter.\n\n```\npip install -U anthropic\nexport ANTHROPIC_API_KEY=\"your-key-here\"\n```\n\nThe first command installs or upgrades the official Python SDK. The second stores your key in the shell session, and the SDK reads `ANTHROPIC_API_KEY` automatically. On Windows PowerShell, use `$env:ANTHROPIC_API_KEY=\"your-key-here\"`.\n\n#### Step 1: Classification and Extraction\n\nThese are the two jobs Haiku was built for: a short input and a short, structured answer, repeated thousands of times. The code uses JSON outputs, which constrain the reply to a schema you provide. It also holds the shared price table and a cost helper that the next two scripts reuse.\n\n```\n# haiku_tasks.py\n\"\"\"Fast, cheap Claude Haiku 5.5 calls: classification and extraction with JSON outputs.\"\"\"\nimport json\n\nimport anthropic\n\nMODEL = \"claude-haiku-5-5\"\nclient = anthropic.Anthropic()    # reads ANTHROPIC_API_KEY from the environment\n\n# USD per million tokens (input, output) for prompts up to 100K tokens.\nPRICES = {\n    \"claude-haiku-5-5\": (0.10, 0.50),\n    \"claude-sonnet-5-5\": (2.00, 10.00),\n    \"claude-opus-5-5\": (4.00, 20.00),\n}\n\nCATEGORY_SCHEMA = {\n    \"type\": \"object\",\n    \"properties\": {\"category\": {\"type\": \"string\", \"enum\": [\"billing\", \"shipping\", \"technical\", \"other\"]}},\n    \"required\": [\"category\"],\n    \"additionalProperties\": False,\n}\n\nINVOICE_SCHEMA = {\n    \"type\": \"object\",\n    \"properties\": {\n        \"vendor\": {\"type\": \"string\"},\n        \"invoice_number\": {\"type\": \"string\"},\n        \"total\": {\"type\": \"number\"},\n        \"currency\": {\"type\": \"string\"},\n        \"due_date\": {\"type\": \"string\", \"description\": \"ISO date, YYYY-MM-DD\"},\n    },\n    \"required\": [\"vendor\", \"invoice_number\", \"total\", \"currency\", \"due_date\"],\n    \"additionalProperties\": False,\n}\n\ndef cost_usd(model, usage):\n    price_in, price_out = PRICES[model]\n    return (usage.input_tokens * price_in + usage.output_tokens * price_out) / 1_000_000\n\ndef ask_json(schema, instruction, text, model=MODEL, effort=\"low\"):\n    \"\"\"One request whose reply must be JSON matching `schema`. Returns (data, usage).\"\"\"\n    reply = client.messages.create(\n        model=model,\n        max_tokens=1000,    # thinking tokens count toward this limit, so leave headroom\n        system=instruction,\n        messages=[{\"role\": \"user\", \"content\": text}],\n        output_config={\"effort\": effort, \"format\": {\"type\": \"json_schema\", \"schema\": schema}},\n    )\n    if reply.stop_reason in (\"refusal\", \"max_tokens\"):\n        raise RuntimeError(f\"No usable answer, stop reason: {reply.stop_reason}\")\n    # A reply can start with a thinking block, so pick the text block by type.\n    answer = \"\".join(block.text for block in reply.content if block.type == \"text\")\n    return json.loads(answer), reply.usage\n\ndef classify(text, model=MODEL):\n    data, usage = ask_json(CATEGORY_SCHEMA, \"Classify the customer message.\", text, model)\n    return data[\"category\"], usage\n\ndef extract_invoice(text, model=MODEL):\n    data, usage = ask_json(INVOICE_SCHEMA, \"Extract the invoice fields from the text.\", text, model)\n    return data, usage\n\nif __name__ == \"__main__\":\n    for message in [\"I was charged twice this month.\", \"My parcel never arrived.\", \"The app crashes on login.\"]:\n        category, usage = classify(message)\n        print(f\"{category:<10} {usage.input_tokens} in / {usage.output_tokens} out  <- {message}\")\n\n    invoice = \"Acme Cloud Ltd, invoice AC-2291. Total due: 1,240.50 USD by 15 November 2026.\"\n    fields, usage = extract_invoice(invoice)\n    print(fields, f\"(${cost_usd(MODEL, usage):.6f})\")\n```\n\n`PRICES` lists input and output prices per million tokens for the three models (from Anthropic's [launch page](https://www.anthropic.com/claude-haiku-5-5) and [pricing page](https://platform.claude.com/docs/en/about-claude/pricing)), and `cost_usd` turns a response's token counts into dollars. The two schemas describe the output you want: `CATEGORY_SCHEMA` limits `category` to four allowed values, and `INVOICE_SCHEMA` lists five fields.\n\n`ask_json` is the core function. It sends one request with the schema inside `output_config.format`, and `effort` set to `low`, so the model spends little time thinking on an easy task. Anthropic's [JSON outputs](https://platform.claude.com/docs/en/build-with-claude/structured-outputs) guarantee valid JSON that matches the schema. Notice what is missing: there is no `temperature`, because Haiku 5.5 rejects it. `max_tokens` is 1000 even though answers are tiny, since thinking tokens count against it. Two checks follow. A stop reason of `refusal` or `max_tokens` raises an error instead of failing silently on a half-empty reply. Then the text is read by block type, because a reply may begin with a thinking block, and parsed as JSON.\n\nI used JSON outputs instead of forcing a tool call on purpose. Haiku 5.5 [accepts a forced tool call](https://platform.claude.com/docs/en/models/haiku-5-5/migration-guide), but Opus 5.5 [rejects one with a 400 error](https://platform.claude.com/docs/en/models/opus-5-5/whats-new-opus-5-5), so JSON outputs are the portable choice for the three-model comparison in Step 3. One caveat: JSON outputs are [not available on Amazon Bedrock](https://platform.claude.com/docs/en/models/haiku-5-5/whats-new-haiku-5-5) for Haiku 5.5, so on Bedrock you describe the format in the prompt and validate the result yourself. Run it:\n\n```\npython haiku_tasks.py\n```\n\nThe `__main__` block classifies three messages and extracts fields from one invoice, printing the tokens used and the cost of the extraction. Expect one category per message and a dictionary with five fields.\n\n#### Step 2: Sub-Agents\n\nA sub-agent setup splits the work. A larger model decides what to do and writes the final answer, while many Haiku workers handle the narrow, repetitive jobs in parallel. This is the pattern Anthropic names for Haiku, and [Cognition reports](https://www.anthropic.com/claude-haiku-5-5) using Haiku 5.5 as the sidekick in Devin Fusion with Opus 5.5 as the lead.\n\n```\n# subagents.py\n\"\"\"A lead model delegates narrow jobs to parallel Haiku 5.5 workers, then writes the answer.\"\"\"\nimport asyncio\n\nimport anthropic\n\nfrom haiku_tasks import MODEL as WORKER, cost_usd\n\nLEAD = \"claude-sonnet-5-5\"\nclient = anthropic.AsyncAnthropic()\n\ndef text_of(reply):\n    return \"\".join(block.text for block in reply.content if block.type == \"text\")\n\nasync def summarize(name, document, limit):\n    async with limit:    # cap how many workers run at once\n        reply = await client.messages.create(\n            model=WORKER,\n            max_tokens=1500,\n            system=\"Summarize the document in two sentences. Keep names, dates and amounts exact.\",\n            messages=[{\"role\": \"user\", \"content\": document}],\n            output_config={\"effort\": \"low\"},\n        )\n    return name, text_of(reply), cost_usd(WORKER, reply.usage)\n\nasync def answer(documents, question):\n    limit = asyncio.Semaphore(8)\n    notes = await asyncio.gather(*(summarize(n, d, limit) for n, d in documents.items()))\n    worker_cost = sum(cost for _, _, cost in notes)\n\n    brief = \"\\n\".join(f\"[{name}] {summary}\" for name, summary, _ in notes)\n    reply = await client.messages.create(\n        model=LEAD,\n        max_tokens=2000,\n        system=\"You are the lead analyst. Answer using only the worker notes.\",\n        messages=[{\"role\": \"user\", \"content\": f\"Question: {question}\\n\\nWorker notes:\\n{brief}\"}],\n        output_config={\"effort\": \"medium\"},\n    )\n    return text_of(reply), worker_cost, cost_usd(LEAD, reply.usage)\n\nif __name__ == \"__main__\":\n    documents = {\n        \"contract-a\": \"Northwind renewed its support contract on 3 March 2026 for 48,000 USD per year.\",\n        \"contract-b\": \"Contoso signed a 12-month license on 9 May 2026. The fee is 15,500 USD, billed quarterly.\",\n        \"contract-c\": \"Fabrikam's agreement ends on 30 June 2026 and renews only if either party gives notice.\",\n    }\n    text, worker_cost, lead_cost = asyncio.run(answer(documents, \"Which agreements need action before July 2026?\"))\n    print(text)\n    print(f\"workers: ${worker_cost:.6f}  lead: ${lead_cost:.6f}\")\n```\n\n**summarize** is one worker. It asks Haiku for a two-sentence summary at low effort and returns the document name, the summary, and the cost. The `Semaphore` caps how many workers run at the same time, which keeps you inside your rate limits. **answer** starts every worker at once with `asyncio.gather`, adds up the worker cost, and then sends only the short summaries to the lead model — here Sonnet 5.5 at its default effort. The lead never reads the full documents, and that is where the savings come from. The function returns the answer plus both costs, so you can see where the money went.\n\n#### Step 3: Comparing Cost and Latency\n\nPublished numbers only go so far, so this script runs the same classification task on all three models and measures accuracy, latency, and cost on your own account.\n\n```\n# compare_models.py\n\"\"\"Run the same classification task on three models and compare accuracy, latency and cost.\"\"\"\nimport statistics\nimport time\n\nfrom haiku_tasks import classify, cost_usd\n\nMODELS = [\"claude-haiku-5-5\", \"claude-sonnet-5-5\", \"claude-opus-5-5\"]\n\nTICKETS = [\n    (\"I was charged twice for my last order.\", \"billing\"),\n    (\"Please send me a copy of my invoice.\", \"billing\"),\n    (\"Where is my package? It was due on Monday.\", \"shipping\"),\n    (\"My order was delivered to the wrong building.\", \"shipping\"),\n    (\"The app crashes every time I open settings.\", \"technical\"),\n    (\"I cannot log in even after resetting my password.\", \"technical\"),\n    (\"Can you tell me about your company history?\", \"other\"),\n    (\"My card was declined but the money left my account.\", \"billing\"),\n]\n\ndef run(model):\n    seconds, cost, hits, output_tokens = [], 0.0, 0, 0\n    for text, label in TICKETS:\n        start = time.perf_counter()\n        category, usage = classify(text, model)\n        seconds.append(time.perf_counter() - start)\n        hits += category == label\n        cost += cost_usd(model, usage)\n        output_tokens += usage.output_tokens\n    n = len(TICKETS)\n    return hits / n, statistics.median(seconds), cost / n * 1000, output_tokens / n\n\nif __name__ == \"__main__\":\n    print(f\"{'model':<20}{'accuracy':>9}{'median s':>10}{'$/1k calls':>12}{'out tok':>9}\")\n    for model in MODELS:\n        try:\n            accuracy, median_s, per_thousand, out_tokens = run(model)\n        except Exception as error:    # for example, a model or platform that rejects the request\n            print(f\"{model:<20} failed: {error}\")\n            continue\n        print(f\"{model:<20}{accuracy:>9.0%}{median_s:>10.2f}{per_thousand:>12.3f}{out_tokens:>9.0f}\")\n```\n\n**run** sends each of the eight test messages through `classify` with a chosen model and records the time, cost, correctness, and output tokens. `per_thousand` converts the average to dollars per 1,000 requests. The main block runs Haiku, Sonnet, and Opus in turn and prints one row each. If a model or platform rejects the request, the script prints the error and moves on. Eight messages are a smoke test, so replace them with samples from your own traffic before you decide anything.\n\n```\npython compare_models.py\n```\n\nWhile you wait for your own numbers, list prices give a clean comparison. Take a classification call with 300 input tokens and 30 output tokens, and ignore thinking tokens. At the [published prices](https://platform.claude.com/docs/en/about-claude/pricing), that costs:\n\n| Model | Input / output per million tokens | Cost per 1,000 calls | \n|---|---|---|\n| Haiku 5.5 | \\$0.10 / \\$0.50 | \\$0.045 | \n| Sonnet 5.5 | \\$2.00 / \\$10.00 | \\$0.90 | \n| Opus 5.5 | \\$4.00 / \\$20.00 | \\$1.80 | \n\nThe cost per 1,000 calls is (300 × input price + 30 × output price) ÷ 1,000,000 × 1,000. This is arithmetic from list prices, not a measurement, and the three models share the same tokenizer family, so the token counts are comparable. On speed, Anthropic says Haiku 5.5 is its [fastest model at standard speed](https://www.anthropic.com/claude-haiku-5-5), though Opus models in Fast Mode are quicker. Customers report the gap in practice: Asana saw [over 30% lower task latency](https://www.anthropic.com/claude-haiku-5-5) than the model it uses today, and Box measured [about half the latency of Haiku 4.5](https://www.anthropic.com/claude-haiku-5-5).\n\n## When to Reach for Haiku, and When Not To\n\nReach for Haiku 5.5 when the task is narrow, the volume is high, or a person is waiting: classification, routing, extraction, summaries, compaction, and sub-agent work. AlphaSense reported that Haiku 5.5 beat Haiku 4.5 on its document question-answering workload — [0.84 against 0.76](https://www.anthropic.com/claude-haiku-5-5) — on a job that makes about 8 million calls a week. Stay with Sonnet 5.5 or Opus 5.5 for complex agentic coding, where Anthropic says the larger models [remain the better choice](https://www.anthropic.com/claude-haiku-5-5). The gap is visible in the benchmarks above. A good rule is to start with Haiku on every high-volume step, test it on a sample of your real data, and move a step up only where the results fall short.\n\n## Wrapping Up\n\nHaiku 5.5 also has a longer runway than its predecessor. Anthropic lists its earliest retirement at [October 7, 2027](https://platform.claude.com/docs/en/about-claude/model-deprecations), while Haiku 4.5's earliest date is October 15, 2026 — which is today, though it is still listed as active and Anthropic commits to advance notice before retiring a model. The SDKs also gained [beta support for computer use and browser use](https://www.anthropic.com/claude-haiku-5-5), the tasks Anthropic says suit a fast, cheap model. My read is that more agent work will move to small models running in parallel under a larger planner, since the evidence so far from Anthropic's customers points that way. That is an expectation, not a promise.\n\nTo recap: Haiku 5.5 cuts list prices by 90% for most prompts and adds adaptive thinking, a 1M context window, and a large jump on Anthropic's benchmarks. Migrating means dropping sampling parameters and prefill, reading content blocks by type, and budgeting for more tokens. Use it for classification, extraction, and sub-agents, measure it against Sonnet and Opus on your own data, and escalate only when it falls short.\n\n \n\n \n\n[**\\[Shittu Olumide\\](https://www.linkedin.com/in/olumide-shittu/)**](https://www.linkedin.com/in/olumide-shittu) is a software engineer and technical writer passionate about leveraging cutting-edge technologies to craft compelling narratives, with a keen eye for detail and a knack for simplifying complex concepts. You can also find Shittu on [Twitter](https://twitter.com/Shittu_Olumide_).", "url": "https://wpnews.pro/news/claude-haiku-5-5-whats-new-and-how-to-use-it-for-fast-cheap-ai-workflows", "canonical_source": "https://www.kdnuggets.com/claude-haiku-5-5-whats-new-and-how-to-use-it-for-fast-cheap-ai-workflows", "published_at": "2026-10-19 16:00:00+00:00", "updated_at": "2026-10-19 16:18:47.092845+00:00", "lang": "en", "topics": ["large-language-models", "artificial-intelligence", "ai-products", "ai-tools", "ai-agents"], "entities": ["Anthropic", "Claude Haiku 5.5", "Claude Haiku 4.5", "Claude Sonnet 5.5", "Claude Opus 5.5", "Amazon Web Services", "Google Cloud", "Microsoft Azure"], "also_reported_by": [], "alternates": {"html": "https://wpnews.pro/news/claude-haiku-5-5-whats-new-and-how-to-use-it-for-fast-cheap-ai-workflows", "markdown": "https://wpnews.pro/news/claude-haiku-5-5-whats-new-and-how-to-use-it-for-fast-cheap-ai-workflows.md", "text": "https://wpnews.pro/news/claude-haiku-5-5-whats-new-and-how-to-use-it-for-fast-cheap-ai-workflows.txt", "jsonld": "https://wpnews.pro/news/claude-haiku-5-5-whats-new-and-how-to-use-it-for-fast-cheap-ai-workflows.jsonld"}}