Claude Opus 5 for Product Managers: The Effort Toggle and What Changes

What Is Claude Opus 5 and What Actually Changed

Anthropic released Claude Opus 5 on July 24, 2026, positioning it as the most capable model in the Claude family. The headline benchmark is ARC-AGI 3, a test of fluid reasoning that prior models struggled with. Opus 5 scores approximately 3x the next-best model on this benchmark, which measures the ability to reason through genuinely novel problems that cannot be solved by pattern matching on training data alone.

Beyond the benchmark, four architectural and behavioral changes matter for product teams:

Effort-control parameter

What it is: A new API parameter (low, medium, high) lets callers specify how much reasoning the model should apply per request. Low effort is fast and cheap; high effort activates extended thinking that can run for minutes on hard problems.

Why it matters for your product: For the first time, you can tune reasoning depth per action rather than choosing between 'smart and expensive' or 'fast and cheap' across your entire product.

Adaptive thinking on by default

What it is: The model decides when to apply extended reasoning without being explicitly told. On straightforward queries it answers quickly. On ambiguous or complex ones it applies a longer reasoning chain before responding.

Why it matters for your product: Latency variance increases. A simple request finishes in under two seconds; a complex one might take 45 seconds. Your UX needs to handle both states gracefully.

Mid-conversation tool swaps (beta)

What it is: The model can add or remove tools from its available set during a multi-turn session, based on what the conversation requires.

Why it matters for your product: Agentic workflows that currently require multiple separate sessions can be consolidated. Fewer round trips, lower latency, simpler product architecture for multi-step tasks.

Automatic safety fallbacks

What it is: When Opus 5 encounters a request that triggers a safety refusal, it can automatically route to an alternate model or a constrained response mode rather than returning a hard refusal.

Why it matters for your product: Reduces friction for edge cases that would previously have required manual escalation flows. But it makes safety behavior less predictable and requires testing across more scenarios.

The Effort Toggle: A New Product Decision

The effort toggle is the most product-relevant feature in Opus 5. Prior models had one mode: the model did as much or as little reasoning as it internally decided. With Opus 5, you choose the depth. That shifts a model-internal behavior into an explicit product design decision.

The three tiers map roughly to:

Low effort

Latency: Under 2 seconds

Cost: Lowest

Best for: FAQ answering, intent classification, simple extraction, UI copy generation, short-form summarization. Tasks where the correct answer is unambiguous and speed is the primary user value.

Risk: Will miss nuance on ambiguous inputs. Do not use low effort for any decision-critical path.

Medium effort

Latency: 2 to 15 seconds

Cost: Standard

Best for: Multi-part user queries, moderate reasoning tasks, drafting that requires judgment, analysis with a few competing considerations. This is the default for most product use cases.

Risk: May not catch subtle errors in complex reasoning chains. Add human review gates on critical outputs.

High effort

Latency: 15 to 90+ seconds

Cost: Highest (3 to 6x standard)

Best for: Legal document analysis, complex code review, scientific literature synthesis, multi-step financial modeling, anything where an incorrect answer has significant downstream consequences.

Risk: Latency makes it unsuitable for real-time UX without explicit progress indicators. Cost makes it unsuitable for high-volume use cases without caching or batching.

The practical implication: your product needs a routing layer that assigns an effort tier to each user action before the API call. This is a product architecture decision, not just a configuration choice. Building it after launch means retrofitting it across every AI-powered surface.

Building an Effort Routing Layer

The effort toggle only creates value if your product routes requests correctly. A routing layer is a classification component, upstream of the Opus 5 API call, that maps incoming user actions to an effort tier. Here is how to build one that works.

Step 1: Classify action types

Work with your team to categorize every user-facing AI action in the product. Group them by stakes and complexity, not by feature. A 'summarize this document' action might warrant low effort for a meeting note and high effort for a contract. The document type, not the action name, determines stakes.

Step 2: Set consequence-based defaults

For each action category, assign a default effort tier based on the consequence of a wrong answer. Wrong output for a search suggestion: low consequence, low effort. Wrong output for a contract clause: high consequence, high effort. Start with conservative defaults and tune down when you have eval data showing low effort performs well enough.

Step 3: Add signal-based overrides

Certain signals in the input should override the default tier. Long input (above a token threshold) suggests complexity and warrants bumping effort up. Queries that contain 'compare,' 'analyze,' or 'recommend' vs. those that contain 'define' or 'list' suggest different reasoning depth. Build these overrides as configurable rules so PMs can tune them without engineering changes.

Step 4: Measure and close the loop

Log the effort tier, the output quality (from your eval suite or user feedback), and the cost per request. Track: what fraction of high-effort calls were actually needed based on quality signal? Are low-effort routes producing acceptable outputs? This data tells you where to re-calibrate without guessing.

Step 5: Make effort invisible to users

Users should not know which tier they triggered. What they experience is: fast answers for quick tasks, longer waits with clear progress indicators for complex ones. If you are showing a progress indicator for high-effort calls, make it informative, not just a spinner. 'Analyzing the contract clauses...' is better than 'Loading...'

Build AI Products With Confidence

The AI PM Masterclass covers model selection, routing architecture, and cost management for production AI features. Taught live by a Salesforce Sr. Director PM.

ARC-AGI 3 and What It Means for Your Product

ARC-AGI 3 is a reasoning benchmark designed to test generalization, not recall. Tasks require building a rule from a small number of examples and applying it to a new case. The test is constructed so that memorizing training data cannot produce high scores; the model genuinely needs to induce novel rules.

Opus 5 scoring 3x the next-best model on this benchmark has concrete implications:

Stronger on novel problem types

If your product handles requests that do not pattern-match to common training examples, Opus 5 will perform significantly better than prior models. Regulatory edge cases, unusual contract language, uncommon medical presentations, rare error codes. These are exactly the cases where prior models hallucinate or deflect.

More useful for low-volume, high-stakes workflows

ARC-AGI 3 performance correlates with reliability on tasks a model sees infrequently. This makes Opus 5 the right default for internal enterprise tools where each query is genuinely different, rather than consumer products where queries cluster into predictable patterns.

Does not make evals less important

A higher ARC-AGI 3 score does not mean the model performs well on your specific use case. Domain-specific evaluation on your own task distribution is still required. The benchmark tells you the model reasons better; it does not tell you it reasons correctly for your problem.

Expect fewer confident wrong answers

Empirically, models with higher generalization scores show better calibration, meaning they are less likely to answer confidently on questions they cannot reliably answer. Opus 5 should produce fewer hallucinations with high confidence, though this is still not zero.

Migration Considerations: Should You Switch?

If you are already running Claude Opus 4.8 in production, here is a structured framework for deciding whether to migrate to Opus 5 and how quickly.

Migrate immediately if...

Your product handles genuinely novel or edge-case inputs where Opus 4.8 shows a measurable hallucination rate. Legal, medical, scientific, and financial domains are the primary candidates. The ARC-AGI 3 gap is real and directly translates to these use cases.

Migrate in the next sprint if...

Your current product uses a uniform model call for all actions with no effort routing. The effort toggle alone creates enough cost and quality benefit to justify a migration investment.

Evaluate before committing if...

Your product relies heavily on fine-tuned behavior from Opus 4.8 prompting. Adaptive thinking changes response patterns in ways that can break carefully engineered prompts. Run your full eval suite on Opus 5 before switching production traffic.

Consider staying on Opus 4.8 if...

Your product is latency-critical (under 2-second P99 requirement) and your use cases are well within Opus 4.8's capability. Adaptive thinking will increase latency variance. Only migrate if you have tested Opus 5 on your specific latency distribution.

The one thing to do before you migrate

Run your existing eval suite against Opus 5 with medium effort before touching production. This gives you a quality baseline that is directly comparable to your Opus 4.8 numbers. If quality is equal or better, the migration decision becomes straightforward. If there are regressions, you know which prompts need updating before traffic shifts.

Positioning Opus 5 in Your Model Stack

No product should run a single model for all tasks. Claude Opus 5 belongs at the top of a tiered model stack. Here is how to think about the full stack:

Tier 1: Claude Haiku 4.5 — High-volume, low-stakes actions

Intent classification, simple form validation, short-form completions, inline autocomplete. Under $0.50 per 1 million output tokens.

Tier 2: Claude Sonnet 5 — Standard product interactions

Multi-turn conversations, moderate summarization, code completion, content generation. Balanced quality and cost. The default tier for most user-facing features.

Tier 3: Claude Opus 5 (low/medium effort) — Complex or decision-critical interactions

Multi-step analysis, report generation, nuanced document review, anything with meaningful consequence if wrong.

Tier 3 extended: Claude Opus 5 (high effort) — Expert-level reasoning tasks

Legal contract analysis, complex technical debugging, scientific synthesis, rare edge cases. Reserve for asynchronous or explicitly acknowledged wait states.

The practical upside of this stack: Opus 5's effort-control parameter means you can collapse Tiers 3 and 3-extended into a single model with a single API surface, rather than managing two separate model configurations. The routing becomes an effort-tier assignment, not a model-selection decision.