DeepSeek V4.1 Flash appeared on Hugging Face on 10 September 2026: a 552-billion-parameter mixture-of-experts model released under the MIT licence, with a 51-page technical report sitting in the same repository. DeepSeek describes it as the smallest model in a new architecture family. It reads input with 8 billion active parameters, writes output with 16 billion, holds a one-million-token context window and takes images natively. The repository drew 734 likes on its first day.
The release is also a retirement notice. From 04:00 UTC on 14 September, every API request addressed to deepseek-v4-pro will be answered by DeepSeek V4.1 Flash and billed at the new model’s lower rates, and that routing stays in place until a V4.1 Pro ships. DeepSeek’s announcement says tests “by multiple parties put V4.1-Flash ahead of V4-Pro on performance, cost, speed & total runtime.”
The model card’s own numbers back that claim for agent work: DeepSeek V4.1 Flash leads V4 Pro on all 12 agentic benchmarks where DeepSeek published scores for both models. The same card shows V4 Pro ahead on 12 of 16 base-model rows, including a 12.9-point lead on SimpleQA-Verified, a factual-recall test. What follows works through the architecture, the KV cache arithmetic, both directions of the benchmark table, the new price sheet, the hardware bill for running the weights yourself, and what to check before the cutover. For the previous generation, see our DeepSeek V4 guide.
Table of contents
- What DeepSeek V4.1 Flash Actually Is
- Inside the Causal Encoder-Decoder
- How DeepSeek V4.1 Flash Shrinks the KV Cache
- Training DeepSeek V4.1 Flash on 45 Trillion Tokens
- DeepSeek V4.1 Flash Benchmarks Against Frontier Models
- DeepSeek V4.1 Flash Pricing and the 14 September Cutover
- Where DeepSeek V4.1 Flash Trails the V4 Pro It Replaces
- Running DeepSeek V4.1 Flash on Your Own Hardware
- What DeepSeek V4.1 Flash Means for Businesses
- DeepSeek V4.1 Flash: Frequently Asked Questions
- References and Further Reading
What DeepSeek V4.1 Flash Actually Is
The repository at a glance
The Hugging Face repository deepseek-ai/DeepSeek-V4.1-Flash was created at 02:17 UTC on launch day and had last been updated at 07:17 UTC when we checked. It carries 88 files: the weights in safetensors format, a config.json declaring the deepseek_v41 architecture, the technical report, a reference inference folder, a prompt-encoding folder and an evaluation folder for reproducing the DeepSWE results. The pipeline tag is image-text-to-text, and both the licence file and the model card say MIT, covering the repository and the weights.
The config fills in details the headline leaves out. The text stack has 40 hidden layers, a hidden size of 5,120, a vocabulary of 129,280 tokens, and 384 routed experts plus one shared expert in each mixture-of-experts layer. Position embeddings reach 1,048,576 tokens through YaRN scaling by a factor of 16 from a 65,536-token base. The vision tower is a separate 32-layer encoder that caps each image at 1,024 tokens.
Why Hugging Face shows 484.6B instead of 552B
The parameter counter on the DeepSeek V4.1 Flash repository reads 484.6 billion, not 552 billion. The gap is a storage artefact, not a smaller model. The routed expert weights are stored at 4 bits, two weights to a byte, and the counter reports 278.6 billion 8-bit integer elements. Doubling that gives 557.2 billion, the exact expert parameter count vLLM’s serving recipe lists for the routed and DSpark experts. Of the remaining 206 billion, 204 billion are 8-bit floats, the format vLLM lists for the Engram memory tables.
How it lines up against V4 Flash and V4 Pro
| Specification | DeepSeek V4 Flash | DeepSeek V4 Pro | DeepSeek V4.1 Flash |
|---|---|---|---|
| Backbone parameters | 284B | 1.6T | 552B |
| Activated parameters | 13B | 49B | 8B reading, 16B writing |
| Layout | Decoder MoE | Decoder MoE | Causal encoder-decoder MoE |
| Context window | 1M | 1M | 1M |
| Vision on the API | Separate vision-exp model | Not supported | Native |
| API status | Retired 10 Sep, name routes to V4.1 Flash | Routes to V4.1 Flash from 14 Sep | Live as deepseek-flash |
| Licence | MIT | MIT | MIT |
DeepSeek’s report says the DeepSeek V4.1 Flash base model matches V4 Pro’s base model on world knowledge, reasoning and coding “using only 1/3 total parameters and 1/4 activated parameters”, with 5% to 10% gains on held-out evaluations it does not publish. The 1/3 figure is straightforward: 552B is 34.5% of 1.6T. The 1/4 figure only works as an average. The 8B and 16B active counts average 12B, which is 24.5% of V4 Pro’s 49B, while the 16B used for every generated token is 32.7% of it.
Inside the Causal Encoder-Decoder
Reading costs 8B, writing costs 16B
The architecture DeepSeek calls a Causal Encoder-Decoder, or CED, splits the 40-layer Transformer into a 20-layer causal encoder followed by a 20-layer decoder. In a conventional decoder-only model, every layer builds its own key-value cache from its own hidden states. In CED, the decoder’s global KV cache is projected from the encoder’s final hidden states instead. The practical effect is asymmetric compute: 8 billion parameters activate per token during prefill, when the model reads the prompt, and 16 billion during decode, when it writes.
That split is aimed at a specific workload. Agent sessions are input-heavy, because a coding agent re-reads files, tool outputs and conversation history far more than it writes new text. The report says prefill “remains computationally expensive” even after earlier long-context work, and CED is DeepSeek’s answer. Halving the active parameters on the read side attacks the larger share of an agent’s token bill, which is why DeepSeek V4.1 Flash is pitched at agent builders first.
384 experts, six at a time
Each mixture-of-experts layer holds 384 routed experts and one shared expert that every token passes through. A router picks six routed experts per token, scored with a sqrtsoftplus function and a routed scaling factor of 1.5. With 6 of 384 routed experts active, each token touches about 1.6% of the routed pool, which is how a 552B model activates parameters in the single-digit billions.
Two further components round out the backbone. Single-Pass mHC is a revised residual-stream mixing scheme, with a Mega-mHC kernel that DeepSeek says halves activation memory traffic compared with the original four-kernel version. The Hierarchical Sparse Indexer, covered in the next section, keeps attention cost bounded as context grows.
Engram memory and DSpark drafting
Two more components sit outside the 552B backbone count. Engram is a conditional memory module of 196B parameters, accessed sparsely through token-based lookup; the config places its lookups at layers 1 and 14, using n-grams of up to four tokens. DSpark is a speculative decoding design in which three extra prediction layers draft blocks of five tokens semi-autoregressively.
A confidence head then predicts how many drafted tokens will survive verification, and a scheduler combines those estimates with profiled throughput curves to pick the verification length for each request. Unlike the multi-token prediction module in DeepSeek-V3, which trained alongside the backbone through pre-training, DSpark is added in a dedicated stage.
How DeepSeek V4.1 Flash Shrinks the KV Cache
The technical report is titled “Pushing the Limits of KV Cache Compression”, and the KV cache is where DeepSeek V4.1 Flash makes its most specific claims. A model’s KV cache stores attention keys and values for every token already processed, so it grows with context length and has to sit in fast high-bandwidth memory, or HBM, while a session is active.
CSA2 shares work across layers
Compressed Sparse Attention 2 gives each attention layer one of three static modes. A Full layer computes its own main KV cache and selects the top 512 positions to attend to. A Reindex layer reuses an earlier layer’s KV and indexer keys but rescores positions with its own queries. A Reuse layer takes both the KV and the selected indices from an earlier layer, and the report says most Reuse layers run with only 15 GPU kernels during prefill and 11 during decode.
In the decoder, a Hierarchical Sparse Indexer limits later indexing layers to a candidate pool built by the first Full layer: 2,048 blocks of 8 positions, or 16,384 positions in all. Deeper indexing cost therefore stops growing with context length. The report says extending context 256-fold, from 4K to 1M tokens, raises decode compute by only a quarter.
FP4 keys and values
The main KV cache is stored in FP4, using the E2M1 format with one E4M3 scale shared per 16 channels. Combined with cross-layer reuse, DeepSeek puts the global KV cache of DeepSeek V4.1 Flash at 890 bytes per token. That is roughly a quarter of DeepSeek-V4-Flash’s footprint and about 437 times smaller than the original DeepSeek-V1.
What 890 bytes per token means at one million tokens
The per-token figure becomes a session figure with one multiplication. A full context of 1,048,576 tokens at 890 bytes each needs 933,232,640 bytes of global KV cache: about 933 MB, or 0.87 GiB. At roughly four times the footprint, DeepSeek-V4-Flash would need something close to 3.7 GB for the same session. At 437 times, DeepSeek-V1’s per-token cost works out to about 389 KB.
Measured against DeepSeek-V4-Flash, the two cache savings DeepSeek quotes land at different depths:
Why the SSD figure matters for cache-hit pricing
The second saving comes from SWA Bounded Replay. Every layer also runs sliding-window attention, and V4 kept those window caches on SSD alongside the global cache so a returning session could resume. DeepSeek V4.1 Flash stops persisting them. They now live in a memory pool built from 10% of each machine’s host DRAM with a time-to-live of minutes, and when an entry expires the model replays only the most recent 128-token window to rebuild it. Global KV stays in the persistent cache with a guaranteed lifetime of at least 72 hours.
That storage change is tied directly to price. DeepSeek’s announcement says “cache-hit charges often account for a large share of agent costs”, and the new cache-hit input rate is $0.006 per million tokens at peak, against $0.044 for V4 Pro.
Training DeepSeek V4.1 Flash on 45 Trillion Tokens
A 7:1 text-to-multimodal diet
DeepSeek trained DeepSeek V4.1 Flash from scratch on a multimodal corpus of 45 trillion tokens, mixed at a 7:1 ratio of text-only to multimodal data. Sparse attention was trained from the start at a 64K sequence length with no dense-attention warm-up stage, and the model card says context was extended to one million tokens at 34T tokens.
The vision encoder, DeepSeek-ViT, was also trained from scratch, with 2D rotary position embeddings and 3×3 pixel-unshuffle downsampling. A two-layer MLP projector feeds its output into the language model from the first day of pre-training, rather than bolting vision on afterwards as V4 Flash’s separate vision model did.
A deliberately ordinary post-training recipe
The report is unusually direct that post-training brought “no algorithmic innovation”. The recipe is supervised fine-tuning, then reinforcement learning, then on-policy distillation, unchanged from V4 development. What changed was the data pipeline: automated synthesis of agent tasks and environments, with the data, tasks and rollouts used during reinforcement learning scaled up in stages. DeepSeek’s announcement credits “larger-scale RL post-training” for the results ahead of V4 Pro.
Reasoning effort from 1 to 100
DeepSeek V4.1 Flash replaces named effort tiers with a numeric budget from 1 to 100, and the report measures what the dial buys. Raising effort from 25 to 100 lifts the average score on eight reasoning-heavy benchmarks from 67.1% to 76.3%, DeepSWE v1.1 from 66.0% to 74.2% and Terminal-Bench 2.1 from 82.4% to 90.6%, at the cost of roughly 2.5 times more output tokens. Every headline score on the model card uses the maximum setting of 100.
Output tokens are the expensive line on the price sheet, so that multiplier matters. At the $1.20 peak output rate, a job that writes 40,000 output tokens at effort 25 costs $0.048 for output, and the roughly 100,000 tokens the same job would write at effort 100 cost $0.12.
DeepSeek V4.1 Flash Benchmarks Against Frontier Models
DeepSeek published an instruct comparison against Claude Opus 5, OpenAI’s GPT-5.6 Sol, Moonshot’s Kimi K3, Z.ai’s GLM-5.3 and its own V4 models, all run at maximum reasoning effort, with agent tasks run through harnesses including Claude Code and DeepSeek’s own. Selected rows from that table:
| Benchmark | Claude Opus 5 | GPT-5.6 Sol | Kimi K3 | GLM-5.3 | V4 Pro | V4.1 Flash |
|---|---|---|---|---|---|---|
| GPQA Diamond | 93.4 | 94.1 | 92.9 | 88.1 | 92.4 | 90.9 |
| Humanity’s Last Exam | 56.3 | 44.5 | 43.5 | 42.0* | 42.7* | 36.8 (39.1*) |
| Terminal-Bench 2.1 | 89.1 | 88.8 | 88.3 | 88.2 | 87.9 | 90.6 |
| Terminal-Bench 4.0 | 51.8 | 39.9 | 12.6 | 37.9 | 12.4 | 31.2 |
| DeepSWE v1.1 | 74.0 | 73.0 | 67.5 | 66.9 | 62.7 | 74.2 |
| ProgramBench | 37.0 | 23.0 | 17.5 | 19.0 | 15.5 | 20.3 |
| NL2Repo-Bench | 75.3 | 56.8 | 58.0 | 58.0 | 61.5 | 64.0 |
| CyberGym | not listed | 84.5 | 80.0 | 84.5 | 83.3 | 88.1 |
| AutomationBench | 50.3 | 45.8 | 46.7 | 48.8 | 43.2 | 54.8 |
| BabyVision with tools | 94.1 | 88.9 | 85.7 | not listed | not listed | 89.6 |
Scores are Pass@1 or resolved rate as reported by DeepSeek. An asterisk marks the text-only subset of Humanity’s Last Exam.
Where it leads
On the benchmarks closest to everyday agent work, DeepSeek V4.1 Flash posts the top score in the table. It reaches 90.6 on Terminal-Bench 2.1, 74.2 on DeepSWE v1.1 (0.2 points ahead of Claude Opus 5), 54.8 on AutomationBench, 88.1 on CyberGym and 31.8 on Agent’s Last Exam. Its Codeforces rating of 3,471 is the highest DeepSeek reports, although that is an internal benchmark and the frontier columns for it are blank.
The report sums up the profile as “fully capable of handling everyday coding tasks and white-collar workflows.” For a close open-weight rival released two weeks earlier, our GLM-5.3-Flash analysis works through Z.ai’s own Terminal-Bench and DeepSWE claims.
Where the gap to Claude Opus 5 is widest
The same table shows where the model stops. On Terminal-Bench 4.0, DeepSeek V4.1 Flash scores 31.2 against 51.8 for Claude Opus 5, a 20.6-point gap. On ProgramBench it scores 20.3 against 37.0, on NL2Repo-Bench 64.0 against 75.3, and on Humanity’s Last Exam without tools 36.8 against 56.3.
DeepSeek does not hide this. The report says “a gap with giant models remains on science-oriented agentic tasks, such as Terminal-Bench 4.0, that require expert-level domain knowledge,” and that “a distinct overall performance gap remains when compared to giant closed-source systems.”
Terminal-Bench 4.0 is the row that separates the field most sharply:
The scaffold moves the score
DeepSeek also ran DeepSWE v1.1 and Terminal-Bench 2.1 through eight agent scaffolds, from Claude Code and Codex to three modes of its own DeepSeek Harness, labelled DSH below.
| Scaffold | DeepSWE v1.1 resolved | Terminal-Bench 2.1 Pass@1 |
|---|---|---|
| Claude Code | 69.8 | 88.0 |
| Codex | 65.6 | 84.1 |
| OpenCode | 65.5 | 85.0 |
| Pi | 66.2 | 86.1 |
| mini-SWE | 74.2 | 90.3 |
| DSH Minimal | 72.6 | 90.6 |
| DSH Standard | 70.5 | 85.8 |
| DSH PTC | 67.6 | 85.8 |
The harness alone moves the DeepSWE result for DeepSeek V4.1 Flash by 8.7 points, from 65.5 in OpenCode to 74.2 in mini-SWE. That spread is larger than the 6.7-point lead the model holds over Kimi K3 in the headline table, and the headline 74.2 comes from the best-scoring scaffold. On Terminal-Bench 2.1 the spread is 6.5 points. Teams running Codex or OpenCode should expect DeepSWE-style results nearer 65 until they measure their own.
DeepSeek V4.1 Flash Pricing and the 14 September Cutover
The new price sheet
New prices took effect at 04:00 UTC on 10 September. DeepSeek bills per million tokens in US dollars, charges peak rates from 01:00 to 04:00 and from 06:00 to 10:00 UTC on weekdays, and halves them at all other times. The pricing page lists DeepSeek V4.1 Flash under the model name deepseek-flash next to the outgoing V4 Pro build, DeepSeek-V4-Pro-0813.
| Per 1M tokens (US$) | V4.1 Flash off-peak | V4.1 Flash peak | V4 Pro off-peak | V4 Pro peak |
|---|---|---|---|---|
| Input, cache hit | $0.003 | $0.006 | $0.022 | $0.044 |
| Input, cache miss | $0.15 | $0.30 | $0.66 | $1.32 |
| Output | $0.60 | $1.20 | $1.98 | $3.96 |
| Concurrency limit | 2,500 | 2,500 | 500 | 500 |
| Vision input | Supported | Supported | Not supported | Not supported |
Both models list a 1M context and a maximum output of 384K tokens. The cuts are deepest on cached input, the line DeepSeek says dominates agent bills:
What V4 Pro callers get after the switch
From 04:00 UTC on 14 September, which is noon in Beijing, requests to deepseek-v4-pro route to DeepSeek V4.1 Flash and are billed at Flash prices “until V4.1 Pro is released in the future”, in the pricing page’s words. The legacy names deepseek-v4-flash and deepseek-v4-flash-vision-exp already route to it, because DeepSeek retired both models on launch day. Neither the pricing page nor the announcement mentions a way to opt out. Official partners WorkBuddy, including CodeBuddy, and OpenCode support the new model from day one.
A worked agent session
Take a hypothetical agent session that reads 2 million input tokens, 90% of them cache hits, and writes 100,000 output tokens, all at peak rates. On V4 Pro that is $0.079 for 1.8 million cached tokens, $0.264 for 200,000 uncached tokens and $0.396 for output: $0.739 in total.
On DeepSeek V4.1 Flash the same session costs $0.011, $0.060 and $0.120: $0.191 in total, which is 74.2% less. Off-peak, both totals halve, to $0.370 and $0.095. The cheaper cached line is what makes long, repetitive agent loops so much cheaper.
Two days of beta first
The launch followed a short public test. According to TechNode, DeepSeek ran a limited-time beta through its existing API under the model name deepseek-v4.1-flash-expires-on-0910, priced the same as V4 Flash, capped at 20 concurrent requests per account and scheduled to go offline on 10 September, the day the full release arrived.
Where DeepSeek V4.1 Flash Trails the V4 Pro It Replaces
DeepSeek’s pricing page says that after extensive testing the new model beat V4 Pro “in performance, cost, speed, and total time”. For agent workloads the model card agrees. For knowledge-heavy work, the base-model table points the other way.
Knowledge recall
| Base-model benchmark | V4 Pro Base | V4.1 Flash Base | Difference |
|---|---|---|---|
| SimpleQA-Verified | 55.2 | 42.3 | -12.9 |
| LongBench-V2 | 51.5 | 45.2 | -6.3 |
| MultiLoKo | 50.9 | 45.5 | -5.4 |
| MGSM | 84.4 | 80.2 | -4.2 |
| MATH | 64.5 | 61.1 | -3.4 |
| BBEH | 29.8 | 27.2 | -2.6 |
| HumanEval | 76.8 | 79.4 | +2.6 |
| BigCodeBench | 59.2 | 60.6 | +1.4 |
| MMLU-Pro | 73.5 | 74.1 | +0.6 |
Of the 16 base-model benchmarks both checkpoints ran, V4 Pro scores higher on 12 and DeepSeek V4.1 Flash on 4. DeepSeek treats scores within 0.3 points as equivalent, and no pair falls inside that band. The largest gap is SimpleQA-Verified, a 25-shot test of short factual answers, where V4 Pro leads by 12.9 points. MultiLoKo, a multilingual knowledge test, favours V4 Pro by 5.4.
Three of the new model’s four wins are code and grade-school maths: HumanEval, BigCodeBench and GSM8K. The fourth is MMLU-Pro, by 0.6 points. V4 Pro’s other leads, on AGIEval, C-Eval, SuperGPQA, BBH, DROP and HellaSwag, run between 0.8 and 1.4 points.
Long-context reading
LongBench-V2 is the other large gap: 51.5 for V4 Pro against 45.2, a 6.3-point deficit on a benchmark built around long documents. That sits awkwardly beside a KV cache engineered for million-token sessions. DeepSeek V4.1 Flash holds long context far more cheaply than V4 Pro, but on this test it reads it less accurately.
Reasoning at the top end
The instruct table repeats the pattern on a smaller scale. V4 Pro scores 92.4 on GPQA Diamond against 90.9, and 42.7 on the text-only subset of Humanity’s Last Exam against 39.1. None of these rows is a verdict on a specific workload, but together they identify which workloads deserve a test before 14 September: factual lookup, multilingual knowledge, long-document question answering and graduate-level science.
Running DeepSeek V4.1 Flash on Your Own Hardware
The hardware bill
vLLM’s recipe lists the DeepSeek V4.1 Flash checkpoint at roughly 511 GB on disk, or 476 GiB, and breaks it down by component:
| Checkpoint component | Parameters | Stored size |
|---|---|---|
| Routed and DSpark experts (MXFP4) | 557.2B | 259.5 GiB |
| Engram tables (MXFP8) | 196.6B | 188.8 GiB |
| Attention, norms, routers (MXFP8) | 6.0B | 5.6 GiB |
| Embedding, LM head, misc | 3.0B | 5.8 GiB |
| Quantisation scales | 23.6B | 21.9 GiB |
The Engram memory tables take nearly three-quarters as much storage as all the experts combined:
The recipe sets a minimum of 614 GB of accelerator memory, which is the weight total multiplied by a 1.2 headroom factor. It says that fits one GB200 NVL4 tray of four GPUs with 768 GB at tensor parallelism 4, or one eight-GPU H200 node with 1,128 GB “with room for KV cache”, but warns that “1M context will need the context or batch capped — measure before assuming.”
Serving requires the vllm/vllm-openai:deepseekv41-flash Docker image, which is vLLM 0.30.0 or later, because no pip wheel supports the architecture yet. The recipe sets a one-hour engine start-up timeout for the long first load, and the --language-model-only flag skips the vision encoder to free memory for KV cache on text-only workloads. DeepSeek’s own inference folder converts the weights into one file per tensor-parallel rank, with an eight-rank example, and calls itself “a readable reference implementation rather than a production serving engine.”
This is data-centre hardware, not a workstation job. Our 2-bit quantization analysis of GLM-5.3-Flash shows how far aggressive compression can shrink a 320B model; DeepSeek V4.1 Flash starts well beyond that envelope. DeepSeek’s announcement even invites anyone “planning a large-scale deployment with 2,000 GPUs + a storage cluster” to get in touch.
No chat template in the box
The repository ships no Jinja chat template, which is the file most serving stacks read to format a conversation. Instead there is encoding.py, a Python reference encoder with test cases, and a new GitHub project, deepseek-recipe: Rust libraries with Python bindings that convert Messages, Chat Completions and Responses API requests into V4 and V4.1 prompts and parse the output back.
Three prompt-format changes will break parsers written for V4. Tool-call tags now carry a leading space inside the DSML markers, reasoning effort is rendered as a numeric budget, and system messages can appear mid-conversation. Anyone self-hosting DeepSeek V4.1 Flash behind a custom tool-calling layer needs to retest it.
Two effort scales that disagree
The string aliases for reasoning effort do not match between DeepSeek’s reference encoder and vLLM’s recipe. In encoding.py, “low” maps to 50, “high” to 75 and “max” to 100, and the default is “high”. In the vLLM recipe, “low” is 25, “high” is 50, “xhigh” is 75 and “max” is 100.
A request that says “high” therefore runs at 75 through one path and 50 through the other. Since the report’s own effort curve moves Terminal-Bench 2.1 by 8.2 points between settings of 25 and 100, send integers rather than names.
What DeepSeek V4.1 Flash Means for Businesses
For companies already calling DeepSeek’s API, the release is an unrequested model swap with a lower bill attached. For companies still evaluating it, DeepSeek V4.1 Flash is a strong, cheap agent model with published weaknesses, open weights and a set of questions that have nothing to do with benchmarks.
A pre-cutover checklist
- Find every call that names
deepseek-v4-pro,deepseek-v4-flashordeepseek-v4-flash-vision-exp, including inside agent frameworks and API gateway configuration. - Run your own evaluation set against
deepseek-flashbefore 04:00 UTC on 14 September, weighted towards factual recall, multilingual answers and long documents. - Pin reasoning effort as an integer, and re-budget output tokens if you raise it.
- Re-forecast spend with the new price sheet, and note the concurrency limit rises from 500 to 2,500.
- Decide in advance what happens if a V4 Pro workload regresses: another provider, self-hosting the open weights, or accepting the change.
Data residency and the distillation question
DeepSeek’s hosted API is run by a Chinese company that, according to Reuters, is preparing for a listing on Shanghai’s STAR Market. This week US agencies also named DeepSeek among six Chinese companies accused of distilling American models, which our AI distillation advisory breakdown covers in detail. Neither changes a benchmark score, but both belong in vendor management reviews before sensitive data flows to a hosted endpoint.
Open weights as an exit route
The MIT licence is the counterweight. Because the weights are public, a business that likes DeepSeek V4.1 Flash but not the hosting arrangement can run it on its own hardware or through an inference provider in its own jurisdiction, and vLLM already publishes a verified recipe. The same freedom is what made August’s open-weight releases, including Alibaba’s Qwen3.8-Flash, attractive to buyers wary of a single vendor. For the wider field, see our AI models and tools hub.
DeepSeek V4.1 Flash: Frequently Asked Questions
Is DeepSeek V4.1 Flash open source?
The weights and repository are released under the MIT licence on Hugging Face. The release includes the safetensors weights, a technical report, a reference inference implementation, a prompt encoder and scripts for reproducing the DeepSWE results.
How big is DeepSeek V4.1 Flash?
It has 552 billion backbone parameters plus 196 billion in Engram memory tables, with 8 billion active per token when reading and 16 billion when writing. The checkpoint is roughly 511 GB on disk, and vLLM’s recipe asks for at least 614 GB of GPU memory to serve it.
How much does DeepSeek V4.1 Flash cost on the API?
Under the model name deepseek-flash, peak rates are $0.30 per million uncached input tokens, $0.006 per million cached input tokens and $1.20 per million output tokens. Off-peak rates are half of those.
What happens to deepseek-v4-pro on 14 September?
From 04:00 UTC, requests using that model name are served by DeepSeek V4.1 Flash and billed at its prices, until DeepSeek releases a V4.1 Pro.
Can DeepSeek V4.1 Flash read images?
Yes. Vision is native, trained jointly with text from the start of pre-training, and the API lists vision support for deepseek-flash but not for deepseek-v4-pro.
References and Further Reading
DeepSeek-V4.1-Flash model card on Hugging Face
DeepSeek-V4.1-Flash: Pushing the Limits of KV Cache Compression (Technical Report)
Introducing DeepSeek-V4.1-Flash: smarter, faster, more efficient
DeepSeek API Docs: Models and Pricing
DeepSeek-V4.1 text and vision encoding reference
vLLM Recipes: deepseek-ai/DeepSeek-V4.1-Flash
DeepSeek says new Flash AI model beats Kimi K3 on cyber, coding benchmarks
DeepSeek begins limited-time beta of V4.1 Flash multimodal model
More AI coverage: explore Progressive Robot's AI Models, Tools & Releases hub — hands-on reviews, setup guides and benchmarks in one place.