TokenMix Research Lab · 2026-07-25

Claude Opus 5 Effort Levels: 94% Max Cost, Routing Guide

Claude Opus 5 Effort Levels: 94% Max Cost, Routing Guide

Last Updated: 2026-07-25 Author: TokenMix Research Lab Data verified: 2026-07-25 - Claude Platform effort and pricing documentation, Opus 5 migration notes, Artificial Analysis effort-level measurements, and Anthropic's launch materials

Claude Opus 5 max effort cost 94% more than high in one independent evaluation while adding two Intelligence Index points. That does not make max bad. It makes effort a routing decision: start at high, test medium, and escalate only tasks whose failure costs more than the extra reasoning.

Opus 5 exposes five effort levels: low, medium, high, xhigh, and max. Anthropic sets high as the default. Independent measurements reported scores of 56, 59, 60, and 61 from medium through max, while evaluation spend rose from $1,114.96 to $3,835.51. This guide converts that curve into workload budgets, escalation thresholds, and API-safe routing rules. It complements the broader Claude Opus 5 review, which covers release details, pricing tiers, benchmarks, and migration behavior.

Table of Contents

Quick Verdict

High effort is the safest Opus 5 production baseline; medium is the first cost test, and max belongs behind a value-aware escalation rule.

Statement Status Evidence
Opus 5 supports five effort levels from low to max Confirmed Claude Platform docs
High is the default effort level Confirmed Claude Platform docs
Max scored 61 versus high at 59 on the AA Intelligence Index Confirmed independent measurement Artificial Analysis
The reported max evaluation cost was 94% above high Confirmed calculation Based on $3,835.51 versus $1,973.77
Max is 94% more expensive for every customer task False Token use varies by task, prompt, tools, and stopping behavior
Medium can match max on every workload False It scored lower in the cited suite; local acceptance tests are required
Thinking is enabled by default Confirmed Opus 5 migration notes
Disabling thinking at xhigh or max returns HTTP 400 Confirmed Opus 5 migration notes
Cache and Batch discounts remove effort-related output cost False They reduce billed token rates, not the number of generated tokens
Routing by cost per successful task is better than routing by score Confirmed recommendation Production economics, not a provider benchmark claim

Effort Levels and Evidence Boundaries

The effort ladder changes reasoning depth, token use, latency, and quality; it does not change the $5/$25 standard token rate.

Effort AA Intelligence Index Reported evaluation cost Suite output tokens Production interpretation
Low 51 Not available in the cited snapshot Not available Lowest reasoning budget; validate on simple tasks
Medium 56 $1,114.96 29M Cost-focused premium route
High 59 $1,973.77 52M Anthropic default; production baseline
Xhigh 60 $2,909.91 76M Escalation after a high-effort failure
Max 61 $3,835.51 100M Highest reasoning budget and steepest cost

The score and cost rows come from Artificial Analysis measurements of its own Intelligence Index suite (medium, high, xhigh, max). They are Confirmed independent measurements, not Anthropic invoices and not universal task multipliers.

The standard API rate remains $5 per million input tokens and $25 per million output tokens at every effort level. Effort changes how many reasoning and output tokens the model consumes. A task that stops early at high may cost almost the same at max; a long agent loop can create a much larger gap.

The 94% Max-vs-High Cost Curve

Max added two index points over high while the cited evaluation spend increased by $1,861.74.

Comparison Score change Cost change Output-token change Marginal interpretation
Medium to high +3 +$858.81, or 77.0% +23M, or 79.3% Largest measured score gain
High to xhigh +1 +$936.14, or 47.4% +24M, or 46.2% Expensive one-point gain
Xhigh to max +1 +$925.60, or 31.8% +24M, or 31.6% Highest-cost final point
High to max +2 +$1,861.74, or 94.3% +48M, or 92.3% Nearly double the evaluation spend

The high-to-max calculation is:

Cost increase = ($3,835.51 - $1,973.77) / $1,973.77
              = 94.3%

Score increase = 61 - 59
               = 2 points

This is not proof that every max request costs 94% more. It is evidence that the marginal cost curve can become steep after high. The correct operational response is to measure your own cost per accepted result.

A second useful calculation is cost per measured index point:

High: $1,973.77 / 59 = $33.45 per index point
Max:  $3,835.51 / 61 = $62.88 per index point

That ratio is only descriptive of this suite. It shows why a leaderboard maximum can be economically weaker than a slightly lower setting.

Cost per Workload

Effort changes token volume, while cache, batch, fast mode, and geography change the price applied to those tokens.

Assume a baseline high-effort coding run uses 100K input tokens and 20K output tokens. Standard cost is $1.00:

(0.10 x $5) + (0.02 x $25) = $1.00

The next table models effort as an output-token multiplier for planning only. These are scenarios, not measured Opus 5 guarantees.

Scenario Input Output Standard cost Status
Medium planning case 100K 12K $0.80 Speculation scenario
High baseline 100K 20K $1.00 Example baseline
Xhigh planning case 100K 30K $1.25 Speculation scenario
Max planning case 100K 40K $1.50 Speculation scenario
High with cache hit 100K cached 20K $0.55 Confirmed price calculation
High through Batch API 100K 20K $0.50 Confirmed price calculation
High in fast mode 100K 20K $2.00 Confirmed price calculation

The speculative rows are not benchmark claims. They show how to build a budget before production data exists. Replace the output assumptions with usage logs after the first canary.

Output tokens dominate Opus 5 cost. At $25 per million, an extra 20K output tokens add $0.50 even when input is fully cached. Cache can make repeated context cheap; it cannot make a verbose agent loop free.

Monthly Budget Scenarios

At 10,000 calls, a $0.50 per-call effort difference becomes $5,000 per month.

Calls per month $0.80 medium case $1.00 high baseline $1.25 xhigh case $1.50 max case
100 $80 $100 $125 $150
1,000 $800 $1,000 $1,250 $1,500
10,000 $8,000 $10,000 $12,500 $15,000
100,000 $80,000 $100,000 $125,000 $150,000

These totals use the planning scenarios above. They do not claim that medium, xhigh, or max will always consume those token amounts.

The break-even question is not "Is max smarter?" It is:

Extra model cost per task
< probability of avoiding failure x financial cost of failure

If max costs an extra $0.50 and reduces failure probability by one percentage point, it breaks even when a failed task costs more than $50:

$0.50 / 0.01 = $50

If the failure costs $5, the same one-point improvement is not enough. If the failure costs $5,000, the extra reasoning is trivial.

Effort Routing Rules

An effective router starts cheap enough to preserve margin and escalates only after evidence of difficulty.

Task signal Initial effort Escalation Why
Routine transformation with deterministic validation Medium High on validation failure Cheap first pass
Complex repository change High Xhigh after failed tests Default premium path
Root-cause debugging with weak observability High Xhigh, then max Difficulty becomes visible through failure
Legal, finance, or safety-critical analysis High Max when review value exceeds cost Failure cost is high
Long autonomous agent with many tools High Xhigh under a token budget Prevent uncontrolled loops
Classification or simple summary Do not start with Opus Route to Sonnet or cheaper model Opus effort is unnecessary
Offline benchmark or evaluation High via Batch Max only for failed cases 50% Batch discount

A minimal routing function:

def choose_effort(task):
    if task.kind in {"classification", "simple_summary"}:
        return {"model": "claude-sonnet-5", "effort": "medium"}

    if not task.failed_at_high:
        return {"model": "claude-opus-5", "effort": "high"}

    if task.failure_cost_usd >= 10000:
        return {"model": "claude-opus-5", "effort": "max"}

    if task.failure_cost_usd >= 1000:
        return {"model": "claude-opus-5", "effort": "xhigh"}

    return {"action": "human_review"}

The thresholds are examples. A production router should learn from task value, retry history, validator results, tool errors, and user-facing latency requirements.

Log the selected effort on every request. Without that field, a cost spike can look like a model-price change even when it came from routing policy.

The HTTP 400 Configuration Trap

Opus 5 rejects disabled thinking at xhigh and max, so a cost-control field copied from another configuration can break escalation.

Thinking setting Low Medium High Xhigh Max
Default/on Valid Valid Valid Valid Valid
{"type": "disabled"} Valid Valid Valid HTTP 400 HTTP 400

This request fails:

response = client.messages.create(
    model="claude-opus-5",
    max_tokens=64000,
    thinking={"type": "disabled"},
    output_config={"effort": "max"},
    messages=[{"role": "user", "content": "Diagnose this production failure."}],
)

Use one of two fixes:

# Keep thinking disabled; cap effort at high.
thinking = {"type": "disabled"}
output_config = {"effort": "high"}

# Keep max effort; remove disabled thinking.
output_config = {"effort": "max"}

Anthropic also warns that thinking-disabled Opus 5 requests can occasionally emit a tool call as visible text or include internal XML tags. Lowering effort while leaving thinking enabled is the safer general cost control (migration notes).

Token Budgets, Cache, and Output Control

Effort should be paired with explicit token and tool budgets because max effort without stopping rules can turn a rare escalation into an open-ended loop.

Control What it limits What it does not limit Recommended use
max_tokens Thinking plus visible output Input context cost Hard safety ceiling
Effort Reasoning depth Token price per unit Quality/cost routing
Prompt cache Repeated input price Output or thinking volume Large stable context
Batch API Input/output token rate Token count Offline jobs
Fast mode Latency Cost; price doubles User-facing SLA
Tool-call cap Agent actions Initial reasoning Prevent loops
Retry cap Repeated attempts First-attempt verbosity Bound failure cost

The Claude pricing documentation confirms $0.50 per million cache-hit input tokens, a 50% Batch discount, and $10/$50 fast-mode pricing. Those discounts can change the best route without changing effort.

For repeated 100K input and 20K output:

Standard high example: $1.00
Cache-hit high example: $0.55
Batch high example: $0.50
Fast high example: $2.00

Cache and Batch each save about half in this token shape. Fast mode doubles cost. That difference can be larger than moving between adjacent effort levels.

When Max Effort Pays

Max effort pays when its expected reduction in failure cost exceeds its extra token and latency cost.

Workload Failure cost Max decision Confidence
Simple summary Below $1 Avoid max High
Internal code formatting Below $10 Avoid max High
Pull-request review before routine merge $10-$500 High or xhigh after validator failure Medium
Production incident diagnosis $1,000+ per hour Max may pay quickly Likely
Contract or financial-model review High human-review cost Test max against expert corrections Likely
Autonomous deployment change Potentially severe Max is not sufficient without safeguards Confirmed risk
Scientific hypothesis generation High value, uncertain validation Max can help; independent validation remains required Likely

Max is not a substitute for permission controls, deterministic tests, human review, or rollback. More reasoning can improve a plan while still producing a harmful action.

The economic decision should use accepted outcomes:

Cost per accepted task =
total model cost + retry cost + human correction cost
------------------------------------------------------
number of accepted tasks

A medium route with two retries can cost more than a high route that succeeds once. A max route that writes twice as much without changing acceptance can be a regression.

Migration Checklist

A safe effort rollout needs separate quality, cost, latency, and API-contract checks.

Check Pass condition
Build a 100-300 task canary Matches production task distribution
Record effort per request No unlabeled usage
Record thinking and output tokens Cost can be attributed
Track validator and human acceptance Quality is measured by outcomes
Cap retries and tool calls Worst-case cost is bounded
Test disabled-thinking combinations No xhigh/max HTTP 400 surprises
Compare medium and high Finds the lowest acceptable effort
Escalate failed high tasks Max traffic stays selective
Re-run after prompt changes Effort and prompt behavior interact

The broader Opus 5 review covers model availability, cloud IDs, benchmarks, and Opus 4.8 migration. This page answers the narrower production question: how much reasoning should each task buy?

Final Recommendation

Use Opus 5 high as the baseline, test medium as the cost floor, and put xhigh/max behind failure-value thresholds.

The 94% figure is a real calculation from one independent evaluation, not a universal API multiplier. Its value is directional: the cost curve steepens after high. Production routing should optimize cost per accepted result, not the highest benchmark score.

FAQ

What is the default Claude Opus 5 effort level?

The default effort level is high. Anthropic recommends starting there and moving down where quality holds or up for the most demanding work.

Is Claude Opus 5 max always 94% more expensive than high?

No. The 94.3% figure comes from one Artificial Analysis evaluation suite: $3,835.51 at max versus $1,973.77 at high. Your difference depends on task length, tools, output, and stopping behavior.

How much intelligence did max add over high?

Max scored 61 versus high at 59 on the Artificial Analysis Intelligence Index. That is a two-point gain within that evaluator's methodology, not a universal two-point quality increase.

Should production workloads use medium or high?

Start at high, then test medium on representative tasks. Choose medium only where acceptance rate, retries, and human correction remain within target.

When should a router escalate to max?

Escalate after a high-effort failure when the expected failure cost exceeds the extra model and latency cost. Production incidents, difficult debugging, and expensive expert review are stronger candidates than routine summaries.

Can thinking be disabled at max effort?

No. Opus 5 returns HTTP 400 when thinking: {"type": "disabled"} is combined with xhigh or max. Keep thinking enabled or lower effort to high or below.

Does prompt caching reduce max-effort reasoning cost?

Caching reduces repeated input price to $0.50 per million tokens. It does not reduce the number or price of output and thinking tokens, so a long max-effort loop can still be expensive.

Can Batch API and fast mode be combined?

No. Fast mode is not available with Batch API. Use Batch for asynchronous 50%-discount work and fast mode only where lower latency justifies $10/$50 pricing.

About TokenMix

TokenMix.ai is an AI API relay that routes Claude, OpenAI, Gemini, DeepSeek, Qwen, and other large language models through a single OpenAI-compatible endpoint at https://api.tokenmix.ai/v1. Current model availability and per-token rates are listed on the pricing page and the model catalog. Integration uses the standard OpenAI SDK; details are in the OpenAI compatibility reference.

Sources

Related Articles