When the expensive option gets cheap
Imagine you run a delivery service. You've got bicycles for small local errands (cheap and fast), delivery vans for bigger routes around town (reliable, good all-rounders), and one high-tech cargo drone reserved for critical, long-distance jobs. That drone is amazing, but it costs so much to fly that you only wheel it out as a last resort, when everything else has failed. Now imagine the drone's manufacturer cuts its running cost by more than half. It's still your priciest option — but no longer painfully so. Suddenly you're not saving it for emergencies anymore. You're using it for all your important, complicated deliveries, because a botched van delivery — the delays, the redo, the annoyed customer — now costs you more than just sending the drone in the first place.
Anthropic's Claude Opus 4.5, released on November 24, 2025, is that cheaper cargo drone. It's a top-tier AI model — meaning it's generally the smartest and most capable in its lineup — and its price has just dropped into a new zone of everyday usefulness. For the engineers who build AI systems, that changes the whole calculation of which model to reach for, especially when building AI "agents": AI systems designed to work through complicated, many-step tasks mostly on their own, like a junior employee you can hand a whole project to instead of a single question.
Until now, the priciest, smartest models were treated like that drone — powerful but too expensive for routine work, so they were kept in reserve for when cheaper models failed. Opus 4.5's price cut flips that logic. For certain kinds of hard, high-stakes jobs, it now makes more sense to just start with the best model rather than trying cheaper ones first and cleaning up after their mistakes.
How it works
Anthropic's announcement of Claude Opus 4.5 on November 24, 2025, was more than a product release; it was a shift in the economic landscape for AI developers. For architects, the most important number wasn't a benchmark score, but a price: $5 per million input tokens and $25 per million output tokens [1]. To understand why this matters, we need to look at the model in the context of its family and the architectural patterns its pricing enables.
The Claude 4.5 Family: A Tiered Architecture
Claude 4.5 is not a single model but the final piece of a three-tiered model family released throughout the fall of 2025. This family is explicitly designed to give developers a portfolio of options, balancing cost, speed, and capability [4]. An effective system will likely use all three.
Model | Released | Input Price ($/Mtok) | Output Price ($/Mtok) | Position |
|---|---|---|---|---|
Haiku 4.5 | October 2025 | $1 | $5 | Fast, cost-effective for high volume |
Sonnet 4.5 | Sep 29, 2025 | $3 | $15 | Balanced workhorse for general tasks |
Opus 4.5 | Nov 24, 2025 | $5 | $25 | Frontier intelligence for complex reasoning |
Data sourced from Anthropic & MindStudio blog [1, 4].
Haiku 4.5 is the fast, economical choice for high-throughput tasks like content moderation, simple summarization, or routing user queries. Sonnet 4.5 is the versatile mid-tier, the "workhorse" capable of handling a wide range of enterprise tasks.
And then there is Opus 4.5. Anthropic positions it as "the best model in the world for coding, agents, and computer use" [1]. Anthropic hasn't released a specific SWE-bench score for Opus 4.5, but its launch materials include a chart showing it outperforming other state-of-the-art models on the benchmark [1]. The qualitative feedback is just as strong, with early testers reporting that it "just 'gets it'" [1] and reviewers calling it "the best model currently available" [3].
The Architectural Shift: From "Opus as Escalation" to "Opus as Default"
For the last couple of years, the standard architecture for cost-conscious AI applications has been a "cascade" or "routing" tier.
The Old Pattern: A user request comes in. It's first sent to the cheapest, fastest model (a Haiku-class model). The router analyzes the model's output. If the model indicates it's not confident, or if the output fails a validation check, the request is escalated to a more capable, more expensive model (a Sonnet-class model). Only for the most valuable, complex, or persistently failing queries would the system escalate to a frontier model like a previous-generation Opus, whose cost was often an order of magnitude higher. One early access customer noted that previous Opus models were "cost prohibitive" [1].
This pattern treated frontier models as a safety net, an expensive resource to be used as sparingly as possible. The new pricing of Opus 4.5 fundamentally challenges this architecture.
The New Pattern: At $5/$25 per million tokens, Opus 4.5 is still the most expensive model in the family, but it's no longer in a completely different league. As the same customer remarked, it's "now at a price point where it can be your go-to model for most tasks" [1]. This allows for a new routing strategy: for certain classes of problems, Opus 4.5 becomes the default, not the exception. The tasks that Anthropic highlights — complex software engineering, multi-step agentic workflows, and deep research — are now candidates for an "Opus-first" approach.
The calculation is no longer just about token cost. It's about the total cost of task completion. If a Sonnet 4.5 run fails and requires a retry, you've paid for two model calls and added latency. If that failure requires human intervention, the cost skyrockets. In these scenarios, paying the 2x premium for an Opus 4.5 run that succeeds on the first try is the more economical choice.
A Worked Example: Routing Logic for an Agentic Workflow
Let's make this concrete. Imagine you're building an agent to help developers migrate a large Python 2 codebase to Python 3. This is a complex, multi-step task that perfectly fits the profile for the Claude 4.5 family. Here's how you might design the routing logic.
Initial Planning: The user provides the agent with a link to the git repository and the instruction: "Migrate this codebase to be Python 3 compatible." The agent's first job is to analyze the repository, identify dependencies, and create a multi-step migration plan. This is a high-stakes, ambiguous, and complex reasoning task.
Old Router: Might try Sonnet first, hope for the best, and have complex logic to detect if the plan is coherent.
New Router: This is a bullseye for Opus 4.5. The risk of a flawed plan from a lesser model, which could derail the entire process, is too high. The router sends this directly to Opus.
Per-File Code Conversion: The agent now iterates through the files identified in its plan. For each file, it needs to apply transformations, like changing
printstatements toprint()functions. This is a well-defined coding task.Router Logic: Sonnet 4.5 is the perfect workhorse here. It's more than capable of handling this deterministic code transformation at a lower cost than Opus.
Generating User Updates: As the agent works, it provides status updates to the user in a Slack channel. "I've analyzed 15 of 57 files. So far, the main challenge is the outdated
urllib2library."Router Logic: This is a simple summarization task. Sending this to Opus or even Sonnet would be a waste of money and capability. This is a job for Haiku 4.5.
Here is what a simplified router might look like in code. Note that the API model string for Opus 4.5 is claude-opus-4-5-20251101 [1]; the strings for Sonnet and Haiku are placeholders as they were not provided in the sources.
# A simplified model router for our Python migration agent
def select_model_for_task(task_type: str, prompt: str) -> str:
"""
Selects the most appropriate and cost-effective Claude model for a given task.
"""
if task_type == "agent_planning" or task_type == "complex_reasoning":
# For initial strategy, debugging complex errors, or handling ambiguity.
# The cost of failure is high, so we default to the most capable model.
print("Routing to Opus 4.5: High-stakes reasoning task.")
return "claude-opus-4-5-20251101"
elif task_type == "code_generation" or task_type == "file_transformation":
# For well-defined, repetitive coding tasks.
# Sonnet 4.5 is the reliable, cost-effective workhorse.
print("Routing to Sonnet 4.5: Standard code generation task.")
return "claude-sonnet-4.5-20250929" # Placeholder model string
elif task_type == "summarization" or task_type == "user_update":
# For low-complexity, high-volume tasks.
# Haiku 4.5 provides the best value.
print("Routing to Haiku 4.5: Simple text generation.")
return "claude-haiku-4.5-20251020" # Placeholder model string
else:
# Default fallback
print("Defaulting to Sonnet 4.5 for unknown task type.")
return "claude-sonnet-4.5-20250929" # Placeholder model stringThe Agent Unlock: Model + Harness
A powerful model is only one part of the equation for building effective agents. As McKay Wrigley notes, "An agent's harness matters almost as much as its model" [2]. This "harness" is the surrounding software — the SDKs, execution loops, and tool-use frameworks — that allows the model to interact with the world, maintain state over long periods, and recover from errors.
Anthropic is clearly thinking along these lines. The Opus 4.5 release was accompanied by updates to the Claude Developer Platform and "new tools for longer-running agents" [1]. Wrigley argues that pairing Opus 4.5 with the Claude Agent SDK is what makes the "year of agents" a reality, calling it a "major unhobbling" [2]. He draws an analogy to Alan Kay's famous quote, suggesting, "people who are serious about models should make their own harness" [2]. The architectural lesson is clear: you cannot evaluate a model in a vacuum. Its performance in a real-world agentic system is a function of both the model's intelligence and the quality of the framework it operates within.
What this means in practice
The shift from "Opus as escalation" to "Opus as default for complexity" has tangible consequences for builders and users.
Your metrics are probably wrong. If your dashboard only tracks cost per thousand tokens, you're optimizing for the wrong thing. What actually matters is the cost per successfully completed task. That takes a more careful approach to logging: you need to count not just API bills, but also the hidden costs of failure — retries that add latency, engineers who have to step in and fix things by hand, and customers who quietly give up on a feature that doesn't work reliably.
Agentic workflows can get more ambitious. For the past year, building reliable agents has meant fighting the flakiness of the models underneath them. The dream of a "Waymo"-style agent — where you give it a destination and simply trust it to get there, the way you'd trust a self-driving car [2] — felt far off. With Opus 4.5's improved reasoning and reliability, that's closer to reality. Teams building products for genuinely hard tasks — code refactoring, pulling together scientific research, running marketing campaigns with minimal supervision — should be reassessing just how ambitious they can be. Anthropic claims tasks that were "near-impossible for Sonnet 4.5 just a few weeks ago are now within reach" [1].
The baseline quality of everyday AI features rises. While the architects are busy thinking about routing and agents, ordinary users will just notice things working better. Anthropic says Opus 4.5 is "meaningfully better at everyday tasks like deep research and working with slides and spreadsheets" [1]. In practice that means sharper summaries, more useful data analysis, and chat assistants that are less likely to go off the rails. The "it's a joy to use" reaction from expert reviewers [3] should, over time, show up as less friction for everyone else too.
Budgeting conversations get more strategic, not simpler. The conversation with finance shifts from "how do we minimize the AI bill" to "how do we get the best return for each dollar spent." A well-designed system that routes tasks across the whole Claude 4.5 family can be pitched as a way to optimize for both cost and quality, rather than just a line item to shrink. But it's worth heeding Zvi's caution: Opus 4.5 "should not be your exclusive model" [3]. Using a mix of models thoughtfully still beats defaulting to the most expensive one for everything.
Where this is heading
The release of Claude Opus 4.5 clarifies some trends and leaves other questions open. Here's what's worth watching as you plan around it.
Speed is the big unanswered question. None of the launch materials or early reviews give concrete numbers on how fast Opus 4.5 responds or how much traffic it can handle [1, 2, 3, 4]. For anything real-time and interactive — a chat assistant, a live coding tool — speed can matter as much as intelligence. A brilliant answer that arrives after the user has already given up and left is worthless. Opus 4.5 seems built for longer, more deliberate tasks, where a few extra seconds don't matter much. But if you're considering it for anything user-facing, test its actual response times against your own workload rather than taking this on faith.
Someone now has to manage the model portfolio. The trends above point to a new kind of job. It's no longer enough to just pick a model once. At scale, building with AI means actively managing a mix of models — deciding which task goes where, tracking the true cost of getting things done (including failures), and knowing when to trade up to a smarter, pricier model or down to a cheaper, faster one. That's a genuinely specialized skill, part engineering and part budgeting, and it's becoming its own role rather than an afterthought.
The surrounding toolkit — the "harness" — is becoming the next battleground. McKay Wrigley's argument [2] suggests the competition among AI companies is expanding beyond who scores highest on a benchmark. It's increasingly about who provides the best complete experience for building complex, dependable systems — the model plus the software scaffolding around it. Pairing a frontier model like Opus 4.5 tightly with a dedicated toolkit like the
Claude Agent SDKis a strong combination, and it's reasonable to expect more companies to sell model and toolkit together as a single package, rather than the model alone.Your own tests matter more than published benchmarks. The industry is shifting toward more realistic, practical benchmarks like SWE-bench [1], which is a good thing — but it isn't enough on its own. The benchmark that actually matters is the one built around your specific product. Before moving any real workflow to Opus 4.5, it's worth building your own small set of test tasks, measuring how your current setup (say, Sonnet 4.5) performs on them, and then comparing Opus 4.5 against that baseline on three things: how good the output is, how much it costs once you include failures and retries, and how long it takes. Only with numbers like that in hand can you make a decision you can actually defend.
