Anthropic has introduced Sonnet 5.5, a new model in the Claude 5.5 family. According to the provider, it is faster and more economical than its predecessor and, for knowledge work, is almost on a par with the significantly larger Opus 5.5. The biggest difference, however, is in programming tasks.
In Terminal-Bench, a benchmark that measures models on realistic command-line tasks, the result rises from 10.3 to 70.6 per cent. A jump of this magnitude within a single model generation is unusual and affects precisely the way of working that is becoming increasingly common in AI-assisted development: the model does not just work in a chat window but executes commands, reads files, starts tests and responds to error messages.
Why this particular benchmark is relevant
Many well-known coding benchmarks test isolated tasks: writing a function, finding a bug in a manageable code snippet. Terminal-Bench targets the level above that – multi-step processes in a real working environment. That is where it is decided whether a model can repair a build, prepare a deployment or get a test suite running without someone specifying every step.
For agencies and internal development teams, this is the more practically interesting yardstick. A model that works reliably in such scenarios can be integrated into tools that handle tasks independently – for example updating dependencies, preparing migration steps or taking on recurring maintenance work.
The cost side shifts the choice
Until now, a simple rule of thumb applied in many projects: the largest available model for demanding tasks, the smallest for simple routine work. This split was less a technical than an economic decision. Large models cost significantly more per request, and in agentic processes – that is, with tools that independently execute several steps in succession – these costs quickly add up, because each task involves not one but many model requests.
If a mid-sized model like Sonnet 5.5 catches up strongly on coding tasks and at the same time works more cheaply than its predecessor, this calculation shifts. Tasks that were previously done manually for cost reasons, or not automated at all, can become economically viable. Conversely, for some of the workloads that have so far depended on the top model, it is worth checking whether the smaller variant is sufficient.
Three tiers as the standard lineup
With the announced Haiku 5.5, Anthropic would again have a complete three-tier lineup of small, medium and large models – a direct counterpart to OpenAI's lineup around GPT-6. This structure is becoming established as a pattern among the major providers and has consequences for the architecture of applications.
Anyone integrating an AI function into a product today should not commit to a single model but treat model selection as a configurable parameter. In practice, this means:
- Abstraction layer: The application code does not communicate directly with a specific model API but with its own intermediate layer that allows switching without rebuilding.
- Routing by task type: Classification, summarisation or format checking run on the small model, complex analyses on the large one.
- Your own test cases: Provider benchmarks do not replace measurement against your own data and tasks. A set of realistic test cases shows more quickly whether a model change holds up.
- Cost measurement per use case: What matters is not the price per request but the effort required until a task is actually completed.
What benchmark scores do not cover
A high benchmark score is an indication, not a guarantee. Terminal-Bench measures a certain class of tasks under controlled conditions. Grown projects with their own conventions, older dependencies or specific deployment chains look different from a benchmark environment.
In addition: the more independently a model executes commands, the more important safeguards become. These include isolated execution environments, clearly limited access rights, traceable logs and a review step before changes are merged. A model that is right in 70 per cent of cases is simply not right in the remaining cases – and without checkpoints, that only becomes apparent late.
Assessment for project practice
Model generations are currently changing at intervals shorter than the runtime of many web projects. Anyone tying AI functions firmly to one provider and one model version is building in technical debt that becomes visible with every generation change.
For web and software projects, this means concretely: the interchangeability of the model belongs in the architecture, not in the retrofit. And the decision on which model to use should be made regularly on the basis of your own measurements – because a price-performance ratio that holds today can be outdated within a few months.