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

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.

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.

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.

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.

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.

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 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 asks the earlier question of whether a task needs one, with the vendors' advice and the evidence on both sides.

Frequently asked questions

Sources

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