Claude Sonnet 5.5 costs exactly what Sonnet 5 did, $2 per million input tokens and $10 per million output, which is also cent for cent what OpenAI charges for GPT-6 Sol. Anthropic kept the price and changed almost everything else: the benchmarks jumped, thinking can no longer be switched off, forced tool calls now return a 400, and the effort setting swings the bill by a factor of twenty.
This guide covers the Claude Sonnet 5.5 specs, pricing, the official benchmarks and what the system card admits, then our own tests: the same three DevOps tasks we ran for Claude Opus 5.5 and GPT-6 Sol, graded by real linters and a real cluster, an effort sweep, and a Claude Code run that checks the “fewer tool calls” claim. Every result from our own runs came from the live API and Claude Code on launch day in September 2026, with the Kubernetes output deployed on k3s v1.36.4 running Ubuntu 26.04.1.
What is new in Claude Sonnet 5.5
Sonnet 5.5 landed on September 28, 2026, six days after Opus 5.5, as the second model in the Claude 5.5 family. Anthropic’s announcement pitches it as the fast, cheaper partner to Opus 5.5 for well-scoped work: bug fixing, everyday coding, documents, slides and spreadsheets. Haiku 5.5 is promised “in the coming weeks”. The model card facts, pulled from the platform docs and the Models API:
| Spec | Claude Sonnet 5.5 |
|---|---|
| API model ID | claude-sonnet-5-5 (no date suffix) |
| Bedrock ID | anthropic.claude-sonnet-5-5, global profile global.anthropic.claude-sonnet-5-5 |
| Context window | 1M tokens, no long-context premium |
| Max output | 128K (300K on the Batches API with the output-300k-2026-03-24 beta) |
| Knowledge cutoff | June 2026 |
| Thinking | Adaptive, on by default; lowest setting is between_tools |
| Effort levels | low, medium, high, xhigh, max |
| Default effort | high on the API, medium in Claude Code and the Claude apps |
| Minimum cacheable prompt | 512 tokens (Sonnet 5: 1,024) |
| Tokenizer | Same as Sonnet 5, so token counts carry over |
| Retirement date | Not sooner than September 28, 2027 (Sonnet 5 stays active) |
Anthropic claims three headline gains over Sonnet 5: output generated more than 30% faster, up to 30% lower cost per task because it needs fewer tokens and tool calls, and much stronger agentic coding. It is also the first Sonnet to ship with the cyber safeguards Anthropic built for its top models, plus classifiers that block attempts to extract its reasoning. Those safeguards have a visible cost that the system card spells out, covered further down.
The launch page’s speed demo gives each model the same prompt, “A murmuration of 400 starlings in one HTML file”, and records the race. At the frame below, Sonnet 5 is still writing code at 4,520 tokens:
At the same moment, Sonnet 5.5 finished in 4,158 output tokens and its starlings have been flying for 12.5 seconds:
A vendor demo picks its best prompt, so treat that as a claim. Our own measurements below show where it holds and where it does not.
Claude Sonnet 5.5 pricing
List prices did not move. Sonnet 5 launched in June with $2/$10 as an introductory rate, and Anthropic made that permanent in August instead of stepping up to the planned $3/$15. Sonnet 5.5 inherits it, which puts it level with GPT-6 Sol and at half the price of Opus 5.5:
| Per 1M tokens | Sonnet 5.5 | Sonnet 5 | Opus 5.5 | GPT-6 Sol |
|---|---|---|---|---|
| Input | $2 | $2 | $4 | $2 |
| Output | $10 | $10 | $20 | $10 |
| Cache write (5 min; Sol has one tier) | $2.50 | $2.50 | $5 | $2.50 |
| Cache write (1 hour) | $4 | $4 | $8 | n/a |
| Cache read | $0.20 | $0.20 | $0.20 | $0.20 |
| Batch (in/out) | $1 / $5 | $1 / $5 | $2 / $10 | 50% off |
| Fast mode | Not offered | Not offered | $8 / $40 | 2x |
Two smaller pricing details matter for real bills. US-only inference adds a 1.1x multiplier on every token category, and on Google Cloud the regional endpoint charges $2.20/$11 against $2/$10 on the global one. The whole 1M context bills at the standard rate.
The “up to 30% cheaper per task” line depends entirely on the model using fewer tokens, because the rate card is unchanged. Artificial Analysis measured the opposite on its own suite: at max effort Sonnet 5.5 cost $7.60 per Intelligence Index task, about 50% more than Sonnet 5. Our runs show both effects are real, and which one you get depends on the workload and the effort level.
Claude Sonnet 5.5 benchmarks
Anthropic’s launch table compares Sonnet 5.5 with Sonnet 5, Opus 5.5 and GPT-6 Sol. The Terminal-Bench 4.0 jump from 10.3% to 70.6% is the eye-catcher, and Sonnet 5.5 beats Opus 5.5 on that one test:
| Benchmark | Sonnet 5.5 | Sonnet 5 | Opus 5.5 | GPT-6 Sol |
|---|---|---|---|---|
| Terminal-Bench 4.0 | 70.6% | 10.3% | 66.4% | n/a |
| FrontierCode 1.1 (Main) | 52.1% xhigh, 46.2% max | 42.4% | 54.4% | 49.3% |
| CursorBench 4.0 | 55.5% | 34.1% | 57.8% | n/a |
| GDPval-AA v2.1 (Elo) | 1844 | 1449 | 1846 | 1487 |
| AA-Briefcase v1.1 (Elo) | 1811 | 1359 | 1822 | 1483 |
| Humanity’s Last Exam (tools) | 64.5% | 54.9% | 67.7% | n/a |
| OSWorld 2.1 (partial) | 80.1% | 57.0% | 81.8% | n/a |
| Chartography (no tools) | 61.6% | 15.6% | 64.4% | 53.6% |
Read the FrontierCode row carefully. Sonnet 5.5 scores lower at max effort than at xhigh (46.2% vs 52.1%), and Anthropic’s own footnote says so. More thinking is not always better on this model.
The 148-page system card adds results the launch page skips. SWE-Bench Pro is 81.3% (Sonnet 5: 63.2%, Opus 5.5: 89.9%), SWE-Bench Multilingual 90.3%, and on AutomationBench Sonnet 5.5 edges past Opus 5.5, 44.7% to 42.5%. On FrontierSWE v2 it scores 61.9% against 62.3% for Opus 5.5 and 65.5% for GPT-6 Astra. CursorBench climbs steeply with effort: 39.2% at medium, 47.8% at high, 53.1% at xhigh and 55.5% at max. That last series matters when you pick an effort level, because the headline CursorBench number is a max-effort score.
Independent numbers from Artificial Analysis mostly agree on capability and disagree on cost. Sonnet 5.5 at max effort scores 56 on their Intelligence Index, second only to Opus 5.5 at max. Their own Terminal-Bench 4.0 run gave 64%, ahead of Opus 5.5 and GPT-6 Astra at 60%. The catch is tokens: about 193K output tokens per index task at max effort, the most they have ever measured, around 60% more than Opus 5.5 and roughly 7x GPT-6 Astra. On factual recall (AA-Omniscience) it trails Opus 5.5, 54% against 66%, though with a lower hallucination rate (47% against 59%). AA ran a pre-release build that had a structured-outputs bug, fixed for launch, so a rerun may nudge those numbers up.
What the system card admits
Anthropic says Sonnet 5.5 does not cross any new RSP threshold, and its alignment risk is rated low. Several findings in the card cut against the launch tone, and they are the ones that affect production use.
Cyber capability rose sharply. On CyScenarioBench it completed 46.1% of scenarios, where Sonnet 5 managed 0.7%, and in binary exploitation it produced 50 control-flow hijacks against 3 for Sonnet 5. That is why the cyber safeguards ship with it, and the card is blunt about the side effect: “users should expect increased refusals with Sonnet 5.5, even on benign cybersecurity-related tasks.” In Claude Code a cyber-flagged request reruns on Sonnet 5, while a biology-flagged one simply ends in a refusal. The API reports declines as HTTP 200 with stop_reason: "refusal" and a stop_details category (cyber, bio, frontier_llm, reasoning_extraction or general_harms), and server-side fallback only retries the cyber and frontier_llm ones.
Prompt injection resistance improved over Sonnet 5 but stays behind Opus 5.5. Gray Swan’s indirect injection attacks succeeded 3.4% of the time at 15 attempts (Sonnet 5: 6.7%), and it is the first model Anthropic tested with zero successful browser-use attacks (0 of 110 without safeguards). The regressions are small but real: refusal of malicious computer-use tasks fell from 84.68% to 79.46%, malicious Claude Code refusals from 87.9% to 85.2%, and the card notes Sonnet 5.5 is “slightly more likely to state an incorrect answer than Sonnet 5” on AA-Omniscience. It also skipped the dedicated reward-hacking review that the Opus 5.5 card carried.
We tested Sonnet 5.5 against Sonnet 5, Opus 5.5 and GPT-6 Sol
Same harness as our Opus 5.5 and GPT-6 tests, unchanged prompts. Each model gets a terse “output only the file” system prompt and three tasks: a Kubernetes Deployment plus Service for nginx with probes, resource limits and runAsNonRoot; a set -euo pipefail PostgreSQL-to-S3 backup script; and an OpenTofu VPC with a subnet, internet gateway, route table and security group. Three runs per task, each model at its API default effort, plus Sonnet 5.5 at low, medium and max. That is 63 calls in total.
The judges are tools, not opinions. kubeconform -strict and a real deploy on k3s for the manifests, shellcheck plus a behaviour test for the scripts (unset variables must fail, a gzip must land, a stubbed aws s3 cp must fire, a 10-day-old dump must be deleted and a 3-day-old one kept), and tofu validate plus tofu fmt -check for the HCL.
| Model (effort) | Lint pass | k3s deploy + HTTP 200 | Output tokens (9 calls) | Wall time | Cost |
|---|---|---|---|---|---|
| Sonnet 5.5 (high, API default) | 9/9 | 3/3 | 11,868 | 77 s | $0.1230 |
| Sonnet 5.5 (medium) | 9/9 | 3/3 | 6,217 | 36 s | $0.0665 |
| Sonnet 5.5 (low) | 9/9 | 0/3 | 6,163 | 35 s | $0.0660 |
| Sonnet 5.5 (max) | 9/9 | 3/3 | 135,413 | 892 s | $1.3585 |
| Sonnet 5 (default) | 9/9 | 0/3 | 6,071 | 60 s | $0.0650 |
| Opus 5.5 (default) | 9/9 | 3/3 | 12,934 | 130 s | $0.2674 |
| GPT-6 Sol (default) | 9/9 | 3/3 | 6,987 | 125 s | $0.0728 |
Every one of the 63 files passed its linter, and all 21 backup scripts passed the behaviour test. Linters were never going to separate these models. The cluster did. Here is each manifest deployed into its own namespace, with a curl pod hitting the Service:
Sonnet 5 failed all three, and so did Sonnet 5.5 at low effort. Sonnet 5.5 at medium, high and max went 9 for 9, level with Opus 5.5 and GPT-6 Sol. Two different bugs caused the six failures.
Error: mkdir() “/var/cache/nginx/client_temp” failed (13: Permission denied)
All three Sonnet 5 manifests and one low-effort Sonnet 5.5 manifest set runAsNonRoot with UID 101 and stopped there. The stock nginx image needs to write /var/cache/nginx and its PID directory, which a non-root user cannot do, so every pod crash-looped with this log line:
2026/09/28 20:37:07 [emerg] 1#1: mkdir() "/var/cache/nginx/client_temp" failed (13: Permission denied)
nginx: [emerg] mkdir() "/var/cache/nginx/client_temp" failed (13: Permission denied)The fix is two writable emptyDir volumes. Every passing Sonnet 5.5 manifest added them on its own; this excerpt is verbatim from the first default-effort run:
volumeMounts:
- name: cache
mountPath: /var/cache/nginx
- name: run
mountPath: /run
volumes:
- name: cache
emptyDir: {}
- name: run
emptyDir: {}That is the exact failure GPT-6 Luna hit in our earlier test. It is a knowledge gap that thinking fixes: Sonnet 5.5 at medium effort already gets it right.
FailedMount: configmap “web-nginx-conf” not found
The other two low-effort manifests went the opposite way. They mounted the emptyDirs and also a ConfigMap named web-nginx-conf over /etc/nginx/conf.d, which the prompt never asked for and the file never defined. The pods sat in ContainerCreating with this event:
FailedMount MountVolume.SetUp failed for volume "conf" : configmap "web-nginx-conf" not foundA dangling reference passes kubeconform -strict because schema validation cannot know what exists in the cluster. This is the strongest argument we found against running Sonnet 5.5 at low effort for infrastructure code: the output looks more thorough than Sonnet 5’s and fails for a different reason.
The effort setting decides the bill
On single-file generation, the API default of high cost almost twice what Sonnet 5 did (11,868 output tokens against 6,071) for the same lint results and better runtime results. Medium effort matched Sonnet 5’s token count, passed everything Sonnet 5 failed, and finished the nine calls in 36 seconds against Sonnet 5’s 60. That is the speed claim holding up.
Max effort is where the Artificial Analysis token warning shows up in a real workload. One nginx manifest took between 20,275 and 26,237 output tokens and about two and a half minutes. Averaged over the Kubernetes task that is 36 times the medium-effort output for a file that deployed no better. Across all nine calls, max spent 22 times the tokens and 20 times the money of medium for identical scores.
| Sonnet 5.5 effort | K8s manifest (avg out tokens) | Bash script | OpenTofu VPC | k3s result |
|---|---|---|---|---|
| low | 590 | 645 | 819 | 0/3 |
| medium | 639 | 614 | 819 | 3/3 |
| high (API default) | 1,562 | 1,262 | 1,132 | 3/3 |
| max | 23,323 | 18,364 | 3,450 | 3/3 |
Anthropic’s guidance says to start at high for work that is not agentic, and single-file generation is exactly that, so this result runs against the official default: medium matched high on every judge we had, at half the tokens. For agentic coding on well-specified tasks Anthropic already recommends medium. The CursorBench effort series above says harder, longer tasks do gain from high and xhigh, so this table argues against max on routine work, not against effort in general.
Sonnet 5.5 in Claude Code: fewer tool calls, a third of the cost
The one-shot test cannot measure the claim Anthropic leans on most, that Sonnet 5.5 batches tool calls and finishes agentic work in fewer steps. So we built a small Python log parser with four planted bugs (a timezone-less strptime format, a regex that rejects - as a response size, a percentile off by one, and > 500 where it should be >= 500) and an eight-test pytest suite. Claude Code ran it headless, three times each on Sonnet 5.5, Sonnet 5 and Opus 5.5, every run on a fresh copy of the repo at Claude Code’s default effort. That default is medium for Sonnet 5.5 and Opus 5.5 but high for Sonnet 5, so the comparison is each model as Claude Code ships it, not the same effort level. This is the loop body from the runner script:
timeout 900 claude -p "$PROMPT" --model "$m" --output-format stream-json --verbose \
--setting-sources project --strict-mcp-config \
--allowedTools "Read,Edit,Write,Glob,Grep,Bash(python3 -m pytest:*),Bash(python3:*),Bash(ls:*),Bash(cat:*)" \
> "$A/runs/$m.r$r.jsonl" 2> "$A/runs/$m.r$r.err"The judge reran pytest afterwards and diffed tests/ to catch any model that “fixed” the suite instead of the code. Nobody cheated, and all nine runs ended green. The difference was how they got there:
Sonnet 5 took 12 or 13 tool calls per run: it read the files one at a time, then fixed the bugs with three or four separate Edit calls. Sonnet 5.5 used three (four in the run with a retry, below). It ran the suite and listed the package in one Bash call, dumped the source files and tests in a second, then fixed all four bugs and reran pytest in a single scripted third call. Averaged, that is $0.057 and 12 seconds per run against $0.157 and 48 seconds for Sonnet 5, so about a third of the cost at four times the speed. Opus 5.5 took the same three-call path at $0.100 per run.
That batching has a side effect worth knowing before you copy our permission list. Sonnet 5.5 and Opus 5.5 never called the Edit tool. They rewrote the source files from a python3 heredoc inside Bash, which our Bash(python3:*) rule allowed. If your review workflow depends on seeing Edit diffs, a broad interpreter allow rule lets the model change files without them. Scope it tighter, or leave interpreters off the allow list.
Error: No such tool available: bash. Tool names are case-sensitive: call Bash instead.
One Sonnet 5.5 run called a tool named bash in lowercase, got this error back, and retried with Bash on the next turn. It cost one extra turn and about a cent. Harmless in Claude Code, but a custom agent loop that treats an unknown tool name as fatal would stop there, so return the error to the model as a tool result instead.
To switch an interactive session, /model sonnet now resolves to Sonnet 5.5 on the Anthropic API. On Bedrock, Google Cloud, Microsoft Foundry and Claude Platform on AWS the sonnet alias still points at an older Sonnet (4.5, or 4.6 on Claude Platform on AWS), so pass the full ID there. The Claude Code cheat sheet covers the model and effort flags, and our token-usage guide covers the other half of the bill.
Breaking API changes when moving from Sonnet 5
Swapping the model string is not enough. We sent Sonnet 5.5 the thinking, sampling and tool settings that older Claude code carries, and sent the two most common of them to Sonnet 5 for comparison. Sonnet 5 accepted thinking: disabled and a forced tool_choice; Sonnet 5.5 returned a 400 for both, and for three other patterns:
The error text is what you will search for, so here is each one with its fix.
“thinking.type.disabled” is not supported for this model
Thinking can no longer be disabled. Send "thinking": {"type": "between_tools"}, which turns off up-front thinking and only keeps short progress notes between tool calls. Without tools the response is plain text, exactly like disabled on Sonnet 5.
output_config.effort ‘max’ is not supported when thinking is disabled on this model
between_tools only works at low, medium and high. For xhigh or max, omit the thinking field (adaptive is the default). With between_tools the effort also cannot change mid-conversation.
tool_choice: type “tool” and “any” are not supported for this model
Forced tool use is gone, the same change Opus 5.5 made. Use tool_choice: {"type": "auto"}, mark the tool strict: true so its input matches the schema, and tell the model in the prompt when to call it. On Bedrock strict tools are not available for this model, so validate the tool input in your own code there. The same rule applies to the token-counting endpoint.
The last two errors, "thinking.type.enabled" is not supported for a manual budget_tokens and `temperature` is deprecated for this model, are not new: Sonnet 5 already rejected manual budgets and non-default sampling parameters, so code that runs on Sonnet 5 today does not send them. Four more changes do not show up as a 400 on a simple request. Thinking blocks are signed against the conversation history, so on accounts created on or after August 31, 2026, replaying a block after editing the system prompt, the tools or an earlier message returns a 400; keep histories append-only. computer_20251124 is rejected on the Claude API and Google Cloud in favour of computer_toolset_20260801. And text the model writes between tool calls now arrives inside thinking blocks, empty at the default display, so a UI that streams those notes goes silent until you set display. The advisor tool also no longer accepts Opus 4.8, Opus 4.7 or Sonnet 5 as the advisor for a Sonnet 5.5 executor, and returns the advice encrypted. The official migration guide lists the checklist per starting model.
A request that works on Sonnet 5.5 as written sets the effort and nothing else that can fail:
curl -s https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "content-type: application/json" \
-d '{
"model": "claude-sonnet-5-5",
"max_tokens": 4096,
"output_config": {"effort": "medium"},
"messages": [{"role": "user", "content": "Give the one-line kubectl command that restarts every deployment in the web namespace."}]
}' | jq '{model, stop_reason, content: [.content[] | {type, text}], usage: {input_tokens: .usage.input_tokens, output_tokens: .usage.output_tokens}}'The reply comes back as a single text block. Read content blocks by type rather than taking content[0], because adaptive thinking can put a thinking block first on harder prompts:
{
"model": "claude-sonnet-5-5",
"stop_reason": "end_turn",
"content": [
{
"type": "text",
"text": "```\nkubectl rollout restart deployment -n web\n```\n\nWhen no deployment name is given, this restarts all deployments in the `web` namespace."
}
],
"usage": {
"input_tokens": 34,
"output_tokens": 48
}
}Where Claude Sonnet 5.5 is available
It shipped everywhere on day one. On the Claude API it is claude-sonnet-5-5 for all customers. Amazon Bedrock serves it through the global cross-region profile global.anthropic.claude-sonnet-5-5, and Claude Platform on AWS (North America at launch) uses the plain ID. Google Cloud and Microsoft Foundry both use claude-sonnet-5-5. Zero data retention is available, as with Opus 5.5.
In the tools developers use daily, Claude Code picked it up the same day as the default Sonnet on the Anthropic API, at medium effort. GitHub Copilot made it generally available to Pro, Pro+, Max, Business and Enterprise with a gradual rollout, and Cursor lists it in the model picker under Settings, Models. For how it stacks up against other terminal agents doing infrastructure work, see our AI coding agent comparison for DevOps.
Which effort level to run Sonnet 5.5 at
Start at medium. In our runs it was the only setting that was cheap, fast and correct at once: Sonnet 5’s token bill, faster than Sonnet 5, and every manifest deployed. It is also what Claude Code already uses, so in the terminal you get the good setting without touching anything.
On the API, set output_config.effort explicitly, because the default of high roughly doubled output tokens on routine generation with no gain we could measure. Move to high or xhigh for long, open-ended agentic work, where Anthropic’s CursorBench series shows real gains. Keep max for evals that prove it pays: on FrontierCode it scored below xhigh, and on our tasks it bought identical results for twenty times the money. Skip low for infrastructure code, since it was the only Sonnet 5.5 setting that shipped manifests that failed on a real cluster.
If you run Sonnet 5 today, the upgrade is worth it at the same price, provided you fix the request patterns above first and re-baseline your cost at the effort you pick. For judgment-heavy work where Sonnet still falls short, Opus 5.5 remains the step up, at twice the rate.
