Anthropic released Claude Sonnet 5.5 on 28 September 2026 as the faster, lower-cost member of its 5.5 model family. The company says it generates output more than 30% faster than Sonnet 5 and can cost up to 30% less per task while keeping the same headline token prices. Those are Anthropic's measurements, not independent guarantees for every application.
The more important engineering story is not one benchmark score. Sonnet 5.5 changes request parameters, thinking behavior, tool selection, response blocks and computer-use integration. A deployment that changes only the model ID can fail with HTTP 400, hide progress text, invalidate edited conversation history or silently alter the economics of a tool loop.
The official model overview lists a one-million-token context window, up to 128K output tokens, adaptive thinking and a high default effort level. The launch announcement positions the model for well-scoped everyday work, bug fixing and polished artifacts, while Opus 5.5 remains the company's recommended option for the most open-ended work requiring sustained judgment. Production routing should preserve that distinction rather than treating a new Sonnet as a universal replacement.
Start with task economics, not token price
Sonnet 5.5 keeps standard pricing at $2 per million input tokens and $10 per million output tokens, with $0.20 cache reads. Anthropic's claim of lower cost per task comes from using fewer tokens and completing work faster, not from a lower list price. That difference matters because an agent bill contains much more than one input and one output.
Measure the whole execution: uncached input, cache writes, cache reads, thinking and visible output, tool calls, retries, wall-clock duration, failed attempts and reviewer time. Divide the total by accepted outcomes. A run that saves 25% of output tokens but requires an extra human correction may be worse. A run that costs more per request but finishes in half the attempts may be better.
Create workload classes before choosing the route. A deterministic extraction, a bounded code fix, a multi-repository migration and an ambiguous architecture review have different failure costs. Route by the evidence collected for each class, not by one global model preference.
Treat the migration as a request-contract change
The migration guide identifies settings that can return errors: manual thinking budgets, non-default sampling parameters, assistant prefills, forced tool choice and the disabled thinking mode. The model ID is claude-sonnet-5-5, but the deployable unit is a versioned request bundle containing the model, system instructions, tools, response parser, retry policy and effort level.
Inventory every request builder before editing production configuration. Search for explicit temperature, top-p or top-k values; thinking budgets; assistant-message prefills; tool choice set to any or a named tool; positional parsing such as content item zero; old computer-use declarations; and beta headers that the new toolset rejects.
Keep the old and new request bundles side by side. A rollback that restores only the model name while leaving the new parser and parameters in place is not a rollback. Version the bundle, record it on every trace and make routing changes independently reversible.
Thinking changes state, parsing and cost
Adaptive thinking is on when the thinking field is omitted. To remove up-front thinking, Sonnet 5.5 uses the new between_tools mode at low, medium or high effort; the older disabled value returns an error. At xhigh or max effort, between_tools is not accepted. The effort setting is therefore part of the contract, not a decorative tuning knob.
Responses can begin with thinking blocks, so read every content block by type rather than assuming the first block contains text. In a tool loop, send thinking blocks back unchanged with the assistant turn. Anthropic documents that Sonnet 5.5 thinking blocks are bound to the model and conversation prefix. Editing earlier history and then replaying those blocks can return an error on accounts where binding is enforced.
Keep execution history append-only. If product instructions or tools change mid-conversation, use the documented mid-conversation mechanisms or start a fresh run from verified application state. Do not make hidden reasoning the only copy of task state. The portable record is the user's request, validated tool results, durable application state and explicit completion evidence.
Thinking tokens also count against maximum output and are billed as output. Revisit max_tokens and cost alerts. A limit designed for visible prose can truncate a long tool task after the model has spent much of the budget reasoning.
Replace forced tools with application enforcement
Sonnet 5.5 rejects tool choice set to any or a forced named tool. The documented migration is automatic tool selection plus strict schemas where supported. That change removes a convenient API switch, but it should not remove a product guarantee.
If a workflow requires a lookup before answering, express the requirement clearly and verify it in application state. If a mutation requires approval, enforce approval outside the model. Validate the selected tool, its schema, the current user permission, the resource scope, idempotency key and expected state transition. A model deciding to call a tool is never the authorization boundary.
Strict tools reduce malformed inputs, but they do not prove that the requested operation is correct. Keep semantic checks in code: an order belongs to the current tenant, a refund does not exceed the captured amount, a deployment targets an allowed environment and a destructive action has a current approval.
Keep progress visible without treating narration as truth
The what's-new documentation notes that longer text between tool calls can move into thinking blocks. With the default omitted display, an interface that previously streamed those notes may appear silent even though the request continues. This is a response-shape change without a failed API call.
Decide whether the product needs model narration or operational progress. Operational progress should come from your executor: task accepted, tool started, waiting for approval, retry scheduled, output verified. It remains trustworthy across model versions. If summarized model updates help users understand a long run, render them separately and label them as progress commentary rather than an audit log.
Test the empty intervals. Measure time to first visible signal, time between verified milestones and the timeout at which a user assumes the run is stuck. A faster model can still feel slower if the interface loses progress messages.
Build a router around evaluated workload classes
Anthropic positions Sonnet 5.5 as a fast model for well-scoped tasks and Opus 5.5 for the most complex open-ended work. Turn that product positioning into an explicit routing policy. Start with workload metadata: task class, risk, context size, tool count, expected duration, reversibility and required quality bar.
Use Sonnet for a class only after it passes that class's acceptance set. Escalate when the task crosses defined boundaries—for example, an architecture review spans more services than expected, the first attempt fails a critical check, or the task asks for irreversible action. Do not route based on prompt length alone; a short instruction can authorize a high-risk operation.
Avoid invisible model switching inside one conversation. Because thinking-block compatibility varies across models, a fallback may lose hidden state even when the API request succeeds. When escalation is needed, build a fresh handoff package from durable facts: objective, constraints, verified inputs, completed steps, tool outputs and unresolved questions.
Re-run the evaluation sweep at every effort level
Effort levels are recalibrated. Anthropic recommends starting around medium for well-specified agentic work and moving to high for harder or longer tasks; chat and latency-sensitive work may begin at low or medium. Carrying the previous model's effort label forward does not preserve the same latency, reasoning depth or cost.
Use a frozen evaluation set drawn from production-shaped work. Include successful common cases, ambiguous inputs, tool failures, long context, permission denial, duplicate delivery and a task that should refuse or escalate. Score exact postconditions: tests pass, cited facts match sources, side effects occur once, forbidden actions do not occur and the user can understand the final state.
For each workload class and effort level, record accepted-task rate, critical failure rate, median and tail latency, input and output tokens, tool-call count, retry rate, reviewer minutes and total cost per accepted task. Vendor benchmarks are useful hypotheses; your release decision needs local evidence.
Canary the complete release bundle
Begin with offline replay. Then run shadow traffic with mutations disabled and compare outputs without exposing them to users. When the new bundle meets the bar, canary a small eligible cohort behind a stable route key so one user or organization does not bounce between bundles across requests.
Define rollback thresholds before launch: critical-action error, accepted-task regression, refusal spike, p95 latency, retry rate, cost per accepted task and silent-progress duration. Alerts should name the workload class and bundle version, not only the model.
Preserve traces with sensitive data controls: request-bundle version, effort, tool versions, cache state, stop reason, block types, validated side effects and final acceptance result. Do not log private thinking content as an observability shortcut. You need enough evidence to explain execution, not a copy of hidden reasoning.
The practical decision
Claude Sonnet 5.5 is a credible candidate for high-volume, well-scoped agentic and knowledge workflows. Anthropic reports a significant speed and efficiency improvement, while its own documentation makes clear that the API contract changed in ways that can break existing integrations.
Migrate when the new request bundle passes contract tests, real tasks improve at the chosen effort level, tool authorization remains in application code, progress remains understandable, and the entire previous bundle can be restored quickly. Route by accepted outcome and failure cost—not by launch excitement, list price or a single benchmark.
The durable advantage is not merely using a newer model. It is owning a release process that can evaluate, route, observe and reverse every model change without guessing.
Official references
These references document the tools discussed. Examples and design decisions are illustrative and should be adapted to the project and its versions.
Prepared by: Noor Yasser
Working through a similar engineering challenge?
I help teams turn architecture decisions into a clear scope and dependable, reviewable implementation.




