A model that cannot solve your problem will usually not tell you so. It will produce a long, confident, expensive chain of reasoning that looks correct and is not. A paper accepted to the Findings of ACL 2026 gives that behavior a name -- futile reasoning -- and trains models to abort it instead, using a reward scheme that ranks a valid refusal above a wrong answer arrived at through elaborate work. The same week, a separate group cut total token consumption by up to 68.5 percent on reasoning tasks by reallocating compute between partial answers mid-thought rather than letting every attempt run to the end.
Key facts
- "Knowing When to Quit" identifies specious reasoning -- output that looks superficially valid but contains subtle errors -- as the dominant failure mode, and says it escalates with task difficulty (arXiv:2607.29211, accepted to Findings of ACL 2026).
- Its method, CaRL, rewards correct answers highest, valid refusals next and incorrect reasoning lowest, and converts failed reasoning traces into refusal training data.
- Gambit, a separate inference algorithm, reduces total token consumption by up to 68.5 percent versus standard parallel sampling while gaining up to 6.7 percentage points of accuracy on a hard math benchmark (arXiv:2608.08020).
- Both are public: CaRL's code and Gambit's code are on GitHub.
Start with why this is a safety problem and not just a billing problem. The CaRL authors put the risk plainly: models "generate computationally expensive yet semantically void reasoning on beyond-capability tasks, creating risks where plausible-sounding but incorrect derivations mislead users." A model that fails loudly is annoying. A model that fails with twelve paragraphs of legible working is dangerous, because the working is what people use to decide whether to trust the answer. The paper's diagnosis is that models are systematically miscalibrated between what they can do and how they behave -- universal capability overreach, in its phrasing -- and that baseline models essentially never abort on their own, even when prompted to.
CaRL's fix has two halves. The first is reward shaping with an explicit ordering: right answer best, honest refusal second, confident wrong answer worst. That inverts the incentive most training creates, where attempting something always beats declining it because an attempt might get partial credit. The second half is the clever one, called hindsight refusal augmentation: take the traces where the model reasoned at length and got it wrong, and relabel them as examples of situations where it should have refused. The model's own failures become the curriculum for knowing its limits. The reported outcome is a substantial reduction in futile reasoning while preserving performance across difficulty levels.
The best analogy is a surgeon's decision not to operate. The valuable skill is not only technique; it is recognizing the cases where technique will not help, and that recognition is learned from reviewing outcomes rather than from a rule. This connects to a topic the site has covered before -- calibration, the question of whether a model's confidence carries any information -- except that CaRL turns calibration into a behavior instead of a number.
Gambit attacks the same waste from the opposite end. It does not try to stop reasoning; it moves compute to where reasoning is going well. The standard way to spend more compute at inference is parallel sampling: generate many independent attempts and pick the best. That treats every attempt as equally worth finishing, which is obviously false by the third paragraph -- some are already off the rails. Gambit periodically prunes the unpromising trajectories and immediately branches new ones from the high-quality prefixes, using a lightweight scorer that reads the model's internal states to rank partial work. Because it branches at the moment it prunes, it never leaves the hardware idle, which is where naive pruning loses its gains. The reported result is up to 6.7 percentage points of absolute accuracy over pruning baselines on a hard math competition benchmark, more than double the throughput on completed traces, and up to 68.5 percent fewer tokens than standard parallel sampling.
The framing the Gambit authors use is the sharpest sentence in either paper: the critical question has shifted "from how much compute to spend, to where to allocate it." That is a meaningful change in how test-time compute is understood. For two years the story was that thinking longer makes models smarter, and the follow-on assumption was that the budget is the lever. These results say the budget is mostly being wasted on branches that were dead early, and that a scheduler beats a bigger allowance.
Two other same-day papers fill in the remaining corners. Claim-level reliability assessment replaces scoring a whole reasoning trace with extracting the handful of decision-critical claims and then asking the same model to try to refute each one, aggregating what survives -- spending the budget on falsification rather than on more full attempts. And a method called Second Thought uses the dead time while an agent waits for its environment to respond: it forks auxiliary reasoning branches, decodes them in parallel during the wait, and merges them when the observation arrives, which reduces sequential decoding on the main thread rather than raising raw accuracy.
The caveat is that none of these agree on a metric, which makes the savings hard to compare. CaRL measures the share of failures that were futile attempts rather than refusals; Gambit measures tokens against parallel sampling; the claim-level method measures tokens against self-consistency. Each baseline is a different thing to be better than. And CaRL's own results are mixed on out-of-distribution puzzles: wasted effort falls sharply, accuracy does not uniformly improve. Teaching a model to quit is not free, and how much it costs depends on how often it quits when it should not have.
Originally published on Ground Truth, where every claim is checked against the primary source.
