DeepSeek-V4.1-Flash, explained step by step

A LLM does not manipulate words but tokens. His only talent: from a sequence of tokens, predict the next. To write an answer, he predicts a token, adds it to the sequence, and then starts again. It's the generation autoregressive.

This work takes place in two very different phases:

• Prefill : the model reads all the prompt at once. All the tokens are treated in parallel, which makes large multiplications of matrices. This phase is limited by the calculation power.
• The decode The model produces the answer one token at a time. At each step, it only calculates a token, but must reread all its weight and all its memory of the context. This phase is limited by the memory bandwidth.

To predict the future, every token needs information from previous tokens.attention. Each token produces three vectors:

• a request Q (query) : « What am I looking for? » ;
• a K key (key) : "This is what I have in mind", like the label of a drawer ;
• a value V (value) : the contents of the drawer, the information actually transmitted.

The current token compares its query with all the keys (scalar product). It converts these scores into weights that amount to 1 (softmax), then makes the weighted average of the values. A model stacks dozens of layers DeepSeek-V4.1-Flash has 40 of them.

In a model causal, a token never looks at the future. The keys and values of a past token never change again. Rather than recalculating them at each new token, we store them: it is the KV cache. It grows linearly with the length of the context:

This cache lives on three floors of memory, from the fastest and rarest to the slowest and abundant:

An agent (code assistant, desktop automation, etc.) runs dozens of tool calls. On each turn, the output of the tool (a file, a log, a web page) is added to the context. read (prefill), then write some lines (decode). Result: Workloads become Mostly in entry (input-heavy).

There are two mechanisms to maintain the cost:

• Prefix cache : if the beginning of the context has already been read, you reload your KV cache instead of recalculating it. store This cache, sometimes for a long time, on SSD.
• Cheaper Prefill : for new tokens, and for cases where the cache has been lost (cache miss), we have to recalculate everything.

In a Transformer, each layer alternates attention and feed-forward network. MoE, this network is cut into many small experts. A router only activates a few by token. DeepSeek-V4.1-Flash uses in each layer 1 shared expert (always active) and 384 routed experts, including 6 are chosen for each token.

That's why we distinguish total parameters (552 B, stored knowledge) and active parameters (the calculation actually made for a token). Particularity of V4.1: this second digit is 8 B in prefill and 16 B in decodeChapter 4 explains why.

A context of a million tokens poses a problem: if each new token compares its request with a million keys, in each layer the cost explodes. The DeepSeek family therefore combines several forms of attention:

• Dense global attention Look at all the past. It's accurate but its cost increases with length.
• Attention with slippery windows (SWA) only look at the n_win = 128 last tokens. Its cost and cache are limited.
• Sparse attention (sparse) : a small module, theindexer, notes all entries of the past and keeps only the top 512 (top-k). The main attention reads only those, plus the local window.

DeepSeek-V3.2 and V4 have introduced these sparse and compressed attentions. The decor of V4.1 is therefore: a branch local (SWA) in each layer + one branch global compressed and sparse.

In DeepSeek-V4, each layer combines two branches of attention:

• a global branch which covers the whole context. global KV, composed of: main KV (the inputs read by attention) and theindexer K (the keys of the indexer that chooses the entries to read);
• a local SWA branch which maintains the SWA KV Of the last 128 tokens.

The KV SWA has a fixed size, regardless of the length of the context. Global KV that dominates memory. It is limited by the capacity of the HBM. In addition, part of the cache is Persistence on SSD or host RAM to reuse prefixes, adding two constraints: storage capacity and input/output bandwidth.

Paper presents compression as the fruit of optimization joint Each is the subject of a chapter in this course:

Announced balance: at equal sequence length, V4.1-Flash only needs about ¼ of the runtime KV cache (in HBM) and about ⅛ of the persistent KV cache (SSD / RAM host) from V4-Flash. Yet it is a model larger (552 B versus 284 B of parameters) and higher performance.

All improvements also combine on the calculation side. Figure 2 counts the operations needed to generate one It weighs operations BF16, FP8 and FP4 by 1, 0.5 and 0.25. For V4.1-Flash, the curve is almost flat: multiply the context by 256, from 4K to 1M tokens, increases the cost of a token only bya quarter.

Here is the general map before going into details:

• 40 causal Transformer layers, organized in one causal encoder of 20 layers followed by one decoder with 20 layers. The word “encoder” may seem surprising: here, it remains causal (it never looks ahead). It is simply the lower half of the network.
• Each layer combines a global attention (CSA2) and one local SWA attention, except the first two, in SWA alone.
• All feed-forward layers are DeepSeekMoE standard.
• One vision encoder (DeepSeek-ViT) and a MLP projector transform the images into embeddeds processed with the text from the beginning of pre-training.
• Four additional components: Single-Pass mHC (residual connections), Engram (a memory searchable by hash), DSpark (speculative decoding) andHierarchical sparse indexer.

For the curious, here is the configuration given in section 4.2.1 of the report. No need to remember everything: we will return to each important number over the chapters.

In agent workflows, tool calls generate a lot of prefill queries. When KV cache is not available (cache missIt is necessary to recalculate everything. YoCo (You Only Cache Once, Sun et al., 2024). In YoCo, the upper half of the layers directly reuses the KV cache produced by the lower half. CED builds on this idea and adds structural improvements to increase the KV cache capacity and the computational depth that produces it.

The L/2 = 20 layers from the bottom form the causal encoder. For the top layers (decoder, l > L/2), global KV entries are not not calculated from their own hidden state H_l. They are projected directly from the hidden state of the last layer of the encoder, H_L/2, with weights specific to each layer:

Combined with CSA2 (Chapter 5), this is the layer of the decoder in Full mode which calculates its global KV from H_L/2. The other layers of the decoder reuse this KV.

For the slippery window attention, CED keeps the classic calculation layer per layer : the local keys and values of the layer l come from his own hidden state H_lThis increases the "calculation depth" of the local KV, but creates an awkward dependency.

For the decoder to start generating, it needs the KV SWA of the last 128 tokens in each of its layersNow the window of layer 30 depends on the outputs of layer 29 on a larger window, which itself depend on layer 28 on an even larger window... The windows pile up. Reconstitute exactly these states requires to pass about n_win × L/2 = 128 × 20 = 2 560 tokens in the decoder layers.

For multi-round interactions with short messages, this additional cost becomes important: we would replay 2,560 tokens to read only a few hundred new ones. Fortunately, previous work (Chen et al., 2025) showed that the effective receiving field SWA is much smaller than the theoretical field n_win × L/2. Hence the Decoder SWA Bounded Replay : the decoder only passes the last 128 tokens The resulting states are approximate, and the paper notes a "negligible" impact on the quality of the responses. The mechanism is detailed in Chapter 8.

During the prefill, almost all the tokens of the prompt pass through only the 20 layers of the encoder. Only the last 128 pass through the bounded replay. A token of prompt only activates about half of the parameters: 8 B. A token generated during the decode goes through the 40 layers: 16 B. Since agent charges are dominated by reading, the 8 B figure weighs the most on the bill.

The authors break down the cost of the KV cache into three dimensions multiplicative :

• The size of each entry : GQA reduces the number of KV heads; MLA (DeepSeek-V2/V3) shares a small latent vector between all heads.
• The Sequence Dimension : one compresses m consecutive single entry tokens, such as CSA and HCA in V4.
• The dimension of the layers : some layers reuse the cache or selections of other layers instead of keeping theirs.

The axis of the layers had already been explored. IndexCache re-uses top-k indices from one layer to another; YOIO calculates sparse routing only once for the entire network; HySparse re-uses the KV of dense layers by sparse layers. But each of these methods has a limit, according to the authors. Reusing the indices does not save the main KV storage. Sharing routing throughout the network limits performance. Hybrid designs keep layers of attention complete. Above all, none covers the three axes at once. CSA2 combines them.

Like CSA, each CSA2 layer contains:

• the main KV : the entries of the global cache, each summarising m consecutive tokens. m = 1, without compression, is a special case, used in the decoder;
• one light indexer : it notes each entry of the main KV by combining a indexer Q (calculated for the query) and one indexer K (one per entry), then keep the top 512 ;
• l'main attention : the request (main Q) reads the selected entries and the local KV SWA of the layer.

CSA2 simplifies also two things in relation to CSA:

1. In CSA, with a ratio m, each entry was made from 2m original entries, with overlap between adjacent inputs and absolute position encoding. CSA2 eliminates overlap and absolute encoding.
2. CSA calculated the K indexer by a separate compression path, from the hidden states. CSA2 gets the K indexer by a simple Hand projection KV.

Both changes simplify implementation and speed up training.

Each CSA2 layer receives, statically (fixed in the architecture), one of the three modes. In all three cases, the layer calculates its own query (hand Q) and its own KV SWA, and produces a new attention output. Modes differ in how they get three things: main KV, l'indexer K and top-k indices.

Two distinct mechanisms are at work, and the paper insists on their decoupling :

• Share the main KV and indexer K reduced the storage I'm in hiding.
• Reuse top-k indices avoids computation of the indexer.

Reindex mode is the intermediate: storage is shared, but the layer itself chooses which entries to read. The selection can thus evolve from layer to layer.

The exact distribution of modes (section 4.2.1):

• Encoder : 0 and 1 layers in pure SWA, then 18 layers CSA2 with m = 2, in 3 identical groups of 6 layers: 1 Full + 5 Reuse.
• Decoder : 20 layers CSA2 with m = 1, in 5 groups of 4. First group: 1 Full + 3 Reuse. The next four groups: 1 Reindex + 3 Reuse. The Full layer of the decoder calculates its global KV since the encoder output (CED).

The paper announces 890 bytes of global KV per token, without detailing the calculation. exactly from published hyperparameters:

• Only the layers Full store a global KV: 3 in the encoder (with m = 2, or 1⁄2 input per token each) and 1 in the decoder (m = 1, 1 input per token). Total: 3 × 1⁄2 + 1 = 2.5 entries per token.
• An entry of main KV a 512 channels. In FP4, this is 512 × 4 bits = 256 bytes, plus an E4M3 scale of 1 byte per block of 16 channels (32 bytes). Total: 288 bytes.
• One indexer K dimension 128 in MXFP4 format is 64 bytes, plus 4 scales of 1 byte (one per block of 32). Total: 68 bytes.
• 2.5 × (288 + 68) = 2.5 × 356 = 890 bytes.

Previous work (Xu et al., 2026) made the indexer himself sparse: they first noted block-mediated representations, then looked in detail at only the best blocks. The authors note that, in the decoder, the information of the shallow indexers can naturally restrict the candidates of the deeper indexers, without any additional condition.

The mechanism, used only in the decoder CED:

For a fixed pool size, the cost per request of deep indexers goes from linear in the length of context to constant. Only the first Full layer continues to browse the entire context.

DeepSeek-V4 already used thequantification conscious training (QAT) to store in FP4 requests and keysindexer. This accelerated indexing and reduced the indexer cache. For these tensors, DeepSeek chose the standard format MXFP4 of the OCP, compatible with as many materials as possible, even if other formats were more precise in their experiments.

V4.1 extends the QAT to main KV. Here, FP4 is not used to accelerate matrice multiplications, only at reduce storage. Values are decompressed before attention. Therefore, one can choose a more precise format than MXFP4 without requiring that the material be able to multiply natively in this format.

Each value is a floating 4 bit number E2M1 : 1 bit of sign, 2 bits of exponent, 1 bit of mantisse. It can only represent 8 amplitudes :

To cover larger or smaller values, each block of 16 channels share a scale factor stored in E4M3 (an 8-bit float). This is the NVFP4 schema. without the second global scale. Why can we do without it? The authors justify it by calculating the limits:

• The format can represent up to 448 (maximum of E4M3) × 6 (maximum of E2M1) = 2 688.
• After normalisation of RMS (RMSNorm weight driven ≤ ~1), the L2 standard of the 512 channel latent vector is at most s512. RoPE rotation preserves this standard, so no value exceeds 22.6.
• In practice, the maximum observed during training revolves around 10.

The margin is huge. Delete the global scale therefore does not cost "no measurable loss of precision" and simplifies the layout of the cache.

• QAT during post-training : the model learns to work with a FP4 cache.
• Same format for the part with RoPE and the part without RoPE of the vector.
• Quantification after RoPE quantification before provided only a marginal gain in precision and would have added work to each decode step.
• KV SWA remains in FP8, because it is more sensitive to quantification.

Compared to the main KV in FP8 of V4, this format divides almost by two The print, in HBM as on SSD. An input of 512 channels is increased from 512 bytes to 288 bytes.

In the deployment of V4, a persistent cache on SSD, with a LRU eviction policy (we throw away what has been used the least recently), separately manages two types of KV:

• the global KV, stored in full: one hit allows you to reuse the entire prefix;
• the SWA KV, stored in two specific places: the end of the prompt and the end of the answer. This allows to regenerate a response or to continue a conversation from this point.

The cache was dimensioned so that both types remained resident more than 72 hours problem: although we only keep n_win SWA entries at these positions, this uncompressed KV SWA occupied almost half the ability of the persistent cache, especially in short-round conversations.

The V4 report already proposed a "Zero SWA Caching": do not store the KV SWA and recalculate it if it is missing. But reconstruction exact requires a complete pass on L × n_win tokens, a cost considered prohibitive in production.

SWA dependencies accumulate from layer to layer (see cone of chapter 4) The limited replay therefore accepts states approximate : he only replays the n_win last tokens and truncates SWA attention to the replayed segment. For a replay starting at the position s, a request in position i only look at the SWA keys in the meantime:

The reduction of the persistent cache by 8 is the result of two factors which multiply:

In a classic Transformer, a single "residual flow" crosses the layers: each block reads this flow, calculates, and adds its result. mHC (manifold-constrained Hyper-Connections, Xie et al., 2026), introduced in V4, maintains n residual flows in parallel (n = 4 in V4.1. For each token, these fluxes form a matrix X_l ∈ ℝ^n×d, updated as follows:

Ideally, the transition between two blocks would be one operation: read (n + 1)d values (flows + output from previous block) and write them (n + 1)d. This gives a lower bound of (2n + 2)d V4 used in practice three successive cores, due to data dependencies:

Single-Pass mHC offsets the input mixing coefficients of a block. Each block uses the coefficients A produced by the previous block:

In pre-training, DeepSeek keeps the multi-core implementation: the offset only changes the coefficients applied by each block. In deployment, a single merged kernel, Mega-mHC, updates the residual, the input mixture, the coefficient prediction, the pre-normalization and the FP8 conversion. The residual is read once and written once: you reach the ideal terminal and you split by two the memory traffic of the activations in relation to the original implementation.

Engram (Cheng et al., 2026) is a conditional memory The idea: a lot of knowledge is linked to precise tokens ("Route Eiffel", "import numpy as"...). Instead of having them "recalculated" by the layers, they are stored in huge tables of embeddings, addressed by a N-gram hashing before the current token. For each token, we read a few table lines: it is a memory access, not a heavy calculation.

V4.1 repeats the original design: compression of vocabulary (tokenizer compression), multi-head hash, door (gating) depending on context, multi-branch integration. It makes two changes:

1. the short causal convolution is withdrawn : its gains did not justify the added complexity in the inference engine;
2. tables are optimized by a update to momentum followed by a balance of Sinkhorn (chapter 13).

Critical point for inference: Addressing is deterministic. The lines to be read depend only on the input tokens, not on the calculations of the network. preload from host memory For the first module (layer 1), this preload is done during the calculation of the first Transformer block. Thus, these 196 B of parameters do not occupy the precious HBM.

At training, the same principle allows preloading for the entire local lot before each stage of the pipeline begins. The tables are partitioned by lines between groups of dedicated processes. During rollouts of RL, on the other hand, they remain in GPU memory to relieve the memory of the host.

A small fast model (the drafter) offers several tokens in advance. The large model verifies them all in one pass, as a mini-prefill. We keep the longest prefix accepted, plus a token that the large model produces itself at the pass. If the draft is good, we advance several tokens for the price of a decode step.

• Drafter : 3 Transform blocks with a 128 token slippery attention window.
• Semi-autoregressive draft : only one pass in these blocks calculates the basic logits for 5 positions of draft in parallelA light Markov head then modulates the dependencies between these tokens.
• A confidence head predicts, for each position, the conditional probability of acceptance, deducing the probability of "survival" of each prefix.
• The scheduler combines these estimates with measured flow curves on the engine. He chooses dynamically, for each request, how many tokens check, in order to maximize the expected total flow under the current load.

Unlike the DeepSeek-V3 MTP module, trained with the backbone during all pre-training, DSpark arrives in a dedicated step after pre-training. Only DSpark is trained, the backbone remains frozen. During post-training, DSpark continues to be trained with the backbone, but without propagating gradient It thus remains aligned with the evolving policy. It then accelerates both the online service and the generation of rollouts for RL and distillation (OPD).

The visual encoder follows the Vision Transformer architecture with several modifications, all thought to look more like a LLM:

• 2D-RoPE instead of absolute positions, to accept arbitrary resolutions;
• the patch embedding convolution is replaced by a linear projection, compatible with the Muon Optimizer;
• RMSNorm and SwiGLU, as in the backbone ;
• 32 layers, size 1,024, 16 heads. Resolutions are supported up to about 1 344 × 1 344 pixels.

His training takes place in two stages, before integration into the backbone:

During pre-training of the complete model, the visual encoder remains frozen Only its final normalization and the projector remain trainingable. It is then thawed and optimized with the LLM, with a lower learning rate.

DeepSeek balances the load of MoE experts without auxiliary loss. Each expert has a correction bias added to the routing score: we lower it if the expert is overloaded, we mount it if it is underused. Problem: image and text tokens do not have the same preferences. Balance the load total can cache a strong imbalance within of each modality.

V4.1 therefore maintains two sets of biases, one for text and one for images. Each token chooses its experts with the biases of its modality, but weighs their outputs with the original scores. After each step, the two games are updated independently, with a speed of 0.001.

Muon can be seen as a gradient descent preconditioned : it "orthogonalizes" the updating of a weight matrix before applying it (iterations of Newton-Schulz). one pre-conditioner for the entire query matrix, therefore for all heads at once. Muon per head First cut this matrix head by head. Each head receives its own preconditioner, which better manages the heterogeneity between attention heads. DeepSeek observes that it surpasses the standard Muon; GLM 5 and Kimi-K3 made the same observation.

Applying Adam to the 196 B of Engram's parameters would have blew up the memory. two states per parameter (mean and variance of gradients). DeepSeek instead uses a momentum update (one state, like Muon) followed by a Sinkhorn balancingShe surpasses Adam empirically.

The procedure follows the same pattern as Muon, replacing orthogonalisation with alternating standardization of the rows and columns the update:

• a line corresponds to a token or N-gram (the identity to be stored), a column with a hidden dimension;
• each row, then each column, is divided alternately by its standard. With an odd number of steps (K = 11), one ends up normalizing the lines;
• multiply byn to switch from a unit L2 standard to a unit RMS per line;
• near-zero rows (norm ≤ τ × mean) are masked for numerical stability;
• the learning rate is corrected by γ = 0.18 to equal the amplitude of Adam's updates (near 0.2 used in Moonlight).

Result: RMS per line and per column of the update are approximately equal to 1.

In the contrasting phase of the visual encoder, the loss is calculated over the whole batch. Therefore, it is necessary to collect (all-gather) the text and image vectors of all the machines, which represents a lot of communication. But the gradient of the text vectors depends only on the collected image vectors, and vice versa. while a useful calculation:

With CSA2, a layer can reuse the main KV, the K indexer or the clues of another layer. However, these layers can be found on different stages of the pipeline, so on different GPUs. Three mechanisms make this transparent:

• Ghost indexers (shadow indexers) : a light and executable replica on each stage concerned, with only one logical owner of the shared parameters. The owner manages the optimization and checkpoints. Synchronization of the parameters and aggregation of the gradients keep the replicas consistent.
• Extensions of pipeline payload : intermediate representations and route information travel with existing point-to-point communications when the source and the consumer are on either side of a floor border.
• Management of micro-lot shared statements : one tracks the lifetime of each state shared through forward, recalculation of activations and backward. Each one is released as soon as its last consumer has finished.

The two pipelines are merged: when a sample exists in text and multimodal version, the multimodal version replaces the other. The final corpus has a ratio of 7:1 between text tokens alone and multimodal tokens. The sequence filling algorithm (best-fit packing) reached a padding rate of not more than 10⁻⁴.

The lot is fixed at 100.6 million tokens during all training. sparse attention is trained from the start at a sequence length of 64K, without heating phase in dense attention. The sequence passes to 1M 34T tokens. The paper states: "without any instability".

Table 1 compares three core models evaluated in the same internal framework: V4-Flash-Base (284 B, 13 B activated), V4-Pro-Base (1.6 T, 49 B activated) and V4.1-Flash-Base (552 B, 8/16 B activated). Variations of 0.3 point or less are considered equivalent.

To measure real-world R&D capabilities, the team also measures the perplexity on internal corpuses never seen: internal documentation, proprietary code repositories, academic documents. The metric is the number of bits per byte (BPB, bits-per-byte) : the lower it is, the better the "compress" model, so predicted, the text.

The recipe is standard: SFT (fine-tuning supervised), then RL (learning by strengthening), then OPD (distillation on-policy), without any change from V4. The effort consists of three steps:

1. synthesize various tasks and verifiable, with their reference solutions and reward signals;
2. to construct by procedural agent environments interactive ways to collect and evaluate low-cost trajectories;
3. Filter, deduce and calibrate the difficulty.

Each task is one triplet (problem, environment, verification system) Its quality is judged on two axes: difficulty (not trivial) and the correction (no critical flaws in all three components). The model starts to know how to build its own training tasks. DeepSeek therefore trains it to build better ones, with difficulty and correction as rewards. Each task is monitored throughout its life: each new use in RL provides trajectories that allow it to be re-audited.

The large-scale asynchronous RL is pushed in two directions: computation training and training number of scaffolds (the "harnesses" of agents: Claude Code, OpenCode, Pi, DeepSeek Harness...). Performance continues to rise with the steps of RL, whether in a single scaffold, between versions of the same scaffold or between heterogeneous scaffolds.

Two engineering ideas accompany this move to scale:

• Separate scaffold from control : one agent sandbox spins the scaffold and its tools. worker container orchestrate the rollout independently of the scaffold and normalize interactions in a common trajectory format. Both spin out of the pre-emptible GPU pool. If the trainer is pre-empted, the rollout can be suspended and unloaded with all its condition.
• Merge models to restart : Checkpoints are merged from training on different scaffolds or configurations to reset the next training. This combines progress achieved by different optimisation paths, and increases in performance and efficiency in tokens.

To train agents, you need environments where they actually execute code. DSec (DeepSeek Elastic Compute) is the deepseek sandbox platform. For V4.1, the demand is increased to millions of simultaneous instances.

In RL for LLM, some very long answers always delay the whole lot: this is the problem of the long tail. The generation has therefore become asynchronous for almost all tasks of RL and OPD. Rollout and training share the same GPU, in shared time. Each task sets a maximum of samples "in flight". when Relaunching new prompt:

During the RL, the following instruction is added at the top of the prompt system:

For each training prompt x, several responses are sampled at each level of effort b. The same answers (x, b) form a subgroup, in which rewards are centered to calculate relative benefits, such as GRPO. never directly Two levels of effort between them. The specific behavior at each level comes from a penalty of length that depends on b :

The public API, launched in September 2026, offers three steps that correspond directly to this setting. We change the operating point without touching the weights or decoding parameters:

Training uses only a finite number of levels, but intermediate values give interpolated behaviors.

The winnings are concentrated at the beginning. The 60–80 range already recovers most of the precision of the maximum adjustment, for less than half of its budget in tokens. The last step towards 100 extends the agent trajectories from 1.6 to 1.8× for marginal gains. The max level is therefore to be reserved for the most difficult tasks.

The annex details the eight reasoning benchmarks. Length increases steadily, from 2.0 to 3.1× between forces 25 and 100: from 4.6k to 11.4k tokens on AIME 2026, from 29.1k to 86.1k on MathArena Apex 2025. Accuracy does not decrease on any benchmarks: +40.3 points on MathArena Apex 2025 (25.3 → 65.6%), 100% on AIME 2026. In code scaffolds, however, the length always increases with effort, but the Pass@1 follows only from afar, with plateaus and hollows.

• Reasoning : GPQA Diamond, Humanity’s Last Exam (HLE), Codeforces (internal benchmark), MathArena Apex.
• Code agents : Terminal-Bench 2.1 / 3.0 / 4.0, DeepSWE v1.1, ProgramBench, NL2Repo-Bench. Rated with DeepSeek Harness Minimal Mode, 1M context tokens, temperature 1.0, top-p 0.95 (mini-SWE for DeepSWE).
• Cybersecurity : SEC-Bench Pro, CyberGym, ExploitGym.
• General-purpose agents : AutomationBench, Agents' Last Exam.
• Vision agents : Chartography, BabyVision, ZeroBench (with the harness Claude Code, context of 512k).

To limit cheating in code evaluations, internet access is cut, Git history is removed and compilation or package caches are purged. However, exploit searching behaviors have been observed, such as decompiling Ubuntu packages to find vulnerabilities in CyberGym. The authors call on the community to take this into account in future benchmarks.

A model is rarely deployed in a single harness. The authors keep the same checkpoint, the same decoding configuration and the same tasks, and only change the scaffold (prompt system, tools, turn logic): eight configurations from six families.

Capabilities are transferred well between scaffold families, which is consistent with the diversity of environments and tool formats of synthesized data. On Claude Code, four versions tested give on average 68.9 % on DeepSWE and 87.8 % on Terminal-Bench 2.1 (annex, table 5).

Preliminary experience: the mode Agent Team DeepSeek Harness. A chief agent asynchronously creates appointed and persistent teammates (spawn_teammate) Each starts either "new" or with a copy of the leader's history (fork) All share the same checkout of the deposit. They communicate through a durable mailbox (send_message) The Chief monitors the status of the team (list_agents, wait_agent), can interrupt a partner (interrupt_agent) and maintains a shared task table. At the end, it rereads, tests and books.

RL training combines three terms: task performance, a collaboration bonus (delegate, communicate) and latency penalty derived. This latency is the length of the critical path An acyclic graph of events: costs in tokens are converted at fixed prefill/decode speeds, plus the measured time of the tools, thus encouraging useful parallelism and penalising unnecessary waiting.

The next priorities announced are:

• extend stress tests, especially the research on very long contexts and the SWA reconstruction at the borders of recovery of the cache ;
• monitor actual loads to characterize failure modes;
• Continue to evolve the evaluation protocols, as benchmarks saturate. Close scores do not mean capabilities equal to the best closed systems on the toughest problems. The paper quotes Fable-5 and GPT-6 Astra as leading references;
• growing together data, model capacity and RL, and co-design the model with its agent harness (model–harness co-design).

The ambition displayed: lower costs and increase capabilities at the same time, to make agents very capable more accessible and easier to deploy.

• The full technical report: local copy (PDF, 51 pages) · on Hugging Face
• Checkpoints of the model: huggingface.co/deepseek-ai/DeepSeek-V4.1-Flash
• The work on which it is based, cited in the report: YoCo (Sun et al., 2024), mHC (Xie et al., 2026), Engram (Cheng et al., 2026), DSpark (Cheng et al., 2026), DeepSeek-V4 (DeepSeek-AI, 2026).