1. Why this matters
Historically, improving Large Language Models (LLMs) meant scaling up train-time compute: feeding models larger datasets during pretraining. However, a new paradigm emerged with OpenAI's o1 series: test-time compute scaling. Instead of answering immediately, the model "thinks" before responding, allowing it to solve complex reasoning problems by spending more computational effort at inference time.
While closed-source models have successfully demonstrated this capability, their methodologies are highly proprietary and typically rely on vast reinforcement learning (RL) pipelines requiring millions of training samples. This paper asks a fundamental scientific question: What is the absolute simplest recipe to achieve test-time scaling?
2. The Big Idea
The authors hypothesize that the ability to reason is already latent in modern pretrained base models due to exposure to trillions of high-quality tokens during pretraining. Rather than building complex RL architectures, we can activate and control this reasoning capability using a remarkably simple two-step methodology:
- Supervised Fine-Tuning (SFT) on a tiny, meticulously filtered dataset of only 1,000 samples (s1K) containing rich reasoning traces.
- Budget Forcing: A dynamic decoding-time intervention that forcefully terminates thinking early or extends the model's thinking process by appending a simple "Wait" token sequence when the model attempts to stop prematurely.
3. Curation of the s1K Dataset
The authors curated an initial pool of 59,029 questions from 16 diverse sources. To identify the absolute best 1,000 samples, they designed a multi-stage filtering pipeline based on three core principles: Quality, Difficulty, and Diversity.
Interactive s1K Filtering Pipeline
Simulate the exact filtering stages used to reduce 59,029 raw samples down to the highly effective s1K dataset. Toggle the filters below:
Removes API errors, poor formatting, ASCII art, and inconsistent question structures.
Removes questions that either Qwen2.5-7B-Instruct or Qwen2.5-32B-Instruct can already solve easily. Only keeps challenging problems requiring deep reasoning.
Classifies questions into 50 distinct mathematical and scientific domains (e.g., topology, quantum mechanics) and samples uniformly, favoring longer reasoning traces.
4. Budget Forcing
How do we control how long the model thinks at test time? The authors propose Budget Forcing, a simple decoding-time intervention:
- To terminate early: Append the end-of-thinking token delimiter (e.g.,
<|im_start|>answer) once the budget is reached, forcing the model to output its final answer immediately. - To extend thinking: Suppress the generation of the end-of-thinking delimiter, and instead append the string
"Wait"(or"Wait, let's re-read...") to the current context, encouraging the model to reflect and catch its mistakes.
Budget Forcing Playground
See how budget forcing alters the model's internal thinking trace on the classic trick question: "How many 'r's are in raspberry?"
5. Results & Scaling Curves
Does this simple recipe actually scale? Yes. On competition math benchmarks, the s1-32B model exhibits classic test-time scaling properties. More importantly, the authors show that sequential scaling (budget forcing) is far more compute-efficient than parallel scaling (majority voting) or rejection sampling.
Sequential vs. Parallel Scaling on AIME24
Hover over points to see performance data and exact compute allocations.
| Model | Finetuning Size | AIME24 | MATH500 | GPQA Diamond |
|---|---|---|---|---|
| o1-preview (API) | Proprietary | 44.6% | 85.5% | 73.3% |
| s1-32B (Ours, w/ BF) | 1,000 (s1K) | 56.7% | 93.0% | 59.6% |
| s1.1-32B (DeepSeek-R1 traces) | 1,000 (s1K-1.1) | 56.7% | 95.4% | 63.6% |
6. Limitations & Open Questions
Despite the impressive scaling behavior, the authors identify critical limitations to simple budget forcing:
- Thinking Loops: Forcing the model to wait too many times (e.g., 6x or more) eventually causes performance to flatten or degrade because the model enters repetitive loops instead of generating novel paths.
- Context Window Constraints: Since sequential thinking consumes tokens, long-running reasoning traces eventually hit the model's maximum context window length, leading to truncated outputs and failures.
- Arithmetic Control: Off-the-shelf models struggle to accurately count their own tokens, meaning conditional prompt instructions (e.g., "Think for exactly 1024 tokens") fail without explicit external interventions like budget forcing.
7. Glossary
Test-Time Scaling
The technique of increasing the computation allocated during inference (test time) rather than training, allowing models to generate intermediate thoughts or search trees to achieve higher accuracy.
Budget Forcing
A dynamic decoding-time intervention that either forces a model to stop thinking early by appending an answer delimiter, or forces it to think longer by suppressing the delimiter and appending a prompt sequence like "Wait".
Superficial Alignment Hypothesis
Originally proposed in the LIMA paper, this hypothesis states that a model's capabilities are almost entirely learned during pretraining, and SFT simply teaches the model the format or style desired by users.
Cite this paper
@misc{muennighoff2025s1simpletesttimescaling,
title={s1: Simple test-time scaling},
author={Niklas Muennighoff and Zitong Yang and Weijia Shi and Xiang Lisa Li and Li Fei-Fei and Hannaneh Hajishirzi and Luke Zettlemoyer and Percy Liang and Emmanuel Candès and Tatsunori Hashimoto},
year={2025},
eprint={2501.19393},
archivePrefix={arXiv},
primaryClass={cs.CL},
url={https://arxiv.org/abs/2501.19393},
}