The short version
DeepSeek V4.1 Flash combines a causal encoder-decoder, shared sparse attention state, FP4 main KV caching, and bounded replay to reduce inference overhead. Our writing snapshot makes default effort a promising low-cost drafting option, with limits on ranking and cost comparisons.
- V4.1’s global KV cache is about one quarter of V4 Flash’s; this is not total model memory.
- Default effort averaged 43 seconds and $0.007744 per writing draft in our September 10 snapshot.
- Compare usable output and editing time on your own evaluations before paying for more reasoning.
DeepSeek V4.1 Flash averaged 43 seconds and less than a cent per script draft in our writing benchmark. That is the result that changed my shortlist for writing at scale. The paper explains why the model deserves attention from engineers building long-running agents, too.
Its backbone has 552 billion parameters, almost twice V4 Flash’s 284 billion. Yet its global KV cache uses about a quarter of the memory per token. The team made a larger model and reduced one of the costs that grows with the conversation.
I’m Louis-François, CTO and co-founder of Towards AI. We turn engineers into AI engineers who build and ship AI products. Our new book, AI Engineering For Production, launches October 20, 2026. This model is a useful case study in the kind of tradeoffs those products require.
Why the cache matters for agents
An agent adds tool calls, results, and messages to its conversation. The next request needs that history. A reusable prefix cache can avoid recomputing attention state for the unchanged part, although providers may still charge for cached input. The remaining suffix still needs processing.
The KV cache stores keys and values used by attention. It lets a model reuse earlier computation while generating new tokens. It is one part of inference memory, alongside model weights and other working state. It does not contain everything the model knows or explain how it understands language.
Long contexts make this cache expensive to store and move. DeepSeek V4.1 targets that pressure with three related changes: less prompt computation, more sharing of global attention state, and fewer persistent local snapshots. The details come from DeepSeek’s technical report, especially sections 2.2, 2.3, and 3.2.1–3.2.2. Read the report.
What actually changed over V4 Flash
V4 Flash already used compressed sparse attention. Encoder-decoder architectures and cross-layer cache reuse also have prior research behind them. V4.1’s contribution is the particular design and deployment strategy described in this report.
| Mechanism | What V4.1 changes |
|---|---|
| Prompt processing | A causal encoder-decoder split lets most prompt tokens traverse only the encoder stack. |
| Attention state | CSA2 shares more global KV state and indexing work across layers. |
| Cache precision | The main global KV cache moves from FP8 to FP4. V4’s indexer already used FP4. |
| Persistent storage | Bounded replay reconstructs local attention state instead of retaining all local snapshots long term. |
Process most of the prompt through 20 layers
The network has 20 encoder layers and 20 decoder layers. The decoder derives its global keys and values from the encoder’s final output, rather than requiring each prompt token to traverse all decoder layers to build that global state. It still needs layer-specific local attention state, rebuilt by replaying a 128-token window.
That is why the model activates about 8 billion parameters during prefill and 16 billion during generation. The nearly halved prefill computation refers to avoiding most decoder processing within this architecture. It is not a measured promise that every request takes half as long as V4 Flash.
The report cites earlier work including YOCO. V4.1 introduces this arrangement relative to V4 Flash while building on earlier encoder-decoder and cache-sharing research.
The report’s architecture diagram, shown at 05:35 in the source video.
Share the cache and the search work
In the reported configuration, four of the 40 layers create fresh global KV state. Most other layers reuse it; the first two layers use only sliding-window attention. CSA2 also shares some indexer state and selected positions across layers.
CSA2 operating modes, shown at 06:33 in the source video.
Sparse attention selects 512 global entries alongside a local 128-token window. The decoder’s first global indexing layer scans the visible context and creates a candidate pool of up to 16,384 positions. Later indexing layers search that pool, while some layers reuse a previous selection. This reduces repeated search work. The first scan still depends on context length.
The main KV cache also moves from FP8 to FP4, with overhead for quantization scales. Together, these changes bring global cache storage from 3,514 to 890 bytes per token. A million-token global cache is about 0.89 GB. That number excludes the model weights and other memory needed to run it.
Hierarchical sparse indexing, shown at 07:25 in the source video.
Rebuild local state when needed
V4.1’s deployment strategy avoids keeping all per-layer sliding-window snapshots long term. Encoder snapshots can live briefly in host memory for active sessions. When needed state is absent, bounded replay reconstructs an approximation using a short cached suffix. Decoder sliding-window state is rebuilt during prefill rather than kept in the prefix cache.
The approximation matters. Replaying 128 tokens does not reconstruct every layer’s exact original state. DeepSeek reports negligible quality impact in its testing and acknowledges possible edge cases, without publishing a dedicated numerical ablation for this approximation.
Combined with the smaller global cache, the deployment analysis reports roughly one eighth of V4 Flash’s persistent KV footprint. That is a cache-storage result. Application cost still depends on the workload, provider, cache hits, and generated tokens.
Where performance still has limits
V4.1 Flash supports image and text input, text output, and contexts up to one million tokens. The report lists a 552B backbone plus a separate 196B Engram parameter component. Its mixture-of-experts design activates a small part of the backbone for each token.
The paper’s agentic results are strong on several suites. DeepSWE rises from 54.4 for V4 Flash to 74.2 for V4.1 Flash, a 19.8 percentage-point improvement. Opus 5 scores 74.0 and GPT-5.6 Sol 73.0 in that table. But Terminal-Bench 4.0 shows a clear gap: 31.2 for V4.1, versus 51.8 for Opus 5 and 39.9 for Sol. These are reported evaluations under the paper’s setup, not a guarantee for your agent.
The paper also estimates how decoding computation grows with context length. It shows roughly 25% more precision-weighted FLOPs per decoded token at a million-token context than at 4K. That is an engineering result about computation, not a latency or API-price measurement.
The report’s decode-compute curve, shown at 09:15. FLOPs describe computation, not API prices or measured latency.
What our writing benchmark measured
Our September 10 snapshot covers 148 model configurations, 10 writing tasks, and five drafts per configuration per task. Three model judges score anonymized drafts against the same detailed editorial rubric. The benchmark asks whether a model can follow the instructions and write educational scripts in our voice. It does not measure every kind of writing.
| Model and setting | Rubric score / 100 | Average USD per draft | Average seconds |
|---|---|---|---|
| DeepSeek V4.1 Flash, default | 87.13 | $0.0077 | 43.1 |
| DeepSeek V4.1 Flash, max | 86.75 | $0.0124 | 74.6 |
| Kimi K3 | 88.19 | $0.2598 | 234.3 |
| Claude Opus 5, max | 88.76 | $0.2927 | 131.7 |
| Claude Fable 5.1, max | 89.71 | $3.1525 | 622.5 |
Regenerated from the September 10 benchmark snapshot. Exact values appear in the table above.
Costs are the repository’s token-based averages. DeepSeek and Kimi use recorded OpenRouter usage; Claude Code runs use measured output with API-equivalent pricing, not subscription charges. Timings include provider and harness differences. These numbers describe that snapshot, not a standing price quote.
For this comparison, I regrouped the snapshot to keep the highest-Elo configuration of each model, including ultra. DeepSeek places seventh in that view. Its max and default entries rank 22nd and 24th among all 148 configurations. Elo is computed from task-level comparisons, so its order can differ from the average rubric score. Nearby positions have overlapping confidence intervals.
That is why I would not turn a close score into “matches Fable.” Fable still leads this board. DeepSeek offers a useful cost tradeoff for drafts a person will edit.
Start with high, then test max
DeepSeek’s API exposes low, high, and max reasoning effort, with high as the default. The thinking-mode documentation describes the mapping.
In our writing test, max cost about 60% more and took about 73% longer than default. Their Elo confidence intervals overlap, so the result does not establish a quality advantage for max or prove the settings equivalent. Two max drafts also hit the original 32K output cap. Extra reasoning consumes output budget that may be needed for the script itself.
Measured averages and 95% bootstrap Elo intervals for the two effort settings.
For outlines and first drafts, I would start at high and measure the editing still required. If max consistently reduces that work on your own tasks, the extra time and tokens may be worth it. The paper’s effort curves concern its own evaluation mix; our writing result should not be generalized to difficult reasoning tasks.
Before using it in an application
We switched our academy’s AI Tutor to V4.1 after running our own evaluations and tests. That is the process I would repeat for another product: test the task, measure failures and editing, then compare cost and latency.
For existing Pro users, DeepSeek announced that deepseek-v4-pro requests will route to V4.1 Flash from September 14, 2026, at 04:00 UTC, until V4.1 Pro launches. An alias is not a guarantee of an unchanged model. Check your provider’s versioning options and rerun evaluations before relying on the migration. Official API release notice.
The model’s strongest case in my writing workflow is a low-cost first pass. When the words are the final product, I still care about the quality gap and the time I spend correcting it. The useful number is how much work the finished draft saves me.
FAQ
What is new in DeepSeek V4.1 Flash?
Relative to V4 Flash, the report introduces a causal encoder-decoder design, CSA2 cache and indexing reuse, FP4 for the main global KV cache, and bounded replay for local attention state. Sparse attention and encoder-decoder research predate this model.
Does DeepSeek V4.1 Flash fit in 1 GB of memory?
No. At 890 bytes per token, a million-token global KV cache is about 0.89 GB. That excludes the model weights, local state, and other memory required for inference.
Should I use high or max reasoning effort?
High is the API default. In our September 10 writing test, default and max had overlapping Elo confidence intervals, while max cost about 60% more and took about 73% longer. Test the settings on your own tasks before choosing.
How much did DeepSeek V4.1 Flash cost per script?
Default averaged $0.007744 per draft and max $0.012425 in the benchmark snapshot. These are token-based costs for the tested provider and rates, not guaranteed prices for every script or subscription charges.
How did DeepSeek V4.1 Flash rank in the writing benchmark?
Grouping all effort settings under each model and keeping the highest Elo places V4.1 Flash seventh in this comparison. Its max and default configurations rank 22nd and 24th among 148 configurations. Nearby Elo confidence intervals overlap.
Is V4.1 Flash prefill always twice as fast as V4 Flash?
No. The reported compute saving comes from processing most prompt tokens through the encoder without traversing the full decoder. That architectural result does not guarantee half the latency of V4 Flash for every request.