Reasoning Effort Control
Definition
A reasoning model is an LLM that emits an intermediate reasoning trace before its final answer. Reasoning effort control is the mechanism that lets one such model spend very different amounts of that trace on demand — low/medium/high/max, or a continuous 0–1 value — without swapping models. The label is not a prompt trick: it is trained in during post-training, then selected at inference through a system message or chat template.
Source: Sebastian Raschka, Controlling Reasoning Effort in LLMs (2026-07-18).
Core Ideas
Reasoning is a trained behaviour, not a tag
- RLVR (reinforcement learning with verifiable rewards) gives a 0/1 reward on domains a checker can verify — math (SymPy/Wolfram) and code (compilers, unit tests). DeepSeek-R1 popularised the recipe; Kimi K1.5 published the same day, and Tülu 3 coined “RLVR” two months earlier.
- The reasoning trace itself is not used as a training signal in R1 — only the final answer and format. Reasoning behaviour (backtracking, self-correction — the “aha moment”) emerges from outcome rewards alone.
- R1-Zero proved pure RL on a base model is enough, with no supervised fine-tuning first. It is weaker than full R1, but it settles the question.
<think>tags are cosmetic. They mark where the trace starts and ends so the pipeline or UI can hide it. Any other delimiter works; the model does not reason better because of them. They stick because a format reward is added:R_total = R_accuracy + R_format.
Two scaling axes, not one
| Axis | What changes | Example |
|---|---|---|
| Training / model scaling | The weights — a different trained model | Picking Luna vs Terra vs Sol |
| Inference scaling | Tokens spent at answer time, same weights | Raising the effort setting |
The two overlap in practice: a smaller model at high effort can match a larger model at low effort. On the Artificial Analysis Coding Agent Index the per-model curves cross, so cost — not size — is the thing to optimise against. Returns also saturate: the top GPT-5.6 settings buy little accuracy for a lot of cost.
Other inference-scaling levers exist independently of effort — self-consistency (majority vote over N samples), self-refinement. DeepSeekMath-V2 stacked extreme inference scaling on top of a reasoning model for olympiad math.
From on/off switch to effort dial
- First generation — separate models. DeepSeek-V3 (plain) and DeepSeek-R1 (reasoning). R1 is verbose even on trivial prompts and has no off switch.
- Hybrid — Qwen3’s
enable_thinking=Falseprefills an empty<think></think>block at the start of the assistant turn, so generation goes straight to the answer./thinkand/no_thinkin the prompt are the soft switch; the prefill is the hard one. - Graded effort — GPT-5.6 exposes ~6 levels; the UI almost certainly maps the menu choice to a system-prompt line, exactly as the open
gpt-osschat template does.
How effort gets trained in
Two mechanisms, usually combined:
- Effort-conditioned RLVR — vary the per-token length penalty by the requested effort. Roughly
R(e) = R_task − λ(e)·N_tokens, where low effort uses a large λ (short traces) and high effort a small one. - Effort-conditioned SFT — after RLVR, fine-tune on prompts paired with targets that already exhibit the intended trace length.
A third ingredient makes models robust to externally imposed budgets, which is what a harness actually does: it cuts the trace off mid-thought.
Recipes across the flagship open-weight models
| Model | Training mechanism | Inference control |
|---|---|---|
| DeepSeek V4 | Three specialists (Non-think / Think High / Think Max), each with its own context window and length penalty, distilled on-policy into one checkpoint | System instruction — Think Max prepends “Reasoning Effort: Absolute maximum with no shortcuts permitted” |
| Nemotron 3 Ultra | Medium-effort introduced via SFT on GPT-OSS-120B traces + ~2.5% of RLVR prompts; separately trained on randomly truncated traces with the inserted </think> masked from the loss | Chat template (enable_thinking, medium_effort) plus a hard client-side budget that closes the block if the model hasn’t |
| Kimi K2.5 | ”Toggle” — alternate a budgeted RL phase (per-problem budget from a percentile of correct rollouts, only enforced once accuracy clears a threshold) with an unconstrained phase | None — Toggle produces a single policy. ~25–30% fewer tokens at ~equal benchmark score, transferring from math/code RL to GPQA and MMLU-Pro |
| Kimi K3 | Nine specialists (3 efforts × general / general-agent / coding-agent), trained max-first then budget lowered; over-budget responses get reward −1 instead of 0. Multi-teacher on-policy distillation into one model | Natural-language thinking-effort instruction |
| GLM-5 | Multi-task SFT + updated chat template, then reasoning/agentic/general RL and a distillation recovery step | Turn-level thinking is the on/off switch; also interleaved (a block before each tool call) and preserved (blocks retained across turns) thinking |
| Qwen3 | ”Thinking Mode Fusion” SFT mixing /think and /no_think examples, reinforced by general RL | On/off switch + a hard budget. Notably, continuing sensibly from a forcibly stopped trace was never trained — it emerged |
| Inkling (Thinking Machines) | Continuous effort 0.0–1.0 in the system message, token cost scaled by it, across 30M+ asynchronous RL rollouts | Thinking effort level: 0.8 in the system message |
The shared shape: SFT + chat template introduces the mode → mode-conditioned RL (context window and length penalty vary by effort) makes it real → truncation-robustness training keeps quality when a budget cuts the trace short.
Where this is heading
Raschka’s read: effort stays an explicit model input delivered through the system prompt, but the agent harness or an internal router increasingly infers the right mode from task state and remaining budget — with a user override kept, since you sometimes want to optimise for latency or cost rather than accuracy. GPT-5’s Auto mode was the first attempt at automatic selection and was quietly removed, which says the problem is unsolved rather than easy.
Why it matters in practice
- Effort ≠ verbosity. It controls how much the model thinks, not how much it says. Shortening visible output needs a separate instruction — see Context Engineering.
- Re-sweep effort per model. Defaults carried over from a previous model are usually wrong; the cost/quality curve moves with every release.
- Cheap-and-often beats expensive-and-once for tasks where accuracy holds at low effort — a fast pass now, a thorough pass later.
Relationships
- Context Engineering — the prompt-side counterpart; effort is one of its levers
- Transformer — the architecture underneath
- AI Model Routing — the router that could pick the effort level automatically
- Machine Learning — RL and SFT fundamentals
- AI & Machine Learning — parent topic
- Coding Agents and AI Tools — where effort settings are consumed daily
Source References
- Controlling Reasoning Effort in LLMs — Sebastian Raschka, 2026-07-18