3 of 5 · A working choice

Reasoning effort

Give the model enough room to work through a problem. Stop paying before it circles an answer it already has.

You choose: How much thinking a task gets
You spend: Output tokens and waiting time
Good default: Start at medium, then adjust

Reasoning effort controls how many tokens a model spends on a problem before it answers. Most of that spending is thinking tokens: scratch work that the model writes before the answer you see. Each thinking token is one more pass through the same model. The weights do not change, so the model knows nothing new. It only takes more steps.

Providers expose this control in different ways. Some offer effort levels such as low, medium, and high. Others take a budget of thinking tokens. This page uses a token budget, because the budget shows the cost directly.

More effort helps when a task has dependent steps, such as tracing a race condition or planning a migration. It adds little to a rename or a format change. Cost and waiting time rise with every thinking token, also after the answer stops improving.

Find the useful stopping point

In Figure 1, the top edge of each template is the quality curve for one kind of task. The gantry moves along a scale of thinking tokens, and its roller follows the curve. Quality rises while the model has useful steps left. Then the curve levels off, at a point that depends on the task.

Try it · 1 min

Choose a task, then drag the Budget slider. Stop where the gauge barely moves. Then switch tasks and compare where that happens.

Budget8,000

Quality: 77%
Next 1k adds: +1.5 pts
Added wait: ≈89 s
Cost per request: $0.20

Roller follower and gauge: the quality readingTemplates: one quality curve per taskPins on the scale: low, medium, high, and maxEach template's top edge is a quality curve. The gantry spends thinking tokens as it moves right, and the follower stops rising where the curve flattens. The curves are teaching examples. Cost uses the site's example output rate of $25 per million tokens, and wait assumes 90 tokens a second.

Cost

Thinking tokens bill as output tokens, and most providers charge more for output than for input. A larger budget raises the bill and the response time together.

The three tasks lead to three choices:

Mechanical work levels off early. A rename, a format change, or boilerplate needs little scratch work.
Ordinary features need a middle budget. The model has room to plan the change and check the interfaces that it touches.
Hard bugs keep paying for longer. A concurrency bug or a security review can need a long chain of checks.

Effort cannot supply missing facts. If the model does not know your internal framework, give it that context or use a different model. Raise effort when the model knows the pieces but skips steps between them.

Pick a level

Estimate two things: the number of dependent steps in the task, and the cost of a wrong answer after tests and review. Use a low level for short tasks that are easy to check. Use a high level for long chains of reasoning or expensive mistakes. Use the middle for normal work.

Level	Use it when	Examples
low	The task is mechanical and easy to undo, and tooling checks the output.	Renames, formatting, boilerplate, config edits, a summary of a diff
medium	The task is normal engineering work with a few parts that interact. This is the daily default.	A scoped feature, a clear bug, new tests, a review of a small change
high	The answer depends on several deductions in a row, or the task spans systems.	Intermittent bugs, API design, performance work, a security review
max	You get one attempt at an answer that must be correct, and a check is expensive.	Migration plans, concurrency rules, the root cause of a live incident

Use each result to tune the next run. If the thinking repeats the same ideas, the budget is too large. If a fast answer rests on an assumption that nobody checked, the budget is too small.

Effort and model choice solve different problems

Effort gives the same model more steps. A stronger model brings better judgment to every step. A smaller model can spend a large budget on a bad path. A stronger model can still miss an interaction if it answers too fast.

A third option spreads the spending across runs. When answers are cheap to check, several low-effort attempts and one verifier can do better than one long attempt. That is where orchestration starts.

Defaults that hold up

Start at medium. Change the level only when the task gives you a reason.
Use less effort when tests catch mistakes quickly.
If high effort still misses, add context or change the model.