Claude Sonnet 5.5 vs Opus 5.5 for Coding

A coding agent never sends just one request. It reads files, runs the test suite, edits, and runs it again, and every one of those turns bills input, cache reads and output on whichever model the job started on, so the model choice gets multiplied by every tool call the agent makes.

Anthropic's price list makes that choice look simple: Claude Opus 5.5 costs exactly twice as much as Claude Sonnet 5.5 for every kind of token. Anthropic's own measurements say the price list is the wrong place to look. On a subset of SWE-bench Pro, Opus 5.5 at low effort solved 87.4% of tasks for $0.12 per solved task, while Sonnet 5.5 at its default high effort solved 87.6% for $0.11, according to Anthropic's cost guide as of November 9, 2026.

So the real decision is a model and an effort level together. Sonnet 5.5 at its default is the cheapest way to get about 88% of those tasks done. Opus 5.5 at its default solves 92.8% for twice the cost per solved task. Once a failed task costs a developer even a few minutes, Opus 5.5 at low with its failures re-run at high is the cheapest policy of all. One example runs through every section below: a CI bot that tries to fix 2,000 failing test jobs a month for a US team, with the test suite deciding whether each fix worked.

What Each Model Costs per Token

Anthropic launched Claude Opus 5.5 on September 22, 2026 and Claude Sonnet 5.5 on September 28, 2026, per the Claude Platform release notes. Both have a 1M-token context window billed at standard rates, 128K max output tokens, a June 2026 knowledge cutoff and the same rate limits in every usage tier. The Start tier gives each model 4,000 requests, 2 million input tokens and 400,000 output tokens per minute.

The prices come from Anthropic's pricing page, checked November 9, 2026, in USD per million tokens:

Every column is exactly 2x, cache reads included. Sonnet 5.5 read its cache at $0.20 until October 7, 2026, when Anthropic cut it to $0.10, so both models now bill cache hits at 5% of the input price instead of the usual 10%. Anthropic says cache reads make up the majority of agentic and coding costs, because an agent rereads its cached repository context on every turn, so this rate matters more than the headline ones. Fast mode, which Anthropic says gives up to 2.5x more output tokens per second, is offered on Opus 5.5 but not on Sonnet 5.5, and it doubles the Opus price again.

For the CI bot, the per-token view says Sonnet 5.5 halves the bill. That is true per request and misleading per fix.

Why Cost per Solved Task Is the Number That Matters

A model that solves more tasks per attempt can cost less per finished task even at a higher token price. The lever that moves both sides is the effort parameter, which sets how much thinking, tool calling and self-checking a model does. On the API, Opus 5.5 defaults to medium and Sonnet 5.5 defaults to high.

Anthropic's guide Optimizing for cost and intelligence prices each setting the way a customer is billed, on a SWE-bench Pro subset whose scores are not comparable to the public leaderboard:

Three things stand out. Opus 5.5 at low buys nothing over Sonnet 5.5 at its default: the same pass rate for about 7% more per solved task. Opus 5.5 at its default buys 5 more points for twice the cost per solved task. And the re-run policy, where every task runs at low and only the 13% that fail get a second run at high, beats running everything at high on both pass rate and price.

Turning Sonnet 5.5 down has a real price. At medium, it scored about 7 points lower than at high for about 59% of the cost per task, and on Anthropic's internal agentic-coding benchmark it dropped from 77.8% to 62.7%. Keep that in mind for Claude Code, which runs Sonnet 5.5 at medium by default.

Each attempt on this 482-problem subset cost cents, and Anthropic warns the figures drift with prices and transcript length, so measure your own.

Where Sonnet 5.5 Beats Opus 5.5

Sonnet 5.5 wins one major agentic coding benchmark outright. In the table on Anthropic's Sonnet 5.5 launch post, Sonnet 5.5 scores 70.6% on Terminal-Bench 4.0, and Opus 5.5 scores 66.4%, a figure Anthropic footnotes as Opus 5.5 at xhigh effort, its highest score. On everything else in that table Opus 5.5 leads by a little: 57.8% to 55.5% on CursorBench 4.0, 81.8% to 80.1% on OSWorld 2.1, and 67.7% to 64.5% on Humanity's Last Exam with tools.

The same post adds the caveat that matters for long jobs: in Anthropic's testing and that of outside testers, "Opus 5.5 remains clearly stronger at complex, open-ended work requiring sustained judgment." At default effort on 45 DeepResearch Bench II tasks in Anthropic's cost guide, Opus 5.5 scored 2.6 points above Sonnet 5.5 for 1.5 times the cost per task; across all 50, Opus 5.5 was not measurably ahead.

For the CI bot, shell-heavy fixes are Sonnet territory, and gnarly multi-file failures are where Opus 5.5 earns its rate.

Pricing the CI Bot: Six Policies, One Month

The script below turns Anthropic's measured pass rates and per-task costs into a monthly bill for 2,000 failing test jobs. It takes one argument: what each job the bot gives up on costs once a developer has to finish it. The Sonnet 5.5 medium row is derived from the "about 7 points, about 59%" figures above.

js
Copy
// policies.mjs - node policies.mjs <usd-per-failure>
const TASKS_PER_MONTH = 2000;
const HUMAN_COST_PER_FAILURE = Number(process.argv[2] ?? 0);
const sonnetHighPerTask = 0.11 * 0.876; // $0.11 per solved task at 87.6%

const policies = [
  { name: "Sonnet 5.5 @ medium", solved: 0.876 - 0.07, perTask: sonnetHighPerTask * 0.59 },
  { name: "Sonnet 5.5 @ high (API default)", solved: 0.876, perTask: sonnetHighPerTask },
  { name: "Opus 5.5 @ low", solved: 0.874, perTask: 0.11 },
  { name: "Opus 5.5 @ medium (default)", solved: 0.928, perTask: 0.21 },
  { name: "Opus 5.5 @ high", solved: 0.953, perTask: 0.29 },
  { name: "Opus 5.5 low, re-run fails @ high", solved: 0.97, perTask: 0.17 },
];

const usd = (n) => "$" + n.toFixed(0).replace(/\B(?=(\d{3})+(?!\d))/g, ",");
console.log("policy                              solved  unsolved   API bill   total");
for (const p of policies) {
  const solved = Math.round(TASKS_PER_MONTH * p.solved);
  const unsolved = TASKS_PER_MONTH - solved;
  const api = TASKS_PER_MONTH * p.perTask;
  const total = api + unsolved * HUMAN_COST_PER_FAILURE;
  console.log(p.name.padEnd(35) + String(solved).padStart(6) + String(unsolved).padStart(10) +
    usd(api).padStart(11) + usd(total).padStart(8));
}

With failures treated as free, which is roughly true for a bot whose failed attempts just get closed, Node 25.5 prints:

text
Copy
policy                              solved  unsolved   API bill   total
Sonnet 5.5 @ medium                  1612       388       $114    $114
Sonnet 5.5 @ high (API default)      1752       248       $193    $193
Opus 5.5 @ low                       1748       252       $220    $220
Opus 5.5 @ medium (default)          1856       144       $420    $420
Opus 5.5 @ high                      1906        94       $580    $580
Opus 5.5 low, re-run fails @ high    1940        60       $340    $340

Now assume each unsolved job costs $25, about 15 minutes of a developer at a loaded $100 an hour. That figure is our assumption, so swap in your own:

text
Copy
policy                              solved  unsolved   API bill   total
Sonnet 5.5 @ medium                  1612       388       $114  $9,814
Sonnet 5.5 @ high (API default)      1752       248       $193  $6,393
Opus 5.5 @ low                       1748       252       $220  $6,520
Opus 5.5 @ medium (default)          1856       144       $420  $4,020
Opus 5.5 @ high                      1906        94       $580  $2,930
Opus 5.5 low, re-run fails @ high    1940        60       $340  $1,840

The ranking flips. The API bill is the small number in every row once a person has to handle the leftovers. The re-run policy costs $147 a month more than Sonnet 5.5 at its default and leaves 188 fewer failures, so it wins as soon as a failure costs more than about 78 cents of anyone's time. It has two conditions. You need a failure signal, which the test suite already is, and every first-pass failure takes two runs of wall-clock time.

What Changes in the API When You Switch

The two models share an API surface but not every default. Per Anthropic's thinking documentation, Opus 5.5 always thinks: thinking: {type: "disabled"} returns a 400 error, and effort is the only control. Sonnet 5.5 also rejects "disabled", but it accepts thinking: {type: "between_tools"}, which turns off up-front thinking at high effort or below. Code that ran an older Sonnet with thinking off has to switch to that setting.

Forced tool use (tool_choice of any or tool) returns a 400 error on both; Anthropic's migration guides say to send auto, mark the tool strict: true and say in the prompt when to call it. Fast mode for Opus 5.5 left research preview on October 15, 2026 and no longer needs a beta header. Changing the top-level effort value mid-conversation invalidates the cached message blocks, becuase effort is rendered into the prompt. To escalate inside one conversation, use the per-message effort change (beta header mid-conversation-output-config-2026-07-01), which keeps the cache on both models.

Anthropic's models overview puts the defaults side by side and labels Opus 5.5's latency "Moderate" and Sonnet 5.5's "Fast":

Which Model Claude Code Uses

Claude Code's model configuration docs say the default setting resolves to Opus 5.5 on Pro, Max, Ultra, Team and Enterprise plans and on the Anthropic API, as of Claude Code v2.1.280. Before that release, Pro and Team Standard users started on Sonnet 5. Opus 5.5 and Sonnet 5.5 both start at medium effort in Claude Code.

/model sonnet moves a session to Sonnet 5.5, /effort changes the level, and /model opusplan uses Opus 5.5 in plan mode and Sonnet 5.5 for execution. The Opus 5.5 launch post also raised five-hour usage limits on Pro, Max, Team and seat-based Enterprise plans. API users pay for the Opus default per token; subscription users spend it against those limits.

Side by Side

How to Choose Without Guessing

1. Find your failure signal. For the CI bot it is the test suite; elsewhere it might be a type checker. If nothing can tell a good result from a bad one, the re-run policy is off the table and you are choosing on pass rate alone.
2. Put a dollar figure on a failure. Usually that is developer minutes. Run the script above with that number. With Anthropic's figures, Sonnet 5.5 at high stays cheapest only while a failure costs less than about 78 cents.
3. Run 50 real tasks at three settings. Sonnet 5.5 at high, Opus 5.5 at low and Opus 5.5 at medium, each in a seperate session so effort changes do not reset the cache. Price them per solved task, not per token.
4. Look at your hardest tenth. Anthropic found two problems carrying 43% of the spend on a 20-problem WideSearch run. The tail decides the bill, not the median task.
5. Escalate instead of upgrading everything. If Opus 5.5 at low passes most tasks, re-run only its failures at high rather than raising the default.

Conclusion

Claude Sonnet 5.5 is half the price of Claude Opus 5.5 per token, yet Opus 5.5 at low costs only about 7% more per solved task than Sonnet 5.5 at its default, at the same pass rate. If tests can check the work, run Opus 5.5 at low and re-run failures at high: it fixed 1,940 of 2,000 jobs for $340 in our example. If a failure costs nothing, or the agent lives in the shell, Sonnet 5.5 at its default high is the better buy.

Related DevToolLab Tools

• Prompt Caching Calculator - prices cached repository context on both models at their 5% read rates ($0.20 and $0.10), the line that dominates an agent's bill.
• JUnit XML Viewer - lists the passed, failed and skipped cases in the test report the CI bot uses as its failure signal.
• Log File Viewer - opens the log a failing job leaves behind, even a multi-gigabyte one, and jumps from error to error.
• GitHub Actions Validator - checks the bot's workflow file for schema errors, retired runners and outdated actions before you push it.

Related Guides

• Claude Prompt Caching Pricing in 2026 explains the cache write and read math behind the 5% rates in the price table.
• Best CLI AI Coding Agents compares Claude Code with Codex CLI, OpenCode, GitHub Copilot CLI and other terminal coding agents.
• Claude Code Git Worktrees shows how to run several Claude Code sessions on one repository, each in its own Git worktree.
• LLM API Outages has 90 days of incident data for Anthropic and other LLM APIs.