thenaivekid/reasoning-models-cannot-budget-their-thinking

Paying more to be wrong: small reasoning models cannot tell how long to think

Where this came from

I came to this through model-routing work at a startup, where the job was to decide, per query, which model should answer. One idea going around from university and industry labs was to treat reasoning effort itself as a routing signal: a larger model costs more per token, but if it thinks briefly it can end up cheaper per answer than a small model that thinks for a long time. To make that work I had to look at what the models actually do — tokens emitted, latency, cost per answer — across budgets, instead of at one accuracy number. That is when the pattern showed up. The same question, the same model, would be right at a low reasoning budget and wrong at a higher one. The length a model chose had almost nothing to do with how hard the question was. Asking it to be brief changed nothing. The best single feature I ever found for "is the small model about to be wrong" was simply "has it been talking for a while". Once I knew what to look for I found pieces of this in the literature (overthinking, budget forcing, inverse test-time scaling), but every paper reports one aggregate curve; nobody looks per query, on the same sweep, at the small models people actually deploy. So I built the sweeps, logged everything, and this is what came out. What kept me on it is that this is not a benchmark curiosity: it decides whether a small model is deployable at all. If you cannot predict what an answer will cost, cannot bound how long it will take, and cannot trust that paying more makes it better, then the three things a deployer actually controls — cost, latency, accuracy — are all out of your hands, and no leaderboard score tells you that.

1. The blind spot

A model cannot calibrate how much it thinks to how hard the question is, and more budget is not safe: it often turns a right answer wrong. Benchmarks hide this because they fix one generous budget and report one number. Deployers pay for it three ways:

• Cost. On MMLU-Pro, Qwen3-4B-Thinking spends 31% more tokens per question than Qwen3-30B-A3B-Thinking (4,628 vs 3,541) and scores 6 points lower (0.746 vs 0.808). The "cheap" model is not cheaper per answer. On GPQA-Diamond its wrong answers cost 46% more tokens than its right ones. You pay most for the answers you should have thrown away.
• Latency. The 4B model's median GPQA trace is ~8.5k tokens: at 60 tok/s on a single consumer GPU that is 2.4 minutes per question, and 4.3 minutes at the 90th percentile of its wrong answers. Anything interactive cannot wait 2–4 minutes, and cutting it off early is not an option (section 2.4).
• Accuracy. On R2-Bench, 24% of all 30,968 queries are ones Llama-3.2-3B answers fully correctly at some cheaper budget and wrongly at its best fixed budget. If a per-query oracle picked the cheapest correct budget, Llama-3B would go from 26.4% to 54.5% fully correct while spending 453 instead of 2,000 tokens. On MCQ alone, where grading is exact-match and judge noise is not a factor, 38.8% of queries are right at a cheaper budget and wrong at the best fixed one. If you set effort=high "to be safe", on this data you bought more wrong answers for more money.

Size does not fix it. On the same benchmark, 58% of the queries Qwen3-30B-A3B-Instruct ever solves and 73% of those Qwen3-235B-Instruct ever solves later flip to not-fully-correct at a larger budget (data/r2bench_large_reference_scores_by_budget.parquet; these are non-thinking instruct models, so this shows the flipping is not a small-model artifact, not that it transfers to large thinking models — that run is still to do). The small models here are the ones I can run and inspect end to end.

Models evaluated (all 1.5B–4B, open weights). Qwen3-4B-Thinking is my choice; Llama-3.2-3B and Qwen2.5-Math-1.5B are the two clean sub-6B models in the R2-Bench release, which I re-analysed per query.

Model	Mode	Why
Qwen/Qwen3-4B-Thinking-2507 (FP8)	thinking	primary model: the closest small open-weight analogue of a frontier thinking recipe (Qwen3 family, 2507 refresh, <think> channel, same chat/thinking interface as the 235B). Like every small Qwen3 it is distilled from the large models, which is itself part of the diagnosis in section 3: it inherits the teacher's trace lengths without ever having been charged for them. Preferred over DeepSeek-R1-Distill-1.5B/7B and SmolLM3-3B because it is the current generation of the family whose large member defines the frontier behaviour I was routing against.
meta-llama/Llama-3.2-3B-Instruct	non-thinking	16-budget sweep on 30,968 queries; obedience to a budget instruction
Qwen/Qwen2.5-Math-1.5B-Instruct	non-thinking	15-budget sweep; a domain-specialised small model

---

2. Evaluation (full tables in REPORT.md; every number is in figures/metrics.json)

2.1 More budget makes right answers go wrong

R2-Bench: 30,968 queries, 20 categories, graded 0–1 by an LLM judge, 16 budgets (10 … 8000). Budget = "You have a strict budget of N words" in the prompt plus a hard stop at N+10 tokens. One sample per cell.

model	ever fully-correct queries	later drop below 1.0	later drop to 0.0	still correct one level later	first flip at the very next level
Llama-3.2-3B	16,889	86.0%	62.5%	35.9%	71.7%
Qwen2.5-Math-1.5B	11,414	85.3%	74.7%	38.7%	70.1%

These are single samples, so part of this is sampling and judge noise and the per-query rates are upper bounds. Two things are not noise: the MCQ subset, where grading is exact-match — 94.7% of the MCQs Llama-3B ever gets right it later gets wrong — and the gap between "solved at budget ≤ B" and "solved at B" — what a pass@budget leaderboard reports versus what the model actually produces — which reaches +28.8 pp for Llama-3B and +23.9 pp for Math-1.5B at the top budget (fig 1, right panel). The aggregate dips at the 4000 level (Math-1.5B 19.7 → 12.9; Llama graded 46.1 → 42.7, recovering at 8000) are on ~31k queries per cell, but both models dip at the same level, so I cannot rule out an upstream batch or judge effect there and do not lean on it.

2.2 What knowing when to stop is worth

model	best fixed budget	fully correct there	per-query oracle (cheapest correct budget)	oracle mean tokens	of the best-fixed solves, already solved cheaper	right cheaper but wrong at best fixed (% of all queries)
Llama-3.2-3B	2000	26.4%	54.5%	453	90.0%	24.1%
Qwen2.5-Math-1.5B	1200	19.7%	36.9%	229	82.5%	14.1%

The oracle is an upper bound (same n=1 caveat), but even halved it is a 10–15 point accuracy gain at 4–5× lower cost. It is worst on multiple choice (REPORT.md §A, by question type).

2.3 Telling it the budget does not work (without training for it)

"strict budget of N words"	mean tokens	≤ N tokens	hit the hard cap (N+10)	mean score
N = 50	54.8	11.2%	85.7%	0.252
N = 200	191.4	16.2%	82.1%	0.417
N = 800	553.4	68.6%	31.0%	0.455

Llama-3B obeys the instruction only when the budget is already larger than it wanted to write. L1 shows a model can learn to obey a length instruction; off the shelf, it does not. And when the budget is slack (the 8000-word level, where it uses ~1.6k tokens on average; 10,039-query held-out split), its length is unrelated to difficulty: 1,346 tokens on questions no reference model can solve, 1,273 on questions all ten solve, Kendall τ = −0.13, within-level spread larger than any between-level difference (fig 6).

2.4 The thinking model cannot be stopped early either

Qwen3-4B-Thinking, GPQA-Diamond (n=198, accuracy 0.626, no trace hit the 32k cap):

• Tokens when correct: mean 7,376 (median 7,022). When wrong: 10,786 (10,972). Length alone predicts wrongness with AUC 0.74; accuracy by length quintile falls 0.88 → 0.77 → 0.65 → 0.54 → 0.30. Long traces are mostly the ones it loses.
• Forced early commit — generate k thinking tokens (temp 0.6), inject </think> and The answer is \boxed{, read the next token greedily:

k	0	256	1024	full (~8.7k)
accuracy	0.379	0.348	0.404	0.626
agrees with its own final answer	0.505	0.500	0.535	—

Chance agreement if the early pick were independent of the final one is 0.25. After a thousand tokens of its own reasoning the model is only weakly committed to what it will eventually say, so no external controller can cut it short without losing ~22 points. Self-consistency does not expose a hidden commitment either: 8-sample majority vote 0.607 vs single 0.616, and when all 8 samples agree the answer is right only 74% of the time.

2.5 What this does and does not show

The 16-budget sweeps are on non-thinking models with the budget applied to the whole response; the thinking-model evidence is natural length plus forced early commit. The flagship thinking model has not yet had the flagship sweep — that is the first thing I would run next. thinking_budget_sweep_colab.ipynb (open in Colab) loads Qwen3-4B-Thinking-2507 on a free T4 and runs the same protocol on the <think> channel (budget sentence, hard cap, forced-box answer, obedience logged, flips counted, a flip printed side by side so you can read where the longer trace went wrong); scripts/budget_sweep_qwen3_thinking.py is the same thing as a script for Modal or a bigger GPU. R2-Bench generations and judge scores were produced by the R2-Bench authors; the per-query analysis — flips, survival, closure inflation, oracle-vs-fixed, length-vs-difficulty — and all Qwen3-4B experiments are mine. Each symptom has prior work, in aggregate: overthinking ("Do NOT Think That Much", "Stop Overthinking", ThoughtTerminator's length-difficulty calibration); budget control (s1, L1/LCPO, ThinkPrune, AdaptThink, Thinkless, Qwen3's thinking budget); non-monotone scaling ("Inverse Scaling in Test-Time Compute", "Does Thinking More Always Help?"); early exit (DEER, answer-convergence stopping); length-instruction following (LIFEBench). What I add is narrower and, I think, more useful to a deployer: the same sweep analysed per query, the closure-inflation number, the oracle priced in tokens, and the forced-commit self-agreement measurement.

---

3. Path forward

Nothing in training charges for tokens or rewards stopping. SFT shows the model long traces; outcome RL rewards being right eventually; distillation hands a small model the teacher's trace lengths wholesale. Three things I would change, plus one about evaluation.

(a) Data: let the trace length carry the difficulty. Today's SFT and preference data mostly comes from one generous setting, so a one-line factual question and a six-step deduction get traces of similar length. I would build the data the other way round: for every question, sample many correct traces and keep the short ones for easy questions and the long, thorough ones for hard ones — not bucketed into short/medium/long, but as a continuous spread where trace length follows what the question actually needed (the cheapest-correct-budget computed per query here is a direct estimate of that). If the training distribution has that shape, the model does not need to be told how much to think. The same pool gives DPO pairs for free: short-correct preferred over long-correct when the question was easy, the reverse when it was hard. And the budget instruction has to be in the data too. "Think for at most 200 tokens" is a sentence the model has never been trained to act on; pair it with traces that respect it, across many budgets, so it becomes a control it has seen rather than a request it has to guess at. ThinkPrune and AdaptThink also train towards shorter correct traces; L1 conditions on a user-given length. The difference here is the label source: the per-query cheapest-correct budget from a sweep, which conditions length on the question, with the instruction as a fallback.

(b) Training. A flat length penalty makes the model short on everything, including questions that need a long derivation. Penalise tokens beyond the shortest correct rollout instead (group-relative length penalties of this shape exist — Kimi k1.5, ShorterBetter; the point here is to anchor them to the per-question minimum, estimated from ≥4 rollouts because single-sample minima are noisy, as this data shows). Then train a stop head. The 4B model, cut off at 1,000 tokens, agrees with its own eventual answer only half the time — it has no idea yet what it is going to say. A small side head that predicts, every few hundred tokens, whether the answer at this point equals the final answer, trained with the label [answer@k == answer@final] from the model's own completed traces — the 198×3 forced-commit records in this repo are already that training set in miniature. It is the stop condition, and it attacks flipping at the root: most flips here are a model that had the right answer and kept generating past it. Success criterion: commit agreement at 1k tokens above 0.8 (today 0.53) and flip rate under the sweep below 20%.

(c) Architecture. A language model has no counter; asking a 3B model to stay under 200 words asks it to track something it cannot see. Make the budget an input: a countdown token every N tokens during training under randomly drawn budgets, so running out is a situation it has wrapped up from thousands of times. Qwen3's thinking budget injects </think> at the cap; the difference is that the model sees the budget shrinking and learns to land, rather than being cut. Measured by the same three numbers: cap-hit rate, flip rate, commit agreement.

(d) Evaluation. Report closure inflation: CI(B) = P(solved at some budget ≤ B) − P(solved at B). Here it is 24–29 points at the top budget, i.e. "solved at ≤ 8k" overstates what the model does at 8k by a quarter of the dataset. Report the accuracy–cost curve and CI(B) alongside accuracy, or leaderboard-tuned models will keep overthinking.

---

Files

README.md, REPORT.md
thinking_budget_sweep_colab.ipynb   Colab (T4) notebook: thinking-mode budget sweep on Qwen3-4B-Thinking-2507
figures/fig1..fig7 + metrics.json   every number quoted above
data/
  r2bench_small_models_scores_by_budget.parquet     30,968 queries x 2 models x 16 budgets; qtype; n_ref_models_solving
  r2bench_large_reference_scores_by_budget.parquet  same for Qwen3-30B-A3B / Qwen3-235B (transfer statement only)
  r2bench_budget_obedience_compact.parquet          Llama-3.2-3B, budgets 50/200/800: tokens generated, hit_cap, score
  r2bench_budget_obedience_examples.jsonl            120 full prompt/response examples
  r2bench_llama3b_length_vs_hardness.json            natural length (8k cap, no budget sentence) by difficulty
  gpqa_diamond_qwen3_4b_thinking_per_question.jsonl  198 rows: pred, correct, gen_tokens
  qwen3_4b_phase0_early_commit.json, qwen3_4b_mmlu_pro_cascade.json, qwen3_4b_phase0_sc.json, qwen3_4b_router_a_only_metrics.json
scripts/
  build_dataset.py               exports data/ from the raw experiment outputs (needs the original run dirs)
  make_figures.py                recomputes every metric and figure from data/ (fig 6 plots the upstream length summary as stored)
  budget_sweep_qwen3_thinking.py 16-budget thinking-mode sweep, Qwen3-1.7B/4B, Colab T4 / Modal
  upload_to_hf.py

Generation settings: Qwen3-4B-Thinking-2507-FP8 via vLLM, temp 0.6 / top_p 0.95 / top_k 20, max_new_tokens 32,768, \boxed{LETTER} extraction. GPQA question text is not redistributed; rows index into fingertap/GPQA-Diamond.