latent
When DeepSeek dropped R1, the AI industry had one of those rare moments where everyone had to recalibrate at the same time. A lab working under US chip export restrictions had produced a reasoning model that stood toe-to-toe with OpenAI's o1 on math, coding, and multi-step logic. Then they released the weights. The technical, economic, and geopolitical fallout all hit at once.
What R1 actually is
DeepSeek R1 is a large language model trained specifically for extended reasoning. Standard instruction-tuned models generate answers in a single pass. R1 produces an internal chain of thought before it commits. It thinks out loud, works through problems step by step, self-corrects, and considers multiple approaches before answering.
This isn't prompt engineering. The reasoning behavior is baked in via reinforcement learning. R1 doesn't reason because you told it to think step by step. It reasons because that's how it was trained to operate.
The base is a mixture-of-experts (MoE) architecture with 671 billion total parameters, of which roughly 37 billion are active during any given forward pass. That's a deliberate design choice. MoE gives the model massive knowledge capacity while keeping inference cost manageable, because only a fraction of parameters fire per token.
The benchmark shock
When the benchmarks landed, they got attention.
| Benchmark | DeepSeek R1 | OpenAI o1 |
|---|---|---|
| AIME 2024 (Math) | 79.8% | 79.2% |
| MATH-500 | 97.3% | 96.4% |
| Codeforces (Competitive Programming) | 96.3 percentile | 96.6 percentile |
| GPQA Diamond (Graduate Science) | 71.5% | 75.7% |
| SWE-bench Verified | 49.2% | 48.9% |
DeepSeek R1 vs OpenAI o1 across five reasoning benchmarks. Codeforces is reported as percentile; the rest are accuracy %. Bars sit so close together that the parity story is the chart.
Near parity. R1 edges ahead on some, o1 holds a lead on others. The story isn't about who won which benchmark. It's that a gap everyone assumed would take years to close had been closed in months.
The $6 million question
DeepSeek claimed R1 cost roughly $6 million to train. For context, GPT-4 is estimated to have cost north of $100 million. Even granting that R1 builds on DeepSeek's existing base model infrastructure, that number is striking.
A few things made it possible.
MoE efficiency. Training an MoE model is cheaper per effective parameter than a dense model of equivalent capability. You get more knowledge capacity per FLOP.
RL on reasoning. Instead of training reasoning capability from scratch through massive pretraining, DeepSeek used RL to teach an already-capable base model to reason. That's much cheaper than scaling pretraining compute.
Algorithmic innovation under constraint. US export controls limited DeepSeek's access to the latest NVIDIA chips, which forced the team to squeeze more out of available hardware through better algorithms, more efficient training recipes, and clever engineering. The constraints did the team a favor.
The $6 million figure should be taken with the usual caveats. It probably doesn't include the cost of training the base model, the cost of failed experiments, or researcher salaries. Even with generous adjustments though, the total is a fraction of what Western labs spent on comparable capability.
How they did it: GRPO and the training recipe
The technical recipe behind R1 is one of the most interesting parts of the release. DeepSeek introduced Group Relative Policy Optimization (GRPO), a reinforcement learning algorithm that trains the model to produce better reasoning chains.
The core idea: given a problem, generate multiple candidate reasoning chains. Score each one based on whether it lands on the correct answer. Then update the model to increase the probability of chains that worked and decrease the probability of chains that didn't. The "group relative" part means rewards are normalized within each batch, which removes the need for a separate value model and cuts training complexity.
# Simplified GRPO intuition
for problem in training_set:
# Generate K candidate reasoning chains
chains = [model.generate(problem) for _ in range(K)]
# Score each chain: did it reach the correct answer?
rewards = [score(chain, problem.answer) for chain in chains]
# Normalize rewards within the group
normalized = (rewards - mean(rewards)) / std(rewards)
# Update model: upweight good chains, downweight bad ones
model.update(chains, normalized)This is elegant because it sidesteps the complexity of training a separate reward model. The reward signal is simple and verifiable: did the reasoning chain produce the right answer? That works particularly well for math, coding, and logic, where correctness is objective.
DeepSeek also used distillation from their larger models to create smaller, more efficient variants. The DeepSeek-R1-Distill series takes the reasoning patterns learned by the full model and compresses them into smaller architectures based on Qwen and Llama. That's how you get reasoning capability on consumer hardware.
Why open weights change everything
DeepSeek released R1 with open weights under a permissive license. The consequences cascade.
Reproducibility. Researchers can study the model, probe its reasoning patterns, identify failure modes, and publish findings. None of that is possible with closed models where you only have API access.
Fine-tuning. Organizations can take R1 and adapt it to their domains. A legal firm fine-tunes on case law. A biotech company fine-tunes on molecular biology. The base reasoning capability transfers; the domain knowledge gets added on top.
On-premise deployment. Companies with data sensitivity requirements (and there are a lot of them) can run R1 internally without sending data to an external API. This isn't a niche concern. It's a hard requirement for healthcare, finance, defense, and government workloads.
No API dependency. Closed models can change pricing, modify behavior, or deprecate versions whenever the provider feels like it. Open weights give you a stable, versioned artifact you actually control.
Community acceleration. Within weeks of the R1 release, the open-source community had produced quantized versions that run on single GPUs, merged models that combined R1's reasoning with other models' strengths, and fine-tuned variants for specific tasks.
The geopolitical dimension
It's impossible to talk about DeepSeek without the geopolitical context. US export controls were designed, in part, to slow Chinese AI development by restricting access to advanced chips. DeepSeek's success suggests those controls had an unintended side effect — they pushed Chinese labs toward algorithmic efficiency rather than brute-force scaling.
That's not the whole picture. DeepSeek had access to significant compute, likely including pre-embargo hardware. And the controls may well have slowed development in other areas. But the idea that compute restrictions alone could maintain a durable capability gap took a real hit.
The broader dynamic is worth watching. If algorithmic innovation can compensate for hardware disadvantage, the global AI landscape becomes more competitive, not less. That has implications for policy, investment, and the long-term shape of the industry.
Distilled models: reasoning on consumer hardware
The most practically significant part of the R1 release is the distilled model family. DeepSeek-R1-Distill-Qwen-32B and DeepSeek-R1-Distill-Llama-70B bring reasoning capability to hardware that real people and small companies actually own.
The 32B Qwen variant in particular runs comfortably on a single high-end consumer GPU with 4-bit quantization. It doesn't match the full R1 on the hardest benchmarks, but on the vast majority of practical reasoning tasks it performs surprisingly well.
# Running the distilled model locally with Ollama
ollama run deepseek-r1:32b
# Or with llama.cpp for more control
./llama-server -m deepseek-r1-distill-qwen-32b-Q4_K_M.gguf \
--ctx-size 32768 \
--n-gpu-layers 99This is the real story. When a graduate student with a single GPU can run a model that reasons at near-frontier level on their specific research problems, the dynamics of AI research change.
What comes next
R1 isn't the end of the open-source reasoning story. It's the proof of concept. The training recipe is public. The algorithmic innovations are documented. Other labs and research groups are already building on the work.
The implication for the industry: reasoning capability is no longer a moat. It's a commodity in the making. Competition will shift to what you build on top of reasoning, how you integrate it into products, and how efficiently you can deploy it at scale.
For practitioners the message is just as clear. You should be evaluating open reasoning models for your use cases right now. The performance is there. The cost advantage is real. And running models on your own infrastructure, with your own data, under your own control is worth more than most people realize until they need it.