More Reasoning Is Not Free. Less Isn’t Automatically Cheaper.
A shorter turn can make the task longer. The unit that matters is successful completion, not tokens per turn.Thinking gets expensive when it forgets what it was trying to solve. (Image generated by author using AI — ChatGPT).A model spends 21 minutes thinking about an SVG. It burns 22,276 reasoning…
Annons
Annons
A shorter turn can make the task longer. The unit that matters is successful completion, not tokens per turn.Thinking gets expensive when it forgets what it was trying to solve. (Image generated by author using AI — ChatGPT).A model spends 21 minutes thinking about an SVG. It burns 22,276 reasoning tokens before producing 3,223 output tokens. In the same setup it can consume an 8,192-token context limit deliberating over problems that are not difficult.That sounds like a very clean argument for turning reasoning down.The numbers come from Simon Willison’s local test of Qwen3.8–27B, under one specific quantized build, hardware setup, and serving stack. They are useful because they make overthinking visible, not because they establish a benchmark.And Qwen’s own documentation complicates the obvious fix: at the pinned August 2026 revision, the model exposed reasoning_effort as xhigh, medium, or low, with xhigh documented as the default, and the same documentation warns that lower reasoning effort can make an individual response faster while causing insufficient analysis, more failures, and more retries across multi-turn agentic work.So the local optimization can flip. A shorter turn can make the task longer, and that is the point where reasoning stops being only a capability question and becomes a runtime budget.The cheap turn and the cheap task are different measurementsPer-turn efficiency is tempting because it is easy to see. One response used fewer reasoning tokens. One call returned faster. One prompt was smaller. One model was cheaper.None of those measurements necessarily describes the cost of finishing the work.Suppose a low-reasoning step returns in half the time of a deeper one, fails validation, and has to be repeated twice. The individual turn was cheaper; the task was not. The reverse failure is just as ordinary — a model can spend several minutes deliberating before a reversible tool call whose result could have been checked directly, and the extra thought may be excellent while also solving uncertainty a cheap validator would have removed in seconds.The useful accounting boundary is successful end-to-end completion; for an agent workflow, that can include model turns, input and output tokens, reasoning tokens where the runtime exposes them, wall-clock time, tool calls, external round trips, validation failures, retries, reroutes, human intervention, and whatever provider or infrastructure cost attaches to all of it.There is no universal formula for combining those things, because providers account for them differently and different tasks value them differently.The narrower question survives anyway:Did the extra deliberation improve the probability or quality of a valid result enough to justify what it consumed?A long reasoning trace can be efficient if it prevents an expensive failure, and a short one can be wasteful if it creates three attempts.Reasoning belongs in the control plane once the runtime can allocate itOnce reasoning depth is configurable, leaving it at a fixed default is still a policy, just an implicit one, and it is being applied uniformly to steps that do not resemble each other.A better allocation decision starts with the step in front of the model. Five properties matter repeatedly:Complexity. Is this a bounded transformation, or a problem with interacting constraints?Ambiguity. Is the input clear, or does the model have to reconcile conflicting evidence or missing structure?Consequence. Is a wrong answer cheap to undo, or does it trigger an externally visible or hard-to-reverse action?Recoverability. Can a validator catch the mistake cheaply, or does failure corrupt state, waste external resources, or require human recovery?Loop depth. Is this one model turn, or a tool-using sequence where the same default gets paid repeatedly?These are not a scoring formula. They are a way to stop pretending that every step deserves the same amount of internal work. A routine extraction with an immediate check may justify a small budget; a multi-source synthesis with conflicting evidence may justify more; a consequential external action may justify deeper reasoning before execution precisely because recovery is expensive.A step that has failed twice for the same reason may justify none of those. It may need a different model, a source recheck, a smaller subproblem, a different tool, or an operator decision — because more thinking is only one intervention, and a policy that can only escalate has just one.Tool loops make bad defaults expensiveThe budget matters more when a model is operating a loop instead of producing one answer.A typical agent might interpret the task, choose a tool, inspect the result, choose another tool, recover from a failure, synthesize an answer, validate it, and revise it.If every transition inherits maximum deliberation, the system pays the reasoning cost at each one, and the expense hides because each step looks locally defensible while the loop keeps re-solving the same uncertainty.Separating three modes helps.Planning can deserve deeper reasoning when dependencies interact, or several constraints have to stay coherent.Execution can often operate under a narrower budget once the plan exists, particularly when the action is reversible, and the result can be checked cheaply.Recovery deserves more reasoning only when the failure adds new evidence, invalidates the plan, or changes the hypothesis; repeating the same reasoning at greater length is not recovery.Tools also change where reasoning is worth spending. A reversible action with strong validation may need less pre-action deliberation, because the system can simply inspect what happened. A hard-to-reverse action should move more of the budget before execution, into evidence checks, authority checks, and explicit verification.The placement matters as much as the amount.A budget that can only escalate is a ratchetA reasoning policy needs a stop condition. Without one, every failure becomes an argument for more thinking, including the failures where thinking was never the missing resource.A practical policy can be described without pretending there is a single correct numeric setting:Reversible transformationStart: Low or boundedEscalate when: Validation exposes a non-trivial errorStop escalating when: Retries repeat the same failure without a new hypothesisAmbiguous synthesisStart: ModerateEscalate when: Sources conflict or material assumptions remainStop escalating when: More text appears without resolving the conflictHigh-consequence actionStart: Deeper reasoning plus verificationEscalate when: Evidence is incomplete but recoverableStop escalating when: Authorization is missing; that is a gate, not a reasoning problemTool-loop recoveryStart: Targeted reasoningEscalate when: The failure adds new evidence or invalidates the planStop escalating when: The next retry would repeat the same planOpen-ended explorationStart: Bounded exploratory budgetEscalate when: New evidence changes the search spaceStop escalating when: Alternatives multiply without improving the decisionThe categories are the useful part; the exact model control will vary. Some models expose reasoning effort directly, and some do not, but the orchestration problem exists either way, because the system is choosing models, prompts, retries, tools, validators, and stopping rules regardless of what the model exposes.What matters is whether the runtime can tell the difference between “this needs more analysis” and “this is failing for another reason.”Measure what the task boughtA reasoning budget is only useful if the system can observe the effect, and the minimum telemetry is ordinary:total wall-clock time;model turns;tool calls;retries and validation failures;token usage where available;measurable provider or runtime cost;final task success;reroutes;human-intervention events.Those measurements separate failure classes that otherwise get flattened into “the model struggled.” Very high reasoning use with no improvement suggests over-allocation. Low per-turn cost with repeated retries suggests under-allocation, poor decomposition, or both. Repeated escalation against the same failure suggests that reasoning depth may not be the limiting variable at all.In that last case, the missing resource could be context, or the wrong tool, or an unsuitable model, or missing authority, or a task definition that cannot be satisfied as written.“Think harder” is a poor universal error handler, and a system whose only control is reasoning depth will reach for it every time.Context reduction can move cost instead of removing itReasoning is not the only place where local savings create downstream work. Context compaction has the same accounting problem:A smaller prompt reduces work on one turn and can still increase work for the task, if the removed information has to be reconstructed, re-fetched, or rediscovered through failed attempts.That does not mean more context is always better; it means the accounting boundary should follow the task rather than the prompt.A specific numeric estimate for what compression costs is in circulation on this topic. It is not used here because the primary page behind it could not be reliably reopened for verification, and an unavailable source does not become more authoritative because its claim is convenient.The systems point survives without it:Local token reduction and local reasoning reduction can both move cost downstream instead of removing it, and the task boundary is where either saving has to prove itself.A control surface is not evidence about economicsNous Research’s neuron-steering work is useful adjacent evidence, because it shows another way model behavior can be placed behind an explicit control surface. It does not establish the economics of reasoning depth, and the distinction is worth keeping because “more model controls” is easy to compress into one broad trend claim.Two mechanisms can share a direction without sharing an objective, a measurement model, or a cost effect.For this argument, Qwen’s configurable reasoning effort and its retry warning are load-bearing. Neuron steering is not. Control is not the same thing as evidence that the control is worth using.The hard-task objection is the pointThe strongest objection to reasoning budgets is that difficult tasks genuinely can need more thought.Correct.Turning reasoning down can make a model faster and worse: Willison’s own comparison found that disabling reasoning made one task dramatically quicker while producing output he judged worse than the long-reasoning version, and Qwen’s documentation separately warns about retries in multi-turn work. A consequential planning task can justify expensive pre-action analysis precisely because the recovery cost is much higher than the deliberation cost.So the objective is not minimum reasoning. It is selective reasoning with observable consequences. A budget says some tasks deserve more, and it also says the expenditure needs a reason, a limit, and a way to tell whether it improved the task — which is stronger than either fixed maximum reasoning or blanket minimization, because the runtime has somewhere to go when either default fails.The failure class should decide what happens nextA useful default is a control contract rather than a fixed reasoning level. Start with the smallest budget justified by the task’s complexity and consequence.Escalate when evidence shows the current budget is insufficient. Move more reasoning before hard-to-reverse actions. Use validation where cheap checks are stronger than prolonged deliberation. Measure successful completion rather than isolated turn cost.Then stop when the failure changes class. If the evidence points to missing context, a wrong tool, a bad decomposition, missing authorization, or poor model fit, spending more reasoning does not repair the boundary; it only makes the same mistake more expensive.A reasoning budget is not a limit on thinking. It is a reason for it.From Dream Atlas: Reasoning Depth Needed A Budget — the original log behind this article.I’m continuing to write about AI workflows, product work, and what I’m learning as I build, test, and tinker. If that sounds useful, follow me here on Medium. And if this piece earned a clap, I’d appreciate it ✨This story is published under the Generative AI publication. Connect with us on LinkedIn and follow Zeniteq to stay in the loop with the latest AI stories. Let’s shape the future of AI together!More Reasoning Is Not Free. Less Isn’t Automatically Cheaper. was originally published in Generative AI on Medium, where people are continuing the conversation by highlighting and responding to this story.