Where does sleep-time compute fit in the taxonomy of test-time scaling?
This explores where 'sleep-time compute' — doing inference work before a question is asked, during idle time — sits within the broader map of test-time scaling methods.
This explores where 'sleep-time compute' fits in the test-time scaling map — and the short answer is that the corpus treats it less as a category of its own and more as a shift in *when* compute happens rather than *how much*. Most test-time scaling research organizes itself around a single primary split: internal methods (training a model to reason autonomously) versus external methods (search and verification bolted on at inference) How do internal and external test-time scaling compare?. Sleep-time compute doesn't slot neatly into either axis — it lives on a different dimension entirely, which is why one of the corpus notes flags it alongside 'post-completion' compute as a *novel direction* that moves the timing of computation rather than its volume How should test-time scaling methods be categorized and designed?.
To see why that's interesting, it helps to notice that the classic scaling axes are all about volume and shape *at the moment of the query*. There's the parallel-versus-sequential trade-off — breadth of coverage against depth of reasoning How should we balance parallel versus sequential compute at test time? — and the finding that, once you control for total compute, the specific framework (best-of-N, MCTS) matters far less than the budget you spend Does the choice of reasoning framework actually matter for test-time performance?. Sleep-time compute sidesteps that whole framing: instead of asking how to spend tokens *now*, it asks what you can precompute *before* the user shows up, so the query-time latency bill is smaller.
The deepest connection the corpus offers is actually to pretraining, not inference. 'Thinking-augmented pretraining' generates reasoning traces and folds them into training data, achieving roughly 3x data efficiency — and the authors explicitly describe this as applying test-time-scaling-style reasoning *ahead of time* Can training data augmentation match test-time compute scaling benefits?. That's the same conceptual move as sleep-time compute: amortize reasoning into an idle window so it doesn't have to be paid for at the moment of demand. It also rhymes with the finding that inference compute and parameter scaling are not independent resources but trade against each other Can inference compute replace scaling up model size? — sleep-time compute is one more way to reshuffle *when* in the pipeline a fixed compute budget gets spent.
So the honest placement is: sleep-time compute is orthogonal to the dominant internal/external taxonomy. It's a 'when' axis crosscutting the field's usual 'how much' and 'what shape' axes. The reader curious about this should know the field hasn't fully absorbed it yet — it shows up as a frontier item How should test-time scaling methods be categorized and designed? rather than a settled branch, and its closest intellectual cousins are pretraining-time reasoning augmentation and the compute-substitution results, not the search-versus-reasoning debates it superficially resembles.
Sources 6 notes
Research shows test-time scaling methods split into internal (training models for autonomous reasoning) and external (inference-time search and verification). They complement rather than compete; internal builds capability while external extracts performance from existing capability.
Research identifies internal vs external as the primary taxonomic split for test-time scaling, with training-side constraints (policy entropy collapse) and novel directions that shift *when* compute happens (sleep-time, post-completion) rather than just *how much*. Methods like consensus games and recursive LMs sidestep traditional scaling tradeoffs.
Parallel methods improve coverage; sequential methods enable depth. The optimal choice depends on task structure: parallel wins for independent short problems, sequential for compositional chains requiring intermediate accumulation.
Information-theoretic analysis shows BoN and MCTS converge in reasoning accuracy when controlling for total compute. Snowball errors accumulate per step regardless of framework; mitigation depends on search scope and reward function reliability, not the specific algorithm.
Augmenting pretraining data with LLM-generated reasoning traces improves data efficiency 3x and reasoning benchmark performance 10%+ for 3B models. Harder tokens automatically receive longer traces, creating a natural compute-allocation mechanism analogous to test-time scaling.
Snell et al. (2024) showed that inference-time compute trades off against model parameter scaling, especially on difficult prompts. This reveals pretraining and inference compute are not independent resources.