Claude Sonnet 5.5: Faster Coding, 1M Context, and New Agent Capabilities

Anthropic released Claude Sonnet 5.5 on September 28, 2026, positioning it as the Claude model with the best balance of speed and intelligence. At first glance, the release looks straightforward: faster generation, stronger coding performance, and the same $2/$10 per-million-token API pricing as Sonnet 5. But the more important changes are underneath.

Sonnet 5.5 introduces a different approach to reasoning control, new capabilities for long-running agents, dynamic tool management, conversation compaction, and several breaking API changes developers need to understand before upgrading.

Claude Sonnet 5.5 at a Glance

• Model ID: claude-sonnet-5-5
• Context window: 1 million tokens
• Maximum standard output: 128K tokens
• Batch API output: up to 300K tokens in beta
• Input price: $2 per million tokens
• Output price: $10 per million tokens
• Cache read: $0.20 per million tokens
• 5-minute cache write: $2.50 per million tokens
• 1-hour cache write: $4 per million tokens
• Batch API: 50% discount
• Thinking: adaptive
• Default API effort: high
• Knowledge and training cutoff: June 2026
• Release date: September 28, 2026

Anthropic’s official model documentation labels Sonnet 5.5 as a fast model while giving it a 1M-token context window and 128K maximum standard output. The Batch API can extend output to 300K tokens through beta functionality.

Coding Is Where Sonnet 5.5 Makes Its Biggest Jump

Anthropic is clearly positioning Sonnet 5.5 as a serious everyday coding model. Its published evaluations show substantial gains over Sonnet 5 on agentic coding benchmarks, including Terminal-Bench, CursorBench, and FrontierCode.

• Terminal-Bench 4.0: Sonnet 5.5 scored 70.6% versus 10.3% for Sonnet 5 in Anthropic’s published results.
• CursorBench 4.0: Sonnet 5.5 scored 55.5% versus 34.1% for Sonnet 5, with Opus 5.5 at 57.8%.
• FrontierCode 1.1: Sonnet 5.5 reached 46.2% at Max effort, while Opus 5.5 scored 54.4% in Anthropic’s chart.

These are vendor-reported benchmark results, so they should not be treated as universal real-world rankings. The more practical story is that Anthropic says Sonnet 5.5 batches tool calls more efficiently, completes tasks in fewer steps, and uses fewer output tokens than Sonnet 5. For coding agents, that can matter as much as raw benchmark accuracy.

Sonnet 5.5 vs Opus 5.5

Anthropic is not positioning Sonnet 5.5 as a replacement for Opus. Instead, the two increasingly look like different layers of the same development workflow.

Use Sonnet 5.5 for

• Feature implementation
• Bug fixing
• Refactoring
• Routine code review
• Well-defined agent tasks
• UI implementation
• Repeated development iterations
• Tool-heavy workflows where speed and cost matter

Use Opus 5.5 for

• Architecture
• Difficult debugging
• Ambiguous technical problems
• Complex planning
• Open-ended reasoning
• Long-running tasks requiring sustained judgment

A practical pattern is to let Opus handle architecture and difficult decisions, then hand well-scoped implementation work to Sonnet. That architect-builder model can be more cost-effective than running the most expensive model for every step.

Adaptive Thinking Becomes the Main Control

Sonnet 5.5 uses adaptive thinking, with the effort parameter controlling how much computation and token usage the model applies. The Claude API defaults to high effort, while Anthropic recommends reevaluating effort levels rather than copying Sonnet 5 configurations directly.

• Low: simple operations and high-volume work
• Medium: routine implementation and well-defined multi-step tasks
• High: complex debugging and longer-running work
• XHigh or Max where supported: the hardest reasoning tasks

For agent builders, this means routing can happen not only between models but also between effort levels inside the same model. A repository lookup does not need the same reasoning budget as an architectural decision.

Traditional Sampling Controls Are Going Away

Sonnet 5.5 does not accept custom non-default values for temperature, top_p, and top_k. Unsupported values return an HTTP 400 error. Anthropic is increasingly steering developers toward prompts, system instructions, effort levels, adaptive thinking, structured outputs, and strict tool schemas instead of traditional sampling controls.

Five Breaking Changes Developers Need to Know

1. thinking: disabled Is Replaced

Sonnet 5.5 no longer accepts thinking: disabled. Developers who want to skip initial up-front reasoning while still allowing reasoning between tools should use thinking type between_tools. The old configuration returns a 400 error.

{
  "thinking": {
    "type": "between_tools"
  }
}

2. Forced Tool Calls Are No Longer Supported

Sonnet 5.5 rejects tool_choice configurations that force any tool or a specific named tool. Supported behavior centers on auto and none. If an application needs schema-valid tool calls, Anthropic recommends automatic tool selection with strict tool use or structured outputs.

3. Thinking Blocks Are Bound to the Conversation

Sonnet 5.5 thinking blocks have stronger relationships with the model, conversation history, system instructions, tool definitions, and originating account. Modifying earlier history and replaying an existing thinking block can produce an API error. For persistent agents, the safest architecture is increasingly append-only conversation history.

4. Computer Use Has a New Toolset

On the Claude API and Google Cloud, older computer-use integrations need to move from computer_20251124 to computer_toolset_20260801. Agent loops may also need to handle toolset-member calls, batched actions, and updated result structures.

5. Advisor Compatibility Changed

Sonnet 5.5 changes which Claude models can act as advisors. Newer models from the Opus, Fable, Mythos, and Sonnet families are supported, while some combinations involving older models that worked with Sonnet 5 are rejected when Sonnet 5.5 is the executor.

Dynamic Tools Could Be a Big Deal for Agents

One of Sonnet 5.5’s most interesting capabilities is mid-conversation tool changes. Anthropic also introduced a beta capability called Define tools in a message. Using the inline-tools-2026-09-15 beta, an application can introduce an entire tool definition during an existing conversation.

That means a persistent assistant does not need every possible integration in its initial prompt. It can start with core tools such as GitHub, Notion, Calendar, or SSH, then load project-specific APIs, deployment controls, monitoring tools, or billing functions only when they become relevant.

• Less tool-schema information constantly occupying context
• Less confusion between dozens of irrelevant tools
• Better prompt-cache reuse because the original tool list does not need to be rebuilt

Compact on Demand for Long-Running Agents

Long-running assistants eventually accumulate too much conversation history. Sonnet 5.5 supports a server-generated signed compaction block that summarizes previous conversation state. Applications can replace older messages with that block while continuing the conversation, giving persistent assistants a more native way to operate for long periods without resending their entire history.

Prompt Caching Gets Easier

Sonnet 5.5 lowers the minimum cacheable prompt size to 512 tokens, compared with 1,024 tokens for Sonnet 5. That makes caching practical for smaller agent configurations and system prompts, especially when combined with dynamic tools.

The Cost Story Is More Interesting Than the Token Price

Sonnet 5.5 keeps Sonnet 5’s standard API price at $2 per million input tokens and $10 per million output tokens. Anthropic’s more interesting claim is that Sonnet 5.5 can cost up to 30% less per completed task because it often uses fewer tokens and fewer steps.

For agent systems, cost per completed task is usually more meaningful than cost per token. A cheaper model that needs repeated retries, extra tool calls, and correction loops can cost more than a stronger model that completes the job efficiently.

A Better Model-Routing Strategy

• Simple or high-volume work → low-effort execution
• Routine implementation → Sonnet 5.5 at Medium effort
• Complex implementation or debugging → Sonnet 5.5 at High effort
• Architecture or ambiguous problems → Opus 5.5
• Implementation after architecture → Sonnet 5.5

The optimization space is no longer only “which model?” It is increasingly Model × Effort × Tools × Context.

What This Means for Claude Code Users

For developers using Claude as a coding agent, Sonnet 5.5 looks particularly suited to the repetitive middle layer of software development: exploring repositories, implementing scoped features, fixing bugs, changing multiple files, running tests, responding to compiler errors, refactoring, creating UI, reviewing changes, and iterating quickly.

That does not mean Sonnet should replace Opus for everything. A strong workflow is to let Opus handle architecture and difficult decisions, use Sonnet for implementation and iteration, and return to Opus for review only when the complexity justifies it.

Migration Checklist

1. Change the model ID to claude-sonnet-5-5.
2. Replace thinking: disabled with between_tools where needed.
3. Remove forced tool_choice: any and named-tool forcing.
4. Use strict tools or structured outputs where schema guarantees matter.
5. Treat conversation histories containing thinking blocks as append-only.
6. Update older computer-use integrations to computer_toolset_20260801 where required.
7. Review advisor-model compatibility.
8. Re-test effort levels instead of assuming Sonnet 5 settings behave identically.
9. Run your own coding and agent evaluations before moving production traffic.

The Bigger Picture

Claude Sonnet 5.5 is interesting not only because it is faster or because benchmark scores increased. The larger story is the architecture Anthropic is building around Claude: adaptive reasoning, dynamic effort, dynamic tools, mid-conversation system instructions, persistent thinking state, prompt caching, conversation compaction, computer use, advisor models, and long-running agent workflows.

Taken together, these features point toward AI systems that behave less like single-request chatbots and more like persistent software agents. The model itself still matters, but capability increasingly comes from how the model, tools, reasoning budget, context, and state work together.

Final Thoughts

Claude Sonnet 5.5 looks like one of Anthropic’s most practical models for developers. It keeps Sonnet-level pricing while Anthropic reports meaningful improvements in coding performance, execution efficiency, and latency.

The most important improvements may not be visible in benchmark charts. Dynamic tools, per-message effort, compaction, adaptive thinking, and conversation-aware reasoning make Sonnet 5.5 particularly interesting for serious AI agents. For everyday development, Sonnet increasingly looks like the execution model; for difficult architecture and open-ended judgment, Opus remains the stronger option according to Anthropic. Combining the two may ultimately be more useful than choosing only one.

FAQ

What is Claude Sonnet 5.5?

Claude Sonnet 5.5 is Anthropic’s Sonnet-class AI model released on September 28, 2026. Anthropic positions it as the best balance of speed and intelligence in the Claude lineup.

What is the Claude Sonnet 5.5 API model ID?

claude-sonnet-5-5

How large is Claude Sonnet 5.5’s context window?

Claude Sonnet 5.5 supports a 1-million-token context window.

How much does Claude Sonnet 5.5 cost?

Standard Claude API pricing is $2 per million input tokens and $10 per million output tokens, with additional savings available through prompt caching and the Batch API.

Can I directly replace Sonnet 5 with Sonnet 5.5?

Not always. There are multiple breaking API changes involving thinking configuration, forced tool use, thinking-block persistence, computer use, and advisor compatibility. Review Anthropic’s Sonnet 5.5 migration guidance before upgrading production integrations.

Sources

• Anthropic — Claude Sonnet 5.5 announcement
• Claude Platform — Sonnet 5.5 overview
• Claude Platform — What’s new in Sonnet 5.5