Anthropic’s SWE-bench testing tells the story: Claude at medium effort uses 76% fewer output tokens than at high effort while completing the same coding tasks. That single setting change, available to every API user and Claude Code subscriber since May 28, is the largest cost lever most teams are ignoring.
Three weeks before Anthropic shipped effort controls in Opus 4.8, Google quietly changed Gemini 3.5 Flash’s default thinking level from high to medium. OpenAI’s GPT-5.5, released in April, ships with five effort tiers and defaults to medium. All three major platforms converged on the same conclusion during the same quarter: maximum reasoning is almost never what you actually need.
This guide breaks down what each level does, what it costs, and when to reach for each one across Claude, GPT-5.5, and Gemini.
Three Platforms, Three Dials, One Principle
The reasoning effort parameter controls how many internal “thinking” tokens a model generates before producing its visible response. More thinking tokens means deeper reasoning chains, slower responses, and higher costs. Fewer thinking tokens means faster output and lower bills, with accuracy that barely moves on routine tasks.
Each platform names the levels slightly differently:
| Level | Claude (Opus 4.8) | GPT-5.5 | Gemini 3.5 Flash |
|---|---|---|---|
| Off / Minimal | (n/a) | none |
minimal |
| Low | low |
low |
low |
| Medium (default) | medium |
medium |
medium |
| High | high |
high |
high |
| Extra High | xhigh |
xhigh |
(n/a) |
| Max | max |
(n/a) | (n/a) |
Claude offers the widest range, with Opus 4.7 and 4.8 exposing both xHigh and Max above the standard high tier. GPT-5.5 matches with its own xhigh for the hardest asynchronous agent tasks. Gemini caps at high, relying instead on its raw speed advantage at lower tiers.
The practical difference between these names is smaller than it looks. What matters is the token budget each level unlocks.
What Each Level Actually Does
Low effort allocates roughly 0 to 2,000 thinking tokens. The model skips deep reasoning chains entirely. It still reads your full prompt and applies its training, but it will not pause to verify its own logic or explore alternative approaches.
Best for: classification, routing, sentiment analysis, data extraction, format conversion, and any task where the answer is a lookup rather than a derivation.
Medium effort (the current default on all three platforms) allocates roughly 2,000 to 8,000 thinking tokens. The model will reason through multi-step problems but stops short of exhaustive exploration.
Best for: code review, structured reports, summarization with analysis, multi-step planning, and production agentic workflows where reliability matters but latency matters more.
High effort removes most thinking constraints. The model will generate long reasoning chains, reconsider its initial approach, and explore edge cases.
Best for: novel algorithm design, multi-constraint optimization, ambiguous specification interpretation, and debugging problems where the root cause is not obvious from the surface error.
xHigh and Max (Claude and GPT only) are specialized tiers for tasks that benefit from near-unlimited reasoning budgets. At max effort on Claude Opus 4.8, the model may generate tens of thousands of thinking tokens before producing a single line of output.
Best for: competition-level math, formal proofs, long-horizon agent planning where a single wrong decision cascades, and security audits where missing one edge case is unacceptable.
The Cost Math
Reasoning tokens are billed as output tokens on all three platforms. That makes effort level the single biggest cost variable in any API call, often larger than the choice of model itself.
Here is what the data shows.
A 2026 benchmark study across five frontier models found that moving from medium to high effort on math tasks lifts AIME pass rates by 18 to 22 points, but requires 4 to 5 times more tokens per answer. On GPT-5.5 Pro at high effort, each correct math answer costs $0.78 in tokens. The same model at medium drops to roughly $0.19.
For coding tasks, the gap narrows. Anthropic’s SWE-bench testing showed 76% fewer output tokens at medium versus high effort with equivalent task completion rates. The model simply reasons more efficiently when you constrain it, cutting out redundant verification loops that do not change the final answer.
Latency follows the same curve. Gemini 3.5 Flash at high effort posts a time-to-first-token of 17.75 seconds. At low or medium, that drops below 5 seconds. For user-facing applications, that difference determines whether customers wait or leave.
The rule of thumb from running these models in production: medium effort is correct for roughly 80% of tasks. The remaining 20% splits between low (simple extraction and routing) and high or above (hard reasoning where accuracy is non-negotiable).
A Routing Table for Real Work
Instead of thinking about effort levels in the abstract, map them to the actual tasks hitting your API:
| Task | Recommended Effort | Why |
|---|---|---|
| Email classification / triage | Low | Pattern match, not derivation |
| Data extraction from documents | Low | Structural, not reasoning-dependent |
| Code completion (inline) | Low to Medium | Context-dependent; medium for unfamiliar codebases |
| Summarization with analysis | Medium | Needs reasoning for the “so what” framing |
| Code review (PR diffs) | Medium | Catches most bugs; high adds diminishing returns |
| Multi-step agent workflows | Medium | Default for production agents per both OpenAI and Anthropic guidance |
| Novel architecture design | High | Benefits from exploring alternatives |
| Debugging production incidents | High | Root cause analysis requires deep chains |
| Competition math / formal proofs | xHigh or Max | Every point of accuracy matters |
| Security vulnerability audit | Max | Missing one edge case has outsized consequences |
This table is not prescriptive. The right approach is to start at medium, measure accuracy on your specific workload, and adjust only when you see measurable quality gaps. Moving from medium to high on a classification pipeline wastes tokens without improving results. Moving from medium to high on a theorem prover is the difference between a correct proof and a plausible one.
Setting Effort in Practice
Claude Code users can type /effort to cycle between levels during a session. The default changed from high to medium in version 2.1.68 after users reported burning through rate limits 10x faster on Opus 4.6 than on the previous generation.
Claude API users set effort through the thinking.budget_tokens parameter, with Anthropic mapping effort labels to specific token ceilings.
GPT-5.5 API users pass reasoning_effort directly in the request body. The five-tier system (none, low, medium, high, xhigh) maps to internal token budgets that OpenAI does not publicly disclose.
Gemini API users set thinking_level with four options: minimal, low, medium, and high. The parameter replaced the older integer-based thinking_budget in the 3.5 generation.
For teams running multi-model pipelines, the practical approach is to normalize on the four-tier system (low, medium, high, max) and map each provider’s specific parameter names at the routing layer.
The Default Shift Tells the Story
When all three frontier labs independently move their default from high to medium in the same quarter, that is not a coincidence. It reflects months of production telemetry showing that most API calls were spending tokens on reasoning that did not change the output. The models got good enough at medium effort that the extra thinking became waste, not insurance.
For practitioners, the lesson is straightforward. Start at medium. Measure. Raise effort only where your evaluation data shows a real gap. The 76% token savings on Claude’s coding benchmarks and the 3.5x latency reduction are not theoretical projections: they are what happens when you stop paying for reasoning you did not need.