DeepSeek’s research papers explain the ideas behind its models: how they use computation more efficiently, learn to reason, work with images, and handle long conversations. If you want to understand reasoning, start with DeepSeek-R1. For model architecture and training, start with DeepSeek-V3, then follow the long-context work through V3.2, V4, and V4.1-Flash.
This guide connects the main papers and technical reports, explains what each contributes, and helps you choose a reading path. It also covers the specialist work on code, mathematical proofs, vision, and OCR. The links lead to original papers or DeepSeek’s own repositories; Chat-Deep.ai is an independent guide.
Which DeepSeek paper should you read first?
Choose a question before choosing a paper. R1 is a useful starting point for “How does a model learn to solve a problem?” V2 and V3 are more useful for “How can a large model be economical to train and serve?” You do not need to read every paper chronologically.
If you are new to the subject, read the introduction and conclusion of your first paper before attempting its equations. Then look at one method diagram and the experiment that tests the main idea. That gives you a reason to work through the technical sections.
| Your goal | Suggested reading path | What to follow |
|---|---|---|
| Understand model efficiency | DeepSeekMoE → V2 → V3 | Expert selection, attention memory, and training design |
| Understand reasoning and reinforcement learning | DeepSeekMath → R1 → Math-V2 | Rewards, training stages, and checking the reasoning itself |
| Study long contexts and agent workloads | V3.2 → V4 → V4.1-Flash | Sparse attention and the cost of storing conversation context |
| Study code models | DeepSeek-Coder → Coder-V2 | Code data, infilling, and specialization of a general model |
| Study formal theorem proving | Prover → Prover-V1.5 → Prover-V2 | Synthetic proofs, proof-assistant feedback, and subgoals |
| Work on images or documents | VL/VL2 for understanding; Janus for generation; OCR/OCR 2 for document reading | Pick the branch that matches the task before comparing results |
These are reading recommendations, not rankings of models to buy or deploy. A researcher studying proof verification needs a different starting point from a developer extracting text from scanned pages. The sections below explain those differences and link directly to the relevant work.
What the research covers
DeepSeek research includes general language models, specialist models, training methods, and the systems used to run them. A paper may introduce a whole model family, such as V3, or investigate one component, such as expert routing or memory lookup. Reading both kinds helps explain how the larger systems fit together.
The useful detail is often below the headline benchmark: which component changed, what the authors kept fixed, and whether an experiment isolates the benefit of that change. Those details let you learn from an older paper even after its model is no longer a sensible default for a new application.
The broad timeline starts with the DeepSeek LLM, MoE, coding, and mathematics papers in 2024, followed by V2 and V3. In 2025, R1 made reinforcement learning for reasoning a central part of the reading list, alongside further proof, vision, and sparse-attention work. The 2026 papers extend the discussion to optical document processing, million-token contexts, memory compression, and serving systems.
For the release-by-release account of older checkpoints, use our DeepSeek model history. Here, the focus is what the research teaches you, rather than every product release between papers.
Architecture and training: from DeepSeek LLM to V4.1
Three questions connect this group: how to allocate computation, how to store information from earlier tokens, and how to train the resulting system efficiently. The papers address different parts of that problem, so their efficiency claims should not be treated as interchangeable.
DeepSeek LLM: the scaling foundation
The DeepSeek LLM paper (2024) studies scaling laws and applies them to 7B and 67B models trained on a corpus of two trillion tokens. It also describes supervised fine-tuning and Direct Preference Optimization to turn base models into chat models.
Read it to understand the decisions that come before a chatbot exists: how much data to use, how model size relates to training, and how a pretrained model is adapted for conversation. The distinction between a base model and a chat model remains useful throughout the later papers.
DeepSeekMoE: more specialized experts
DeepSeekMoE (2024) explores finer-grained experts and shared experts. In a mixture-of-experts model, a routing mechanism selects parts of the network for a token instead of using every expert on every step. Shared experts handle common knowledge, leaving routed experts more room to specialize.
The practical reading question is whether specialization improves the use of a given compute budget. Keep total parameters separate from activated parameters: the first describes the whole model; the second describes the subset used in processing a token. A small activated count does not mean the complete model fits into equally little memory.
DeepSeek-V2: reducing attention memory
The V2 paper (2024) combines DeepSeekMoE with Multi-head Latent Attention, or MLA. V2 has 236B total parameters, activates 21B per token, and supports a 128K context. Its official repository contains the associated model and implementation information.
MLA compresses the key-value cache: the stored information that helps a model attend to earlier tokens without recomputing everything. That makes the paper especially relevant when you want to understand inference memory. Read the MLA discussion separately from the MoE discussion; they reduce different costs.
DeepSeek-V3: architecture and training working together
The V3 technical report (first posted in 2024, revised in 2025) describes a 671B-parameter MoE model with 37B activated per token. It builds on MLA and DeepSeekMoE, adds auxiliary-loss-free load balancing, and uses a multi-token prediction training objective.
Its FP8 training section explains how the team uses lower precision for much of the computation while retaining higher precision where stability requires it. FP8 here is part of a mixed-precision training design, not a claim that every operation uses eight-bit numbers.
For a first read, separate the model architecture from the infrastructure and training sections. That makes it easier to see why an improvement can depend on several choices working together. A reported training cost or GPU-hour figure also needs its stated accounting scope; it is not automatically the total cost of building the company or running the service.
DeepSeek-V3.2: sparse attention and reasoning with tools
The V3.2 paper (2025) connects DeepSeek Sparse Attention, reinforcement learning, and a pipeline for synthesizing agentic training tasks. Sparse attention reduces the work spent attending across long sequences; the training pipeline addresses how a model reasons and follows instructions in interactive tasks.
Use this paper to connect architecture with tool use. The attention method helps explain computational efficiency, while the post-training sections explain a different part of the model’s behavior. Results for the high-compute Speciale variant should be read with that variant’s conditions, rather than silently assigned to every V3.2 deployment.
DeepSeek-V4: million-token context design
The V4 report (2026) describes the Pro and Flash models with one-million-token contexts. Its main architecture changes include Compressed Sparse Attention and Heavily Compressed Attention, alongside Manifold-Constrained Hyper-Connections and the Muon optimizer.
This is the next step after V3.2 if you want to understand the cost of long contexts. Look at how the report combines attention compression, connections between layers, and optimization. Its comparison of inference computation and cache use is tied to a particular context setting; it should not become a blanket promise about every request’s speed or price.
DeepSeek-V4.1-Flash: compressing the cache further
DeepSeek-V4.1-Flash: Pushing the Limits of KV Cache Compression (2026) focuses on multimodal and agentic workloads. It introduces a Causal Encoder-Decoder design, cross-layer cache reuse through Compressed Sparse Attention 2, and FP4 key-value caching.
The report distinguishes the global cache kept in GPU high-bandwidth memory from persistent cache stored in host memory or on SSD. That distinction matters when reading the compression ratios: they describe different storage footprints. Compare each with the stated V4-Flash baseline, rather than combining them into one general “memory reduction” figure.
Across these papers, MoE concerns which experts do the work; MLA and later attention methods concern how context is represented and accessed; lower precision changes how numbers are stored and processed. Keeping those roles separate makes the architecture diagrams much easier to follow.
Reasoning, mathematics, and formal proofs
These papers ask related but different questions. A model can produce the right numerical answer, write a convincing explanation, or generate a proof accepted by a formal checker. Those are different outcomes, and the evaluation needs to match the one you care about.
DeepSeekMath: where GRPO enters the picture
DeepSeekMath (2024) combines math-focused data selection with continued training of a 7B code model. It introduces Group Relative Policy Optimization, or GRPO, a reinforcement learning method used to improve mathematical reasoning.
In the method description, GRPO estimates a baseline from scores within a group rather than training the separate critic model used in the PPO setup discussed by the authors. For a reader, the important connection is between the reward signal and the behavior being encouraged. The quality of the training data still matters; the algorithm is not the whole explanation.
DeepSeek-R1: the difference between R1-Zero and R1
The original R1 report (2025) describes two training paths. R1-Zero applies large-scale reinforcement learning without supervised fine-tuning as a preliminary step. R1 adds cold-start data and a multi-stage process to address issues including readability and language mixing.
That distinction prevents a common misreading: “no preliminary supervised fine-tuning” describes R1-Zero’s experiment, not every stage of R1. The report also describes training smaller Qwen- and Llama-based models with outputs from R1. This distillation transfers useful behavior into smaller models; it does not make them identical to the original system.
Focus on the training stages and the evaluation conditions before comparing scores. The updated arXiv record also links the work to its Nature publication. Use the version that supports the specific claim you are citing.
DeepSeekMath-V2: checking the reasoning
DeepSeekMath-V2 (2025) asks what happens when a correct final answer is not enough. It develops an LLM-based verifier, uses that verifier to train a proof generator, and encourages the generator to identify and fix problems in its own proofs.
This is useful reading if your interest is rigorous mathematical explanations. Pay attention to how verification is trained and how extra computation is used at evaluation time. An LLM judging a proof and a formal proof assistant accepting one are different forms of checking; the Prover papers address the latter.
DeepSeek-Prover: from synthetic data to subgoals
DeepSeek-Prover (2024) tackles the shortage of formal proof data by generating Lean 4 statements and proofs, filtering the material, and training on it. Start here to understand how a natural-language mathematics problem becomes training material for a formal system.
Prover-V1.5 (2024) adds reinforcement learning from proof-assistant feedback and a Monte Carlo tree search approach called RMaxTS. The useful shift is from trying only a complete proof in one pass to exploring possible proof paths with feedback.
Prover-V2 (2025) uses a recursive pipeline to decompose difficult problems into subgoals, then incorporates the resulting proofs into training. It also introduces ProverBench. Read it when you want to understand how informal planning can help produce a formally checked result. The official repository links the models and evaluation materials.
The task definition matters as much as the score. A formal theorem prover works with a statement encoded in a proof language. Its benchmark result is not a measurement of how reliably a general chatbot answers every mathematics question.
Coding papers: data, infilling, and specialization
DeepSeek-Coder (2024) introduces code models from 1.3B to 33B parameters, trained with project-level code and an infilling task. Infilling means completing a missing section using the material around it, a useful distinction from simply continuing the next line of code.
DeepSeek-Coder-V2 (2024) continues training from an intermediate V2 checkpoint with additional code and mathematics data. The paper reports a move from 16K to 128K context and broader programming-language coverage compared with the earlier Coder series.
Read the pair to see two ways of building code capability: training a code-focused model and specializing an existing general architecture. When comparing benchmark tables, check the task and generation settings. Completing a function, solving a programming contest problem, and modifying a repository with tools require different evaluations.
If your next step is using the released models, the DeepSeek Coder guide explains the model choices and local setup. For research on reasoning during tool use, return to V3.2 rather than assuming the older Coder papers describe the entire agent workflow.
Vision, image generation, and document reading
A paper about understanding an image does not necessarily describe a model that can generate one. Likewise, reading the text and structure of a page is a more specific task than general visual question answering. Choose the relevant branch before comparing architectures or results.
DeepSeek-VL and VL2: understanding visual input
DeepSeek-VL (2024) studies vision-language understanding across material such as screenshots, charts, documents, and OCR. Its discussion of data selection and the balance between language and vision is useful if you want to understand how a visual assistant is trained.
DeepSeek-VL2 (2024) adds dynamic image tiling and an MoE language component with MLA. Tiling helps process images with different resolutions and aspect ratios. Read this alongside its document, table, chart, and visual-grounding evaluations to see what the design is intended to support.
Janus, JanusFlow, and Janus-Pro: understanding and generation
Janus (2024) separates the visual encoding paths for understanding and generation while using a shared transformer. The central idea is that recognizing what an image means and constructing an image need not use the same visual representation.
JanusFlow (2024) combines autoregressive language modeling with rectified flow for image generation. It is a related research direction, with a different generation mechanism to examine. The paper records its acceptance at CVPR 2025.
Janus-Pro (2025) develops the original Janus approach through changes to training, more data, and larger model scale. Read it after Janus so you can distinguish the underlying architectural idea from the later improvements. A capability shown in these research models should not be assumed to exist in every DeepSeek chat or API product.
DeepSeek-OCR and OCR 2: document structure and compression
DeepSeek-OCR (2025) investigates representing long text contexts as images and recovering their contents through optical compression. Its DeepEncoder and language decoder connect a practical document-reading task with a broader question about how much information can be represented by vision tokens.
DeepSeek-OCR 2 (2026) introduces DeepEncoder V2 and explores reordering visual tokens according to image semantics. That is particularly relevant to pages where the intended reading order does not follow a simple scan from the top-left corner to the bottom-right.
For these papers, inspect the page types, layouts, token budgets, and evaluation method. A reported extraction result does not guarantee identical accuracy on a blurred scan or an unfamiliar layout. For the practical path from images and PDF pages to extracted output, use the DeepSeek OCR guide.
Further reading on architecture, memory, and serving systems
Once you understand the model reports, these narrower studies help explain costs that a parameter count alone cannot show. Choose one that matches the part of the system you are investigating.
mHC: Manifold-Constrained Hyper-Connections studies how to make wider, more interconnected residual streams stable enough to train. It is useful background for the mHC component in V4. Concentrate on what the constraint changes in information flow, rather than treating it as another attention mechanism.
Engram: Conditional Memory via Scalable Lookup explores a memory lookup mechanism that complements MoE computation. The official repository explains how static N-gram memory is retrieved and combined with dynamic hidden states. This is architecture research, not the same thing as an app remembering a user’s past chats.
DualPath examines movement of key-value caches between storage and inference engines for agentic workloads. It is relevant when the bottleneck is getting cached data to the computation, rather than computing the model itself.
DSpark studies speculative decoding: proposing tokens and checking them with a target model. It combines semi-autoregressive drafting with confidence-based decisions about how much to verify. Its serving results should be read alongside the workload and throughput conditions in the paper.
A Programming Paradigm for Spatiotemporal Composability, by researchers affiliated with Peking University and DeepSeek-AI, addresses dynamically composed software components. It develops mechanisms for reverting effects and managing dependencies, implemented in Cordis. This belongs on an agent-systems reading path; it is a software-composition paper rather than a language-model benchmark report.
Finding the right official source
Use a paper for the research method and experiments, a model card for a particular checkpoint, and a repository for the accompanying code and files. For an application you are building now, API documentation answers a different question: what the hosted service accepts and returns. One source cannot safely stand in for all four.
Start with DeepSeek’s papers listing and the original paper links above. Follow the authors’ links to repositories and model cards, check the owner and exact model name, then check the version. Community uploads can be useful, but a similarly named repository is not automatically an official release.
Model updates are not always new papers
The R1-0528 model card documents an update to R1 and links back to the R1 paper. The V3.1 card and V3.2-Exp card are also useful release-specific sources. Keep them labeled as model documentation when assembling a bibliography; a new checkpoint name does not by itself establish a separate research paper.
The same distinction applies to tools and applications. Harness documentation explains an agent environment; API documentation explains a service. Neither should be presented as experimental evidence for a model’s training method. Our DeepSeek overview helps place the research models alongside the ways people use DeepSeek.
How to read the results without losing the context
Check what was actually measured
Before taking a score out of a paper, note the exact model, benchmark version, prompt setup, allowed tools, and generation budget. Look for whether the result describes one attempt, repeated sampling, voting, or a search procedure. A larger inference budget can change the result without changing the model’s weights.
Then ask what comparison the experiment supports. A component ablation can help show whether a design choice mattered within the authors’ setup. A benchmark table compares models under stated evaluation conditions. Neither automatically tells you which service will be best for your own documents, codebase, or response-time needs.
For example, when you compare a paper’s proof-search result with a chatbot’s single answer, you are comparing two different procedures. Keep the test procedure attached to the number. This is also why results from a released checkpoint cannot simply be assigned to an API alias that may later point to another model.
Check what has been released
A downloadable checkpoint lets you inspect and run model weights under its license. It does not automatically include the full training corpus, every processing step, or all infrastructure needed to reproduce training. Check which materials the authors actually provide before describing a result as fully reproducible.
Licenses can also differ across model families and versions. Use the license attached to the exact checkpoint and code you intend to use; a permissive license on a repository is not proof that every related asset has identical terms. Our guide to DeepSeek licenses and commercial use explains the main distinctions.
How to cite a DeepSeek paper or model release
Open the original paper record and use its citation export as a starting point. Keep the author list, title, year, and arXiv identifier or publication DOI. If your discussion depends on wording or results that changed, identify the version you read. An initial preprint date, a revised paper date, and a model launch date can all be different.
For example, a discussion of the original R1-Zero and R1 training setup can point to arXiv:2501.12948v1. A discussion of the later R1-0528 checkpoint should also identify its model card. That gives the reader a way to check both the underlying method and the particular model you mean.
When implementation details matter, record the repository commit or release tag rather than citing a moving branch alone. For a model card, name the checkpoint and record the access date. For a benchmark claim, include the relevant table or section and the evaluation conditions, so the citation supports the actual comparison.
Frequently asked questions
Are DeepSeek research papers free to read?
The arXiv papers linked here can be read without buying a subscription. Open the paper’s abstract page for its PDF and, when available, HTML version. Access to the paper is separate from the license governing code, weights, or data.
Can I understand the papers without a machine-learning background?
You can start with the problem statement, diagrams, and conclusions. Learn terms such as pretraining, fine-tuning, attention, and reinforcement learning as they become relevant. For a first pass, aim to explain what changed and why the authors expect it to help; working through every equation can come later.
Are all DeepSeek papers peer-reviewed?
No. An arXiv posting alone does not establish peer review. Check the publication record for each work. The R1 record lists a Nature journal reference, while the JanusFlow record notes CVPR 2025 acceptance. Do not extend one paper’s publication status to the whole collection.
What is the difference between the V3 and R1 papers?
V3 is the better starting point for architecture and efficient large-model training. R1 focuses on developing reasoning through reinforcement learning and transferring that behavior to smaller models. Read them together when you want to connect a model’s underlying structure with its later training for reasoning.
Does a paper prove that a feature is available in the DeepSeek app?
No. A paper can describe a research checkpoint or experiment that differs from a deployed product. Check the app’s help or the API’s documentation for the feature you want to use, especially for image input, image generation, tools, and context limits.
Can I run the models from these papers locally?
For a released checkpoint, start with its official model card and supported runtime. Feasibility depends on the complete weights, numerical precision, context memory, and hardware. Smaller or distilled models can be more practical, but their results should not be described as those of the full model.
How do I know whether I am reading the right version?
Check the paper’s submission history and the model card’s exact name. If a guide cites a specific arXiv version, open that version when checking the claim, then inspect later revisions for changes. There is no fixed publication schedule you need to follow to understand the established methods.
Turn one paper into a useful next step
Pick the paper closest to the question you are trying to answer and write down three things after reading it: what changed, which evidence supports the change, and what the experiment leaves unresolved. Then follow one reference that explains the part you still do not understand. That gives you a working understanding of DeepSeek’s research without turning the reading list into a task of finishing every paper.