STaR,
explained.

Chain-of-thought showed that models reason better when they write out intermediate steps. The natural follow-up is to train a model to always do that well — but that seems to need a big dataset of high-quality reasoning traces, and those are scarce and costly to write. What you usually have is only the easy part: questions paired with their final answers, no worked solutions.

STaR's move is to close that gap by having the model generate its own rationales and using the known answers as a filter. When the model reasons its way to the correct answer, that reasoning is probably decent — good enough to learn from. When it reasons to a wrong answer, discard it. You never wrote a single rationale; you just judged the model's own reasoning by whether it worked. That turns a pile of question-answer pairs into reasoning training data, for free.

The core loop is three steps, run over your dataset of problems:

Step 2 is the whole trick: the ground-truth answer is a free, automatic quality check that selects which self-generated reasoning to trust. The model isn't told how to reason — only whether its reasoning arrived somewhere correct, and it learns from the ones that did. After fine-tuning on the keepers, the model is a bit better, so the next round it generates more correct rationales, which makes it better still. The runnable version below shows the filter keeping only correct-answer rationales and accuracy climbing each round.

There's a flaw in the plain loop: hard problems never contribute. If the model can't solve a problem, it never produces a correct rationale for it, so that problem is silently excluded from training — forever. The model only ever learns from problems it could already almost do, and the hard ones stay hard. That caps how far bootstrapping can go.

STaR's fix is rationalization. For a problem the model got wrong, give it the correct answer as a hint and ask it to produce a rationale that reaches that answer — reasoning backward from the solution. If it can construct such a rationale, that reasoning trace is added to the training set (with the hint removed). Now the hard problems can contribute reasoning examples too, dramatically widening what the model learns from.

The runnable below makes this concrete: direct solving covers a fraction of problems, and rationalization pulls in a big chunk of the ones it missed — so the training set spans the hard problems the plain loop would abandon.

Run the loop repeatedly and it bootstraps: each iteration's improved model generates better, more numerous rationales, which fine-tune an even better model. It's a self-improvement flywheel powered by nothing but question-answer pairs and the model's own generations. The improvement isn't unbounded — it tapers as the model approaches the limit of what this data and process can teach — but the early rounds compound quickly.

What makes it work is the asymmetry between generating a rationale and checking it: the model can't always reason correctly, but you can always check whether its answer is right. That gap — hard to produce, easy to verify — is exactly what STaR exploits, turning a cheap verifier (does the answer match?) into a training signal for the expensive skill (reasoning). It's the same asymmetry that underlies a great deal of later reasoning work.

STaR delivered the improvement its loop promised, on arithmetic, commonsense, and math word problems:

The practical significance is the data efficiency: reasoning ability that seemed to require expensive hand-written traces could be coaxed out with only answers and the model's own generations. That reframed reasoning as something a model could substantially teach itself.

STaR reads, in hindsight, like a blueprint for the reasoning-model era. Its loop — generate candidate reasoning, keep what's verified correct, train on it, repeat — is precisely the shape of the reinforcement-learning-from-verified-answers methods (like GRPO) that trained the current generation of reasoning systems. STaR did it with supervised fine-tuning on filtered samples; later work does it with RL and reward signals, but the core self-improvement idea is the same.

Its enduring lesson is the generate-verify asymmetry as an engine for self-improvement: whenever producing a solution is hard but checking it is easy, a model can bootstrap by generating many attempts and learning from the ones that pass the check. Reasoning with checkable answers is the clearest case, which is why STaR started there — and why that pattern now underlies how frontier models learn to think. It also sits naturally beside process reward models, which sharpen the "verify" side that STaR relies on.