STOP: Cut Your Losses with Internal Learned Intuition for Efficient Parallel Reasoning
Cut Your Losses! Learning to Prune Paths Early for Efficient Parallel Reasoning
This paper introduces STOP (Super TOken for Pruning), a novel "Type IV" path pruning method for Large Reasoning Models (LRMs) that terminates futile reasoning trajectories early. It utilizes a learnable internal module to identify promising prefixes, achieving SOTA results such as boosting GPT-OSS-20B accuracy on AIME25 from 84% to nearly 90% while significantly reducing computational costs.
TL;DR
Reasoning models waste a staggering amount of compute on "dead-end" logic. STOP (Super TOken for Pruning) is a new architectural plug-in that allows models to peer into their own internal hidden states and kill unpromising reasoning paths early. By doing so, it slashes inference costs by up to 80% while actually improving final answer accuracy through cleaner consensus.
The Problem: The High Cost of "Overthinking"
Parallel reasoning (sampling multiple paths and voting) is the current gold standard for complex problem solving (e.g., OpenAI o1). However, recent research reveals a painful truth: if a model makes a logic error in the first few sentences, it almost never self-corrects. It simply "spirals" into a futile trajectory, wasting thousands of tokens.
Existing solutions are either too "dumb" (using simple token probabilities) or too "slow" (calling a second, expensive "judge" model to read the text).
Methodology: The Rise of Type IV Pruning
The authors propose a taxonomy that categorizes pruning methods by Source (Internal vs. External) and Learnability. They identify a "sweet spot" called Type IV: Learned Intuition.
How STOP Works: "Launch-Check-Resume"
- Launch: Generate short prefixes and cache their internal KV states.
- Check: Append a specialized [STOP] token. A lightweight Critique Adapter (LoRA) reads the internal states to output a "quality score."
- Resume: Only the top- paths continue. The rest are killed instantly, freeing up GPU memory.
Why Internal Signals Win
Text is a "lossy" medium. When a model outputs words, it throws away the rich, high-dimensional uncertainty encoded in its hidden layers. STOP accesses this "first-person" intuition.
Ablation Proof: The authors found that using a simple linear head isn't enough; you need the Critique Adapter to translate "generation features" into "evaluation features." Furthermore, training on Monte Carlo (MC) soft labels (probabilistic success rates) proved far superior to simple binary (correct/incorrect) labels.
Results: Efficiency Without Compromise
Across models from 1.5B to 20B parameters, STOP dominated the competition. On the grueling AIME25 math benchmark, STOP allowed a 20B model to reach nearly 90% accuracy, outperforming standard parallel reasoning that uses significantly more compute.
Deep Insight: How STOP "See" Errors
Attention visualizations reveal that the [STOP] token behaves like a professional grader.
- In High-Scoring paths, STOP pays close attention to "cognitive pivots" like the word "don't" (indicating self-correction).
- In Low-Scoring paths, the model shows "premature closure," fixating on the final answer option while ignoring the flawed logic preceding it.
Conclusion and Takeaways
The era of "brute-force" test-time compute scaling is evolving. STOP proves that internalized self-evaluation is the most efficient way to scale.
- For Developers: Moving the "judge" inside the model via adapters is faster and more accurate than external judge models.
- For Researchers: The Interaction Scaling Law provided in the paper offers a robust blueprint for choosing how many paths to keep versus how much to prune based on your specific GPU budget.
Limitations: While effective at 20B, the behavior at the 70B+ scale and the potential for multi-stage sequential pruning (funneling 64 -> 32 -> 16 paths) remain exciting frontiers for future work.