Claude Haiku 5.5: What’s New, Pricing & How to Try It

Claude Haiku 5.5 just dropped on October 7, and everyone's looking to see if it lives up to the hype—lower pricing, adjustable thinking effort, and a massive 1M-token context window. It is now live on Modellix as anthropic/claude-haiku-5.5.

Here’s the lowdown on what’s new, key subagent use cases where it really shines, and a quick prompt example to help you start testing it.

Claude Haiku 5.5 at a Glance

According to Anthropic’s October 2026 announcement, the model targets frequent, cost-sensitive tasks and can work alongside Opus or Sonnet as a coding subagent.

Here’s a quick look at the core specs and pricing to help you get a sense of where it fits:

The specs above highlight a clear industry shift. AI labs are no longer just racing for benchmark supremacy and they're optimizing for unit economics.

By pairing a 1M-token context window with sub-dollar pricing and adjustable thinking, Anthropic is directly targeting the cost bottleneck that has kept high-frequency agentic workflows stuck in experimental stages.

What’s New in Claude Haiku 5.5?

Repeated Tasks Cost Less per Token

Small tasks add up. An application that summarizes every conversation or extracts fields from every incoming document can generate a substantial bill even when each request is short.

Anthropic prices Haiku 5.5 90% lower per token than Haiku 4.5 for prompts up to 100,000 tokens, and 50% lower above that threshold.

The threshold matters: longer prompts raise both input and output rates. Token counts also change. Anthropic’s documentation says the updated tokenizer produces approximately 30% more tokens for the same text, depending on content.

Pro tip: A few runs with your own prompts will give you a better feel for the bill than the 90% headline discount alone.

On Modellix, the listed input and output rates are $0.09/$0.45 per million tokens for prompts up to 100K, and $0.45/$2.25 above 100K. Cached reads and writes are also 10% below Anthropic’s published rates in both tiers.

You Can Adjust How Much It Thinks

Some requests need a quick decision. Others need the model to work through dependencies before answering.

Haiku 5.5 adds adjustable effort, giving applications a way to choose how much reasoning a task receives. Its adaptive thinking can decide when additional thought is useful, while the effort setting helps steer the balance between quality, response time, and cost.

For a ticket classifier, speed may be the priority. For a code change involving several functions, more reasoning may help. Test the setting against a clear acceptance criterion.

It Can Read More Material at Once

According to Anthropic’s technical documentation, the context window grows from 200K to 1M tokens, while maximum output increases from 64K to 128K tokens.

That gives applications more room for documents, conversation history, or relevant code. A subagent can receive the specification and supporting files together, reducing the need to divide material across requests.

Even with a 1M-token window, a focused prompt makes the task easier to follow and avoids spending tokens on material you don’t need.

It Can Handle More of an Agent’s Execution Work

In its published evaluations, Anthropic reports a 39.2% score on Terminal-Bench 4.0, whereas Haiku 4.5 scored 0.0%. They also noted that Opus and Sonnet are still better options for complex agentic coding, which is where Haiku 5.5 comes in as a subagent.

A setup worth trying is to let Opus 5.5 handle the high-level planning, then pass smaller, well-defined edits to Haiku.

When to Use Haiku 5.5 as a Subagent

Start with tasks that have a clear input, a limited scope, and an output you can check. These are useful candidates to evaluate:

• Code refactoring and edits: Let Opus or Sonnet plan a change, then pass an isolated function and its requirements to Haiku. Run the returned code against existing tests before accepting it.
• Data extraction: Ask Haiku to extract named fields from documents into a defined JSON structure. The 1M-token window provides room for larger inputs, but prompts above 100K tokens use the higher pricing tier. Validate the fields against the source.
• Log and ticket triage: Classify records into predefined categories and return a short explanation. Route uncertain cases or high-impact decisions to the main agent or a person.

How to Try It on Modellix

You can start querying Haiku 5.5 on Modellix right now using the anthropic/claude-haiku-5.5 model ID.

Connecting is simple. Point your OpenAI-compatible clients to https://llm.modellix.ai/v1, or use https://llm.modellix.ai if you’re working natively with the Anthropic SDK or Claude Code. Toss your API key into either the Bearer token or x-api-key header, and you're good to go.

Ready to see what it can do? Here’s a low-stakes code-repair prompt to help you test the waters:

Fix the boundary error in this Python function. Preserve the rule that
negative and out-of-range indices return None. Return the corrected
function and assertions for an empty list, a valid index, an index equal
to the list length, and a negative index. Do not claim to have run them.

def get_item(items, index):
    if 0 <= index <= len(items):
        return items[index]
    return None

What We Saw in a Small Test

To see it in action, we sent this exact prompt to the anthropic/claude-haiku-5.5 Messages endpoint, with adaptive thinking enabled and output_config.effort set to low.

The results were spot on. The model correctly identified the inclusive upper-bound bug, changed the <= to <, and generated the four assertions we asked for. It also followed the constraint not to fake a test execution.

We ran those assertions locally to double-check. All four passed seamlessly, along with 45 additional boundary cases we tested independently.

Here is a quick breakdown of the request metrics:

Just to note: The estimated cost uses Modellix’s $0.09/$0.45 rate for prompts under 100K tokens. Keep in mind this was just a quick, low-effort repair task to verify functionality, not a rigorous latency benchmark or an effort-level comparison.

Try the Request Yourself

You can reproduce this exact test on your machine. Just set your MODELLIX_API_KEY environment variable and run the following in your terminal:

curl -sS "https://llm.modellix.ai/v1/messages" \
  -H "Authorization: Bearer ${MODELLIX_API_KEY}" \
  -H "Content-Type: application/json" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "anthropic/claude-haiku-5.5",
    "max_tokens": 4096,
    "thinking": {"type": "adaptive"},
    "output_config": {"effort": "low"},
    "messages": [{
      "role": "user",
      "content": "Fix the boundary error in this Python function. Preserve the rule that negative and out-of-range indices return None. Return the corrected function and assertions for an empty list, a valid index, an index equal to the list length, and a negative index. Do not claim to have run them.\n\ndef get_item(items, index):\n    if 0 <= index <= len(items):\n        return items[index]\n    return None"
    }]
  }'

Just to note: The original recorded run used an optional X-Mdlx-User-Id header to track request logs on our end, but we’ve stripped it here since you don’t need it for a basic model call.

A successful response confirms that Modellix fully supports adaptive thinking and output_config.effort: low for Haiku 5.5. And remember, the 1M context window is an input limit, not an API parameter you have to explicitly set. For a focused task like this, sending just the function and its constraints is all the model needs.

Ready to give it a try?

An easy way to get a feel for Haiku 5.5 is to give it a small job you know well, such as a script cleanup or a few fields to extract from a document. You’ll have something concrete to compare with your usual workflow.