Claude Opus 5: A Working Developer's Assessment of Anthropic's New Flagship

Where Opus 5 Sits in the Claude 5 Family

Anthropic's Claude 5 family now has four tiers: Fable 5 at the frontier, Opus 5 just behind it, Sonnet 5, and Haiku 4.5. The positioning matters. Fable 5 is the pick for the most ambitious, long-horizon agent work — but it carries $10/$50 per million input/output tokens, a January 2026 knowledge cutoff, and a 30-day data retention requirement that rules it out for many enterprise workloads. Opus 5 slots in as the model teams are meant to reach for by default: near-frontier capability at $5/$25 per million tokens, no data retention requirement, and a May 2026 knowledge cutoff — the freshest of any Claude model.

Anthropic's cadence here is worth noting. Opus 5 shipped July 24, 2026, making it the fourth Claude 5 model in under two months. That pace creates real evaluation overhead for teams maintaining model selection logic. The API model ID is claude-opus-5 with no date suffix, so pinning is straightforward, but your evaluation loop needs to keep up.

What Actually Matters to Developers

Coding Benchmarks Worth Taking Seriously

SWE-bench Verified is the benchmark I trust most for day-to-day coding tasks because it uses real GitHub issues with execution-verified solutions. Opus 5 scores 96.0% on Verified and 79.2% on the harder SWE-bench Pro — up from 69.2% for Opus 4.8. That jump is substantial. On Frontier-Bench v0.1, an agentic coding benchmark, Opus 5 scores 43.3% and beats both Fable 5 and GPT-5.6 Sol outright. CursorBench 3.2 puts Opus 5 at max effort within 0.5% of Fable 5's peak score at half the cost.

For multimodal coding — reading screenshots, diagrams, or UI mockups as part of a task — SWE-bench Multimodal jumped from 38.4% to 59.4%. If any of your agents parse architectural diagrams or UI screenshots as part of a workflow, that improvement is directly useful.

The ARC-AGI-3 score of 30.2% versus 7.8% for the next-best model is the number that surprised me most. ARC-AGI-3 is designed to penalise pattern memorisation; a roughly 3× lead suggests the model handles genuinely novel reasoning better than the benchmark leaders from six months ago.

Effective Context at 1M Tokens

Opus 4.8's 200k window degraded in practice — mid-window performance fell off measurably. Opus 5 extends to 1M tokens with Anthropic claiming consistent performance throughout. I would not take that claim at face value without testing it on your own codebase, but even a honest 600k-token effective window represents a real change for tasks like refactoring a large solution or auditing a sprawling dependency graph.

Max output is 128k tokens. For .NET projects generating scaffolding, migration scripts, or test suites in a single pass, that ceiling matters less often than the input window does.

Opus 5 Inside Claude Code

Switching to Opus 5 in Claude Code is a one-liner:

/model claude-opus-5
# or on the command line:
--model claude-opus-5 --effort high

The effort toggle — low, medium, high, xhigh, max — is the most operationally important new control. At xhigh, the model beats every other offering on the GDPval-AA v2 Elo leaderboard while using 25% fewer output tokens than max effort. That is the sweet spot for complex agent tasks: you get the reasoning depth without burning tokens on extended thinking chain-of-thought.

There is a real gotcha here. At xhigh or max effort the model spends a significant number of tokens on internal reasoning before producing output. If your max_tokens budget was tuned for Opus 4.8 or a smaller model, the agent can silently exhaust its budget mid-task — manifesting as truncated output, abandoned tool calls, or a subagent chain that appears to give up halfway through without an error. Bump max_tokens generously when moving to higher effort levels and verify with integration tests that run to completion.

Two new API betas shipped alongside Opus 5: automatic fallbacks (requests that trip a safety classifier route to Opus 4.8 rather than being blocked outright) and mid-conversation tool changes (swap toolsets between turns without invalidating the prompt cache). The second one is particularly useful if you are building agents that change their available tools based on task phase — for example, transitioning from a read-only analysis phase to a write-capable execution phase in a single session.

Behavioral changes worth flagging: the model self-verifies its output without being prompted, follows review instructions literally (conservative language in a system prompt suppresses recall, not just tone), produces longer default output, and can expand task scope autonomously. All of this is useful in genuinely autonomous sessions, but it means existing pipelines can behave differently after a model-string change even though the API surface is identical.

Cost and Performance Trade-offs

The pricing picture for the Claude 5 family:

Opus 5's fast mode doubles the price to match Fable 5's but without the data retention requirement and with better computer-use and automation scores (OSWorld 2.0: 70.57% versus Opus 4.8's 55.7%; Zapier AutomationBench: 26.0% versus Fable 5's 17.4%). If you need Fable 5-level latency without the retention policy constraint, Opus 5 Fast is the path.

For batch workloads or background agents where latency is irrelevant, standard Opus 5 at medium effort is compelling. Anthropic's own figures show medium effort costing roughly $0.89 per task on AutomationBench at 24% success — roughly half the cost of max effort with only a few percentage points of capability loss on routine tasks.

Practical Guidance for .NET AI Applications

Here is a straightforward model-selection heuristic for .NET coding agents:

• Interactive coding assistant / IDE integration: Opus 5 at medium or high effort. The 96% SWE-bench Verified score and improved self-verification make this the default choice.
• Background CI agent (refactoring, test generation, migration scripts): Opus 5 at xhigh. The 25% output token saving over max effort matters at scale.
• Zero-retention enterprise requirement: Opus 5 is the strongest Claude model you can use. Fable 5 is off the table.
• Latency-critical paths (inline completions, real-time chat): Opus 5 Fast, or drop to Sonnet 5 if the task complexity allows it.
• Most advanced autonomous research agents with no retention constraint: Fable 5 still leads on FrontierCode and Humanity's Last Exam without tools.

For a .NET application using the Anthropic SDK, migration is a model-string change plus careful review of max_tokens:

using Anthropic.SDK;
using Anthropic.SDK.Messaging;
 
var client = new AnthropicClient();
 
var request = new MessageRequest
{
    Model = "claude-opus-5", // was claude-opus-4-8
    MaxTokens = 16384,        // increase from prior budget — effort uses thinking tokens
    Messages = new List<Message>
    {
        new Message(RoleType.User, "Refactor this C# service to use the new IHostedService pattern.")
    },
    System = "You are a senior .NET engineer. Respond with complete, compilable C# code."
};
 
var response = await client.Messages.GetClaudeMessageAsync(request);
Console.WriteLine(response.Content[0].Text);

If you are using the effort toggle through the API:

// Effort is passed as a beta header or extended parameter depending on SDK version.
// Check Anthropic SDK release notes for the exact field name at time of integration.
var request = new MessageRequest
{
    Model = "claude-opus-5",
    MaxTokens = 32768, // generous budget for xhigh effort thinking tokens
    Messages = messages,
    AdditionalProperties = new Dictionary<string, object>
    {
        ["effort"] = "xhigh"
    }
};

Verify the exact SDK field name against current Anthropic SDK release notes; the effort parameter surface was still stabilising at the time of writing.

Caveats and How to Evaluate It on Your Own Workload

Priority Tier is gone. Opus 4.8 supported it; Opus 5 does not. If enterprise capacity planning depends on Priority Tier for throughput guarantees, that is a concrete blocker to resolve before migrating.

Behavioral drift is the real migration risk. The API surface is unchanged, but the model's default behaviour — longer output, scope expansion, self-verification — can alter observable pipeline behaviour without any code change. Run your integration test suite against Opus 5 before promoting it to production, and specifically check that agents complete tasks within expected token budgets and do not expand scope in ways that break downstream consumers.

Security tooling caution. Opus 5 has elevated cybersecurity safeguards, similar to Fable 5. Benign security work — penetration test scaffolding, vulnerability scanning utilities, security research agents — can occasionally trigger those classifiers. The automatic fallback to Opus 4.8 mitigates hard failures, but if accuracy on security tasks matters, verify that fallback behaviour is acceptable rather than assuming it is transparent.

Indirect prompt injection improved but not solved. The Gray Swan benchmark shows attacker success dropping from 5.5% to 2.0% within 15 attempts. For agents that process untrusted input — emails, documents, web content — that is a meaningful improvement, but 2.0% is not zero. Defense-in-depth still applies.

The benchmark story is strong enough that Opus 5 is my default recommendation for new .NET agent projects today. But the right evaluation is always your own task distribution, your token budget, and your latency requirements — not a leaderboard.