What is reasoning effort in an LLM?

Reasoning effort is a per-request setting that controls how many internal reasoning tokens a model spends before answering. GPT-6 Astra exposes low, medium, high, xhigh and max; Gemini 3.8 Flash offers customisable effort levels for quality, cost and latency; Claude and Muse Spark models expose comparable controls. Higher effort raises benchmark scores and cost together. On the Artificial Analysis coding agent harness, GPT-6 Astra ranges from 62.6 index at $1.41 per task on low to 67.0 at $3.27 on xhigh — a 2.3x cost difference for 4.4 index points.

Which reasoning effort level should I use by default?

Start at the lowest level that passes your acceptance criteria, not the highest. Most production workloads are bounded tasks where low or medium effort completes successfully, and the extra reasoning tokens at high effort buy nothing. Reserve high, xhigh and max for open-ended debugging, hard abstract reasoning and long-horizon agent work where failure is expensive. Test at least three levels on a hundred representative tasks before setting a default.

Do benchmark scores use max effort?

Usually yes, and it matters. OpenAI notes that unless stated otherwise its published GPT-6 Astra evaluations ran at maximum effort, which improves results while increasing latency and token consumption. That means a vendor benchmark table describes a configuration you probably will not run in production, and a chart comparing one model at max effort against another at default is not a valid comparison. Always check the effort level before letting a benchmark influence a model decision.

Does higher reasoning effort always give better answers?

No. Returns diminish sharply and can reverse. GPT-6 Astra gains only about 4.4 index points moving from low to xhigh while cost rises 2.3x, and its max setting costs $4.72 per coding task without showing a higher published index than xhigh's 67.0. Higher effort also increases latency, which degrades interactive user experience, and longer reasoning chains give a model more opportunity to talk itself out of a correct initial answer on simple tasks.

Quick Answer

How to Choose LLM Reasoning Effort Levels (2026)

Published: September 4, 2026

The Short Answer

Reasoning effort is the highest-leverage cost knob in 2026, and most teams never touch it.

The rule: start at the lowest level that passes your acceptance criteria, not the highest. GPT-6 Astra spans $1.41 to $4.72 per coding task across its effort levels — a 3.3x range on one model, one price sheet, one API.

Last verified: September 4, 2026.

What the Levels Actually Cost

Artificial Analysis coding-agent harness, GPT-6 Astra via Codex, September 2026:

Effort level	Coding Agent Index	Cost per task
low	62.6	$1.41
medium	65.1	$2.19
high	—	$2.89
xhigh	67.0	$3.27
max	not published	$4.72

Low to xhigh: +4.4 index points for 2.3x the cost. Xhigh to max: no published index improvement for another 44% on top.

On the AA Intelligence Index the same pattern holds — Astra ranges from 56.7 at about 2,200 output tokens per task up to 61.1 at about 14,000. Roughly 6.4x the tokens for 4.4 points.

Which Models Expose the Dial

Model	Effort control
GPT-6 Astra	low → medium → high → xhigh → max
Gemini 3.8 Flash	customisable effort levels (quality/cost/latency)
Claude Fable 5.1 / Opus 5	extended thinking budget
Muse Spark 1.3	effort levels; max still in safety testing
GLM 5.3	thinking mandatory (no off switch)

Note the outliers. Muse Spark 1.3’s top level is not yet available, so its published numbers are not its ceiling. GLM 5.3 makes thinking mandatory, so there is no low-effort escape hatch — plan token budgets accordingly.

The Five-Step Method

Step 1 — Write acceptance criteria before you test. “Good enough” must be a binary check a script can run: tests pass, output parses, required fields present, human reviewer approves. Without this you will drift toward higher effort out of anxiety rather than evidence.

Step 2 — Build a representative task set. A hundred tasks from real production traffic, including the hard tail. Curated examples will mislead you in both directions.

Step 3 — Sweep at least three levels. Run low, medium and high across the full set. Record per task: input tokens, output tokens, cached reads, tool calls, wall-clock latency, and the binary success flag.

Step 4 — Compute cost per completed task at each level. Total spend divided by successful completions. Retries count in the numerator; failures do not count in the denominator. Plot it. The curve usually flattens well before max.

Step 5 — Set the level explicitly in code. Never inherit the default. Defaults change between model versions, and an inherited default is an unbudgeted cost.

Choosing by Workload Shape

Use low effort for: classification, extraction, routing, summarisation, boilerplate generation, simple refactors, format conversion. These are bounded tasks with a recognisable finish line. Extra reasoning tokens buy nothing and add latency.

Use medium for: most production agent steps, standard code changes with clear acceptance criteria, structured document generation, tool-call orchestration. This is the right default for the majority of real workloads.

Use high or xhigh for: open-ended debugging (“figure out why this is broken”), architecture decisions, multi-hour long-horizon agent missions, hard abstract reasoning, and anything where a wrong answer is expensive to detect downstream.

Use max for: almost nothing in production. It is a benchmark setting. The cost-per-point curve has usually gone flat by xhigh, and the latency penalty is real.

Three Traps

Trap 1 — Reading benchmarks at max and deploying at default. OpenAI notes its published GPT-6 Astra evaluations ran at maximum effort unless stated otherwise. Vendor tables therefore describe a configuration you will probably never run. Worse, a chart comparing model A at max against model B at default is not a comparison at all — check the effort level before any benchmark influences a decision.

Trap 2 — Assuming more thinking is always better. It is not. Higher effort increases latency, which directly degrades interactive UX. And on simple tasks, a longer reasoning chain gives the model more opportunity to reason itself out of a correct initial answer. Measure; do not assume monotonic improvement.

Trap 3 — Treating effort as a model property. It is a per-request parameter. The strongest 2026 pattern is classifying each request and setting effort dynamically — the same model at low effort for the 80% of bounded traffic, at high effort for the hard tail. That is cheaper than routing between two different models and avoids maintaining two prompt sets.

Effort vs Model Choice

These are separate decisions, and effort is usually the cheaper lever to pull first.

Consider: GPT-6 Astra (low) scores 62.6 at $1.41 per task, beating Gemini 3.8 Flash (high) at 61.1 and $2.04 — despite Astra costing 13x more per token. Dropping a strong model’s effort often beats switching to a weaker model at full effort, because token-efficient models stay efficient at low effort while verbose models stay verbose.

Practical order of operations:

Tune effort first on your current model. Free, fast, reversible.
Then tune caching. Cheap cache reads — Claude Fable 5.1 at $0.25 per million, Muse Spark 1.3 near $0.15 — matter enormously for context-heavy agent loops.
Then consider routing between tiers for genuinely different task classes.
Only then change models, which costs prompt-engineering time and eval rework.

Operational Hygiene

Keep effort behind config, not hardcoded. Same rule as the model identifier — a change should be a deploy, not a refactor.

Re-measure after every model upgrade. A same-price upgrade is not free if the new version reasons longer at the same nominal effort level. Newer reasoning-tuned models frequently emit more output tokens for identical work.

Log the effort level with every request. When a cost spike or quality regression appears, the first question is which level was actually used, and you cannot answer it retroactively without the log.

Alert on tokens per task, not spend. Total spend moves with traffic. Tokens per completed task isolates the thing you actually control.