Back to feed
News Story
量子位
1 sources

Opus 5 reasoning effort not always better: medium setting peaks performance

An analysis reveals that setting Opus 5's reasoning effort to maximum degrades performance on many tasks, with medium being optimal for coding benchmarks. The model tends to over-engineer solutions when given excessive reasoning budget, leading to unnecessary code refactoring and increased costs. Anthropic recommends using low or medium effort for most tasks to balance quality and cost.

SynthePulse Insight · AI deep reading

Opus 5 Reasoning Tier Trap: Max ≠ Best, Medium Is the Performance Peak

Version 1 · 1 source

Anthropic's Opus 5 reasoning intensity isn't always better. FrontierCode benchmarks show Medium tier delivers peak performance, while Max degrades quality due to over-refactoring. The default High tier hides cost and cache pitfalls; task-based layering is the optimal strategy.

  • FrontierCode benchmarks show Opus 5 reasoning tiers from Low to Max form an inverted U-shaped performance curve, with Medium peaking and Max declining.
  • At higher tiers, the model unnecessarily refactors unrelated code, adjusts imports, renames variables, and inflates small issues into full PRs, degrading quality.
  • Anthropic's official prompt guide recommends: as long as quality doesn't drop, prioritize Low and Medium tiers to reduce cost and latency, reserving high tiers for hard, long-cycle tasks.
  • Opus 5's default reasoning is set to High, contradicting official advice; users must manually adjust.
  • Switching reasoning tiers clears the context cache, causing repeated reloads and potentially increasing overall cost. Locking a single tier per workflow is recommended for sustained cache hits.
Open section navigationInverted Performance Curve: Medium Is the Ceiling

Inverted Performance Curve: Medium Is the Ceiling

A user conducted comprehensive tests on Opus 5's reasoning tiers from Low to Max using the FrontierCode programming benchmark. The results revealed that performance does not monotonically increase with tier; instead, it forms an inverted U-shaped curve: Medium tier achieves peak performance, while Max tier actually declines. This finding overturns the intuition that 'higher reasoning intensity is better.'

Reasoning tiers essentially act as gates on reasoning budget, controlling how much the model thinks before acting. Higher tiers allow the model to think longer and deeper before executing. However, when the task itself doesn't require that much thinking, the extra budget causes the model to repeatedly verify, rehash conclusions, or even deviate from the original requirements.

The 'Over-Acting' Phenomenon in Code Scenarios

In code-fixing scenarios, low tiers (e.g., Low) produce targeted patches, fixing only a few lines of a function's bug. But when intensity is increased, the model's surplus compute drives it to unnecessarily refactor unrelated functions, adjust imports, rename variables, and even optimize unrelated code. A small issue gets inflated into a full PR, turning extra budget into a burden.

This pain point is especially pronounced with Opus 5, which tends to 'over-act' at the slightest provocation. Anthropic's prompt guide almost explicitly tells users to lower the reasoning tier: as long as evaluations confirm quality doesn't drop, widely use Low and Medium to reduce cost and latency, reserving high tiers for truly hard, long-cycle tasks.

Contradiction Between Default Settings and Official Advice

Despite Anthropic's recommendation to prioritize Low and Medium tiers, Opus 5's default reasoning was set to High at launch. This contradiction leads many users to inadvertently choose an excessively high tier, incurring unnecessary cost and quality risks.

Users can adjust the `output_config.effort` parameter via the API or change the default tier in Claude Code configuration. After adjustment, the model no longer 'runs wild,' output tokens shrink significantly, and structured task quality actually improves.

Task-Based Layering and Cache Cost Traps

The optimal strategy is to layer by task: use Low for mechanical tasks like formatting and information extraction; Medium or High for daily coding and code review; and xHigh or Max only for long-cycle agent tasks requiring extended autonomous reasoning.

However, switching tiers clears the context cache because the effort tier is a cache-matching identifier. Even if per-turn cost drops, cache invalidation leading to repeated reloads may increase overall cost. Therefore, it is recommended to lock a single tier per workflow and never change it, to sustain cache hits and compress total overhead.

Credibility boundary

This article is based on QuantumBit's analysis of Opus 5 reasoning tiers, citing FrontierCode benchmark results and Anthropic's official prompt guide. Test data comes from third-party users and has not been officially confirmed by Anthropic, but observations from multiple independent sources (X platform users) are consistent. Default setting information comes from Anthropic's public configuration at launch.

Insight takeaway

Opus 5's reasoning tier is not always better. Medium tier performs best on FrontierCode benchmarks, while Max tier degrades quality due to over-refactoring. Users should avoid blindly maxing out, choose tiers based on task layering, and beware of cache cost traps by locking a single tier per workflow to optimize cost and performance.

Primary report

量子位

Primary source