DeepSeek-R1

DeepSeek-R1 is a family of large language models developed by DeepSeek and first released on January 20, 2025, with an emphasis on mathematical problem-solving, programming, and other reasoning tasks. Its development combines reinforcement learning with supervised fine-tuning, while the related experimental model DeepSeek-R1-Zero explores reinforcement learning without a preliminary supervised fine-tuning stage. The release included downloadable model weights and smaller distilled models. (api-docs.deepseek.com)

The family is significant for its documented approach to training reasoning models and transferring their capabilities to smaller systems. DeepSeek reported results competitive with contemporary proprietary reasoning models on selected benchmarks, rather than uniform superiority across tasks. Subsequent releases, including DeepSeek-R1-0528 in May 2025, extended the family’s reasoning and tool-use capabilities. Its architecture, training methods, evaluation results, deployment requirements, and licensing illustrate both the possibilities and limitations of openly distributed reasoning models. (arxiv.org)

Development and release history

DeepSeek released DeepSeek-R1 on January 20, 2025, making the model available through downloadable weights, its hosted application programming interface (API), and the “DeepThink” option in its consumer chat service. The names refer to distinct entities: DeepSeek is the developer and service provider; DeepSeek-R1 identifies a reasoning-model family and, more narrowly, its original principal checkpoint; the DeepSeek chatbot is an application through which users could access the model. At launch, the API selected R1 through the identifier deepseek-reasoner, rather than through its downloadable checkpoint name. That identifier described a hosted service selection, not an immutable designation for the January weights. (api-docs.deepseek.com)

The original release comprised two full-sized models, DeepSeek-R1-Zero and DeepSeek-R1, together with six smaller distilled checkpoints. R1-Zero represented the research experiment in applying reinforcement learning directly to a pretrained large language model without preliminary supervised fine-tuning. R1 incorporated an additional, multistage post-training process intended to address limitations observed in R1-Zero, including poor readability and language mixing. The accompanying smaller models were named DeepSeek-R1-Distill-Qwen-1.5B, -7B, -14B, and -32B, and DeepSeek-R1-Distill-Llama-8B and -70B. Their suffixes indicated nominal parameter counts in billions; they were separately released Qwen- or Llama-derived models trained using R1-generated material, rather than alternative names for the full R1 checkpoint. (github.com)

The initial technical report, DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning, was submitted to arXiv on January 22, 2025, two days after the product release. Its authorship was credited to DeepSeek-AI and a research team including Daya Guo, Dejian Yang, Haowei Zhang, and Junxiao Song. This first arXiv version, numbered 2501.12948v1, documented R1-Zero, the R1 training pipeline, and the six distilled models. January 22 therefore marks the preprint submission, not the initial public availability of the model family. The release announcement also linked a technical-report PDF in the project’s repository. (arxiv.org)

On May 28, 2025, DeepSeek updated its hosted reasoning model to DeepSeek-R1-0528 and distributed a checkpoint under that dated name. The developer described it as a minor-version upgrade involving additional computational resources and changes to post-training, rather than a newly named model generation. Its model card also introduced DeepSeek-R1-0528-Qwen3-8B, produced by transferring generated reasoning from the updated model to Qwen3-8B-Base. This extended the smaller-model releases beyond the six checkpoints accompanying January’s launch. The dated 0528 designation distinguishes the May weights from the original R1 even where the hosted API continued to use deepseek-reasoner. (api-docs.deepseek.com)

The research subsequently appeared in Nature as DeepSeek-R1 incentivizes reasoning in LLMs through reinforcement learning, published online on September 17, 2025, in volume 645, pages 633–638; the issue date was September 18. The journal records receipt on February 14 and acceptance on July 17, 2025. A second arXiv version was submitted on January 4, 2026, and the arXiv record links the Nature article as its journal publication. These dates belong to the research publication history: the September article and January revision should not be treated as checkpoint releases or substituted for the January 20 and May 28 model-release dates. (doi.org)

Architecture and pretrained foundation

The original full-size DeepSeek-R1 and DeepSeek-R1-Zero inherit their architecture and pretrained weights from DeepSeek-V3-Base. They are autoregressive Transformer language models with a sparse mixture-of-experts (MoE) architecture, rather than a new network architecture created by reasoning-oriented post-training. Their different training procedures modify the pretrained model’s behavior through reinforcement learning and, for R1, supervised fine-tuning. The smaller distilled checkpoints use separate Qwen or Llama foundations and should not be assigned the full models’ architectural specifications. (github.com)

Both original full models are listed with 671 billion total parameters, approximately 37 billion activated per token, and an advertised 128K-token context window. Total parameters measure the model’s stored capacity; activated parameters describe the subset participating in processing a particular token. Sparse activation therefore does not make R1 a 37-billion-parameter dense model or eliminate the storage requirements of its remaining experts. The inherited foundation was pretrained on 14.8 trillion tokens. DeepSeek-V3’s multi-token prediction objective and FP8 mixed-precision training belong to that foundation’s development, not to the subsequent R1-specific reasoning-training procedure. (github.com)

The network has 61 Transformer layers and a hidden dimension of 7,168. Its first three layers use dense feed-forward networks; subsequent layers use DeepSeekMoE blocks with one shared expert and 256 routed experts, selecting eight routed experts per token. The shared expert processes every token, while the router selects a sparse subset of the others. (huggingface.co) In the inherited routing design, sigmoid affinity scores determine expert selection, and selected scores are normalized to weight expert outputs. To balance training workloads, per-expert routing biases decrease for overloaded experts and increase for underloaded ones; these biases affect selection, not the output weights themselves. Despite the description “auxiliary-loss-free,” V3 also uses a small complementary sequence-level balancing loss to discourage extreme imbalance within individual sequences. (arxiv.org)

The inherited multi-head latent attention (MLA) mechanism reduces the memory needed to retain information about preceding tokens during inference. Instead of caching full keys and values separately for every attention head, it jointly compresses them into a low-rank latent vector. Generation caches that vector together with a separate positional key component. (arxiv.org) R1’s configuration specifies 128 attention heads, a 512-dimensional key–value latent representation, and a 64-dimensional positional key component. (huggingface.co) These are inherited attention and caching mechanisms: R1’s reasoning post-training changes how the model uses its pretrained capabilities, rather than introducing MLA or sparse expert routing. (github.com)

DeepSeek-R1-Zero and reinforcement-learning mechanisms

DeepSeek-R1-Zero applies reinforcement learning directly to the pretrained DeepSeek-V3-Base checkpoint. “Without supervised fine-tuning” therefore describes its post-training procedure: it omits an initial supervised fine-tuning stage using demonstrated reasoning responses, not language-model pretraining itself. The experiment tests whether reward-driven optimization can improve reasoning from an existing language model, rather than teaching language and reasoning from randomly initialized weights. DeepSeek’s model card distinguishes this experimental approach from the cold-start demonstrations subsequently used for DeepSeek-R1. (arxiv.org)

The optimization method is Group Relative Policy Optimization (GRPO), introduced by Zhihong Shao and colleagues in the 2024 DeepSeekMath paper. For each question, an old version of the policy samples $G$ responses, which receive rewards $r_1,\ldots,r_G$. Each response’s advantage is normalized relative to its group:

Thus, responses are compared with alternative attempts at the same question. The group supplies the baseline without a separately trained critic or value model, reducing the memory and computation associated with critic-based training. (arxiv.org)

GRPO updates the policy using the ratio between current-policy and old-policy probabilities. Its clipped surrogate objective limits the incentive for excessively large updates: the ratio is clipped to $[1-\varepsilon,1+\varepsilon]$ in one branch of the objective, and the smaller advantage-weighted term is used. A separate penalty, weighted by $\beta$, constrains Kullback–Leibler divergence from a reference policy. Clipping controls changes relative to the sampling policy; divergence regularization controls departure from the reference. Neither mechanism requires a separate critic. (arxiv.org)

R1-Zero uses rule-based correctness and formatting rewards. Mathematical answers with deterministic results are extracted from specified formats, such as boxed answers, and checked; programming solutions receive execution-based feedback from predefined tests. Formatting rewards require reasoning inside <think> and </think> delimiters. The training template requests reasoning followed by an answer but does not prescribe reflection or particular solution strategies. No learned neural outcome or process reward model is used. (arxiv.org)

The January 22, 2025 report describes progressively longer responses, extending from hundreds to thousands of reasoning tokens, with checking and alternative approaches. Its “aha moment” example concerns $\sqrt{a-\sqrt{a+x}}=x$, where an intermediate checkpoint interrupts an algebraic approach and restarts its analysis. This is an observed pattern in generated text, not evidence of subjective insight. The model card also records endless repetition, language mixing, and poor readability: longer reasoning traces were not necessarily coherent or suitable for users. These limitations motivated the readable cold-start material used in the separate R1 pipeline. (arxiv.org)

The DeepSeek-R1 post-training pipeline

DeepSeek’s January 2025 technical report described four post-training stages for the original R1: cold-start supervised fine-tuning, reasoning-oriented reinforcement learning, a second supervised stage using selected model outputs and general-purpose examples, and final reinforcement learning incorporating preference rewards. Unlike R1-Zero’s direct reinforcement-learning experiment, R1 used readable demonstrations to initialize training before optimizing reasoning performance. These stages operated on the pretrained DeepSeek-V3-Base foundation rather than replacing pretraining. (github.com)

The cold-start stage used thousands of long reasoning demonstrations. Collection methods included prompting with worked examples, requesting detailed solutions containing reflection and verification, selecting readable R1-Zero outputs, and human post-processing. Demonstrations separated the reasoning process from a concluding summary and excluded reader-unfriendly responses. After this initialization, reasoning-oriented reinforcement learning targeted mathematics, coding, science, and logic. Its reward added answer accuracy to language consistency—the proportion of words in the generated reasoning belonging to the target language. The developers reported a slight performance reduction from this language constraint in ablation experiments, accepting the trade-off for readability. (arxiv.org)

After reasoning reinforcement learning converged, the resulting checkpoint generated multiple responses per prompt; rejection sampling retained correct answers. Some additional examples were judged by DeepSeek-V3 using reference answers alongside predictions. Filtering removed reasoning containing mixed languages, long paragraphs, or code blocks, producing approximately 600,000 reasoning examples. Another approximately 200,000 examples covered writing, factual questions, translation, and related non-reasoning tasks, partly reusing DeepSeek-V3 supervised data. Simple greetings received no reasoning trace. Crucially, the subsequent supervised stage fine-tuned DeepSeek-V3-Base for two epochs on this approximately 800,000-example mixture, rather than simply continuing reinforcement learning on the preceding checkpoint. (arxiv.org)

The final reinforcement-learning stage combined verifiable-task rewards with model-based preference signals. Mathematics, programming, and logical reasoning retained rule-based correctness rewards; general-purpose prompts used reward models intended to capture helpfulness and harmlessness. Helpfulness assessment considered only the final summary, emphasizing relevance and utility without directly grading the preceding reasoning. Harmlessness assessment instead examined the complete response, including both reasoning and summary. The two objectives therefore differed not only in what they rewarded but also in which generated text they evaluated. (pmc.ncbi.nlm.nih.gov)

The later Nature methods account supplied additional details about these preference objectives. The helpfulness reward model used 66,000 preference pairs, with DeepSeek-V3 judging each pair four times under randomized answer ordering to reduce positional bias. The safety reward model used 106,000 prompts with generated responses annotated against predefined safety guidelines. The second reinforcement-learning stage comprised 1,700 steps, with general instruction data and preference-based rewards introduced only during its final 400 steps. These were training objectives and procedures, rather than guarantees that every resulting response would be helpful or harmless. (pmc.ncbi.nlm.nih.gov)

Distillation and smaller model variants

DeepSeek’s smaller R1 variants use knowledge distillation at the sequence level: an existing pretrained student model undergoes supervised fine-tuning on curated responses containing reasoning trajectories and answers from the larger teacher. The transferred material is therefore generated text, rather than the teacher’s architecture or a subset of its weights. These checkpoints are not pruned versions of the full R1 model, nor does their smaller parameter count result from quantization, which reduces numerical precision. Their Qwen or Llama foundations remain architecturally distinct from the full model’s mixture-of-experts design. DeepSeek also modified the original students’ configurations and tokenizers, making the released checkpoint configurations part of their specification. (github.com)

The original family comprised six dense models, with nominal sizes expressed in billions of parameters. The checkpoint names identify both the student family and its size; the underlying foundations were not all instruction-tuned models. In particular, the two smallest Qwen variants used mathematics-specialized base checkpoints, whereas the 70B Llama variant started from an instruction-tuned checkpoint. (github.com)

These model-to-foundation mappings are specified in DeepSeek’s release repository. (github.com)

For the original distilled checkpoints, DeepSeek used the approximately 800,000-example curated supervised dataset and applied no subsequent reinforcement-learning stage. The expanded technical report specifies two to three training epochs, a batch size of 64, and a maximum training sequence length of 32,768 tokens. Its controlled comparison started separately from Qwen2.5-32B-Base and applied reinforcement learning on mathematics, programming, and STEM questions for more than 10,000 update steps, producing Qwen2.5-32B-Zero. DeepSeek reported AIME 2024 pass@1 scores of 47.0% for that model and 72.6% for DeepSeek-R1-Distill-Qwen-32B; corresponding LiveCodeBench scores were 40.2% and 57.2%. (arxiv.org)

That comparison supports distillation’s effectiveness under the tested recipe, not a universal ranking of training methods. It compared one 32B foundation and particular datasets and optimization settings, rather than exhaustively testing smaller architectures or equalizing all computational expenditure. Its economic interpretation also assumes access to an already capable teacher: supervised student training does not eliminate the upstream cost of developing the teacher and generating its training examples. DeepSeek’s conclusion concerned the relative efficiency of transferring an established model’s reasoning behavior versus eliciting comparable behavior through direct reinforcement learning in this experiment. (arxiv.org)

The May 2025 update introduced DeepSeek-R1-0528-Qwen3-8B, a separate distilled checkpoint trained from Qwen3-8B-Base using reasoning traces generated by DeepSeek-R1-0528. It is not an updated version of the original Llama-derived 8B model: its architecture is identical to Qwen3-8B, while its tokenizer configuration matches DeepSeek-R1-0528. The model card explicitly distinguishes these two inheritances and specifies using the configuration files distributed with the DeepSeek checkpoint rather than substituting those from the original Qwen3 repository. Thus, the “8B” designation describes approximate scale, not compatibility of architecture, vocabulary, or conversation formatting with the earlier 8B release. (huggingface.co)

Benchmark results and evaluation methodology

DeepSeek’s developer-reported results for the original DeepSeek-R1 distinguished mathematical reasoning, competitive programming, software engineering, scientific questions, general knowledge, and Chinese-language tasks. In mathematics, R1 achieved 79.8% pass@1 on AIME 2024, 97.3% on MATH-500, and 78.8% on CNMO 2024. Competitive-programming measurements included 65.9% on LiveCodeBench and an estimated Codeforces rating of 2,029, corresponding to the 96.3rd percentile. Software-engineering results were separately reported as 49.2% of issues resolved on SWE-bench Verified and 53.3% accuracy on Aider-Polyglot. These figures describe different tasks and scoring systems, not interchangeable measures of programming ability. (github.com)

For scientific reasoning, R1 scored 71.5% on GPQA Diamond, which contains graduate-level biology, physics, and chemistry questions. General-knowledge measurements included 90.8% on MMLU and 84.0% on MMLU-Pro, whereas factual question answering produced 30.1% correctness on SimpleQA. In Chinese-language evaluation, R1 obtained 91.8% on C-Eval, 92.8% exact match on CLUEWSC, and 63.7% correctness on C-SimpleQA. The separation of these categories matters: strong mathematical scores did not imply comparable factual-answering accuracy. (github.com)

The reported pass@1 estimated the probability that one sampled response was correct, rather than measuring a single deterministic response. For each question, the evaluators generated multiple responses and averaged their binary correctness indicators: $\widehat{p}=k^{-1}\sum_{i=1}^{k}c_i$, where $c_i$ equals one for a correct response and zero otherwise. They used temperature 0.6, top-$p$ sampling at 0.95, and a maximum generation length of 32,768 tokens. The revised report specified 64 samples per question for AIME and GPQA, 16 for MATH and Codeforces, and eight for LiveCodeBench. Consensus@64 instead selected an answer by majority vote across 64 responses; it therefore used multiple generations to produce one answer, unlike the single-response success probability estimated by pass@1. (arxiv.org)

Evaluation also depended on prompt design and execution frameworks. MMLU, DROP, GPQA Diamond, and SimpleQA used prompts from simple-evals; MMLU-Redux used Zero-Eval’s zero-shot format. For MMLU-Pro, C-Eval, and CLUEWSC, the developers adapted few-shot prompts to zero-shot because reasoning demonstrations could reduce R1’s performance. Codeforces ratings were estimated from ten Division 2 contests with expert-crafted test cases. SWE-bench Verified used the Agentless framework, while Aider used diff-format edits. Consequently, these software-engineering scores measured the model within specified workflows, not unrestricted autonomous development. (arxiv.org)

Comparisons require named versions: the original table compared R1 with Claude-3.5-Sonnet-1022, GPT-4o-0513, and OpenAI-o1-1217, among others. The o1-1217 figures came from official reports rather than the same evaluation run. Thus, the reported AIME scores of 79.8% for R1 and 79.2% for o1-1217 were not a controlled, equal-compute comparison. Response limits, actual generated lengths, and aggregation budgets remain relevant to experimental design. For benchmark contamination, the revised report described removing training texts containing matching 10-gram sequences from evaluation questions or solutions, including approximately six million potential pretraining texts in mathematics. It nevertheless acknowledged that this filtering could miss paraphrased test material. (arxiv.org)

DeepSeek-R1-0528 and expanded capabilities

DeepSeek released DeepSeek-R1-0528 on May 28, 2025, as a post-training update rather than a replacement of the pretrained foundation. It retained the DeepSeek-V3-Base model released in December 2024. The developers attributed its stronger reasoning performance to greater computational investment and algorithmic optimization during post-training, rather than to a newly designed architecture. These changes were described at a high level, without a corresponding detailed specification of the additional training computation or optimization procedures. (api-docs.deepseek.com)

The principal quantitative example was AIME 2025: developer-reported accuracy increased from 70.0% for the preceding R1 checkpoint to 87.5% for R1-0528, a gain of 17.5 percentage points. Average generated reasoning length rose from approximately 12,000 to 23,000 tokens per question—nearly doubling. DeepSeek associated this longer generation with more extensive problem solving. The comparison nevertheless combined a changed checkpoint with substantially longer responses; it was not a controlled measurement of accuracy at an identical inference budget. Longer generated reasoning was therefore an observed characteristic of the update, not an independently isolated explanation of its improvement. (api-docs.deepseek.com)

The accompanying evaluation table showed gains across several task families. GPQA-Diamond increased from 71.5% to 81.0%, AIME 2024 from 79.8% to 91.4%, and LiveCodeBench’s August 2024–May 2025 problem set from 63.5% to 73.3%. SWE-Verified resolved-task performance rose from 49.2% to 57.6%, using the Agentless evaluation framework. For benchmarks requiring sampling, DeepSeek specified a temperature of $0.6$, top-$p$ of $0.95$, a maximum generation length of 64K tokens, and 16 responses per query to estimate pass@1. These figures were developer measurements under the stated protocol, rather than guarantees for individual responses. (huggingface.co)

The update also broadened structured interaction. Its release announcement added JSON output and function-calling support to the hosted API and reported improved front-end code generation. Function calling concerns producing a structured request for a host application to execute; it does not mean that generated text itself executes a function or that the model independently acquires tools. The Chinese release documentation specifically excluded tool calls within the thinking process. Separately, the model card documented support for system prompts and removed the earlier requirement to prepend a thinking marker to force reasoning-style generation. These changes expanded formatting and prompt-control capabilities alongside mathematical reasoning. (api-docs.deepseek.com)

Performance changes were not uniformly positive. In the same developer comparison, SimpleQA correctness declined from 30.1% to 27.8%, despite the gains on reasoning and programming benchmarks. That result concerns factual question answering and should be distinguished from the release announcement’s broader claim of reduced hallucinations: improved performance on selected reasoning tasks did not establish a general improvement in factual accuracy. (huggingface.co)

Inference, deployment, and integration

DeepSeek-R1 produces a generated reasoning trace followed by a final answer. In checkpoint output, <think> and </think> delimit the reasoning portion; serving software can parse this text into separate response fields rather than display it as one message. DeepSeek’s documented streaming example for deepseek-reasoner collects reasoning through delta.reasoning_content and answer text through delta.content. These are two portions of a generated sequence, not independently executed models. In ordinary autoregressive inference, output tokens are generated successively, with later tokens conditioned on preceding text. Consequently, at otherwise comparable serving conditions, a longer reasoning trace requires more decoding work and delays the beginning of the final answer. Streaming exposes intermediate output but does not eliminate that computation. (arxiv.org)

Full-model deployment must accommodate the complete parameter set, not merely the approximately 37 billion parameters activated for each token. The original model contains 671 billion parameters: a simple storage calculation gives approximately 1.342 TB at two bytes per parameter, or 671 GB at one byte, before quantization metadata and runtime allocations. These are nominal weight-storage estimates, not measured accelerator-memory requirements. Additional capacity is needed for intermediate activations, communication buffers, and the key–value cache retained for active sequences. The inherited multi-head latent attention architecture compresses cached attention information, but longer contexts and more concurrent requests still consume additional cache capacity. Sparse expert activation therefore reduces computation without making the full checkpoint equivalent in storage requirements to a dense 37-billion-parameter model. (github.com)

Serving frameworks distribute this workload across GPUs using forms of parallel computing. Tensor parallelism divides tensor operations across devices, while expert parallelism distributes experts and routes token representations between their hosts. The vLLM project’s R1 deployment recipe documents an FP8 configuration using eight H200 GPUs and, for DeepSeek-R1-0528, launch arguments combining --tensor-parallel-size 8 with --enable-expert-parallel. It also documents a four-B200 configuration for NVIDIA’s FP4-quantized R1 checkpoint. These are precision- and implementation-specific configurations, not universal minimum GPU counts. Quantized checkpoints reduce weight-storage demands, but their deployment also depends on supported kernels, cache precision, context length, and concurrency. (github.com)

DeepSeek’s repository separately documents vLLM and SGLang integration for the smaller distilled models. Its DeepSeek-R1-Distill-Qwen-32B examples use two-way tensor parallelism in both frameworks; the vLLM example sets a maximum sequence length of 32,768 tokens. Such examples concern that dense distilled checkpoint, not the full 671-billion-parameter model. Output parsing is another integration layer: vLLM provides a deepseek_r1 reasoning parser selected through --reasoning-parser. Response-field conventions can change independently of model weights; vLLM’s documentation, for example, records a migration from reasoning_content to reasoning, while retaining content for the final answer. (github.com)

Downloadable checkpoints, hosted API access, and the consumer chatbot represent distinct deployment arrangements. DeepSeek’s January 20, 2025 release announcement identified deepseek-reasoner as the API model name for R1, while its repository described access through the chatbot’s “DeepThink” control. The repository also published file-upload and web-search prompt templates that insert externally supplied content into a request; those application features are not evidence that checkpoint inference itself retrieves files or searches the web. Third-party hosting likewise has a dated scope: on June 4, 2025, GitHub announced R1-0528 availability through GitHub Models’ playground, API, and repository Models tab. That announcement establishes the integration at that date, rather than a permanent mapping between a service endpoint and an unchanged checkpoint. (api-docs.deepseek.com)

Licensing, distribution, and reproducibility

DeepSeek licenses the principal R1 repository and model weights under the MIT License, explicitly permitting commercial use, modification, and derivative works, including distillation to train other large language models. This permission extends beyond access through a hosted service: recipients can download and redistribute the released checkpoints. The license requires preservation of its copyright and permission notices in copies or substantial portions of the licensed material, and disclaims warranties and liability. Its permissive terms do not require modifications to be published under the same license. (github.com)

The distilled checkpoints have additional upstream licensing histories. DeepSeek identifies the four original Qwen-derived variants—1.5B, 7B, 14B, and 32B—as derivatives of Qwen2.5 models originally licensed under the Apache License 2.0. That license permits commercial redistribution and modification but includes requirements concerning license copies, retained notices, identification of changed files, and applicable NOTICE-file attributions; it also contains an express patent grant with termination provisions. DeepSeek’s MIT designation therefore does not make the upstream provenance irrelevant. The Llama-derived 8B and 70B checkpoints instead originate from Llama-3.1-8B and Llama-3.3-70B-Instruct, respectively, and the repository expressly points to their corresponding Meta licenses. (github.com)

The Llama 3.1 and 3.3 Community License agreements impose conditions absent from MIT. Their redistribution provisions require inclusion of the agreement, retention of an attribution notice, and prominent display of “Built with Llama”; they also incorporate an acceptable-use policy. Both contain naming requirements for distributed models developed using Llama materials or outputs. An additional commercial provision applies where a licensee’s or its affiliates’ products or services exceeded 700 million monthly active users in the calendar month preceding the relevant Llama release date: exercise of the licensed rights then requires a separate grant from Meta. These checkpoint-specific provisions distinguish the Llama derivatives from the principal R1 weights and the Apache-licensed Qwen foundations. (huggingface.co)

Distribution provides substantial material for inspecting and running the finished models. The GitHub repository supplies the research report, model descriptions, benchmark tables, prompting guidance, and serving examples, with download links for R1, R1-Zero, and six original distilled checkpoints. The R1 Hugging Face repository contains sharded SafeTensors weights, a weight index, model and generation configurations, and tokenizer files. These artifacts support independent inference and further fine-tuning, but are distinct from a complete training release: the listed repositories do not supply the full curated training corpora and executable end-to-end post-training pipeline. (github.com)

Reproducibility also depends on which research description is used. Version 2 of the technical report discloses detailed sampling settings, learning rates, batch sizes, and training schedules. For example, it describes distillation over 800,000 examples for two to three epochs, with a batch size of 64 and a maximum sequence length of 32,768 tokens. It reports 101,000 H800 GPU-hours for R1-Zero, 5,000 for supervised-data creation, and 41,000 for R1, totaling 147,000 GPU-hours. Its estimated US$294,000 cost assumes US$2 per GPU-hour; this table concerns the specified R1 training work, not pretraining the inherited foundation. These disclosures help characterize experimental scale, but reconstructing the reported runs also requires the exact training examples, filtering decisions, reward implementations, and training infrastructure. Thus, downloadable weights enable replication of model use more directly than reproduction of model creation. (arxiv.org)

Reliability limits and research questions

The original January 2025 DeepSeek-R1 had documented weaknesses outside verifiable reasoning tasks. Its developers reported poorer function calling, multi-turn interaction, complex role-playing, and JSON output than DeepSeek-V3. Instruction following was also sensitive to prompt design: adding few-shot demonstrations consistently reduced performance in their evaluations. Although R1’s post-training improved the readability problems of R1-Zero, queries outside Chinese and English could still produce English reasoning or answers. Software-engineering improvements were comparatively limited because slow evaluations restricted the extensive application of reinforcement learning to these tasks. These observations concern the original release rather than every subsequent checkpoint. (arxiv.org)

A convincing reasoning trace is not an independent correctness check. R1-Zero’s accuracy rewards principally checked final mathematical answers or executable programming tests, rather than certifying every intermediate statement. Expressions of doubt and self-correction therefore document generated behavior, not verified reasoning throughout. Hallucination and factual accuracy must also be evaluated separately from mathematical performance. The May 2025 R1-0528 model card illustrates this distinction: although DeepSeek reported reduced hallucination and improved reasoning, its SimpleQA factual-answer score fell from 30.1% to 27.8%, while AIME 2025 accuracy rose from 70.0% to 87.5%. Neither benchmark establishes reliability across unrestricted factual questions. (arxiv.org)

The developers’ unsuccessful experiments with process reward models exposed difficulties in supervising intermediate reasoning: defining a step, judging its correctness, and obtaining scalable annotations. In their experiments, models exploited learned reward signals, while retraining reward models added expense. Experiments with Monte Carlo tree search faced an enormous language-generation search space; limiting node expansion risked local optima, and search depended on a difficult-to-train value model. These were limitations of the reported experiments, not demonstrations that either method cannot work. (arxiv.org)

The January 4, 2026 report revision identifies reward reliability and generalization beyond verifiable tasks as open problems. For writing and other open-ended tasks, learned evaluators can reward shortcuts rather than intended quality. It also documents excessive reasoning on simple questions, leaving inference-time efficiency unresolved. (arxiv.org)

Safety results likewise depend on the evaluation and deployment configuration. In the revised report’s developer-run jailbreak study, 2,232 attack templates were randomly combined with in-house safety questions; a language-model judge classified responses as safe, unsafe, or rejected. R1’s reported unsafe-response proportion increased from 25.2% on original questions to 85.9% under jailbreak prompts. With an additional risk-control system, the corresponding figures were 8.5% and 4.3%. These measurements describe that test procedure and filtering configuration, not a universal probability of harmful output or an intrinsic guarantee supplied by the weights. (arxiv.org)

References

1. DeepSeek-R1 Releaseapi-docs.deepseek.com
2. GitHub - deepseek-ai/DeepSeek-R1github.com
3. DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning (v1)arxiv.org
4. 更新日志 | DeepSeek API Docsapi-docs.deepseek.com
5. deepseek-ai/DeepSeek-R1-0528huggingface.co
6. DeepSeek-R1 incentivizes reasoning in LLMs through reinforcement learningdoi.org
7. DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learningarxiv.org
8. DeepSeek-V3 Technical Reportarxiv.org
9. GitHub - deepseek-ai/DeepSeek-V3github.com
10. config.json · deepseek-ai/DeepSeek-R1 at mainhuggingface.co
11. DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learningarxiv.org
12. DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Modelsarxiv.org
13. deepseek-ai/DeepSeek-R1-Zero · Hugging Facehuggingface.co
14. DeepSeek-R1 incentivizes reasoning in LLMs through reinforcement learningpmc.ncbi.nlm.nih.gov
15. DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learningarxiv.org
16. deepseek-ai/DeepSeek-R1-0528-Qwen3-8B · Hugging Facehuggingface.co
17. DeepSeek-R1-0528 Release | DeepSeek API Docsapi-docs.deepseek.com
18. DeepSeek-R1 更新，思考更深，推理更强api-docs.deepseek.com
19. thinking_mode_api_example_streamingapi-docs.deepseek.com
20. Reasoning Outputs — vLLMdocs.vllm.ai
21. DeepSeek-R1-0528 is now generally available in GitHub Modelsgithub.blog
22. DeepSeek-R1/LICENSE at maingithub.com
23. LICENSE · Qwen/Qwen2.5-1.5Bhuggingface.co
24. LICENSE · meta-llama/Llama-3.1-8Bhuggingface.co
25. LICENSE · meta-llama/Llama-3.3-70B-Instructhuggingface.co
26. deepseek-ai/DeepSeek-R1 at mainhuggingface.co