Test-Time Scaling Makes Overtraining Compute-Optimal

Abstract: Modern LLMs scale at test-time, e.g. via repeated sampling, where inference cost grows with model size and the number of samples. This creates a trade-off that pretraining scaling laws, such as Chinchilla, do not address. We present Train-to-Test ($T^2$) scaling laws that jointly optimize model size, training tokens, and number of inference samples under fixed end-to-end budgets. $T^2$ modernizes pretraining scaling laws with pass@$k$ modeling used for test-time scaling, then jointly optimizes pretraining and test-time decisions. Forecasts from $T^2$ are robust over distinct modeling approaches: measuring joint scaling effect on the task loss and modeling impact on task accuracy. Across eight downstream tasks, we find that when accounting for inference cost, optimal pretraining decisions shift radically into the overtraining regime, well-outside of the range of standard pretraining scaling suites. We validate our results by pretraining heavily overtrained models in the optimal region that $T^2$ scaling forecasts, confirming their substantially stronger performance compared to pretraining scaling alone. Finally, as frontier LLMs are post-trained, we show that our findings survive the post-training stage, making $T^2$ scaling meaningful in modern deployments.

• The paper introduces T² scaling laws that unify training and test-time costs to show overtraining is the compute-optimal strategy.
• The methodology employs both loss-based (T²-NLL) and accuracy-based (T²-Acc) approaches, validated on over 100 models across diverse NLP tasks.
• The findings imply that smaller models trained with substantially more tokens outperform larger Chinchilla-optimal models under equalized compute conditions.

Test-Time Scaling Makes Overtraining Compute-Optimal: A Technical Analysis

Introduction

"Test-Time Scaling Makes Overtraining Compute-Optimal" (2604.01411) offers a formal framework—Train-to-Test ($T^2$) scaling laws—that unifies pretraining and test-time inference costs to determine compute-optimal training regimes for LLMs. Departing from the paradigm established by Chinchilla scaling, which considers only pretraining compute and neglects repeated-sampling at inference, this work rigorously incorporates pass@$k$ inference into the optimization of model size, training duration (token budget), and test-time sampling. The $T^2$ methodology delivers actionable prescriptions for model developers targeting deployment settings with substantial test-time compute budgets, firmly advancing the formal understanding of overtraining in deployment-relevant LLM development.

Figure 1: $T^2$ scaling combines Chinchilla pretraining scaling with pass@$k$ modeling, yielding a distinct optimality regime in which overtraining is consistently favored.

Unification of Pretraining and Test-Time Scaling

Problem Formulation

The paper formalizes the joint optimization over model parameters ($N$), training tokens ($D$), and inference samples ($k$), subject to both pretraining ($C_{\text{train}}$) and test-time ($C_{\text{inf}}$) compute budgets. Traditionally, pretraining scaling laws like Chinchilla [hoffmann2022training] specify that $k$0 and $k$1 should be chosen to minimize loss under the constraint $k$2. This omits the compositional cost and benefit structure of repeated sampling at inference, central to pass@$k$3 workflows prevalent in large-model deployments.

The paper develops two approaches:

1. Loss-based ($k$4-NLL): Models task loss as a function of $k$5, $k$6, and the test-time sampling number $k$7—effectively generalizing Chinchilla to negative log pass@$k$8.
2. Accuracy-based ($k$9-Acc): Directly models predicted pass@$T^2$0 accuracy using a parametric estimator for the distribution of task difficulties (single-pass accuracies), yielding closed-form predictions for mean pass@$T^2$1 via Beta regression.

Both approaches are inference-corrected by explicitly maximizing end-to-end performance under fixed train and test compute allocations, capturing the non-trivial tradeoff in allocating compute between training larger/weaker models and inferencing them more aggressively.

Experimental Results

Extensive experiments are conducted on a suite of over 100 models (<1B parameters, up to $T^2$2 pretraining FLOPs) spanning eight downstream tasks, including both standard NLP benchmarks (LAMBADA, ARC-Easy, SciQ, OpenBookQA) and synthetic challenges (arithmetic reasoning, knowledge, causal and spatial reasoning).

Pretraining Must Change If Test-Time Scaling Is Known

Both $T^2$3-NLL and $T^2$4-Acc forecast dramatic overtraining compared to Chinchilla, recommending models that are smaller (as measured by $T^2$5) and receive many more training tokens per parameter (much greater $T^2$6 ratio), sometimes far exceeding the canonical "20 tokens per parameter" heuristic. As evaluation criteria and inference budgets change, Chinchilla optimality ceases to align with deployment goals.

Figure 2: $T^2$7 approaches forecast a strong shift toward overtraining in both model size and dataset size allocation compared to Chinchilla.

Figure 3: Across all tasks, $T^2$8 frontiers monotonically improve with compute, unlike Chinchilla where scaling is sometimes non-monotonic under test-time correction.

Empirical Validation in the Overtrained Regime

The $T^2$9 scaling laws are validated against newly trained checkpoints extending well into the overtraining regime, as predicted. Overtrained base models consistently outperform Chinchilla-optimal checkpoints with equalized test-time inference budgets. This is observed both before and after post-training adaptation (SFT or standard fine-tuning).

Figure 4: Extrapolation of $T^2$0 to overtrained checkpoints matches empirical results; overtrained small models yield higher pass@$T^2$1 than larger, Chinchilla-optimal models for all real and synthetic tasks.

The performance gap is quantitatively striking—e.g., on LAMBADA, a 37M parameter overtrained model achieves 49.9% pass@$T^2$2 versus 27.3% for the Chinchilla-optimal 455M model; similar effects are evident across all synthetic reasoning tasks.

Persistence After Post-Training

$T^2$3-driven overtraining recommendations remain robust after post-training. Although overtrained models exhibit slightly subdued optimal frontiers (attributed to increased fine-tuning difficulty [springer2025overtrained]), they remain superior to Chinchilla-optimal models under compute-equalized test-time sampling.

Figure 5: $T^2$4 overtraining prescription persists after post-training, confirming the generality of the result across model adaptation protocols.

Theoretical and Practical Implications

Theoretical Advances

This work occupies a critical space at the intersection of pretraining scaling laws and the emergent literature on test-time scaling and overtraining [snell2024scaling, sardana2024beyond, brown2025large]. By formally coupling both regimes into a single optimization, it demonstrates that prior separation is deeply suboptimal for practitioners aiming to maximize downstream performance-per-compute in realistic settings. The equivalence (to within a few percent) between the loss-based and accuracy-based $T^2$5 methods increases confidence in the prescriptions’ generality.

The main theoretical implication is that overtraining becomes the default compute-optimal strategy whenever nontrivial test-time budgets and repeated sampling are permissible. As test-time compute budgets continue to expand in production LLM deployments, the classic Chinchilla ratio is no longer just suboptimal, but actively misleading.

Practical Recommendations

• Model developers targeting repeated sampling (pass@$T^2$6) deployments should pretrain substantially smaller models for far longer than prescribed by Chinchilla.
• $T^2$7 provides a closed-form, easily fit blueprint for obtaining the jointly optimal $T^2$8, $T^2$9, and $k$0 for any target compute allocation—critical for planning compute spend in both training and deployment.

Practically, this shows that the aggressive overtraining seen in modern families (Llama-2/3, Gemma, OLMo) is justified and computably optimal from a test-time-aware perspective.

Limitations and Future Directions

The current work probes model scales up to 1B parameters, with pretraining and test-time FLOPs below the trillion-token regime, though the authors suggest that the qualitative findings generalize to the current frontier. Future work is required to validate $k$1 at GDP-scale runs, to refine the inference cost model for transformer architectures beyond pure parameter-scaling, and to mechanistically link post-training efficiency to overtraining-induced brittleness.

Other promising directions include integrating more advanced sampling strategies (e.g., self-consistency, iterative refinement [wei2022chain, madaan2023self]) into the $k$2 framework and modeling data curation/filtering alongside joint compute allocation.

Conclusion

The Train-to-Test ($k$3) framework presented in (2604.01411) establishes that when deployment entails repeated sampling (test-time scaling), overtraining is not a heuristic but the unique compute-optimal strategy, superseding Chinchilla in all deployment-aware settings. This finding is supported by robust numerical results—pass@$k$4 improvements frequently exceeding 2$k$5 over Chinchilla-optimal models—and is validated through both theoretical modeling and empirical pretraining/post-training experiments. As real-world deployments increasingly leverage large test-time budgets, $k$6 scaling laws provide a critical tool for efficient LLM development, with broad implications for future architectures and deployment paradigms.