Claude Opus 5.5: 5x Cost Efficiency vs Max Effort

There's something quietly remarkable about a model that does better work while costing less to run. Usually, performance gains come with a price tag. You pay for the upgrade.

Anthropic's latest release doesn't follow that pattern. At default effort, the new model scores 5.5 on CLIFF—the benchmark for complex command-line tasks—compared to its predecessor's 5 at maximum effort. The kicker: it costs about one-fifth as much to run.

We don't talk enough about efficiency in AI development. The industry's obsession with bigger numbers often overshadows the practical question: how much compute does this actually require? The 5.5 family flips that script. Most of the work gets done by 5.1, which runs 40% cheaper than the previous Opus 5 while matching or exceeding its performance.

This isn't just about cost savings. It's about what happens when you stop treating inefficiency as inevitable. The 5.5 System Card reads like documentation from a team that actually thought about tradeoffs, not just scaling laws.

Real-World CLI Performance

Opus 5.5 handles complex CLI tasks efficiently on Terminal-Bench 4.0 at x-high effort. In practical comparisons against GPT-6 Astra at high effort, the difference shows up in token usage and task completion rates — not raw accuracy, but how much it costs to get there.

The benchmark numbers tell a clear story:

• Multidisciplinary reasoning (Humanity's Last Exam): 67.7% with tools
• Computer use (OSWorld 2.0): 81.8% partial with tools
• Visual chart recognition (Chartography): 89.0% with tools

At default effort, Opus 5.5 beats Opus 5 at max effort while using roughly a fifth of the cost. It also matches GPT-6 Astra's performance at around 40% of the cost, based on our internal testing.

This matters because real CLI work isn't about acing benchmarks — it's about finishing jobs like the Friday order export that timed out after running for 2 hours on the warehouse query. That kind of failure isn't rare enough to ignore, and it doesn't come with a clean error message. It just hangs.

One engineer left Opus 5.5 running overnight on an unattended task across six repositories. It stayed on track for over 18 hours, mapping out service interactions without supervision. That's the kind of reliability you can't fake with clever prompting alone.

To test this yourself, install the CLI tool and run a basic task:

npx @anthropic/claude-cli --model opus-5-5 --task "List all Python files modified in the last week and summarize their purpose"

It's not magic. But when your pipeline depends on agents that finish what they start, the difference between "close enough" and "actually done" gets expensive fast.

Practical Usage Scenarios

The warehouse export timeout isn't a hypothetical optimization problem. It's a real failure that happened twice this month, where a Friday order export hangs for two hours on the warehouse query before timing out. That's the kind of task an agent should handle autonomously — not just by running a query, but by recognizing the pattern, escalating appropriately, and keeping stakeholders informed while it works.

Claude Opus 5.5 is the model doing that work right now, and the benchmark numbers back it up. On OSWorld 2.0, it scores 81.8%, which means it's not just clicking buttons — it's navigating the messy reality of desktop environments, file systems, and applications that don't have clean APIs. Chart recognition hits 89.0%, and multidisciplinary reasoning on Humanity's Last Exam reaches 67.7% with tools. These aren't toy numbers.

Here's what that looks like in practice when you're running an agent on a real engineering task:

claude --model opus-5-5 \
  --max-tokens 200000 \
  --cost-budget 200 \
  --task "Refactor service communication layer across 6 repositories" \
  --monitor-tokens \
  --timeout 72000

The quote from the field testing is telling: Opus 5.5 used among the fewest tokens and steps measured across both GitHub Copilot CLI and VS Code. One team handed it a large engineering task across six repositories and let it run overnight unattended. It stayed on task for over 18 hours, defining how services talk to each other without human intervention.

Compare that to the cost curve. Opus 5.5 at default effort beats Opus 5 at max effort for about a fifth of the cost. It matches GPT-6 Astra at high effort while spending only 40% of the tokens. On FrontierCode v1.1, it scores 54.6% at default medium effort. That's the real constraint — not raw capability, but capability per dollar when you're running agents that might spin for hours.

Benchmark Deep Dive

The model shows clear strengths in structured reasoning and visual tasks. On multidisciplinary reasoning benchmarks like Humanity's Last Exam, it scores 67.7% with tools — a solid result but not dominant. The standout is chart recognition: 89.0% accuracy on Chartography with tools, leading the category by a wide margin. Computer use tasks trail slightly, with OSWorld 2.0 at 81.8% partial completion using tools.

This pattern shows up in real usage too. A quote from early testing: "I handed Claude Opus 5.5 a large engineering task across six of our repositories and let it run overnight, unattended. It stayed on task for over 18 hours defining how our services talk to each other." The efficiency gains are real — Opus 5.5 at default effort matches GPT-6 Astra at high effort while using about 40% of the compute.

But there's a reliability issue biting teams. One benchmark run failed twice this month because Friday's order export timed out after running 2 hours on the warehouse query. The problem isn't just slow queries — it's that long-running tasks seem to hit resource limits or connection timeouts. This isn't a performance gap; it's an infrastructure problem.

Here's a practical fix for the timeout issue. Instead of running the full export synchronously, break it into chunks:

import asyncio
from datetime import datetime, timedelta

async def chunked_export(start_date, end_date, batch_days=7):
    current = start_date
    while current < end_date:
        batch_end = min(current + timedelta(days=batch_days), end_date)
        query = f"""
        SELECT * FROM orders 
        WHERE created_at >= '{current}' 
        AND created_at < '{batch_end}'
        """
        await run_query_with_retry(query, max_retries=3)
        current = batch_end

This keeps each query under the 2-hour mark and gives you retry logic on failures. The benchmark numbers look good on paper, but this kind of real-world reliability is what actually makes or breaks adoption.

Cost vs. Capability Trade-offs

The benchmark here is doing real work, not parroting back impressive-sounding answers. It measures whether a model can actually navigate a terminal, chain together commands, debug failures, and produce something useful — all without hand-holding. That's a meaningful shift from eval setups that reward sounding knowledgeable over being capable.

What stands out is how much lower-cost models are holding their own. If a 0-rated model can complete these tasks at a fraction of the compute spend of an Opus-tier behemoth, the implication isn't just about performance tiers — it's about what we're actually optimizing for. Maybe raw scale isn't the bottleneck for real-world CLI workflows. Maybe it's knowing which commands to run, how to recover from errors, and whether to stop and ask for help.

Opus 5.5's writing adjustments feel like damage control, not progress. Users complained about stilted prose, so they made it sound more natural — fine. But the deeper issue remains: these models still hallucinate file paths, invent CLI flags that don't exist, and confidently assert incorrect syntax. Polishing the output doesn't fix the reliability gap between what the model says it did and what it actually did.

I'm not convinced UI polish matters much here. The friction isn't in how the model talks — it's in debugging why a perfectly reasonable-looking command sequence failed halfway through. Until that changes, cost savings won't translate into trust.

Conclusion

What actually matters here isn't the benchmark scores — it's that Claude 5 at default effort handles complex CLI workflows that used to require Opus 5 at maximum effort, while costing roughly one-fifth as much. That's not incremental improvement. That's the kind of efficiency gain that changes when and how teams actually deploy these models in production.

The bigger question is whether these gains hold outside controlled benchmarks. The article notes that at this level of capability, benchmark margins have become less reliable as guides to real-world differences. I'm still not sure what to make of that — whether we're hitting diminishing returns on raw performance, or whether the real value is shifting toward how these models integrate into actual workflows rather than how they score on isolated tasks.

Anthropic says more improvements are coming in the next few weeks. If those land anywhere close to the efficiency gains already demonstrated, the cost-performance curve for enterprise adoption just got a lot more interesting for a lot of teams.