# Reasoning effort and thinking budgets: how to set them and what they cost

> Reasoning effort tells a model how hard to think before it answers. OpenAI sets it with reasoning.effort, Claude with output_config.effort and Gemini with thinking_level. Higher levels use more tokens and time, and thinking counts against your output cap. Start at the default, leave a generous cap, then compare lower and higher levels on your own tasks.

Mindket editors · Published 2026-11-06 · Updated 2026-11-06 · https://mindket.com/learn/reasoning-models/reasoning-effort

## In short

- Find the effort parameter for your provider and check which values your model accepts before you send a request.
- Give every call a token cap that covers the thinking as well as the answer.
- Run one of your own tasks at each level, more than once, and keep the lowest level that still gives an answer you would use.
- Re-run the sweep after a model change instead of carrying the old level over.

## Before you start

You need Python 3 and an API key for at least one of the three providers. The steps use Claude's Messages API, because Anthropic's cookbook has a ready loop, and each step names the matching setting on OpenAI and Gemini.

Two terms need pinning down. Effort is a named level, such as low or high, that tells the model how hard to think. A thinking budget is a token allowance for thinking. Older Claude models took it as a number in `budget_tokens`, and Gemini's legacy `thinking_budget` parameter took one too. The newest models in this lesson take levels instead.

## Where each provider keeps the setting

On all three providers the model still decides how much a request needs, and the setting only steers it. OpenAI says its models reason adaptively across efforts, using fewer tokens on simple tasks. Google says `high` lets the model think as deeply as the prompt requires, which is not the same as always thinking at the maximum.

| Provider and API | Parameter | Values | Default and traps |
| --- | --- | --- | --- |
| OpenAI, Responses API | `reasoning.effort` | none, minimal, low, medium, high, xhigh and max, depending on the model | medium on gpt-5.5, GPT-5.6, GPT-6.1 Sol, GPT-6 Sol and GPT-6 Luna. GPT-6 Astra returns HTTP 400 for none, and GPT-6.1 Sol rejects none and minimal |
| Claude Sonnet 5.5, Messages API | `output_config.effort`, with `thinking` set to adaptive | low, medium, high, xhigh and max | high. The older `budget_tokens` form returns a 400 error on this model |
| Gemini 4 Argon, Interactions API | `generation_config.thinking_level` | low, medium and high | medium. It rejects `thinking_budget` with a 400 error and does not support minimal |

## Run one task at every level

The cookbook's loop sends one prompt four times, with only the effort changed. It prints the output tokens and the length of the thinking summary for each level. That makes it a quick way to see what a level does to your own task.

````python
import anthropic

client = anthropic.Anthropic()
max_tokens = 16000
base_messages = [{"role": "user", "content": "<a task from your own work>"}]

for effort in ["low", "medium", "high", "xhigh"]:
    response = client.messages.create(
        model="claude-sonnet-5-5",
        max_tokens=max_tokens,
        thinking={"type": "adaptive", "display": "summarized"},
        output_config={"effort": effort},
        messages=base_messages,
    )
    summary_chars = sum(len(b.thinking) for b in response.content if b.type == "thinking")
    answer = " ".join(b.text for b in response.content if b.type == "text")
    print(f"\nWith effort={effort!r}:")
    print(f"Output tokens (thinking + answer): {response.usage.output_tokens}")
    print(f"Thinking summary length: {summary_chars} characters")
    print(f"Final answer preview: {answer[:120]}...")
````

1. Pick a task from your own work whose answer you can check, and put it in `base_messages`.
2. Run the loop. `usage.output_tokens` counts the full thinking plus the answer, even though the summary you get back is shorter.
3. Compare each answer with one you trust, and note the first level that is good enough.
4. Run the loop at least twice more. One run is noise, as the chart below shows.
5. On OpenAI, call `client.responses.create` with `reasoning={"effort": effort}` and read `usage.output_tokens_details.reasoning_tokens`. On Gemini, pass `generation_config={"thinking_level": level}` and read `usage.total_thought_tokens`.

## Leave room for thinking, or get no answer

A cap that fits the answer can be too small for the thinking in front of it. OpenAI's guide says that when generated tokens reach the limit before any visible output, the response comes back with the status `incomplete` and the reason `max_output_tokens`. You are still billed for the input and the reasoning, and you get no visible text. The guide's own example below sets a cap of 300 tokens to show the check.

````python
from openai import OpenAI

client = OpenAI()

prompt = """
Write a bash script that takes a matrix represented as a string with
format '[1,2],[3,4],[5,6]' and prints the transpose in the same format.
"""

response = client.responses.create(
    model="gpt-6-astra",
    reasoning={"effort": "medium"},
    input=[{"role": "user", "content": prompt}],
    max_output_tokens=300,
)

if (
    response.status == "incomplete"
    and response.incomplete_details.reason == "max_output_tokens"
):
    print("Ran out of tokens")
    if response.output_text:
        print("Partial output:", response.output_text)
    else:
        print("Ran out of tokens during reasoning")
````

- OpenAI: `max_output_tokens` covers reasoning, visible output and formatting tokens together. OpenAI recommends reserving at least 25,000 tokens when you start.
- Claude: thinking tokens count toward `max_tokens`, and the cookbook uses 16,000 with the comment that thinking needs headroom.
- Gemini 4 Argon: `max_output_tokens` caps thinking and output combined. Google recommends keeping it at 32,768 or higher.

## What a level does to the token count

The cookbook saved the output of its loop on a five-talk scheduling puzzle. Claude Sonnet 5.5 produced 1,043 output tokens at low, 794 at medium, 1,150 at high and 1,332 at xhigh. An earlier xhigh call in the same notebook used 1,595. At low and medium the thinking summary came back empty, and the cookbook says Claude may decide a prompt needs no thinking, most likely on easy prompts and at lower effort.

Read that as one run. Medium came in below low, and two xhigh calls differed by 263 tokens. Effort steers an adaptive model and does not fix a count, so a comparison needs repeat runs on a task that is hard enough to matter.

**Output tokens per effort level, Claude Sonnet 5.5** Thinking plus answer, from the output the cookbook saved for its loop, one run per level. The gold bar is the lowest of the four.

- low: 1,043 tokens
- medium: **794 tokens**
- high: 1,150 tokens
- xhigh: 1,332 tokens

Source: [Anthropic on GitHub: Claude cookbooks, Extended Thinking](https://github.com/anthropics/claude-cookbooks/blob/main/extended_thinking/extended_thinking.ipynb) (read 2026-11-06)

## Pick a level

OpenAI's table says where each level fits. It treats `medium` as the default for most work and `xhigh` as a level to earn with evidence. Start at the default.

- Anthropic's cost guide, in its claude-api skill, describes Anthropic's own runs on research and knowledge work. Low gave up a few points for a third to a half off the cost per task, and high bought nothing measurable over medium.
- On long-horizon coding the same guide reports a real tradeoff. Each step down cost a few points of pass rate, in single digits, and the top settings bought little for a large multiple of the cost.
- It also suggests running everything low and re-running only the failures higher. In Anthropic's coding runs that matched the pass rate of the higher setting for a little over half the cost, if a test or checker flags the failures.
- When Claude overthinks a simple task, Anthropic's Opus 4.6 announcement says to dial effort from high down to medium.

| OpenAI level | What the guide recommends it for |
| --- | --- |
| none | Latency-critical work that gains nothing from reasoning, such as voice, fast information retrieval and classification |
| low | Tool use, planning, search and multi-step decisions where speed and cost matter: data analysis, drafting, execution-oriented coding and customer support |
| medium | Most work: agentic coding, research, spreadsheets and slides, and long-horizon tasks |
| high | Hard reasoning, complex debugging and deep planning, where quality matters more than latency. Compare medium and high |
| xhigh | Deep research, long asynchronous runs and security or code review. Use it only when your evals show a clear benefit |
| max | Your most complex tasks. If you use xhigh, check whether max is stronger |

## At the lowest effort, write the prompt up

OpenAI's GPT-5 guide says that GPT-5's minimal reasoning effort, its lowest level, varies more with the prompt than higher levels do. Fewer reasoning tokens means less internal planning, so the prompt has to carry more of it. The guide is archived and was written for GPT-5, so treat the four points below as a starting list for the lowest effort your model accepts, and check them on your own tasks. [The previous lesson](https://mindket.com/learn/reasoning-models/prompt-reasoning-models) covers the base prompt.

- Ask for a brief explanation of the thought process at the start of the final answer. The guide says this improves tasks that need more intelligence.
- Ask for thorough tool-calling preambles that keep the user informed, which the guide says helps agentic work.
- Make tool instructions unambiguous and add a reminder to keep going until the request is fully resolved.
- Put a planning paragraph at the start of an agentic task.

## Common mistakes

- Sending `none` to a model that rejects it. GPT-6 Astra returns HTTP 400 and GPT-6.1 Sol rejects both none and minimal.
- Carrying a level over to a new model. Anthropic's guide says default effort differs by model and the tokens behind each level can change, so sweep again from the new model's default.
- Judging a level from one run. Anthropic's guide calls a difference of a task or two within noise on a single run.
- Raising effort to fix a vague prompt. OpenAI calls effort a tuning knob, not the primary way to recover quality.
- Keeping the old `budget_tokens` call on a model that rejects it.

## Try it yourself

- Run your own sweep three times and plot the output tokens per level. Is the order the same every time?
- Set `max_output_tokens` to 300 on an OpenAI call at medium effort, and see which of the three outcomes in the check prints.
- Pick the lowest level whose answer you would still send, then raise it one step on your hardest example and see whether the answer improves.

## Next: deciding which tasks need it at all

Effort tunes a reasoning model you already chose. [The last lesson](https://mindket.com/learn/reasoning-models/when-to-use-reasoning-models) asks the earlier question of whether a task needs one, with the vendors' advice and the evidence on both sides.

## Check yourself

1. A call to GPT-6 Astra sets reasoning effort to none. What does OpenAI's guide say happens?

   A. Thinking is skipped and the call succeeds
   B. The model falls back to minimal
   C. The API returns HTTP 400
   D. The model thinks at medium

   Answer: C. The guide says GPT-6 Astra does not support none, and setting it returns HTTP 400.

2. Which setting does a request to Gemini 4 Argon reject with a 400 error?

   A. thinking_level set to high
   B. thinking_summaries set to auto
   C. max_output_tokens set to 65536
   D. thinking_budget

   Answer: D. The Gemini cookbook says Gemini 4 Argon does not support thinking_budget and returns a 400 error for it.

3. An OpenAI response is incomplete with the reason max_output_tokens, and no visible text came back. What do you pay for?

   A. Nothing, because there was no answer
   B. The input and the reasoning tokens
   C. Only the input tokens
   D. Only the visible output

   Answer: B. The guide says the cap can be reached before any visible output, so you can be billed for input and reasoning with no response.

4. In the Anthropic cookbook's saved run on Claude Sonnet 5.5, which level used the fewest output tokens?

   A. medium
   B. low
   C. high
   D. xhigh

   Answer: A. The saved output lists 794 tokens for medium against 1,043 for low, which shows why a single run is not a rule.

## Frequently asked questions

### Is reasoning effort the same as verbosity?

No. OpenAI's GPT-5 guide describes a separate `verbosity` parameter that influences the length of the final answer, as opposed to the length of the thinking. Effort controls how hard the model thinks, not how long the reply is.

### Do I still need a thinking budget?

Not on the newest models. The Claude and Gemini models in this lesson reject the budget form and take levels. Older Claude models take `budget_tokens`, which Anthropic's SDK documents as at least 1,024 and counted toward `max_tokens`.

### Does higher reasoning effort always give better answers?

No. OpenAI says to use xhigh only when your evals show a clear benefit that justifies the extra latency and cost, and Anthropic's runs found flat curves on some workloads. The sweep above shows which kind of task you have.

### Why did my reasoning model return no text?

The token cap probably ran out during thinking. On OpenAI the response then has the status incomplete, and raising `max_output_tokens` fixes it. Gemini and Claude count thinking against their caps the same way.

### Can I change the effort in the middle of a conversation?

Yes, but carefully. OpenAI says to add a `configuration_update` item between responses on GPT-6 and later models, because it keeps the cached prompt prefix. Anthropic's cost guide says changing top-level effort between Claude requests invalidates the messages cache.

## Sources

- [OpenAI Docs: Reasoning models](https://developers.openai.com/api/docs/guides/reasoning) (read 2026-11-06)
- [OpenAI Docs: Using GPT-6](https://developers.openai.com/api/docs/guides/latest-model) (read 2026-11-06)
- [OpenAI Cookbook: GPT-5 prompting guide (archived)](https://developers.openai.com/cookbook/examples/gpt-5/gpt-5_prompting_guide) (read 2026-11-06)
- [Anthropic on GitHub: Claude cookbooks, Extended Thinking](https://github.com/anthropics/claude-cookbooks/blob/main/extended_thinking/extended_thinking.ipynb) (read 2026-11-06)
- [Anthropic on GitHub: claude-api skill, cost optimization guide](https://github.com/anthropics/skills/blob/main/skills/claude-api/shared/cost-optimization.md) (read 2026-11-06)
- [Anthropic: Introducing Claude Opus 4.6](https://www.anthropic.com/news/claude-opus-4-6) (read 2026-11-06)
- [Anthropic on GitHub: Python SDK, Messages resource](https://github.com/anthropics/anthropic-sdk-python/blob/main/src/anthropic/resources/messages/messages.py) (read 2026-11-06)
- [Google Gemini on GitHub: Get started with thinking](https://github.com/google-gemini/cookbook/blob/main/quickstarts/Get_started_thinking.ipynb) (read 2026-11-06)

[Browse MCP servers](https://mindket.com/mcp-servers)