06. DeepSeek-R1 and the Open Ecosystem — Reasoning became reproducible and self-hostable¶

~11 min read. R1 ended the "only closed labs can reason" era. The training recipe is public, the weights are open, the distilled variants run on a laptop.

Built on the ELI5 in 00-eli5.md. the time budget — compute we can now study, modify, and self-host across open checkpoints — turned reasoning from a premium API category into an engineering design space.

Why the open ecosystem mattered¶

Closed reasoning systems show behaviour. Open reasoning systems show training choices. Teams can compare checkpoints, benchmark locally, distill into smaller models, inspect failures on private hardware. The conversation shifts from "is the closed lab's model good?" to "what reasoning shape fits our workload, and what does it cost when we own the serving stack?"

open checkpoint
   ├── reproduce benchmarks on private data
   ├── distill into smaller serving tier
   ├── self-host for privacy / sovereignty
   ├── fine-tune for domain shift
   └── price as bargaining chip against closed APIs

See. When the ecosystem is open we can test whether the time budget helps on our tasks instead of trusting marketing benchmarks. The DeepSeek-R1 release in January 2025 was the inflection point.

What R1 actually proved¶

The R1 paper (arXiv 2501.12948, later published in Nature 2025) introduced Group Relative Policy Optimization (GRPO). The trick: drop PPO's value-network critic, compute advantages from group-relative rewards across sampled completions. Memory savings of 40–60% in training. Reward signal flows over whole chains, not next-token.

The bigger surprise was R1-Zero — the no-SFT, pure-RL variant. Starting from a base model, with reward signals on correctness alone, the model showed emergent "aha moments" mid-training. AIME 2024 accuracy went from 15.6% to 77.9% through RL alone. No instruction-tuning. No human preference data. Just outcome reward on math chains.

That settled a debated question. Frontier-class reasoning behaviour does not require proprietary SFT corpora. It needs: - A capable base model - Good reward signals over reasoning chains - A training algorithm that survives sparse rewards (GRPO works) - Compute

The recipe became public. Qwen QwQ, Qwen3-Max-Thinking, Kimi-K1.5, and many smaller efforts followed within weeks. The open-source reasoning curve closed fast on closed models.

By May 2026: R1-0528 reached 87.5% AIME 2025 (vs R1's 79.8%) and 81.0% GPQA Diamond (vs 71.5%). Qwen3.6-Max-Preview leads SWE-bench Pro and SkillsBench. The gap to closed frontier (GPT-5.2/5.5, Opus 4.7) exists but is measurable, not categorical.

What open reasoning enables in your stack¶

Real engineering choices the open ecosystem unlocks.

Tiered routing. Use R1-Distill-Qwen-32B (or similar) for medium-hardness tasks at ~$0.40/M output through an open serving provider; reserve the full closed reasoner for hardest tasks. The cost curve flattens dramatically.

Self-hosting for privacy. Healthcare, defense, and EU-regulated finance can run R1 / Qwen-Max-Thinking on their own GPUs. No data leaves the perimeter. Closed APIs do not allow this.

Domain fine-tuning. Take R1, fine-tune on your domain's reasoning traces (legal IRAC, medical diagnosis chains, factory ticket resolution). Closed APIs offer fine-tuning only on selected base models, often without reasoning support.

Distillation into serving-tier models. R1 ships with official distilled variants (R1-Distill-Llama-8B, -Qwen-7B, -Qwen-32B). These inherit much of the reasoning behaviour at a fraction of the cost. Distilled-32B runs on a single H100 at production throughput.

Bargaining power. Even if you stay on a closed API, the existence of R1-class open models has measurably pulled closed pricing down (Claude Opus 4.5 cut price 67% vs 4.1; o3 cut ~80% mid-2025).

Worked example: routing R1 + closed reasoner¶

You handle 1,000 reasoning-class requests per day. Conservative split: 700 medium, 250 hard, 50 expert-tier.

Approximate May 2026 pricing on output tokens ($/M):

Tier	Model	Output cost
Medium	DeepSeek R1-Distill-32B (Together/Fireworks)	$0.80
Hard	DeepSeek R1-0528 (Together)	$2.20
Expert	Claude Opus 4.7 with `effort=high`	$25.00

Assume average 4,000 output tokens per request (reasoning + answer).

Medium:  700 × 4000 × $0.80/M  = $2.24
Hard:    250 × 4000 × $2.20/M  = $2.20
Expert:   50 × 4000 × $25.00/M = $5.00
                       Total:    $9.44/day

If you routed everything to Opus 4.7 high: 1000 × 4000 × $25/M = $100/day. The mixed strategy is ~10× cheaper with no measurable quality loss on the medium tier (verified by your golden set).

That is why the open ecosystem matters even for teams that prefer closed APIs. You get a credible fallback, a cost anchor, and a privacy lane.

What engineers should watch carefully¶

Open does not mean automatically cheap or automatically good.

Watch for	Why
Tokenizer quirks	R1 and Qwen tokenizers handle code and Chinese differently; affects cost and quality
Serving memory	R1-0528 (~671B MoE total, ~37B active) needs careful sharding; distilled-32B is much friendlier
Quantization drift	int4/int8 quantization can degrade reasoning more than chat behaviour; benchmark after quantization
Tool-call format	Open models often have weaker tool-call training than closed; expect more parse errors
License	Some "open" licenses restrict commercial use or require sharing weights — read before shipping
Verifier compatibility	Open thinking-block format differs across models; your verifier middleware needs adapters
Failure modes	Open reasoning models often hallucinate confidently on niche domain knowledge — closed models do too, just differently

Self-hosting moves cost from API rate to engineering rate. You own GPUs, serving, monitoring, drift detection, model updates. Calculate honestly before committing.

The practical lesson¶

Use open reasoning models when control matters: privacy, cost experimentation, sovereignty, custom fine-tuning. Use them as the medium-tier in a cascade where closed reasoners handle the long tail. Do not assume open is a drop-in replacement — measure on your tasks, evaluate after your quantization, and budget for ops.

The frontier closes fast. The R1 → R1-0528 → Qwen3.6-Max-Preview arc in 15 months showed how quickly open catches up. Your stack should be able to swap models as the frontier shifts. That portability is the deeper value of the open ecosystem.

Where this lives in the wild¶

DeepSeek-R1 / R1-0528 — 671B MoE, MIT license, available on Together AI, Fireworks, DeepSeek's own API, and self-host via SGLang/vLLM. Reference benchmark for any new open reasoner.
Qwen3.6-Max-Preview (Alibaba) — leads SWE-bench Pro, SkillsBench, and SciCode as of April 2026; 260K context; Apache-2.0 compatible license.
Together AI — hosted endpoints for R1, R1-Distill variants, Qwen QwQ-32B at fixed $/M pricing; useful when you want open weights without ops burden.
Fireworks AI — production hosting for open reasoners with low-latency serving; offers function-calling shims that adapt open-model tool formats to OpenAI-compatible APIs.
vLLM / SGLang — high-throughput inference engines for self-hosted reasoning; SGLang has dedicated support for R1's MoE routing and prefix caching across reasoning chains.

Pause and recall¶

What is GRPO and what did R1-Zero prove about it without SFT?
By how much did R1-0528 lift AIME 2025 over R1 in roughly one year?
In the routing example, what was the cost ratio between mixed routing and all-Opus-4.7?
Name three operational concerns specific to self-hosting open reasoning models.

Interview Q&A¶

Q: Your CFO asks "should we move to DeepSeek-R1 and save 90% on inference?" What's your answer? A: Probably partially, not entirely. The right framing is cascade routing, not replacement. Self-host or use Together/Fireworks R1-Distill-32B for medium-difficulty tasks where you measure no quality regression on your golden set. Keep a closed reasoner (Opus 4.7, GPT-5.5) for the hardest 5–15% where the quality gap still matters and the error cost is high. You'll save 60–80% on inference and keep quality on long-tail. The full-swap pitch ignores that open and closed have different failure modes, and that ops/eval cost rises when you self-host.

Common wrong answer to avoid: "We can't risk quality, stay all closed" — that ignores measurable open-model quality on medium tasks and burns budget. Senior loops expect you to defend a mixed strategy with cost-and-quality data, not a one-vendor stance.

Q: How did DeepSeek-R1's training pipeline differ from PPO-based RLHF, and what does GRPO save? A: PPO needs a value-network critic trained alongside the policy; GRPO drops the critic entirely and computes advantages from group-relative rewards over multiple sampled completions. Memory drops 40–60% in training because the critic is the heavy parameter set. R1's recipe was: pretrained base → GRPO with outcome reward on math/code chains → optional SFT for instruction-following polish. R1-Zero skipped the polish and still showed emergent reasoning — proving the SFT step is not required for the reasoning behaviour itself.

Common wrong answer to avoid: "GRPO is just smaller PPO" — the critic-free design is the load-bearing change. It also matters because no critic means simpler reward shaping; you can use programmatic verifiers (compile, unit test) as the reward signal directly.

Q: When does self-hosting R1 not make sense? A: When your traffic is bursty or low-volume — GPU reservations sit idle. When you don't have the eval infrastructure to verify quality post-quantization (most teams underestimate this). When your team's MLOps maturity can't handle 24/7 inference SLOs and model swaps. And when the closed-API price has cut enough that the cost arbitrage is gone (Opus 4.5's 67% cut narrowed the gap dramatically). Calculate ops-engineer hours + GPU rent + eval infra against API costs — most small teams under 5M tokens/day are still better off on APIs.

Common wrong answer to avoid: "Self-hosting is always cheaper at scale" — at very high volume yes, at moderate volume the ops burden often eats the savings. The honest answer is workload-dependent and requires numbers.

Q: A distilled R1 variant scored 89% on AIME 2025 on the model card. Why does your production deployment see 76%? A: Several plausible causes. Tokenizer mismatch — your prompt template differs from the eval template. Quantization — int4 deployment degrades reasoning more than chat. Sampling temperature — model cards report best-of-N or specific decoding settings; greedy decoding can drop accuracy. Contamination differential — benchmarks like AIME 2025 may have partial training-set overlap that doesn't transfer to your problem domain. Tool/runtime differences — model card may use Python execution; your deployment may not. Debug each axis separately, then re-benchmark.

Common wrong answer to avoid: "Model cards lie" — they usually report honest numbers under specific conditions. The gap is almost always deployment-environment drift, not vendor dishonesty.

Apply now (5 min)¶

Pick one reasoning task in your stack currently served by a closed API. Estimate its monthly cost. Find one open variant (R1-Distill-Llama-70B, Qwen3-30B-A3B, or similar) on Together or Fireworks. Calculate the open-model cost at the same volume. Then design one eval task from your golden set to A/B both. If quality matches within 2%, add the open variant as a cascade fallback or primary.

Sketch from memory: Draw the three-tier cascade (cheap-open → medium-open → closed-frontier) with $/M-output for each tier.

Bridge. Open or closed, the deeper question is: why does more inference compute help at all? That's the test-time scaling story — the shared principle behind every reasoning system on the market. → 07-test-time-compute-scaling.md