DeepSeek-R1,
explained.

A standard chat model answers fast — it predicts a response in one flowing pass. That's fine for "summarize this email," but it stumbles on problems that need genuine multi-step work: hard math, tricky code, layered logic. Answering such a question well requires thinking — trying an approach, checking it, backing up, trying another — before committing to a final answer.

OpenAI's o1 had shown that letting a model generate a long internal chain of thought before answering dramatically boosts reasoning — but the recipe was closed. The open question DeepSeek-R1 set out to answer: how do you actually train a model to think like that? And could you do it without a mountain of hand-written reasoning examples?

The boldest experiment came first: DeepSeek-R1-Zero. Take a base model and skip the usual supervised fine-tuning on example reasoning entirely. Instead, apply reinforcement learning directly, with a shockingly simple reward — mostly just: is the final answer correct? (checkable for math and code), plus a small reward for putting the reasoning in the right format.

Crucially, nothing rewards the reasoning itself — no human ranks the steps, no example solutions are copied. The model is only ever told whether it landed on the right answer. Everything about how to get there is left for it to discover. It's the leanest possible teaching signal: outcome only.

The result was the paper's headline. Left to maximize correctness, the model discovered — with no instruction to do so — that thinking longer helps. Over training, its responses grew from short guesses into extended chains of reasoning: laying out steps, computing intermediate results, and exploring more than one path before answering. Accuracy on hard math and coding benchmarks climbed steeply alongside this growing "thinking time."

This is a striking demonstration that a complex skill can be incentivized rather than imitated. Nobody wrote reasoning examples for R1-Zero to copy; the reasoning behavior was an emergent strategy for earning more reward. Give a capable base model the right pressure, and the sophisticated behavior falls out.

The most talked-about observation: during training, the model spontaneously learned to stop and reconsider. Mid-solution, it would effectively say "wait — let me rethink this," abandon a flawed approach, and try again. It also learned to spend more thinking on harder problems and less on easy ones, budgeting its own effort.

None of this self-correction was designed in. It emerged because catching your own mistakes gets more answers right, and the reward found it. The authors called it an "aha moment" — a genuinely surprising sign that reflective, self-checking behavior can arise from pure outcome-based reinforcement.

R1-Zero reasoned impressively but communicated poorly. With only correctness rewarded, its chains of thought were often hard to read and sometimes mixed languages mid-answer — nobody had rewarded clean, human-friendly output. Powerful, but not pleasant to use.

So the full DeepSeek-R1 added structure around the pure-RL core. First, fine-tune the base model on a small batch of high-quality cold-start reasoning examples to instill a clean style. Then run the large-scale RL for reasoning. Then a round of rejection sampling and more training to polish helpfulness and readability. The emergent reasoning is preserved; the output becomes coherent and well-behaved.

Running large-scale RL is expensive, so DeepSeek showed a cheaper path to spread the capability: distillation. Use the strong R1 to generate many high-quality reasoning traces, then simply fine-tune smaller open models (in the 1.5B–70B range) on those traces. No RL needed for the small models — they learn to reason by imitating R1's worked solutions.

The distilled models inherited a large share of R1's reasoning — small models that punch far above their size on math and code. It's strong evidence that reasoning skill, once created, transfers cheaply, putting capable reasoners within reach on modest hardware.

The clean RL recipe works best where answers are automatically checkable — math, code, formal logic. For open-ended tasks with no crisp "correct" signal (writing, judgment, taste), outcome-based RL is far harder to apply, so R1's edge is narrower there. Long chains of thought also cost real test-time compute: thinking longer means more tokens, more latency, more money per answer.

And reasoning fluency isn't truthfulness — a confident, well-structured chain of thought can still reach a wrong conclusion, and the visible "thinking" doesn't guarantee the model actually followed that logic. Emergent self-correction reduces errors; it doesn't eliminate them.

DeepSeek-R1 opened the reasoning era to everyone. It reproduced o1-class reasoning with an openly published recipe and open weights, and — through R1-Zero — showed something conceptually deep: advanced reasoning can be incentivized into existence by rewarding correct outcomes, not painstakingly demonstrated. That reframes how we think about teaching models hard skills.

It also cemented test-time compute — letting a model think longer at inference — as a first-class lever alongside making models bigger. Together with the cheap distillation of reasoning into small models, R1 pushed the whole field toward reasoning-first systems and made them broadly accessible, not just a frontier-lab privilege.