Reasoning Effort: 4 Recipes That Ship (2026)

Quick Answer (2026): reasoning_effort is the request-level knob that tells a reasoning model how hard to think before it answers. OpenAI exposes it as reasoning.effort on a ladder from none through minimal, low, medium, high, xhigh, up to max (each model supports a subset; medium is the balanced default on the GPT-5.x line). Claude has no reasoning_effort field: you get the same control through the extended-thinking budget_tokens target on Claude 4.5-class models, and through output_config.effort on adaptive-thinking models (4.7 and later). Default to the middle. Drop it for extraction and formatting. Raise it only for multi-step reasoning. Below: four recipes that ship, each with the failure mode that bites.

Reasoning models bill you for tokens you never see. Effort is the dial on that meter. Set it wrong and you either pay for thinking a formatting task did not need, or you starve a hard problem and ship a wrong answer. Four recipes.

The effort ladder (2026)

Levels and defaults are model-specific. Read the model card before you hardcode one. Source: OpenAI's reasoning models guide (2026).

Recipe 1: Default to medium, then earn every step away from it

Claim: medium is the right starting point for almost everything. Change it only when you have a measured reason.

Receipt, OpenAI Responses API:

resp = client.responses.create(
    model="gpt-5.1",
    reasoning={"effort": "medium"},
    input="Reconcile these two ledgers and list every mismatch.",
)

Why: reasoning models adapt inside a level, spending fewer tokens on easy inputs and more on hard ones. medium gives you that adaptation without you guessing. On Chat Completions the field is flat: reasoning_effort="medium".

Failure mode: shipping high everywhere "to be safe." You pay for thinking tokens on inputs that never needed them, and p95 latency creeps up with zero quality gain.

Recipe 2: Drop to minimal for extraction and formatting

Claim: for pull-a-field, classify, or reformat tasks, minimal (or none) is a free speed and cost win.

Receipt:

resp = client.responses.create(
    model="gpt-5.1",
    reasoning={"effort": "minimal"},
    input="Return the invoice total as JSON: {\"total\": number}. Text: ...",
)

Why: these tasks have one right answer and no branching logic. Extra reasoning tokens buy nothing. If you like token-thrift as a habit, pair this with our chain of draft recipes on the output side.

Failure mode: reaching for minimal on a task that hides a reasoning step (a word problem, a multi-constraint filter, anything with "and also"). The model answers fast and confidently wrong. When accuracy dips after you lower effort, that is the signal to step back up.

Recipe 3: On Claude, effort is a token budget

Claim: Claude gives you the same dial, just spelled differently. Set the depth, do not go looking for a reasoning_effort key.

Receipt, Claude 4.5-class extended thinking:

resp = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=16000,
    thinking={"type": "enabled", "budget_tokens": 4000},
    messages=[{"role": "user", "content": "Prove or disprove: ..."}],
)

On adaptive-thinking models (Claude 4.7 and later) you drop budget_tokens and set thinking={"type": "adaptive"} with output_config={"effort": "high"} instead. Full parameter rules are in Anthropic's extended thinking docs (2026); we keep a Claude-specific set in our Claude extended thinking recipes.

Why: budget_tokens is a target, not a hard cap. budget_tokens must be at least 1,024 and less than max_tokens, because thinking tokens count against max_tokens. max_tokens is the real ceiling.

Failure mode: setting budget_tokens equal to or above max_tokens. The API rejects it, or you leave no room for the actual answer. Start near 1,024 for simple work and climb; start at 16,000+ for genuinely hard problems.

Recipe 4: Pin effort for the life of a cached conversation

Claim: changing effort mid-conversation silently busts your prompt cache. Pick a level and hold it.

Receipt, the trap:

Request 1  effort=low   -> cache write
Request 2  effort=low   -> cache read  (cheap)
Request 3  effort=high  -> cache MISS, full re-read (you pay again)

Why: the effort or budget value is rendered into the prompt, so a change invalidates cache breakpoints, the same way switching thinking modes does. Anthropic documents the budget-change cache miss directly; OpenAI's reasoning params behave the same way against its cache.

Failure mode: a "smart" router that bumps effort up or down per turn inside one cached thread. It defeats the cache it was supposed to help, and your bill goes up, not down.

When NOT to touch it

If your task is not failing on quality and not too slow, leave effort at the model default and change something else. Effort is a dial for a measured problem, not a knob to fiddle. And do not treat it as a correctness fix: a hard research finding (a March 2025 arXiv study, Estermann et al.) is that reasoning effort scales with problem size only up to a critical complexity, then stops helping. Past that point, more effort is more spend for the same wrong answer. Fix the prompt, not the dial.

Cost to test: about $0.05, a dozen calls across minimal, medium, and high on one mid-tier reasoning model.