Effort

The effort parameter allows you to control how eager Claude is about spending tokens when responding to requests. This gives you the ability to trade off between response thoroughness and token efficiency, all with a single model. The effort parameter is available on all supported models with no beta header required.

How effort works

By default, Claude uses high effort, spending as many tokens as needed for excellent results. You can raise the effort level to max for the absolute highest capability, or lower it to be more conservative with token usage, optimizing for speed and cost while accepting some reduction in capability.

The effort parameter affects all tokens in the response, including:

• Text responses and explanations
• Tool calls and function arguments
• Extended thinking (when enabled)

This approach has two major advantages:

1. It doesn't require thinking to be enabled in order to use it.
2. It can affect all token spend including tool calls. For example, lower effort would mean Claude makes fewer tool calls. This gives a much greater degree of control over efficiency.

Effort levels

Recommended effort levels for Sonnet 4.6

Sonnet 4.6 defaults to high effort. Explicitly set effort when using Sonnet 4.6 to avoid unexpected latency:

• Medium effort (recommended default): Best balance of speed, cost, and performance for most applications. Suitable for agentic coding, tool-heavy workflows, and code generation.
• Low effort: For high-volume or latency-sensitive workloads. Suitable for chat and non-coding use cases where faster turnaround is prioritized.
• High effort: For complex reasoning and tasks where quality matters more than speed or cost.
• Max effort: For tasks requiring the absolute highest capability with no constraints on token spending.

Recommended effort levels for Claude Opus 4.7

Start with xhigh for coding and agentic use cases, and use high as the minimum for most intelligence-sensitive workloads. Step down to medium for cost-sensitive workloads, or up to max only when your evals show measurable headroom at xhigh.

The API default is high. To use xhigh, set effort explicitly; the value you pass overrides the default.

Claude Opus 4.7 also respects effort levels more strictly than Claude Opus 4.6, especially at low and medium. At lower effort levels, the model scopes its work to what was asked rather than going above and beyond. If you observe shallow reasoning on complex problems with Claude Opus 4.7, raise effort rather than prompting around it. If you must keep effort low for latency, add targeted guidance like "This task involves multi-step reasoning. Think carefully before responding."

When running Claude Opus 4.7 at xhigh or max effort, set a large max_tokens so the model has room to think and act across subagents and tool calls. Starting at 64k tokens and tuning from there is a reasonable default.

Recommended effort levels for Claude Opus 4.8

The guidance for Claude Opus 4.7 above also applies to Claude Opus 4.8. Start with xhigh for coding and agentic use cases, use high for most other intelligence-sensitive workloads, and step down to medium or low only when you've measured that the lower level holds quality on your evals.

The default is high on all surfaces, including the Claude API and Claude Code. Set effort explicitly to use a different level; the value you pass overrides the default.

When running Claude Opus 4.8 at xhigh or max effort, set a large max_tokens so the model has room to think and act across subagents and tool calls. Starting at 64k tokens and tuning from there is a reasonable default.

Basic usage

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=4096,
    messages=[
        {
            "role": "user",
            "content": "Analyze the trade-offs between microservices and monolithic architectures",
        }
    ],
    output_config={"effort": "medium"},
)

print(response.content[0].text)

When to adjust the effort parameter

• Use max effort when you need the absolute highest capability with no constraints: the most thorough reasoning and deepest analysis. Available on Claude Opus 4.8, Claude Mythos Preview, Claude Opus 4.7, Claude Opus 4.6, and Claude Sonnet 4.6.
• Use xhigh effort for advanced coding and complex agentic work requiring extended exploration, such as repeated tool calling and detailed search. Available on Claude Opus 4.8 and Claude Opus 4.7.
• Use high effort (the default) for complex reasoning, nuanced analysis, difficult coding problems, or any task where quality matters more than speed or cost.
• Use medium effort as a balanced option when you want solid performance without the full token expenditure of high effort.
• Use low effort when you're optimizing for speed (because Claude answers with fewer tokens) or cost. For example, simple classification tasks, quick lookups, or high-volume use cases where marginal quality improvements don't justify additional latency or spend.

Effort with tool use

When using tools, the effort parameter affects both the explanations around tool calls and the tool calls themselves. Lower effort levels tend to:

• Combine multiple operations into fewer tool calls
• Make fewer tool calls
• Proceed directly to action without preamble
• Use terse confirmation messages after completion

Higher effort levels may:

• Make more tool calls
• Explain the plan before taking action
• Provide detailed summaries of changes
• Include more comprehensive code comments

Effort with extended thinking

The effort parameter works alongside extended thinking. Its behavior depends on the model:

• Claude Opus 4.8 uses adaptive thinking (thinking: {type: "adaptive"}), where effort is the recommended control for thinking depth. Manual extended thinking (thinking: {type: "enabled", budget_tokens: N}) is not supported and returns a 400 error. The model decides when and how much to think based on each request, so it triggers thinking only as needed. At high, xhigh, and max effort, Claude almost always thinks deeply. At lower levels, it may skip thinking for simpler problems. Set thinking: {type: "adaptive"} to enable thinking; without it, requests run without thinking.
• Claude Mythos Preview uses adaptive thinking by default (no thinking configuration required). thinking: {type: "disabled"} is rejected. Effort controls thinking depth the same way as on Opus 4.7 and Opus 4.6.
• Claude Opus 4.7 uses adaptive thinking (thinking: {type: "adaptive"}), where effort is the recommended control for thinking depth. Manual extended thinking (thinking: {type: "enabled", budget_tokens: N}) is no longer supported on Opus 4.7; use adaptive thinking with effort instead. At high, xhigh, and max effort, Claude almost always thinks deeply. At lower levels, it may skip thinking for simpler problems.
• Claude Opus 4.6 uses adaptive thinking (thinking: {type: "adaptive"}), where effort is the recommended control for thinking depth. While budget_tokens is still accepted on Opus 4.6, it is deprecated and will be removed in a future release. At high and max effort, Claude almost always thinks deeply. At lower levels, it may skip thinking for simpler problems.
• Claude Sonnet 4.6 uses adaptive thinking (where effort controls thinking depth). Manual thinking with interleaved mode (thinking: {type: "enabled", budget_tokens: N}) is still functional but deprecated.
• Claude Opus 4.5 uses manual thinking (thinking: {type: "enabled", budget_tokens: N}), where effort works alongside the thinking token budget. Set the effort level for your task, then set the thinking token budget based on task complexity.

The effort parameter can be used with or without extended thinking enabled. When used without thinking, it still controls overall token spend for text responses and tool calls.

Best practices

1. Set effort explicitly: The API defaults to high, but the right starting point depends on your model and workload.
2. Use low for speed-sensitive or simple tasks: When latency matters or tasks are straightforward, low effort can significantly reduce response times and costs.
3. Test your use case: The impact of effort levels varies by task type. Evaluate performance on your specific use cases before deploying.
4. Consider dynamic effort: Adjust effort based on task complexity. Simple queries may warrant low effort while agentic coding and complex reasoning benefit from high effort.