Claude Haiku 5.5 is the first Haiku-class model with an adjustable effort setting. In the Messages API that setting is output_config.effort, and Haiku 5.5 takes all five levels: low, medium, high, xhigh and max.

A request that never sets effort runs at medium. Most Claude models default to high, with Opus 5.5 as the other exception, so code shared across models can land on different levels unless it sets effort itself. On Haiku 5.5, sending "medium" is exactly the same as leaving the field out.

Effort applies to every token in the response: the text, the tool calls and their arguments, and thinking when thinking is active. With tools in the loop, lower levels tend to make fewer calls and finish on a short confirmation, while higher levels may make more calls and explain a plan before acting. A level isn’t a token budget, though. At low the model still thinks when a problem is hard enough, only less than it would at a higher level.

medium is the suggested start for most work, including agentic coding. low, the cheapest and fastest level, fits chat, short tool tasks and simple requests that arrive in high volume, and high fits knowledge work, longer agent tasks and strict instruction following. xhigh and max are for work where a quality gain on your evals justifies the cost. Thinking and replies get much longer at those two levels, so it’s worth running the same evals on Claude Sonnet 5.5 and comparing performance, cost and speed.

low takes more thought in an agent. The effort docs warn that in long agent prompts the model is more likely to skip a search, stop early, or skip a check at that level. Early stopping depends on the prompt too: with a short system prompt it rarely happens, but with a long coding-agent prompt at low the model sometimes hands the task back before the work is done. The prompting guide offers a paragraph to add to the system prompt, and raising effort also reduces early stopping, at a higher cost. In Anthropic’s testing without that paragraph, moving from low to medium roughly halved early stopping and more than doubled the output tokens for each attempt. Whether those tokens are worth it depends on what a stopped run costs you.

Thinking

Thinking is on by default on Haiku 5.5, and it counts toward max_tokens. A small limit carried over from Haiku 4.5 can now end a response after a thinking block, before any text, so the number has to leave room for both.

To get less thinking, lower the effort level. Turning it off is a separate choice: thinking: {"type": "disabled"} works at high or below, and at xhigh or max the same request returns a 400 error, so thinking has to stay adaptive there. Running with it off also has recorded downsides. The model might skip a tool call it needs when you also request JSON output, and reasoning-like text shows up more often in the reply.

Changing effort partway through

On the Claude API and on Claude Models on Google Cloud (Google managed), Haiku 5.5 can run later turns of a conversation at a different level. Per-message effort is in beta and needs the mid-conversation-output-config-2026-07-01 header. The change is a system message with empty content, as in the docs’ example, shortened here and with the model swapped for Haiku 5.5:

response = client.beta.messages.create(
    model="claude-haiku-5-5",
    max_tokens=4096,
    output_config={"effort": "high"},
    messages=[
        {"role": "user", "content": "Plan a migration from SQLite to PostgreSQL in three short steps."},
        {"role": "assistant", "content": "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts."},
        {"role": "system", "content": [], "output_config": {"effort": "low"}},
        {"role": "user", "content": "Summarize the plan in one sentence."},
    ],
    betas=["mid-conversation-output-config-2026-07-01"],
)

Placed between an assistant turn and the next user turn, the new level applies from the next user turn with new input and holds until a later message changes it. A user turn holding only tool_result blocks doesn’t count as new input, so in a tool-use loop a change placed after tool results waits for the next user turn with new input.

So, going back to the example, the reason to change effort with a system message is the prompt cache. If the conversation is cached, nothing before the system message has changed and the cached prefix still matches. A new top-level value on the next request would change the level too, but because top-level effort shapes the rendered prompt, the cache starts over. Per-message changes need adaptive thinking, which is the default: with thinking: {"type": "disabled"}, a per-message effort that differs from the level in effect returns a 400 error.

The prompting guide suggests comparing two or three levels on your own evals. Now that a Haiku-class model has effort too, the model and the level can also be tested together, much like the Sonnet 5.5 comparison above. This note is written from Anthropic’s docs as they currently read. This area moves fast and a beta like per-message effort can change, so parts of it may date soon.