Claude Sonnet 5.5: The Workhorse Tier, Effort Levels and Cost

1. The launch facts

Sonnet 5.5 is available on the Claude API, Amazon Bedrock, Google Cloud, Microsoft Foundry and Claude Platform on AWS. The docs list one model ID, claude-sonnet-5-5, with no date suffix. Anthropic calls it the best combination of speed and intelligence; the launch page says Sonnet 5.5 is strongest at well-scoped everyday tasks, while Opus 5.5 is built for complex work that needs careful judgment.

Two defaults matter before you write any code. Adaptive thinking is on by default, so your output tokens include reasoning unless you lower effort. And the default effort on the Claude API is high, while Opus 5.5 and Haiku 5.5 default to medium: a request that omits effort runs a level higher on Sonnet than on its siblings. Anthropic says Claude Code and its apps default to medium.

2. What actually improved vs Sonnet 5

Per-token prices are the same, so the gain is capability and efficiency. On Anthropic’s launch table, Terminal-Bench 4.0 goes from 10.3% on Sonnet 5 to 70.6% on Sonnet 5.5, CursorBench 4.0 from 34.1% to 55.5%, and OSWorld 2.1 (partial) from 57.0% to 80.1%. Anthropic also says output is 30%+ faster and that Sonnet 5.5 costs up to 30% less per task in its testing, because it needs fewer tokens.

There is a quieter saving: cache reads cost $0.10 per million tokens, half of what Sonnet 5 charged. On the Haiku 5.5 launch page, Anthropic says that halving lowers Sonnet 5.5’s cost on most agentic tasks by about 20%. The API side gained too: a 512-token minimum for caching, per-message effort changes (beta) and mid-conversation system messages, none of which Sonnet 5 has.

Three changes that matter

3. Evidence, with sources

Every benchmark below comes from the table on Anthropic’s launch page, so read it as vendor-reported and directional. According to the page, GDPval-AA and AA-Briefcase were run by Artificial Analysis on a pre-release deployment that had a structured-outputs bug (since fixed, with a small effect expected), and Anthropic ran the others. In the Sonnet 5.5 column, only the FrontierCode row names its effort level.

Against Opus 5.5 the pattern is consistent. Opus leads on seven of the eight rows, by small margins: 2.3 points on CursorBench 4.0, 3.2 on Humanity’s Last Exam with tools, 2 Elo on GDPval-AA. Sonnet 5.5 leads on Terminal-Bench 4.0, 70.6% against 66.4% at Opus’s Xhigh effort. Customer results are quoted by Anthropic and describe their own suites.

4. Opus 5.5, Sonnet 5.5 or Haiku 5.5?

All three share a 1M-token context, 128K max output, a June 2026 knowledge cutoff and adaptive thinking. They differ in price, latency label and how much control you get over thinking. The table uses only values from Anthropic’s model pages and pricing docs; the benchmark row is vendor-reported.

Anthropic’s cost guide adds the one result I would anchor on, labelled internal and directional. On a SWE-bench Pro subset, Sonnet 5.5 at its default high solved 87.6% at $0.11 per solved task, and Opus 5.5 at low solved 87.4% at $0.12, which the guide calls inside run-to-run noise. Opus 5.5 at medium solved 92.8% at $0.22. Sonnet 5.5 at medium solved about 7 points fewer than at high, for about 59% of the cost per task (two runs each).

5. Effort levels and the quickstart

Effort is set in output_config.effort and needs no beta header. I will not repeat how the five levels work in general; what is specific to Sonnet 5.5 is below, followed by working code.

Below: a plain request with an explicit effort and a cached system prompt, then the between_tools form for code that used to send thinking disabled.

import anthropic

client = anthropic.Anthropic()

# Stable instructions. Sonnet 5.5 caches prompts of 512+ tokens.
STABLE_RULES = "...your stable instructions, 512+ tokens..."

response = client.messages.create(
    model="claude-sonnet-5-5",
    max_tokens=4096,                     # thinking counts toward max_tokens
    output_config={"effort": "medium"},  # the API default is "high"
    system=[
        {
            "type": "text",
            "text": STABLE_RULES,
            "cache_control": {"type": "ephemeral"},  # 5-minute cache by default
        }
    ],
    messages=[{"role": "user", "content": "Review this diff and list the risks: ..."}],
)

if response.stop_reason == "refusal":
    ...  # stop_details.category names the policy area
for block in response.content:  # a thinking block may come first
    if block.type == "text":
        print(block.text)
print(response.usage)  # cache_read_input_tokens, cache_creation_input_tokens, ...

tools = [...]  # your tool definitions
messages = [{"role": "user", "content": "..."}]

# Sonnet 5 sent: thinking={"type": "disabled"}  -> now a 400 invalid_request_error
response = client.messages.create(
    model="claude-sonnet-5-5",
    max_tokens=16000,
    thinking={"type": "between_tools"},  # up-front thinking off, no beta header
    output_config={"effort": "high"},    # low, medium or high; xhigh/max return a 400
    tools=tools,
    tool_choice={"type": "auto"},        # "any" and "tool" return a 400
    messages=messages,
)

# Short progress notes between tool calls still arrive as thinking blocks
# with summary text. Send the whole assistant turn back unchanged.
messages.append({"role": "assistant", "content": response.content})
# ...then run your tools and append the tool_result blocks as the next user turn.

With between_tools the model does not think before it answers. In a request without tools that means no reasoning step at all, and Anthropic’s prompting guide says to use adaptive thinking instead for tasks that need a few steps of working out, such as totaling figures or ranking items.

6. Migrating from Sonnet 5

Swap the model string to claude-sonnet-5-5, then check six things. Anthropic’s migration guide lists five breaking changes and one change that alters the response shape without failing any request. Existing Sonnet 5 prompts should perform well unchanged, and with Claude Managed Agents only the model name changes. Effort levels are recalibrated, so re-run your sweep.

# 1. thinking {"type": "disabled"}                -> 400
#    send {"type": "between_tools"} at high effort or below
# 2. tool_choice {"type": "any"} or {"type": "tool"} -> 400
#    send {"type": "auto"} and mark tools "strict": true (max 20 strict tools)
# 3. Thinking blocks are signed over the conversation:
#    keep history append-only, or replaying a block after an edit returns
#    a 400 (enforced by default on accounts created on or after 2026-08-31)
# 4. computer_20251124                              -> 400 on Claude API and
#    Google Cloud; use {"type": "computer_toolset_20260801"}
# 5. Advisor tool: Opus 4.8, Opus 4.7, Sonnet 5 and Haiku 5.5 advisors -> 400
# 6. Text between tool calls now arrives in thinking blocks, empty at the
#    default display ("omitted"): no error, but your UI goes quiet

The silent one is the sixth. Notes longer than a sentence or two between tool calls come back as progress-update thinking blocks, so a chat interface that renders only text blocks shows nothing during a long agentic turn. Fix it with between_tools, where the text comes back without any display field, or with adaptive thinking and display set to updates (beta, header thinking-display-updates-2026-08-18) or summarized.

7. The cost arithmetic

Every figure is a list price from Anthropic’s pricing page; the usage numbers are not mine. For the example I reuse the token counts Anthropic uses in its own worked example in the pricing docs, 50,000 input and 15,000 output tokens (it prices them on Opus 5.5), and run the same arithmetic on the other two tiers. Token cost only: I leave out the $0.08 session runtime in that Managed Agents example.

Output costs 5x input on all three tiers, and thinking tokens are billed as output. That is why effort, not the price list, is your main lever on Sonnet 5.5, and why a default of high deserves a deliberate check.

# 1M input + 1M output tokens
Opus 5.5   : 4.00 + 20.00 = $24.00
Sonnet 5.5 : 2.00 + 10.00 = $12.00   -> 24.00 / 12.00 = 2x
Haiku 5.5  : 0.10 +  0.50 =  $0.60   -> 12.00 / 0.60  = 20x (prompt <= 100k)

# one call: 50,000 input + 15,000 output tokens (Anthropic's pricing-docs example)
Opus 5.5   : 50,000 x 4 / 1M = 0.20     + 15,000 x 20 / 1M   = 0.30   = $0.50
Sonnet 5.5 : 50,000 x 2 / 1M = 0.10     + 15,000 x 10 / 1M   = 0.15   = $0.25
Haiku 5.5  : 50,000 x 0.10 / 1M = 0.005 + 15,000 x 0.50 / 1M = 0.0075 = $0.0125

# same call, 40,000 of the 50,000 input tokens are cache reads
Opus 5.5   : 0.04  + 40,000 x 0.20 / 1M = 0.008  + 0.30   = $0.348
Sonnet 5.5 : 0.02  + 40,000 x 0.10 / 1M = 0.004  + 0.15   = $0.174
Haiku 5.5  : 0.001 + 40,000 x 0.01 / 1M = 0.0004 + 0.0075 = $0.0089

# a static prefix of P tokens sent N times, 5-minute cache, Sonnet 5.5
no cache : N x P x 2.00 / 1M
cached   : (P x 2.50 + (N - 1) x P x 0.10) / 1M
per 1M prefix tokens: N=1 -> $2.00 vs $2.50 | N=2 -> $4.00 vs $2.60 | N=10 -> $20.00 vs $3.40

8. Honest limits: when not to use Sonnet 5.5

Anthropic’s prompting guide for 5.5 is blunt about where the model needs help. For the hardest long-horizon work it says an Opus model is the better choice, and its own numbers show Opus ahead on most rows.

9. What to do this week

Do not switch everything because of a price list. Pick one real workload, run it on Sonnet 5.5 and on your current model, and compare cost per completed task.

Verdict

Sonnet 5.5 is the tier I would test first for everyday agent and coding work: the same $2 / $10 as Sonnet 5, far better on Anthropic’s numbers, cache reads at half price and a thinking setting that finally lets you turn up-front reasoning off. Opus 5.5 still leads most rows by small margins at double the price, and Haiku 5.5 is the cheaper worker for narrow steps.

The catches are real but small: between_tools replaces disabled, forced tool use is gone, and the default effort is high. Choose by cost per completed task on your own hardest cases, keep one effort level per workload, and re-run the sweep instead of carrying settings over.