Technical Summary: EAGER – Entropy-Aware GEneRation for Adaptive Inference-Time Scaling

1. Problem Statement

The rise of reasoning language models (LLMs) and test-time scaling methods has established a paradigm where generating multiple candidate sequences from a single prompt improves performance by exploring diverse reasoning paths. However, standard approaches like FULL PARALLEL sampling allocate a fixed computational budget (a fixed number of sequences, $M$) to every prompt, regardless of difficulty.

This uniform allocation introduces inherent inefficiencies:

• Redundant Computation: For simple prompts, reasoning sequences often converge to identical or near-identical solutions. Regenerating identical prefixes across multiple parallel paths wastes compute.
• Insufficient Exploration: For complex prompts, the fixed budget may be insufficient to discover the correct solution, as the model requires more extensive exploration of alternative reasoning paths.
• Inefficiency in Long CoT: Reasoning sequences are long, and a significant portion of generated tokens are predictable continuations rather than genuine decision points.

The core problem is the lack of an adaptive mechanism to allocate compute resources based on the specific uncertainty and difficulty of each prompt during generation.

2. Methodology: EAGER

The authors propose EAGER (Entropy-Aware GEneRation), a training-free generation method that leverages model uncertainty, measured via token-wise entropy, to dynamically guide resource allocation. The method operates in two stages:

2.1. Uncertainty Quantification via Token Entropy

EAGER utilizes top-$K$ token entropy as a proxy for model uncertainty. At each generation step $t$, the entropy $H^{(K)}_t$ is calculated over the $K$ most probable tokens (where $K=20$).

• High Entropy: Indicates high uncertainty and a potential decision point where multiple reasoning paths are plausible.
• Low Entropy: Indicates high confidence and predictable continuations.
• Correlation: Empirical analysis (Figure 2) reveals a significant negative correlation ($\rho \approx -0.55$) between peak token entropy during generation and the final Pass Rate. High entropy peaks correlate with lower performance, suggesting that these are critical moments requiring additional exploration.

2.2. Stage 1: EAGER-init (Compute Saving)

EAGER-init modifies the generation process to avoid redundant computation:

• Dynamic Branching: Instead of generating $M$ independent sequences from the start, EAGER-init begins with a single sequence.
• Threshold Logic: At each token step, if the entropy $H^{(K)}_t$ exceeds a predefined threshold $\theta$, the current sequence branches into two new candidates. The model reuses the token distribution but selects the top two most likely tokens to ensure divergence.
• Prefix Reuse: If entropy is below $\theta$, the generation continues linearly. Crucially, tokens generated before a branch point are shared across all subsequent branches, eliminating the need to regenerate identical prefixes.
• Termination: Branching continues until the total number of active sequences reaches the limit $M$. For easy prompts, the process may terminate with far fewer than $M$ sequences, saving significant compute.

2.3. Stage 2: EAGER-adapt and Full EAGER (Budget Reallocation)

The computational budget saved by EAGER-init (the difference between the theoretical maximum $M \times |D|$ and the actual sequences generated) is reallocated to improve performance on difficult prompts. Two strategies are defined based on label availability:

• EAGER-adapt (Test-Time, No Labels): In the absence of ground truth, the method identifies "saturating prompts"—those that hit the $M$ sequence cap during EAGER-init. These are assumed to be challenging. The saved budget is reallocated to these prompts to allow further exploration.
• Full EAGER (Training/RLVR, With Labels): When target labels are available (e.g., in Reinforcement Learning with Verifiable Rewards pipelines), the method identifies prompts where EAGER-init failed to produce a correct solution (Pass@k = 0). The saved budget is reallocated to these specific failing prompts.
  • For underutilized prompts, the entropy threshold $\theta$ is lowered to encourage earlier branching.
  • For saturating prompts, the generation limit is extended to $M + b_i$ (where $b_i$ is the allocated budget).

3. Key Contributions

1. Empirical Validation of Entropy as a Proxy: The paper demonstrates that token-wise entropy peaks serve as an effective online indicator of prompt difficulty and the need for exploration, showing a strong negative correlation with model Pass Rate.
2. Training-Free Adaptive Decoding: EAGER introduces a novel decoding method that dynamically reduces compute costs (up to 65% fewer tokens) while maintaining or improving the benefits of inference-time scaling.
3. Adaptive Budget Allocation: The work demonstrates that reallocating saved compute from easy to hard prompts maximizes the utility of inference-time scaling, yielding performance gains without increasing the global computational budget.

4. Experimental Results

The authors evaluated EAGER across multiple open-source models (3B to 20B parameters) and diverse benchmarks (Math: AIME 2024/2025, HMMT 2025; Science: GPQA-Diamond; Code: HumanEval Plus).

• Efficiency: EAGER-init consistently reduced token usage by 40% to 80% compared to FULL PARALLEL sampling. In many cases, the total token count was less than half of the baseline.
• Performance (With Labels): In settings where target labels are accessible (simulating RLVR pipelines), Full EAGER achieved up to +37% improvement in Pass@k on AIME 2025 while using 59% fewer tokens.
• Performance (Test-Time): In test-time settings without labels, EAGER-adapt yielded +12% improvement in Pass@k and 64% fewer tokens compared to the baseline.
• Robustness: The method showed consistent improvements across different model sizes and domains. The entropy threshold $\theta$ was found to be robust, requiring only a small calibration set (10 examples) to generalize across out-of-distribution tasks.
• Pareto Frontier: Scaling the maximum sequence limit $M$ showed that EAGER shifts the performance-efficiency Pareto frontier, achieving higher accuracy at lower token costs compared to fixed-budget sampling.

5. Significance and Claims

The paper claims that EAGER addresses a fundamental inefficiency in current test-time scaling paradigms: the "one-size-fits-all" allocation of compute. By grounding the generation strategy in model uncertainty, EAGER:

• Reduces Redundancy: It avoids regenerating predictable, low-entropy prefixes, which constitute a large portion of long Chain-of-Thought sequences.
• Enhances Exploration: It directs computational resources toward high-uncertainty regions where the model is likely to fail or where diverse reasoning paths are necessary.
• Lowers Barriers: By significantly reducing the computational cost of generating high-quality reasoning traces, EAGER makes advanced reasoning capabilities more accessible to researchers and practitioners with limited compute budgets.
• Energy Efficiency: The reduction in token generation directly translates to lower energy and infrastructure costs associated with test-time scaling workloads.

The authors position EAGER not as a model architecture change, but as a general-purpose, training-free generation layer that can be applied to existing reasoning models to improve their efficiency and effectiveness.