Claude Opus 5 Effort Toggle: Stop Overpaying the API

Claude Opus 5 launched July 24 with a parameter most developers are ignoring: effort

. While the industry debated benchmark numbers, Anthropic shipped a cost dial that can trim your Opus 5 bill by 40–60% on real workloads — without switching models or sacrificing quality where it matters. Most teams are running every request at the default high

effort and paying for reasoning they do not need. Here is how to fix that.

What the Effort Parameter Actually Does #

Set output_config: {"effort": "medium"}

in your API call. Five levels exist: low

, medium

, high

(the default), xhigh

, and max

. The per-token price does not change — Opus 5 bills at $5 input / $25 output per million tokens regardless. What changes is how many output tokens get consumed. Lower effort means fewer thinking tokens, fewer tool calls, and shorter internal deliberation. You pay for what the model actually generates.

This is not a quality slider in the crude sense. It is a reasoning budget. At low

effort, Claude still thinks when a problem is hard — it just thinks less than it would at high

on the same prompt. For a ticket classification task, the difference is invisible. For a multi-constraint architecture review, it matters. The official Anthropic docs describe it precisely: “Effort is a behavioral signal, not a strict token budget.”

Why the Default Is Costing You Money #

The API default is high

. Anthropic designed that as a sensible starting point, not a permanent setting. Their own guidance says to “use low and medium liberally as your primary control for token cost and response time wherever your evals show quality holds.” Most teams skip the evals and leave everything at high

.

On classification, extraction, formatting, summarization, and high-volume pipeline steps, quality at low

or medium

is routinely indistinguishable from high

. You are paying for deliberation that produces no measurable difference in output. Because output tokens cost $25 per million, thinking depth translates directly into cost. The effort parameter is effectively a price dial that also moves quality and latency.

The Routing Strategy Worth Implementing Today #

Treat effort level as a first-class routing decision. Here is a practical map:

The 80/20 rule applies: route the routine 80% of requests through low

or medium

, escalate the hard 20% to high

or above. In practice:

import anthropic

client = anthropic.Anthropic()

def call_claude(prompt: str, effort: str = "medium") -> str:
    response = client.messages.create(
        model="claude-opus-5",
        max_tokens=4096,
        messages=[{"role": "user", "content": prompt}],
        output_config={"effort": effort},
    )
    return response.content[0].text

category = call_claude(f"Classify this ticket: {ticket}", effort="low")

code = call_claude(f"Refactor this function: {fn}", effort="medium")

analysis = call_claude(f"Debug this race condition: {trace}", effort="high")

The effort decision also replaces the old “which model tier” question. Instead of maintaining routing logic across Haiku, Sonnet, and Opus, you stay on one model family and route by reasoning depth required. Simpler to maintain, easier to benchmark.

Stack It with Two More Levers #

Effort is one of three independent cost controls. The other two stack with it:

Prompt caching: Cache reads cost $0.50/million — a 90% discount off the $5/million standard input rate. If you send the same system prompt or large document context on every request (RAG, multi-turn chat, data pipelines), prompt caching is the second biggest lever after effort. One implementation note: changing effort between turns invalidates cached prefixes. Pick one effort level per session and hold it constant.

Batch API: 50% off both input and output ($2.50/$12.50/million) for async, non-time-sensitive workloads. Document processing, nightly analysis runs, offline enrichment pipelines — if you do not need real-time results, batch takes half the bill. It stacks with prompt caching.

The max_tokens Trap at xhigh and max #

If you are moving workloads to xhigh

or max

effort, check your max_tokens

setting. Thinking tokens count against max_tokens

— it is a hard cap on total output (thinking plus response text combined). Legacy code set to max_tokens: 4096

will bottleneck the model before it finishes reasoning. Anthropic recommends starting at 64,000 and tuning from there. Also: passing thinking: {"type": "disabled"}

at xhigh

or max

returns a 400 error. Thinking cannot be turned off at those levels on Opus 5.

Run Your Evals Before Committing #

Before shipping a new effort level to production, run a task-specific eval: send 50–100 representative prompts through both the current and proposed effort level and compare outputs. Find the cheapest setting where quality still meets your bar — do not assume a setting from a blog post applies to your use case. Anthropic is explicit: “If you carried effort settings over from an earlier model, run a fresh effort sweep on your evals rather than reusing them.”

The effort toggle is live, requires no feature flag, and works across all Opus 5 deployments — API, Bedrock, Google Cloud, and Microsoft Foundry. The only reason to wait is if you haven’t run your evals yet. Run them.