Claude Sonnet 5.5: Near-Opus Coding at Half the Price

Sonnet 5 shipped on June 30, 2026. Sonnet 5.5 replaced it on September 28, 2026 at the same list price, and almost everything else moved:

Data verified October 9, 2026 against Anthropic's Sonnet 5.5 model page, its pricing page, the launch post, and the Claude Code changelog.

The other pricing detail worth knowing is the one that is missing: Sonnet 5.5 has no long-context premium. A prompt near the 1M-token limit costs the same per token as a short one. Among current Claude models only Claude Haiku 5.5 has a price step, above 100K-token prompts, and OpenAI's GPT-6 models bill 2x input and 1.5x output once a prompt passes 272K input tokens.

These are the vendor-published numbers from Anthropic's launch post, next to the previous Sonnet, the current Opus, and GPT-6 Sol, the OpenAI model Anthropic chose to compare against. A dash marks a score Anthropic did not publish.

Three readings. Against Sonnet 5 the jump is enormous: 10.3% to 70.6% on Terminal-Bench 4.0 and 34.1% to 55.5% on CursorBench. Against Opus 5.5 the margins are small either way: Sonnet 5.5 leads Terminal-Bench by 4.2 points against Opus at xhigh and trails by 2 Elo on GDPval-AA, while Opus 5.5 leads FrontierCode by 2.3 points and CursorBench by 2.3. And Sonnet's FrontierCode figure is at xhigh effort: at max it scored 46.2%, so more effort is not automatically a better result.

GPT-6 Sol's GDPval-AA figure is OpenAI's own, as quoted by Anthropic. The table does not include GPT-6.1 Sol, which shipped on September 29, 2026, the day after Sonnet 5.5. All figures are vendor-published; we have not reproduced them.

Sonnet 5.5 costs half of Opus 5.5 on every rate: input, output and cache reads. Against the rest of the current lineup, every multiple below is computed from list prices:

A worked example, with the same profile our Opus vs Sonnet vs Haiku comparison uses: one feature card at 300K input and 60K output tokens.

One feature card: 300K input + 60K output tokens

Haiku 5.5   0.3M x $0.10 + 0.06M x $0.50  = $0.06   prompts up to 100K tokens
Haiku 5.5   0.3M x $0.50 + 0.06M x $2.50  = $0.30   prompts above 100K tokens
Sonnet 5.5  0.3M x $2 + 0.06M x $10       = $1.20
Opus 5.5    0.3M x $4 + 0.06M x $20       = $2.40
Fable 5.1   0.3M x $10 + 0.06M x $50      = $6.00

Three things the table hides. Thinking tokens bill as output, and Sonnet 5.5 always thinks, so the effort level moves the output side of the bill. Prompt caching moves the input side: an agent session re-reads its context at $0.10 per MTok on Sonnet 5.5, against $0.20 on Opus 5.5 and $0.25 on Fable 5.1, so on a cache-heavy session Fable's premium over Sonnet shrinks to 2.5x on input while output stays at 5x. And Haiku 5.5's line depends on prompt size: requests above 100K tokens bill at $0.50/$2.50, 5x its short-prompt rate. The math also assumes identical token counts; Anthropic reports Sonnet 5.5 spends up to 30% less per task than Sonnet 5 at the same token prices.

The opusplan pattern: Opus plans, Sonnet executes

Claude Code's opusplan setting runs Opus in plan mode and Sonnet when executing. The 5.5 generation gives it a data argument: Opus 5.5 keeps its lead on FrontierCode and CursorBench, so the stronger model writes the plan, and the execution phase, heavy on edits, builds and test runs, lands on the model with the better Terminal-Bench score. On the same feature, with planning at 50K input and 10K output tokens:

Opus 5.5 plans      0.05M x $4 + 0.01M x $20    = $0.40
Sonnet 5.5 builds   0.25M x $2 + 0.05M x $10    = $1.00
opusplan total                                  = $1.40
All on Opus 5.5                                 = $2.40

That is 42% less than running the whole feature on Opus 5.5, with the flagship still making the architectural calls. The split works when the plan survives contact with the code. On exploratory debugging, where the plan changes mid-implementation, stay on Opus 5.5 end to end; on a routine card, skip Opus and let Sonnet 5.5 plan too. The full playbook is in model routing for coding agents.

Sonnet 5.5 narrows the gap to Opus 5.5; it does not erase it. Opus 5.5 still leads on FrontierCode v1.1 (54.4% vs 52.1% at xhigh), CursorBench 4.0 (57.8% vs 55.5%), Humanity's Last Exam with tools (67.7% vs 64.5%) and OSWorld 2.1 (81.8% vs 80.1%), and Anthropic's own selection guide still says most workloads start with Opus 5.5.

Opus 5.5 has been Claude Code's default model on Pro, Max, Team, Enterprise and API plans since v2.1.280, so Sonnet 5.5 is something you choose. From v2.1.284, /model sonnet resolves to Sonnet 5.5; on older versions the alias still points at the previous Sonnet, so update the CLI first. Claude Code runs Sonnet 5.5 at medium effort by default, where the API defaults to high.

# inside a Claude Code session
/model sonnet        # Sonnet 5.5 from Claude Code v2.1.284
/effort high         # raise effort for this session (default: medium)
/model opusplan      # Opus in plan mode, Sonnet when executing

# from the shell
claude --model claude-sonnet-5-5 --effort high
CLAUDE_CODE_EFFORT_LEVEL=high claude --model claude-sonnet-5-5

To make a level stick, set effortLevel in your Claude Code settings, or set it per model with modelSettings. For a single hard turn, write “ultrathink” in the prompt to ask for deeper reasoning without changing the session's effort.

On the API, it is a new model ID plus six behavior changes from Sonnet 5. A minimal request at the lowest thinking setting:

{
  "model": "claude-sonnet-5-5",
  "max_tokens": 32000,
  "thinking": { "type": "between_tools" },
  "output_config": { "effort": "medium" },
  "messages": [{ "role": "user", "content": "Fix the failing test in ..." }]
}

Full details are on Anthropic's Sonnet 5.5 model page. If a pipeline depends on thinking fully off or on sampling parameters, Claude Sonnet 5 is still served on the API for pinned workloads, at the same $2 in / $10 out per MTok.