DeepSeek R1 & R2: Complete Guide — Open Source Reasoning Architecture, Benchmarks, API, Pricing & Local Deployment 2026

Model Overview

DeepSeek R1 is an open-source reasoning model developed by DeepSeek AI, released in January 2025 under the MIT license. It was the first open-source model to demonstrate that pure reinforcement learning (without supervised fine-tuning on reasoning demonstrations) could produce strong chain-of-thought reasoning capabilities. The model uses a Mixture-of-Experts (MoE) architecture with 671 billion total parameters, of which 37 billion are activated per token, making it efficient to run despite its large total parameter count. DeepSeek R1 achieves 97.3% on MATH (matching OpenAI o3), 71.5% on GPQA Diamond, and 65.9% on ARC-AGI — remarkable results for a fully open-source model. The R1 release was significant because it proved that frontier reasoning capability was achievable outside of closed labs, and the MIT license allows unrestricted commercial use, modification, and redistribution. DeepSeek also released R1-Zero, a variant trained purely through RL without any supervised fine-tuning, demonstrating emergent reasoning behavior. In 2026, DeepSeek R1 and its successor R2 are widely deployed in open-source reasoning pipelines, local deployments, and as the foundation for fine-tuned domain-specific reasoning models.

Architecture & Technical Deep Dive

DeepSeek R1 uses a Mixture-of-Experts (MoE) transformer architecture with 671 billion total parameters and 37 billion active parameters per token. The MoE design means that for any given token, only a subset of "expert" networks are activated, dramatically reducing inference compute compared to a dense model of the same total size. The model was trained using a novel approach combining supervised fine-tuning (for R1) and pure reinforcement learning (for R1-Zero), demonstrating that reasoning can emerge from RL alone.

Mixture-of-Experts Architecture

DeepSeek R1's MoE architecture has 671B total parameters distributed across 256 routed experts, with 8 experts activated per token plus 1 shared expert, yielding 37B active parameters. This design provides the capacity of a 671B dense model at the inference cost of a ~37B model. The routing is learned during training — the model learns which experts to activate for different types of tokens and reasoning steps. The MoE architecture is particularly well-suited for reasoning because different reasoning tasks (math, code, logic) can activate different expert subsets, effectively specializing parts of the network. The model uses Multi-Head Latent Attention (MLA) to compress key-value cache, reducing the memory footprint during long-context reasoning and enabling 128K token context windows on reasonable hardware.

Pure RL Reasoning (R1-Zero)

The most significant architectural insight from DeepSeek R1 is R1-Zero — a variant trained purely through reinforcement learning without any supervised fine-tuning on reasoning demonstrations. R1-Zero was trained directly on the base model using GRPO (Group Relative Policy Optimization) with verifiable rewards (correct math answers, passing code tests). Remarkably, R1-Zero developed emergent reasoning behaviors: it learned to generate chain-of-thought, self-verify answers, backtrack from wrong approaches, and allocate more thinking to harder problems — all without being shown examples of these behaviors. This proved that reasoning can emerge from RL alone, challenging the assumption that supervised CoT demonstrations are necessary. However, R1-Zero had issues with readability, language mixing, and response formatting, leading DeepSeek to create R1 with a small amount of cold-start SFT data to improve usability while preserving the RL-trained reasoning capability.

Chain-of-Thought Integration

Unlike OpenAI o3, which hides its chain-of-thought, DeepSeek R1 shows the full reasoning process to the user. The model generates a block containing its complete reasoning, followed by the final answer. This transparency is a major advantage for research, debugging, and trust — users can see exactly how the model reached its conclusion. The CoT in R1 is trained, not prompted — the model learned to produce structured reasoning through RL, not because a prompt told it to "think step by step." The reasoning can be very long (thousands of tokens) for hard problems and includes self-reflection ("wait, let me reconsider..."), approach switching, and verification steps. The visible CoT also enables downstream applications — developers can parse the reasoning to extract intermediate results or use it for training smaller models.

Reinforcement Learning with Verifiable Rewards (RLVR)

DeepSeek R1's training uses RLVR — the same paradigm as OpenAI o3 but implemented openly. The model is trained on problems with verifiable correct answers: math (answer checked against known solution), code (tested against test cases), and logic (solution verified). The reward is binary — correct or incorrect — providing clean, scalable training signal without human annotation. DeepSeek uses GRPO for the RL optimization: for each problem, a group of candidate solutions is sampled, rewards are computed (1 for correct, 0 for incorrect), and the policy is updated relative to the group mean. This avoids the need for a separate value model (as in PPO), simplifying training. The RL training ran on a large cluster of H800 GPUs, demonstrating that frontier-scale RL is achievable outside of major labs.

PRM vs ORM in R1 Training

DeepSeek explored both Process Reward Models (PRMs) and Outcome Reward Models (ORMs) during R1 development. They found that PRMs — which reward individual reasoning steps — were difficult to scale due to the cost of step-level annotation and the challenge of defining "correct" intermediate steps for open-ended reasoning. Instead, R1 primarily uses ORM-style outcome rewards (correct final answer = reward), which are simpler and more scalable. However, DeepSeek found that the model learns to self-reward intermediate steps implicitly — during RL, the model discovers that certain reasoning patterns (verification, backtracking) correlate with correct final answers and learns to produce them. This emergent process-level reasoning, learned from outcome rewards alone, is a key finding: explicit PRMs may not be necessary if the RL training is scaled sufficiently.

GRPO Implementation

DeepSeek's GRPO implementation is notable for its efficiency and scale. For each prompt, the model samples a group of G candidate responses (typically G=64 or G=128). Rewards are computed for each response using verifiable signals. The advantage for each response is computed as (reward - group_mean_reward) / group_std, normalized to reduce variance. The policy is then updated using a clipped objective (similar to PPO) with a KL penalty to prevent the policy from drifting too far from a reference model. DeepSeek's implementation is highly optimized for their MoE architecture, using expert parallelism and pipeline parallelism to distribute training across thousands of GPUs. The GRPO training ran for multiple rounds, with the model improving steadily over training. DeepSeek released the training details, enabling the open-source community to reproduce and extend the approach.

Distillation and Budget Forcing

A key contribution of DeepSeek R1 is the release of distilled variants — smaller models (1.5B, 7B, 8B, 14B, 32B, 70B) fine-tuned on R1's reasoning outputs. These distilled models retain much of R1's reasoning capability at a fraction of the size, enabling local deployment on consumer hardware. The 32B distilled variant (based on Qwen 2.5 32B) scores 90.6% on MATH — matching the full R1 on math while running on a single 8xH100 node. DeepSeek also employs budget forcing during inference — the model is given a token budget for reasoning and learns to use it efficiently. Unlike o3's explicit effort parameter, R1's budget is controlled via max_tokens and the model naturally adjusts reasoning length to problem difficulty. The R2 model (Q2 2026) adds user-adjustable reasoning depth, bringing it closer to o3's effort control while maintaining open-source availability.

Reasoning & Thinking Benchmarks

Scores based on publicly available data as of July 2026. Independent verification recommended.

Reasoning Benchmark Scores

Reasoning Efficiency & Cost Analysis

Performance Analysis

DeepSeek R1's benchmark performance is remarkable for an open-source model. Its MATH score of 97.3% actually exceeds OpenAI o3's 96.4%, demonstrating that open-source reasoning can match or exceed proprietary models on mathematical reasoning. However, R1 trails o3 significantly on ARC-AGI (65.9% vs 87.5%), GPQA (71.5% vs 83.3%), and SWE-bench (49.2% vs 71.7%), indicating that o3's broader reasoning and coding capabilities remain superior. The R1-Zero variant — trained purely through RL without SFT — scores 95.0% on MATH, proving that reasoning can emerge from RL alone, though it trails the SFT-enhanced R1 on most benchmarks. The distilled 32B variant is a standout: at 90.6% MATH, it matches or exceeds many much larger models while running on a single 8-GPU node. The efficiency table shows R1's key advantage — at $0.004 per standard query via API, it is 22x cheaper than o3's $0.09 at medium effort, and local deployment is free (aside from electricity). For math-heavy workloads, R1 offers o3-comparable quality at a fraction of the cost. The gap on ARC-AGI and SWE-bench suggests that R2 will need to improve broader reasoning and code generation to fully close the gap with o3.

Speed & Latency

DeepSeek R1 inference speed depends on deployment. Via DeepSeek API: 5-15 seconds for standard queries, 20-60 seconds for hard problems with extended reasoning. The API generates ~40-60 tokens/second during reasoning. Local deployment (full 671B MoE): requires 8x H100/H800 GPUs for FP8 inference, generating ~30-50 tokens/second. Distilled 32B: runs on a single 8xH100 node or 2x A100 80GB, generating ~60-80 tokens/second. Distilled 7B: runs on a single consumer GPU (RTX 4090), generating ~100+ tokens/second. The MoE architecture means only 37B parameters are active per token, making inference significantly faster than a dense 671B model. Throughput via API: 1,000 RPM on standard tier. No streaming of reasoning tokens via API (full response returned after reasoning completes); local deployment supports streaming.

API Access, Pricing & Integration Guide

Looking for DeepSeek R1 API pricing in 2026? Below is the complete pricing table, code examples, and integration guide.

API Pricing Table (as of July 2026)

Free Tier & Trial Access

DeepSeek R1 is free to run locally (MIT license). The DeepSeek API offers a generous free tier for new users and charges $0.55/1M input and $2.19/1M output — 27x cheaper than OpenAI o3 ($15/1M input). Context caching reduces input cost to $0.14/1M for cache hits (75% discount). The distilled variants are free to download and run locally with no API costs. For production use, the API is the simplest path; for privacy-sensitive or high-volume use, local deployment eliminates per-query costs entirely.

API Quick Start

# Install SDK
pip install openai  # DeepSeek API is OpenAI-compatible

from openai import OpenAI

# Use DeepSeek API (OpenAI-compatible endpoint)
client = OpenAI(
    api_key="your-deepseek-api-key",
    base_url="https://api.deepseek.com"
)

# Reasoning with DeepSeek R1
response = client.chat.completions.create(
    model="deepseek-reasoner",  # DeepSeek R1
    messages=[
        {"role": "user", "content": "Find all prime numbers less than 100 using the Sieve of Eratosthenes. Explain each step."}
    ],
    max_tokens=16000
)

print(response.choices[0].message.content)
print(f"Reasoning tokens: {response.usage.completion_tokens_details.reasoning_tokens}")

# Local deployment with vLLM (distilled 32B)
# pip install vllm
# vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-32B --max-model-len 32768

from openai import OpenAI
local_client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed"
)

response = local_client.chat.completions.create(
    model="deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
    messages=[{"role": "user", "content": "Prove that there are infinitely many primes."}]
)
print(response.choices[0].message.content)

Supported API Features

Compatible Platforms & Integrations

Fine-Tuning, RAG & Advanced Use

Fine-Tuning Availability

DeepSeek R1 is fully open-source (MIT license) and can be fine-tuned without restriction. The model weights are available on Hugging Face. Fine-tuning options: (1) Full fine-tuning — requires significant compute (8x H100 for the 671B MoE, or 8x H100 for the 32B distill), (2) LoRA fine-tuning — efficient parameter-efficient fine-tuning on the 32B distill runs on a single 8x H100 node, (3) Continued RL training — use GRPO with domain-specific verifiable rewards to improve reasoning on your domain. DeepSeek released training details enabling the community to reproduce and extend the approach. The distilled variants (1.5B-70B) are the most practical for fine-tuning due to their smaller size.

Fine-Tuning Requirements

Full R1 (671B MoE): 8x H100/H800 80GB GPUs for FP8 inference; fine-tuning requires 16-32x H100. R1 Distill 32B: 8x H100 for fine-tuning, 2x A100 80GB for inference. R1 Distill 7B: single RTX 4090 (24GB) for inference, single A100 for fine-tuning. Software: PyTorch 2.x, DeepSpeed or FSDP for distributed training, vLLM for efficient inference. For LoRA fine-tuning: PEFT library, 16GB+ VRAM for 7B distill. Training data: domain-specific verifiable problems (math with answers, code with tests) for RLVR-style continued training.

Fine-Tuning Use Cases

• Cost-effective mathematical reasoning — R1 matches o3 on MATH at 27x lower cost via API or free locally
• Local/private reasoning deployment — run R1 or distilled variants on-premise for privacy-sensitive applications
• Open-source research — reproduce, extend, and modify the reasoning training pipeline with full weight access
• Domain-specific reasoning fine-tuning — fine-tune R1 on domain problems (medical, legal, engineering) with verifiable rewards
• Educational tools — the visible chain-of-thought makes R1 ideal for tutoring applications where students see the reasoning
• Edge reasoning — distilled 7B variant runs on consumer GPUs for on-device reasoning without internet connectivity
• Cost-effective code reasoning — R1 scores 65% on LiveCodeBench at a fraction of o3 cost
• Custom reasoning model development — use R1 as a base for building specialized reasoning models with full control

RAG Integration Guide

DeepSeek R1 can be combined with RAG for knowledge-grounded reasoning. Recommended architecture: User query → Retrieve documents (vector search) → Pass documents + query to R1 → R1 reasons over documents and produces answer with visible CoT. Key advantage: R1's visible chain-of-thought lets you audit how the model used retrieved documents — you can see if it correctly interpreted the information or hallucinated. This is a significant advantage over o3, where the reasoning is hidden. Cost: R1 + RAG costs $0.004 per standard query via API — 22x cheaper than o3 + RAG. For privacy-sensitive RAG (medical, legal), deploy R1 Distill 32B locally with a local vector database for a fully on-premise reasoning + retrieval pipeline.

Prompt Engineering Tips

• The full chain-of-thought is visible — parse the block to extract intermediate results or verify reasoning quality
• Set max_tokens generously (16K+) — hard problems generate long reasoning chains that count against the limit
• For math problems, ask the model to "verify your answer" — it will check its work in the CoT before answering
• Use the distilled 32B variant for local deployment — it matches full R1 on math at a fraction of the compute
• For domain-specific reasoning, fine-tune with RLVR — provide problems with verifiable correct answers
• Use context caching for repeated system prompts — 75% input cost reduction on cache hits
• The R1-Zero variant shows raw RL reasoning — useful for research but less readable than R1
• For code reasoning, provide test cases in the prompt — the model reasons about passing them in its CoT

Use Cases, Strengths & Limitations

Top 10 Real-World Use Cases

Strengths

• ✓ Open Source (MIT) — fully open weights, commercial use allowed, no restrictions on modification or redistribution
• ✓ Best-in-Class Math — 97.3% MATH exceeds OpenAI o3 (96.4%) and matches the best proprietary reasoning models
• ✓ Extremely Cost-Effective — $0.55/1M input is 27x cheaper than o3; free when deployed locally
• ✓ Visible Chain-of-Thought — full reasoning shown to user, enabling auditing, debugging, and educational use
• ✓ Local Deployment — full model and distilled variants can run on-premise for privacy and zero per-query cost
• ✓ Fine-Tunable — open weights enable domain-specific fine-tuning with LoRA or continued RL training
• ✓ Distilled Variants — 1.5B to 70B models retain reasoning capability at sizes suitable for consumer hardware
• ✓ Proven RL Training Method — R1-Zero proved reasoning can emerge from pure RL, providing a roadmap for open reasoning research

Limitations & Weaknesses

• ✗ Trails o3 on Broad Reasoning — 65.9% ARC-AGI vs o3 87.5%; 49.2% SWE-bench vs 71.7%
• ✗ Text Only — no multimodal (image) input, unlike o3 and Gemini Flash Thinking
• ✗ Longer Latency for Hard Problems — extended reasoning can take 30-60 seconds, similar to o3 high effort
• ✗ High Hardware Requirements (Full Model) — 8x H100 needed for full 671B MoE inference
• ✗ No Adjustable Effort (R1) — reasoning depth is automatic, not user-controllable (R2 adds this)
• ✗ CoT Readability Issues — R1-Zero has language mixing and formatting issues; R1 improved but still less polished than o3 summaries
• ✗ Smaller Ecosystem — fewer integrations and tools compared to OpenAI ecosystem, though growing rapidly
• ✗ Chinese-Origin Model — geopolitical concerns may affect adoption in some regions; US export controls on advanced AI chips affect deployment

Who Should Use This Model

Alternatives, Comparisons & Verdict

Top Alternatives

Detailed Comparison

DeepSeek R1 vs OpenAI o3: R1 is open-source (MIT), 27x cheaper ($0.55 vs $15/1M), and scores higher on MATH (97.3% vs 96.4%). o3 dominates on ARC-AGI (87.5% vs 65.9%), GPQA (83.3% vs 71.5%), and SWE-bench (71.7% vs 49.2%). Choose R1 for cost-effective math and open-source needs; o3 for frontier broad reasoning and coding. DeepSeek R1 vs QwQ-32B: Both are open-source reasoning models. R1 (671B MoE) scores higher across all benchmarks but requires 8x H100 for full deployment. QwQ-32B (32B dense) scores slightly lower but runs on a single 8x H100 node and is easier to deploy. R1's distilled 32B variant is comparable to QwQ-32B. Choose R1 for maximum quality; QwQ-32B for simpler deployment. DeepSeek R1 vs Gemini Flash Thinking: Gemini is faster, supports multimodal input, and scores higher on ARC-AGI (70% vs 65.9%) and GPQA (80.1% vs 71.5%). R1 is open-source, cheaper ($0.55 vs $1.50), and scores higher on MATH (97.3% vs 93.2%). Choose Gemini for speed and multimodal; R1 for open-source and math. DeepSeek R1 vs Claude 4 Opus Thinking: Claude scores higher on ARC-AGI (78% vs 65.9%) and SWE-bench (64% vs 49.2%). R1 is open-source, 27x cheaper, and scores higher on MATH. Choose Claude for coding and broad reasoning; R1 for open-source and cost-effective math.

Our Verdict

Internal Links

Frequently Asked Questions