Reasoning effort is a dial, not a constant. Turn it up only where deeper thinking actually changes the answer — and pay nothing extra everywhere else.
Why this, for you: the easy lever is "make it think harder," so it gets pulled on every task — and
your thinking-token bill doubles while the output for a one-line lookup is identical. The skill isn't more reasoning
or less; it's matching the budget to the difficulty so the expensive tokens land only where they earn their keep.
The four rights so far cut tokens by choosing what you send. Effort scaling cuts a different
pool: the thinking tokens a model burns before it answers. Those tokens are pure cost until the task
is hard enough to need them — and most tasks aren't.
1 Budget reasoning the way you budget tier
You already route model tier to task complexity — fast models for exploration, capable models for
implementation, powerful ones for architecture. Reasoning effort is the same trade-off on a second axis: how much the
model deliberates before it commits to an answer.
Spend reasoning effort the same way you spend tier choice — by complexity. A file-search task and a
cross-cutting refactor should not get the same thinking budget, any more than they should get the same model.
Treat the budget as a heuristic keyed on task signals, not a global setting. Cheap signals — query length, number
of files touched, whether a previous pass failed validation — predict difficulty well enough to set the dial without
a second model call.
Task signal
Effort
Why
Lookup, single-file edit, lint fix
Minimal / none
Answer is mechanical; thinking adds tokens, not accuracy
Multi-step implementation
Moderate
Some planning changes the result
Architecture, cross-cutting refactor
High
Deep reasoning is what the task is paying for
2 Escalate on failure — don't pre-pay for it
The cheapest way to find out whether a task needs more effort is to try it cheap and check. Start with the
low-effort pass, run a deterministic gate, and only escalate the ones that fail. This is the same cascade that powers
cost-aware routing: cheap first, escalate on validation failure.
# Two-pass effort cascade — pay for thinking only on the misses1. low-effort pass → fast answer, minimal thinking tokens
2. deterministic gate → tests · linter · type-checker3. on PASS → ship — you never paid for high effort
on FAIL → re-run at high effort with the failure as context
FrugalGPT — the research line behind cascade routing — showed escalate-on-failure cutting cost by up to
98% versus calling the strongest path every time. The same logic applies to effort: most tasks clear
the gate on the cheap pass, so you almost never pay the high-effort price.
The gate has to be cheaper than the thinking it saves
Escalation only pays when the validator is cheap and deterministic — a test suite, a
linter, a type-checker. If the gate takes longer than the cost gap between a low- and high-effort pass, the cascade
adds latency without saving money. Measure the gate before you commit to it.
3 When more thinking stops helping
Effort scaling assumes a difficulty curve: harder tasks get more budget. Two situations break that assumption, and
on both, turning the dial up burns tokens for nothing.
The task is mechanical. A rename, a config tweak, a known one-liner — extra thinking can't
improve an answer that was already determined. The marginal reasoning token changes nothing.
The work is tightly interdependent. When a task can't be cleanly split by difficulty — a
refactor that needs reasoning at every edit — a low-effort first pass just gets re-done at high effort,
and the model re-ingests its own findings. You pay twice.
The win is spending thinking tokens only where they change the answer. Below the
task's difficulty, more effort buys accuracy; above it, more effort buys only a bigger bill.
So the dial has a floor and a ceiling. Scale up to meet difficulty — and stop the moment another increment
of reasoning would land on an answer the model would have reached anyway.
↪ Your win: effort matched to difficulty
Treat effort as a dial — budget reasoning by complexity, exactly as you route model tier.
Key the budget on cheap signals — query length, files touched, prior-pass failure — not a global setting.
Cascade: cheap pass → gate → escalate only on failure — most tasks never pay the high-effort price.
Keep the gate cheaper than the thinking it saves — deterministic tests/linters/type-checkers only.
Stop at the ceiling — past a task's difficulty, extra reasoning changes the bill, not the answer.
Retrieval practice — recall, don't peek
Question 1Reasoning effort should be scaled to…
Question 2In a two-pass effort cascade, you pay for high-effort thinking…
Question 3The escalation gate only saves money if it is…
Question 4On a mechanical one-liner, turning the effort dial up mostly buys…
Question 5 · spaced recall from an earlier lessonTo make the cache prefix hit, you order context…
Ask me anything. Want a concrete signal-to-effort heuristic for your own task mix, or help wiring a
deterministic gate that's cheap enough to escalate behind? Next: Measurement — Spend & the Cost/Quality
Frontier, where we turn all five rights into numbers you can optimize against.