Open Models Almanac
ModelsDeepSeek-V4.1-Flash

DeepSeek · usage rank #3

DeepSeek-V4.1-Flash

What DeepSeek-V4.1-Flash’s own documents say it is built from — every method with the sentence that describes it.

Parameters
552B / 16B active
Context
1M
Attention
sparse (indexer)MLA + Compressed Sparse Attention 2 (Full/Reindex/Reuse modes, hierarchical indexer) + SWA, Causal Encoder-Decoder
Experts
384 routed + 1 shared, top-6; plus 196B Engram memory params
Input
text, image
Licence
MIT
Released
2026-09-10

Rank by open-weight tokens on OpenRouter, week of 2026-10-26.

Against the consensus recipe

Its documents state 2 of the 18 methods the field agrees on.

The recipe from the overview: the methods the most labs adopt, per stage. A missing one is something its documents do not say, not something the model lacks.
  1. Data curation

  2. Training objective

  3. Model architecture

  4. Optimization

  5. Post-training

  6. Inference & serving

Checked in its code

Its code shows 12 of the 19 architecture features checked — 11 of them are not stated in its documents.

Sources say what a lab chose to describe; the modeling code says what the checkpoint runs. Each feature below was put to a code verifier, and only the config values and source lines it cited that were found in the files are shown, linked to the line.

Read from vLLM (__init__.py, quant_config.py, dspark.py, mm_preprocess.py, model.py, engram.py, mhc.py, mega_mhc.py, decode.py, flashinfer_sparse.py, indexer.py, candidate_topk.py) and config.json at revision 314113f8a7, by anthropic/claude-sonnet-5 on 2026-11-07.

FeatureCodeIts documentsVerdict
Grouped-query attention not in its codenot stated

This model uses multi-head latent attention (MLA) with a shared low-rank KV latent, not grouped-query attention; num_key_value_heads=1…

show evidence

This model uses multi-head latent attention (MLA) with a shared low-rank KV latent, not grouped-query attention; num_key_value_heads=1 here reflects the MLA latent cache layout, not a GQA KV-head group.

text_config.num_attention_heads = 64text_config.num_key_value_heads = 1
Multi-head latent attention code only in its codenot stated

The attention mechanism is DeepSeek-style MLA with q_lora_rank/kv-related ranks and a decoupled RoPE key dimension configured in…

show evidence

The attention mechanism is DeepSeek-style MLA with q_lora_rank/kv-related ranks and a decoupled RoPE key dimension configured in text_config.

text_config.q_lora_rank = 1280text_config.qk_rope_head_dim = 64text_config.head_dim = 512
    def _select_dsv4_attn_cls(vllm_config: VllmConfig) -> type[DeepseekV4Attention]:
model.py · L203
Sliding-window attention code only in its codenot stated

text_config.sliding_window is 128 and the model builds an SWA KV cache layer (swa_cache_layer) used across decoder layers and…

show evidence

text_config.sliding_window is 128 and the model builds an SWA KV cache layer (swa_cache_layer) used across decoder layers and decoder-replay logic.

text_config.sliding_window = 128
            self.decoder_replay_layers = DecoderReplayLayers(
                config.sliding_window,
                self._run_replay_layers,
model.py · L901–903
Interleaved sliding-window and global attention code only in its codenot stated

compress_ratios defines a per-layer pattern where some layers are SWA-only (ratio 0) and others combine SWA with a compressed/global KV…

show evidence

compress_ratios defines a per-layer pattern where some layers are SWA-only (ratio 0) and others combine SWA with a compressed/global KV source (ratio 1 or 2), giving a fixed interleaving of local and global attention across the 40 layers.

text_config.compress_ratios = [0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1…text_config.kv_source_layer_ids = [2, 8, 14, 20]
        cut = max(config.kv_source_layer_ids)
        if (
            cut < self.end_layer - 1
            and self._decoder_replay_supported(vllm_config, cut)
model.py · L882–885
Indexer-selected sparse attention (DeepSeek Sparse Attention) code only in its codenot stated

An indexer (DeepseekV4Indexer / SparseAttnIndexer / SparseMQAIndexer) scores past tokens and selects index_topk=512 tokens per query…

show evidence

An indexer (DeepseekV4Indexer / SparseAttnIndexer / SparseMQAIndexer) scores past tokens and selects index_topk=512 tokens per query, configured with index_n_heads/index_head_dim, DeepSeek Sparse Attention style.

text_config.index_topk = 512text_config.index_n_heads = 32text_config.index_head_dim = 128
op.topk_indices_buffer[:num_tokens] = -1
    schedule = decode.schedule_metadata
indexer.py · L260–261
Linear-attention or state-space layers alongside full attention not in its codenot stated

No linear-attention, SSM, Mamba, or lightning-attention token mixer is present; all layers use (sparse) softmax MLA attention, varying…

show the whole verdict

No linear-attention, SSM, Mamba, or lightning-attention token mixer is present; all layers use (sparse) softmax MLA attention, varying only in compression/window pattern.

Gated DeltaNet layers not in its codenot stated

No gated delta rule / delta-net recurrent layer implementation appears in the given files; the model's token mixer is MLA attention…

show the whole verdict

No gated delta rule / delta-net recurrent layer implementation appears in the given files; the model's token mixer is MLA attention throughout.

Mamba-2 layers not in its codenot stated

No Mamba-2 SSD state-space block implementation is present in the provided code or config.

Learnable attention sink code only in its codenot stated

Attention layers pass a learned attn_sink into the sparse MLA kernels as a per-head sink logit absorbing softmax probability mass.

show evidence
                out=decode_output,
                bmm1_scale=bmm1_scale,
                bmm2_scale=bmm2_scale,
                sinks=self.attn_sink,
                cum_seq_lens_q=decode_cu,
                max_q_len=max_decode_query_len,
            )
flashinfer_sparse.py · L540–546
Gated attention output code unclearnot stated

The attention/o_proj implementation (dsv41_o_proj) is imported from files not included here, so whether the attention output is multiplied…

show the whole verdict

The attention/o_proj implementation (dsv41_o_proj) is imported from files not included here, so whether the attention output is multiplied by an input-dependent sigmoid gate cannot be confirmed from the given code.

QK normalization code unclearnot stated

The DeepseekV4Attention base class (which would implement any q/k normalization before the dot product) is imported from a file not…

show the whole verdict

The DeepseekV4Attention base class (which would implement any q/k normalization before the dot product) is imported from a file not included in the provided sources, so this cannot be confirmed.

Partial RoPE code only in its codenot stated

qk_rope_head_dim (64) is smaller than head_dim (512), indicating only part of each head carries RoPE (DeepSeek-style decoupled RoPE key)…

show evidence

qk_rope_head_dim (64) is smaller than head_dim (512), indicating only part of each head carries RoPE (DeepSeek-style decoupled RoPE key), consistent with MLA's partial rotary key.

text_config.qk_rope_head_dim = 64text_config.head_dim = 512
YaRN RoPE scaling code only in its codenot stated

rope_scaling in text_config sets rope_type to yarn with factor 16 and associated beta parameters, and the model's rotary embedding…

show evidence

rope_scaling in text_config sets rope_type to yarn with factor 16 and associated beta parameters, and the model's rotary embedding (rotary_emb.cos_sin_cache) consumes this config.

text_config.rope_scaling = {"rope_type": "yarn", "factor": 16, "beta_fast": 32, "beta_slow": 1, "origina…
attn.rotary_emb.cos_sin_cache,
dspark.py · L284
Layers without positional encoding (NoPE) code unclearnot stated

No explicit no_rope_layers/nope_layer_interval config key or code path is visible in the given files to determine whether some softmax…

show the whole verdict

No explicit no_rope_layers/nope_layer_interval config key or code path is visible in the given files to determine whether some softmax attention layers skip positional encoding entirely.

Mixture of experts in its codeadopted

Feed-forward layers route tokens to a subset of 384 routed experts (6 per token) via a learned router/gate, implemented in DeepseekV4MoE.

show evidencetext_config.n_routed_experts = 384text_config.num_experts_per_tok = 6
        config = vllm_config.model_config.hf_config
        n_routed_experts = config.n_routed_experts
        n_activated_experts = config.num_experts_per_tok
model.py · L139–141
Shared expert code only in its codenot stated

MoE layers include n_shared_experts=1 shared expert(s) that every token passes through, loaded/handled via shared_experts weight paths.

show evidencetext_config.n_shared_experts = 1
            if ".shared_experts." in name:
                if is_pp_missing_parameter(name, self):
                    continue
                experts = self.layers[extract_layer_index(name)].ffn.experts
model.py · L1395–1398
Auxiliary-loss-free load balancing (selection bias) code only in its codenot stated

topk_method is noaux_tc (DeepSeek-V3-style) and the gate carries an e_score_correction_bias used only for expert selection, as referenced…

show evidence

topk_method is noaux_tc (DeepSeek-V3-style) and the gate carries an e_score_correction_bias used only for expert selection, as referenced in weight remapping.

text_config.topk_method = "noaux_tc"
                if name.endswith(".ffn.gate.bias"):
                    name = name.replace(
                        ".ffn.gate.bias", ".ffn.gate.e_score_correction_bias"
                    )
dspark.py · L519–522
Multi-token prediction layers code only in its codenot stated

num_nextn_predict_layers=3 declares MTP modules, and the DSpark/MTP draft model code loads mtp.{0,1,2}.* weights from the target checkpoint.

show evidencetext_config.num_nextn_predict_layers = 3
        self.num_dspark_layers = (
            getattr(config, "n_mtp_layers", None)
            or getattr(config, "num_nextn_predict_layers", None)
            or 3
        )
dspark.py · L90–94
SwiGLU feed-forward code only in its codenot stated

hidden_act is silu and the MoE/MLP implementation uses gate_up_proj with w1 (gate) and w3 (up) stacking typical of SiLU-gated SwiGLU MLPs.

show evidencetext_config.hidden_act = "silu"
            ("gate_up_proj", "w1", 0),
            ("gate_up_proj", "w3", 1),
model.py · L1369–1370

filed at the root 2

Causal Encoder-Decoder (CED) core

“we adopt a Causal Encoder-Decoder (CED) architecture, in which decoder global KV is projected from the final encoder hidden states”

Asymmetric architecture core

“Asymmetric architecture. More intelligence, less cost.”

token mixer 7

softmax attention 1

sliding window attention 1

Decoder SWA Bounded Replay used

“Decoder SWA Bounded Replay, which only prefills the last 𝑛win tokens of the prompt for the SWA computation”

sparse attention 6

Compressed Sparse Attention 2 core

“we design Compressed Sparse Attention 2 (CSA2), which applies cross-layer reuse to global KV (including main KV and indexer K) and Top-K…”

CSA2 Full, Reindex, and Reuse modes core

“CSA2 has three statically assigned modes: Full, Reindex, and Reuse.”

Progressive context-length extension for sparse attention used

“with sparse attention trained at a sequence length of 64K and context extended to 1M tokens at 34T tokens”

Sparse attention training from scratch without dense-attention warmup used

“Sparse attention is trained from scratch at a sequence length of 64K, without any dense attention warmup stages.”

sparse attention indexer 2

Hierarchical Sparse Indexer core

“the first layer assigned to Full Mode constructs a candidate pool that later re-indexing layers use as their search domain”

CSA2 compressor and indexer design core

“CSA2 removes this overlap and absolute positional embedding. In addition, CSA2 obtains indexer K by projecting main KV entries”

channel mixer 3

mixture of experts 3

Mixture of experts core

“DeepSeek-V4.1-Flash, a multimodal Mixture-of-Experts (MoE) model”

Asymmetric input/output parameter activation core

“It activates 8B parameters on input and 16B on output from a 552B-parameter backbone, an asymmetric split”

expert load balancing 1

Modality-specific load balancing core

“we introduce modality-specific load balancing ... for image and text tokens”

positional encoding 1

2D rotary position embeddings used

“A vision encoder (DeepSeek-ViT, trained from scratch with 2D-RoPE and 3×3 pixel-unshuffle downsampling)”

normalization & residual 2

Single-Pass mHC core

“we upgrade the originalmHC ... design to Single-PassmHC”

Manifold-Constrained Hyper-Connections used

“In DeepSeek-V4, we introducedmHC ... which maintains 𝑛 residual streams between adjacent Transformer blocks.”

multimodal architecture 3

Joint vision-language pre-training from the start core

“visual and text embeddings trained jointly from the start of pre-training rather than added afterward”

3×3 PixelUnshuffle downsampling used

“we apply a pixel-unshuffle operation with 3× 3 downsampling to reduce the visual token count by a factor of nine”

Two-layer MLP vision projector used

“a two-layer MLP projector convert images into visual embeddings”

context capacity 1

Engram core

“we integrate the Engram ... conditional memory module to strengthen model capabilities”

training stability 1

Loss masking for excessively stale tokens used

“we add a loss masking scheme that eliminates the contribution of tokens with excessive staleness”

training runtime 1

Checkpoint merging used

“we merge checkpoints from runs across different scaffolds or configurations, combining improvements acquired along different optimization…”

filed at the root 1

Large-scale multimodal pretraining data used

“we train DeepSeek-V4.1-Flash on a large-scale multimodal corpus comprising 45T tokens”

data sourcing 2

Star-threshold filtering of public GitHub repositories used

“public GitHub repositories that meet a star-count threshold”

Voluntary workflow interaction-data collection used

“on a voluntary basis, return interaction data and feedback”

data filtering 1

Filtering and trajectory deduplication of coding-agent sessions used

“filtered to retain highly complex tasks or tasks on which model performance is poor, then deduplicated by trajectory”

synthetic data 7

Automated large-scale data synthesis and environment construction core

“we invest in large-scale, automated pipelines for data synthesis and environment construction”

Automated synthesis of agent tasks and environments with progressive scaling core

“All substantive changes lie instead in the data pipeline: large-scale automated synthesis of agent tasks and environments with progressive…”

Procedural construction and scaling of interactive agent environments core

“procedurally constructs and scales interactive agent environments in which trajectories can be collected and evaluated at low cost”

Synthesis of verifiable training tasks, reference solutions, and reward signals core

“synthesizes diverse, verifiable training tasks together with their reference solutions and reward signals”

Agent screening of coding projects for container execution and automatic verification used

“an agent determines whether the project can be built and fully run inside a container and whether it can be automatically verified”

Agent-designed coding tasks with fail-to-pass and pass-to-pass evaluation points used

“designs several sufficiently complex implementation directions, and produces concrete evaluation points, including both fail-to-pass and…”

Iterative reward-guided training for task construction used

“Using difficulty and correctness as reward signals, we iteratively train the model to construct better tasks.”

data mixture & curriculum 1

Filtering, deduplication, and difficulty calibration of synthesized data core

“applies rigorous filtering, deduplication, and difficulty calibration to ensure data quality and curriculum balance”

filed at the root 1

SFT followed by reinforcement learning and on-policy distillation used

“the recipe follows the standard paradigm of supervised fine-tuning (SFT) followed by reinforcement learning (RL) and on-policy…”

reinforcement learning algorithm 3

Checkpoint merging for successive RL runs used

“we use model merging to reinitialize successive RL runs”

Concatenated routing replay used

“for samples that span multiple checkpoints, we concatenate the expert routing produced at each rollout segment rather than discarding and…”

Effort-conditioned subgroup reward centering used

“Responses sharing the same(𝑥,𝑏)form a subgroup, within which rewards are mean-centered to compute group-relative advantages.”

reward modelling 1

Reasoning-length penalty used

“we add the length-penalty term 𝑟 len 𝑏,𝑗 to the reward of response”

policy distillation 3

Dynamic Post-Training Recipe Reconfiguration used

“We continuously track model capabilities and may adjust the training recipe accordingly, including the dataset mixture, per-dataset…”

Full-Vocabulary On-Policy Distillation with Heterogeneous Teachers used

“the final full-vocabulary OPD task is trained on datasets from all domains using over 40 teacher models”

SFT–RL–On-Policy Distillation Post-Training Recipe used

“The post-training recipe follows the standard SFT → RL → on-policy distillation (OPD) paradigm without algorithmic modifications.”

rollout & RL infrastructure 15

Asynchronous reinforcement learning core

“we extend our post-training infrastructure to allow asynchronous generation of samples”

Compute-node sharding into scale units core

“we partition compute nodes into multiple shards (so-called scale units)”

Sample-level dispatch default

“Our final approach is sample-level dispatch”

Co-located rollout and training used

“We colocate rollout and training on the same physical devices and time-share their execution”

Asynchronous reinforcement learning on synthesized tasks used

“We use large-scale asynchronous RL in synthesized tasks to improve model performance and shape its behavior in complicated scenarios.”

Bounding off-policy sample ratio used

“we can bound the maximum off-policy ratio, ensuring that the training data does not deviate excessively from the current model”

Decoupled sandbox and worker-container architecture for RL rollouts used

“we decouple agent rollout execution into an agent sandbox and a worker container”

Per-dataset rollout concurrency limits used

“the dispatcher can limit concurrency on a per-dataset basis, which helps regulate the proportion of each dataset in the steady-state…”

Reuse of persisted rollout state without re-prefilling used

“the persisted states are directly reused, eliminating the cost of re-prefilling and allowing interrupted samples to continue exactly where…”

Sample-grained garbage collection used

“we perform sample-grained garbage collection, releasing each sample’s states as soon as it completes”

Scaffold-agnostic rollout control and trajectory normalization used

“provides a scaffold-agnostic control layer that orchestrates the rollout, normalizes heterogeneous interactions into a common trajectory…”

State-preserving suspension and resumption of rollouts used

“rollout execution can be suspended and offloaded while preserving its full state for later resumption”

Token-granular persistence of rollout state used

“rollout states such as KV cache and expert routing are persisted at token granularity during generation”

Token-level interruption of generation used

“we support token-level interruption: generation can be halted at any token boundary”

Discarding early-returned short samples optional

“we support discarding early-returned short samples to smooth the transition into the steady-state length distribution”

agentic post-training 12

Durable peer-mailbox communication core

“Agents communicate through a durable peer mailbox.”

Collaborative multi-agent construction of coding environments used

“Environment construction is carried out collaboratively by multiple specialized agents.”

Crash-as-failure trajectory handling used

“If an agent crashes its environment, we treat the crash as a failed trajectory and report a "repercussion" signal to the RL framework.”

Failure replay and targeted reinforcement learning used

“the pipeline enables systematic replay of failures and targeted reinforcement learning against observed model weaknesses”

Generating real-workflow agent environments from feedback and failure cases used

“incorporate them into the pipeline to generate both single-turn and multi-turn agent environments grounded in real workflows”

Independent multi-agent testing and inspection of coding environments used

“multiple distinct agents attempt the task, and an independent quality-inspection agent reviews the environment together with the solving…”

Isolated-container environment setup and packaging used

“sets up dependencies, the initial working directory, test code, and task descriptions in an isolated container, performs self-testing”

Iterative agent-led environment repair and reverification used

“If the inspection does not pass, a repair agent fixes all identified errors, adjusts evaluation points that are too easy or too difficult…”

Lifecycle monitoring and quality re-auditing of RL tasks used

“Whenever a task is used in a new RL run, the resulting trajectories provide fresh evidence for quality re-auditing.”

Mocked-tool construction for real-world interfaces used

“we construct a large set of mocked tools that reproduce the interfaces and behaviors of real-world tools and systems”

Multi-objective reinforcement-learning reward for agent collaboration used

“We train Agent Team mode with an RL reward combining task performance, a collaboration bonus that encourages delegation and inter-agent…”

Fresh or snapshot-based teammate initialization optional

“Each receives a delegated task and starts in either fresh mode without lead history or fork mode with a one-time snapshot of the lead’s…”

1 more mentioned or evaluated
Reinforcement learning mentioned

reinforcement learning algorithm “New pre-training methods + larger-scale RL post-training deliver benchmark results ahead of flagship models”

Not used 2

Batch-level rollout dispatch not used

rollout & RL infrastructure “we experimented with two alternative dispatch granularities. In the first attempt, we dispatched several extra batches at the beginning…”

Prompt-level rollout dispatch not used

rollout & RL infrastructure “In the second attempt, we switched to prompt-level dispatch, where a new prompt was dispatched after one GRPO group finishes, but found…”

decoding strategy 3

DSpark core

“We also introduce the DSpark ... speculative decoding architecture to improve decoding efficiency through semi-autoregressive draft…”

Confidence-scheduled verification core

“through semi-autoregressive draft generation and confidence-scheduled verification”

Semi-autoregressive draft generation core

“through semi-autoregressive draft generation and confidence-scheduled verification”

reasoning control 5

Continuously controllable reasoning effort core

“The scalar effort variable provides a deployment-time control over the cost–quality trade-off without imposing a hard token budget.”

Capped linear reasoning-token length deduction core

“rlen(ℓ,b)=−min{Cmax,k(b) ℓ/Lnorm}”

Effort-dependent exponential token-penalty schedule core

“During reinforcement learning, lower effort levels apply a stronger token penalty, whereas higher effort levels permit more computation.”

Preset effort tiers mapped to scalar values default

“In our public API service, we expose three preset effort levels that map onto this scale:low,high, andmaxcorrespond to effort values of…”

System-prompt reasoning-effort conditioning used

“we prepend the following instruction to the system prompt: Reasoning Effort: {effort}”

KV cache management 2

Compressed KV caching core

“Compared with the previous generation, V4.1-Flash's KV cache needs just: 1/4 the HBM, 1/8 the SSD storage”

SWA Bounded Replay core

“we introduce SWA Bounded Replay, which approximately reconstructs the required SWA KV states by replaying only the most recent 𝑛win tokens”

inference quantization 1

FP4 global KV-cache quantization core

“Combined with FP4 main KV caching (E2M1 format, one E4M3 scale per 16 channels), these designs reduce the global KV cache footprint to 890…”

inference scheduling 5

Independent replica placement using predicted resource availability core

“Each replica predicts resource availability from recent measurements and makes good-enough placement decisions.”

Latency-sensitive execution class core

“DSec therefore introduces a latency-sensitive (LS) execution class.”

Node-local placement validation with hard admission control core

“each node is responsible for validating the final placement decisions, enforcing a hard admission constraint”

SCHED_IDLE prioritization for non-latency-sensitive tasks core

“We apply SCHED_IDLE to non-LS tasks to minimize their scheduling priority”

Sub-NUMA partitioning with NUMA-local worker VMs core

“we use hardware-supported sub-NUMA partitioning and bind each worker VM to an individual NUMA domain”

inference kernel 1

Mega-mHC used

“with an accompanying Mega-mHC deployment kernel that halves activation memory traffic relative to the original four-kernel implementation”

agentic scaffolding 1

Agent Team mode core

“All agents share one repository checkout, making edits immediately visible to one another.”

kernel & quantization library 1

deepseek-recipe optional

“we additionally release deepseek-recipe, a set of Rust libraries with Python bindings that provides the same prompt format as a…”

infrastructure service 3

Core scheduling by priority class core

“use core scheduling to ensure only tasks of the same priority class execute simultaneously on sibling hyperthreads to eliminate interference”

Relaxed-consistency sandbox placement engine core

“DSec employs a custom placement engine to schedule the large number of sandboxes, by trading strong global consistency for scalability”

Sharding and relaxed-consistency scheduling core

“DSec scales through two complementary mechanisms: sharding and scheduling with relaxed consistency.”

filed at the root 3

DAG critical-path latency measurement used

“Derived latency is computed by representing execution events and their collaboration dependencies as a directed acyclic graph (DAG)…”

Score equivalence threshold used

“Scores within 0.3 of each other are considered equivalent.”

Standardized agent evaluation protocol used

“All scaffolds use N=8 samples per task on DeepSWE v1.1 and N=3 on Terminal-Bench 2.1, with Linux containers, temperature=1.0, top_p=0.95…”

cybersecurity - vulnerability discovery; exploit development 2

Internet restriction and Git-history removal used

“we restrict internet access and strip Git histories from the environment”

Transient build and package cache purging used

“we automatically purge transient build and package caches across diverse environments”

evaluation harness 1

DeepSeek Harness Minimal mode used

“the model is evaluated with the Minimal mode of DeepSeek Harness and a 1M-token context window.”

1 more mentioned or evaluated
Controlled agent-scaffold comparison evaluated

“For each scaffold, we keep the model checkpoint, decoding configuration, and task set identical, and only the surrounding harness ... is…”

unfiled 5

Per-sandbox AppArmor and eBPF network-policy isolation core

“We use per-sandbox AppArmor profiles and fine-grained eBPF-based network policies to prevent such attempts.”

Peak/off-peak pricing used

“Peak/off-peak pricing continues to balance demand.”

encoding.py reference prompt-encoding implementation optional

“The encoding folder contains a self-contained Python reference implementation (encoding.py) with test cases for multi-turn conversations…”

2 more mentioned or evaluated
Multi-agent collaboration using DeepSeek Harness Agent Team mode evaluated

“we conduct preliminary experiments with DeepSeek-V4.1-Flash using DeepSeek Harness’s Agent Team mode.”

Pre-training methods mentioned

“New pre-training methods + larger-scale RL post-training deliver benchmark results ahead of flagship models”

Further reading

Picked by hand, not extracted: where to read more, not evidence for anything on this page.

Sources

The curated source list for this model. "not fetched" means the URL is recorded but its text was not read in the current run.

↑