Claude Opus 5 Benchmarks: Scores, Pricing & Routing (2026)

Claude Opus 5 is Anthropic's flagship model, released July 24, 2026. It scores 96.0% on SWE-bench Verified and a record 30.2% on ARC-AGI-3, with a 1M-token context window at $5 / $25 per million input/output tokens - the same price as Opus 4.8.

Claude Opus 5  leads most reasoning and agentic benchmarks, though Fable 5 still edges it on the hardest coding tasks (SWE-bench Pro). For production teams, the bigger story is cost: unchanged pricing plus prompt caching and tiered routing make it the best price-to-performance frontier model as of July 2026.

Claude Opus 5: Key Specifications and Architecture

Context Window and Output Capacity

Claude Opus 5 ships with a 1-million-token context window - the same maximum as its predecessor Opus 4.8, but now set as the default rather than an opt-in configuration. The synchronous output capacity on the Messages API is 128k tokens, which matters for long-form generation tasks like code refactoring across entire repositories or multi-document summarization.

Key specifications:

• API model ID: claude-opus-5
• Context window: 1,000,000 tokens (default and maximum)
• Max synchronous output: 128,000 tokens
• Default model on Claude Max subscription
• Supports computer use, agentic tool use, and MCP (Model Context Protocol)

Anthropic documentation now names Opus 5 as the default starting point: if you are unsure which model to use, start with Claude Opus 5. This is a shift from previous guidance that pointed developers to Sonnet as the default, Opus 5 is now both the most capable and the recommended starting model.

Adaptive Reasoning and Effort Levels

Opus 5 introduces an effort toggle with three levels: Easy, Medium, and High - that controls how much test-time compute the model spends before responding. The default is Adaptive, which lets the model self-select effort based on task complexity.

This matters for cost optimization. A simple extraction task on Easy effort costs a fraction of a complex reasoning task on High effort, even at the same per-token price, because the model generates fewer intermediate reasoning tokens. Production teams should map task categories to effort levels:

• Easy effort: Classification, extraction, simple Q&A, formatting tasks
• Medium effort: Code review, multi-step analysis, document generation
• High effort: Complex refactoring, agentic coding, multi-tool orchestration

The effort toggle is the underreported cost lever. On tasks where Opus 4.8 used full reasoning by default, Opus 5 on Medium effort can reduce output token count by 12-35% depending on task type, with minimal quality loss for straightforward code generation tasks.

Benchmark Performance: New State-of-the-Art Scores

SWE-bench Verified: 96.0%

Claude Opus 5 leads the SWE-bench Verified leaderboard at 96.0%, up from Opus 4.8 at 88.6%. SWE-bench Verified tests whether a model can resolve real GitHub issues from popular Python repositories end-to-end: writing patches, running tests, and submitting working fixes.

On SWE-bench Pro, the harder variant that includes more complex multi-file changes, Opus 5 scores 79.2%, up from Opus 4.8 at 69.2%. This 10-point jump represents a generational improvement in agentic coding capability, not an incremental bump.

ARC-AGI-3: 30.2% - A New High Score

Opus 5 set a new high score on ARC-AGI-3 at 30.2%, completing five Public Demo environments that no model had previously beaten. ARC-AGI-3 tests novel reasoning - the ability to work out unfamiliar rule systems through interaction rather than recalling patterns adjacent to training data. A 30% score means Opus 5 is genuinely reasoning through novel problems, not pattern-matching against familiar structures.

Agentic Tool Use and Computer Tasks

On BenchLM.ai agentic tool use and computer tasks benchmarks, Opus 5 ranks 3rd out of 129 models with an average score of 69.4. This category evaluates multi-step tool orchestration, browser automation, and computer-use tasks - the capabilities that matter most for autonomous agent workflows.

Benchmark Comparison Table

The following table compares Opus 5 against key competitors on coding and reasoning benchmarks:

Opus 5 price-to-performance ratio is the key insight: it matches or approaches Claude Fable 5 (Anthropic higher-tier model at roughly 2x the cost) on most benchmarks while costing half as much. It also undercuts GPT-5.6 Sol on output pricing ($25 vs $30) while posting higher SWE-bench scores.

Pricing and Cost Analysis: The Value Equation

Base Pricing and Optimization Levers

Claude Opus 5 maintains the same pricing as the entire Opus 4.x line:

• Input: $5 per million tokens
• Output: $25 per million tokens
• Prompt caching: Up to 90% cost savings on cached input tokens
• Batch processing: 50% savings on non-real-time requests

Prompt caching is the single most impactful cost lever for production applications. If your system prompt, tool definitions, and context documents are stable across requests, caching reduces the effective input cost from $5/M to $0.50/M for the cached portion. A typical agentic coding session with a 50k-token system prompt cached across 100 queries saves approximately $22.50 per session on input costs alone.

Competitor Price Comparison

Opus 5 is cheaper than GPT-5.6 Sol on output ($25 vs $30) while posting higher coding benchmarks. Gemini 3.1 Pro is cheaper at $2/$12 but trails significantly on SWE-bench Verified (~85% vs 96%). DeepSeek V4 Pro is the price floor at $0.435/$0.87 but lacks agentic and computer-use capabilities entirely.

Cost-Per-Task Worked Example

Consider an agentic coding pipeline that processes 1,000 GitHub issues per month:

• Average input per task: 15k tokens (system prompt plus repo context)
• Average output per task: 3k tokens (reasoning plus code patch)
• With prompt caching (90% of input cached): effective input cost = 15k tokens times 0.1 at $5/M plus 15k tokens times 0.9 at $0.50/M = $0.0075 plus $0.00675 = $0.01425
• Output cost: 3k tokens at $25/M = $0.075
• Cost per task: approximately $0.089
• Monthly cost for 1,000 tasks: approximately $89

Without caching, the same workload costs $0.15 per task ($150/month) — a 40% premium. With batch processing for non-urgent tasks, the output cost drops another 50% to $0.0375 per task, bringing total cost to approximately $0.052 per task.

Production Model Routing: When to Use Opus 5

The Tiered Routing Pattern

The most cost-effective production pattern in 2026 is tiered model routing: route each task to the cheapest model that can handle it reliably. The pattern that has emerged across high-scale AI applications is:

1. Haiku triages: Claude Haiku 4.5 ($1/$5) handles initial classification, intent detection, and simple extraction. It determines whether a request needs escalation.
2. Sonnet builds: Claude Sonnet 4.6 ($3/$15) handles standard generation, code review, and multi-step analysis. Most production traffic lands here.
3. Opus reviews and escalates: Claude Opus 5 ($5/$25) handles complex reasoning, agentic coding, and tasks where Sonnet failed or the failure cost is high.

With a 70/30 Haiku/Opus traffic split, input-token costs drop by approximately two-thirds. An 80/20 split toward Haiku approaches 79% savings. The exact ratio depends on your task distribution, audit your application to find the natural model match for each request type.

Code Example: Provider-Agnostic Routing

from edenai import EdenAI

client = EdenAI(api_key="your_api_key")

def route_request(prompt, task_type, context_tokens=0):
    """Route to the appropriate model based on task complexity."""
    if task_type in ("classification", "extraction", "formatting"):
        # Simple tasks: cheapest capable model
        return client.chat.completions.create(
            model="anthropic/claude-haiku-4-5",
            messages=prompt,
        )
    elif task_type in ("code_review", "generation", "analysis"):
        # Standard tasks: mid-tier model
        return client.chat.completions.create(
            model="anthropic/claude-sonnet-5",
            messages=prompt,
        )
    elif task_type in ("agentic_coding", "complex_reasoning", "refactoring"):
        # Hard tasks: frontier model
        return client.chat.completions.create(
            model="anthropic/claude-opus-5",
            messages=prompt,
        )
    else:
        # Default: Sonnet for unknown complexity
        return client.chat.completions.create(
            model="anthropic/claude-sonnet-4-6",
            messages=prompt,
        )

‍

The key advantage of a multi-provider API like Eden AI is automatic failover: if Anthropic experiences an outage or rate limit, requests automatically route to GPT-5.6 Sol or Gemini 3.1 Pro without code changes. This matters because Opus 5 launch coincided with several hours of elevated latency on Anthropic API,; a pattern that has repeated across every major model launch in 2026.

When to Use Opus 5 vs Alternatives

• Use Opus 5 when: Tasks involve multi-file code changes, agentic tool orchestration, complex reasoning with novel problems, or when failure costs (rework, customer impact) exceed the token cost premium
• Use Sonnet 5 when: Tasks are standard generation, code review, or analysis where 85-90% of Opus quality is sufficient at 40% lower cost
• Use Haiku 4.5 when: Tasks are classification, extraction, formatting, or simple Q&A where latency and cost matter more than frontier reasoning
• Use GPT-5.6 Sol when: You need OpenAI ecosystem (Assistants API, function calling patterns), realtime audio, or when Anthropic is unavailable
• Use DeepSeek V4 Pro when: Cost is the primary constraint and you do not need agentic or computer-use capabilities

Claude Cookbook and Developer Resources

Alongside Opus 5, Anthropic launched the Claude Cookbook - a developer resource hub at platform.claude.com/cookbook/ with a companion GitHub repository at github.com/anthropics/claude-cookbooks. The Cookbook reached 289 points on HackerNews with 156 comments, indicating strong developer interest.

The Cookbook provides practical, copy-paste code examples for:

• Prompt engineering techniques specific to Claude architecture
• Tool use and function calling patterns
• Multimodal capabilities (vision, document analysis)
• Multi-agent system patterns
• Computer use implementation guides

For production teams, the Cookbook multi-agent patterns are particularly relevant to Opus 5 capabilities. The agentic coding and computer-use benchmarks that Opus 5 dominates require specific implementation patterns, the Cookbook documents these with working code rather than abstract descriptions. The GitHub repository includes Jupyter notebooks that can be cloned and adapted directly.

Multi-Provider Strategy: Beyond Single-Vendor Dependencies

Opus 5 launch illustrates a persistent risk in AI infrastructure: vendor concentration. When Anthropic API experienced elevated latency during the Opus 5 launch window, applications without multi-provider failover saw degraded service. This pattern repeats at every major model launch: OpenAI GPT-5.6 launch in July 2026 caused similar disruptions for OpenAI-only stacks.

The production-grade approach is provider-agnostic access through a unified API layer. Platforms like Eden AI provide a single interface to Claude Opus 5, GPT-5.6 Sol, Gemini 3.1 Pro, and 100+ other models with automatic failover. This means:

• When Anthropic is down, requests route to OpenAI or Google automatically
• When a model hits rate limits, traffic distributes across alternatives
• When pricing changes, you switch providers without rewriting application code
• When a new model launches, you test it with a single parameter change

The cost optimization angle compounds: multi-provider routing lets you use Opus 5 for the 20% of tasks that need frontier quality and automatically fall back to Sonnet or Haiku for the 80% that do not, all through a single API endpoint.

Conclusion

Claude Opus 5 represents a generational leap in agentic coding and novel reasoning, with SWE-bench Verified at 96.0% and ARC-AGI-3 at 30.2%. The unchanged $5/$25 pricing makes it the best price-to-performance ratio among frontier models as of July 2026.

FAQs - Opus 5 Benchmarks: Scores, Pricing & Routing