Adaptive thinking changes the question from how many tokens the model may spend to how hard it should try. Thinking is on by default, the model chooses its own depth, and effort tells it what kind of problem it is facing. That sounds like a small API detail. In practice it decides your latency, your bill, and whether a hard task gets a careful answer or a fast guess.
Effort is guidance, not a budget
Older integrations passed a thinking budget: a number that capped reasoning tokens. Adaptive models replaced that with effort. You pick a level, and the model decides how much to think inside it. Two prompts at the same level can produce very different amounts of reasoning, because the model is responding to the problem rather than filling a quota.
The five levels
- low — classification, extraction, formatting, routing, and high-volume checks. If a regex or a lookup table could do the job, low is still more than you need.
- medium — routine drafting, summarization, small edits, and code explanation with clear boundaries.
- high — the default. Multi-file changes, debugging, and analysis where each step depends on the last.
- xhigh — ambiguous, high-blast-radius work: architecture calls, large refactors, and production bugs that resist a first explanation.
- max — the last resort. Correctness-critical reasoning with no cheap way to verify the answer, such as subtle math or long-horizon planning.
Start at high. Effort is not a quality dial that only turns one way: raising it on easy work adds latency and tokens, and can produce a more elaborate answer than the task deserved. The right level is the cheapest one that passes your own evaluation, not the highest one your budget allows.
How to choose without guessing
- 1Set high as the default for anything you could not solve in your head in ten seconds.
- 2Drop to medium or low when the output has a fixed shape and you can check it at a glance.
- 3Move to xhigh only after high has failed on a real input.
- 4Reserve max for decisions where a wrong answer costs more than the tokens.
- 5Run ten real cases at two levels and compare. If the outputs tie, keep the cheaper level.
Sizing max_tokens
max_tokens covers thinking plus the visible answer. It is neither a thinking budget nor a target. Set it from the answer length you measured on a sample, then add headroom for reasoning.
- Measure a typical answer, then allow roughly 50 to 100 percent more for thinking at high effort.
- Check stop_reason after every call. A max_tokens stop means the response was cut off; raise the cap and rerun before judging quality.
- A large cap is not a reservation: you pay for tokens generated, not unused room. An unbounded cap still lets a runaway run spend.
- Give unattended agents a per-run dollar cap in addition to max_tokens.
Switching mid-conversation invalidates the cache
Prompt caching matches an exact prefix. Effort is part of the request configuration, so changing it mid-conversation breaks that match. The next turn pays full input price and writes the cache again. In a long session with a large system prompt, one switch can cost more than the extra thinking it was meant to buy.
Choose effort per session, not per message. If you must escalate, do it at a task boundary and accept one full-price turn. Alternating low and high to save tokens is worse: you pay cache writes on both sides and lose the discount on the stable prefix.
The cost trade-off
Thinking tokens are billed as output, and output is the expensive side of the meter. Higher effort lifts output tokens, latency, and the context carried into later turns. That trade pays when the task is hard to verify and expensive to get wrong; it loses on extraction, formatting, and routine edits. Batch non-urgent high-effort jobs, and track cost per accepted answer rather than cost per request.
An effort policy for a project
A written policy beats per-request tuning. This one sets a default, an escalation rule, and the fields to log.
Default effort: high. Use medium for: summarizing files, commit messages, renames, and small docs edits. Use low for: classification, extraction, formatting, and routing between tools. Escalate to xhigh only when: the change spans more than three files, the error message does not explain the bug, or two high-effort attempts disagree. Use max only when: the answer is hard to verify and a wrong answer is expensive. Ask before spending at max. Never change effort mid-session. Finish the task, summarize state, start a new session. Report effort, max_tokens, and stop_reason for every run.
The policy decides depth. A per-run budget cap decides when to stop.
Frequently asked questions
Does higher effort always mean a better answer?
No. It means more room to reason. On simple tasks the extra reasoning rarely changes the output, and it can make a short answer longer without making it more correct. Judge effort by accepted answers, not by how thorough the response looks.
Does max_tokens include thinking tokens?
Yes. The cap applies to the full response: reasoning plus visible text. If thinking fills the cap, the answer can be cut off, which is why the ceiling needs headroom.
Can I lower effort in the middle of a conversation?
You can, but the change invalidates the cached prefix and the next turn is billed at full input price. Pick a level at the start of a session, or escalate at a clean task boundary.
Is effort a token budget?
No. It is guidance the model uses to decide how much to think. Only max_tokens is a hard limit.
All content is original. The topic was informed by the thinking-and-effort module of a Claude course; no course text is reproduced. Cost figures are computed at build time from the TokenCalc AI catalog.