Reasoning Effort Settings: How Thinking Levels Change API Cost (Claude, OpenAI, Gemini)

Every big AI API now has a “how hard should I think” setting. Claude calls it effort, OpenAI calls it reasoning.effort and Gemini calls it thinking level.

A new Vals AI study shows that turning it down often saves far more money than it costs in quality. This guide explains each setting, gives working Python code and ends with a simple decision table.

How Thinking Settings Change Your Bill

Reasoning models “think” before they answer. That thinking is made of tokens, and all three providers charge for it.

• OpenAI: reasoning tokens are billed as output tokens. You see the count in usage.output_tokens_details.reasoning_tokens.
• Gemini: the price is output tokens plus thinking tokens. You pay for the full thinking, even though the API only returns a summary.
• Claude: thinking is billed as output, and it is charged the same whether you show the thinking or hide it.

Output tokens usually cost several times more than input tokens. For example, Claude Opus 5.5 lists $4 per 1M input tokens and $20 per 1M output tokens. So a model that thinks for 10,000 tokens on a simple question can cost far more than the answer is worth.

Higher effort also means slower replies. Lower effort gives faster, shorter answers with fewer tool calls.

What the Vals AI Study Found

On November 3, 2026, Vals AI published “How Much Does Reasoning Effort Affect Score and Cost?”. It tested seven frontier models at three reasoning levels across the eight benchmarks in the Vals Index.

The key takeaways

• Cost drops faster than score: in Vals AI’s words, lowering effort “reduces cost much more than it reduces score”.
• Half price, 80%+ quality: DeepSeek V4.1 Flash, GPT-6 Astra, Grok 4.7 and Claude Opus 5.5 kept at least 80% of their score at half the cost or less.
• Ties are common: in 22 of 56 model and benchmark pairs, a cheaper setting scored as high as the top one. No cheaper setting scored significantly higher, and 33 scored significantly lower.
• Perfect picking adds little: choosing the best setting for each task with hindsight added only 6.0 points, at a median 64% of top-setting cost.

Where high effort still pays

Some tasks gained a lot from more thinking. The biggest median gains from lowest to highest setting were:

• Legal Research: +19.2 points.
• Code Migration: +15.6 points.
• Terminal-Bench 4: +12.1 points.
• Tax Agent Bench: +11.5 points.
• Vibe Code Bench: +10.6 points.

Note: Vals AI ran each setting on about half the tasks, mostly with one run per setting, so each score is noisier than the full leaderboard. “No significant difference” does not mean the scores are equal.

For how these models rank at their top settings, see my November 2026 AI model leaderboard.

Settings Compared: Claude vs OpenAI vs Gemini

Claude: Effort and Adaptive Thinking

On current Claude models, thinking is “adaptive”. Claude decides how much to think, and effort is the main dial that controls depth and token spend. It sits inside output_config, not at the top level.

import anthropic

client = anthropic.Anthropic()  # reads ANTHROPIC_API_KEY

response = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=16000,
    output_config={"effort": "low"},
    messages=[{"role": "user", "content": "Summarise this support ticket in 3 bullet points: ..."}],
)

answer = next(block.text for block in response.content if block.type == "text")
print(answer)
print("Output tokens (includes thinking):", response.usage.output_tokens)

Claude effort levels

• low: most efficient, with big token savings. Best for simple tasks, chat and subagents.
• medium: balanced. The default on Claude Opus 5.5 and Claude Haiku 5.5.
• high: the default on most other models. For complex reasoning and hard coding.
• xhigh: for long agentic and coding work. Not every model has it.
• max: no limit on token spend. Anthropic says it can add significant cost for small gains on most workloads.

What happened to extended thinking budgets?

Older guides use thinking={"type": "enabled", "budget_tokens": N}. That fixed budget is deprecated. On Claude Opus 5.5, Opus 5, Sonnet 5.5 and Fable 5, sending budget_tokens returns a 400 error.

On Claude Opus 5.5, thinking can’t be turned off at all. Sending {"type": "disabled"} also returns a 400, so lower effort instead. Note that max_tokens covers thinking plus the answer, so leave room at higher levels.

Full model prices are in my Claude API pricing guide.

OpenAI: reasoning.effort

OpenAI’s reasoning models take a reasoning object in the Responses API. Lower effort favours speed and fewer tokens. Higher effort gives more complete thinking.

from openai import OpenAI

client = OpenAI()  # reads OPENAI_API_KEY

response = client.responses.create(
    model="gpt-6-astra",
    reasoning={"effort": "low"},
    input="Classify this review as positive, negative or mixed: ...",
)

print(response.output_text)
print("Reasoning tokens:", response.usage.output_tokens_details.reasoning_tokens)

• Supported values vary: GPT-6 Astra does not accept none (HTTP 400). GPT-6.1 Sol does not accept none or minimal.
• Defaults: GPT-5.5, GPT-5.6, GPT-6.1 Sol, GPT-6 Sol and GPT-6 Luna default to medium.
• Token limit: max_output_tokens covers reasoning plus the visible answer. OpenAI suggests reserving at least 25,000 tokens while you experiment.

Warning: If OpenAI hits max_output_tokens during reasoning, the response comes back incomplete, possibly with no visible answer. You still pay for the input and reasoning tokens.

Model prices and tiers are in my OpenAI API pricing guide.

Gemini: Thinking Level

Gemini models think by default and adjust to the difficulty of each request. You set the ceiling with thinking_level in generation_config. Google’s current docs show it with the Interactions API.

from google import genai

client = genai.Client()  # reads GEMINI_API_KEY

interaction = client.interactions.create(
    model="gemini-3.8-flash",
    input="Explain Occam's Razor with a simple everyday example.",
    generation_config={"thinking_level": "low"},
)

print(interaction.output_text)

Gemini levels by model

• gemini-4-argon: low, medium or high. Default medium.
• gemini-3.8-flash: low, medium or high. Default medium.
• gemini-3.6-flash: minimal, low, medium or high. Default medium.
• gemini-3.5-flash-lite: minimal, low, medium or high. Default minimal.

Google reports thinking tokens separately from output tokens in the usage data. If you hit the output limit mid-thought, the response is marked incomplete and you still pay for the thinking. Google’s advice is to lower thinking_level rather than cut the token limit.

Older Gemini 2.5 tutorials use a numeric thinking_budget. The current thinking docs use thinking_level instead, so prefer it for new code. Prices are in my Gemini API pricing guide.

Decision Table: Which Setting to Use

Use this as a starting point, then confirm with your own tests. It follows the providers’ guidance and the Vals AI results.

How to Run Your Own Effort Sweep

Benchmarks are a guide, but your prompts are what matter. A small sweep takes an afternoon and can cut your bill a lot.

1. Collect 30 to 100 real requests. Use actual user prompts, with the answers you consider correct.
2. Pick a pass rule. Exact match for classification, a checklist for summaries, or tests passing for code.
3. Run every request at each level. For example low, medium and high, with the same model and prompt.
4. Log tokens and cost. Record input, output and reasoning tokens from the usage fields for each run.
5. Compare cost per correct answer. Divide total cost by the number of passing answers, not by requests.
6. Pick the cheapest level that holds quality. Set it per route, not globally, and re-check after model upgrades.

Tip: Combine a lower effort with prompt caching for the biggest savings. My prompt caching guide covers all three providers.

Troubleshooting: Common Problems and Fixes

• Claude 400 error with budget_tokens: current Claude models removed it. Delete the thinking budget and set output_config={"effort": "..."} instead.
• Claude 400 error with thinking disabled: Opus 5.5 can’t run without thinking. Use effort: "low".
• OpenAI 400 error with effort “none”: GPT-6 Astra does not support it. Use the lowest value the model accepts.
• Empty or incomplete OpenAI answer: reasoning used up max_output_tokens. Raise the limit or lower effort.
• Gemini response marked incomplete: thinking hit the output limit. Lower thinking_level instead of the token limit.
• Bill jumped after a model upgrade: defaults change between models. Claude Opus 5.5 defaults to medium while Opus 5 defaulted to high, so always set effort explicitly.
• Answers got shallow at low effort: raise one level for that route only, or add a line asking the model to think carefully about multi-step parts.

Frequently Asked Questions

Does lower reasoning effort really save money?

Yes, often a lot. In the Vals AI study, Claude Opus 5.5 and Grok 4.7 at their lowest settings cost just 16% of their top settings, while keeping 80% and 86% of their scores.

Are thinking tokens billed as output tokens?

Yes. OpenAI bills reasoning tokens as output, Gemini bills thinking tokens on top of output, and Claude bills thinking as output whether or not you display it.

What is the default effort on Claude Opus 5.5?

Medium. Most other Claude models default to high, so set effort explicitly when you switch models.

Can I still use extended thinking budget_tokens on Claude?

Not on current models such as Opus 5.5, Opus 5, Sonnet 5.5 and Fable 5, where it returns a 400 error. Use adaptive thinking with the effort parameter instead.

What reasoning effort values does OpenAI support?

The full list is none, minimal, low, medium, high, xhigh and max, but each model supports only some of them. GPT-6 Astra rejects none.

How do I control thinking on Gemini 4 Argon?

Set thinking_level to low, medium or high in generation_config. The default is medium.

When should I use the highest effort setting?

For hard coding agents, code migrations and legal or tax research, where Vals AI measured the biggest gains. For chat and simple tasks it mostly adds cost.

Want a side-by-side of model prices? See my AI API pricing comparison.

Sources

• Vals AI: How Much Does Reasoning Effort Affect Score and Cost?
• Claude Docs: Effort
• Claude Docs: Adaptive thinking
• Claude Docs: Pricing
• OpenAI Docs: Reasoning models
• Google AI for Developers: Gemini thinking