DeepSeek V4.1 Flash Cuts KV Cache Memory Fourfold
Károly Zsolnai-Fehér argues that DeepSeek V4.1 Flash cuts the VRAM needed to retain context by sharing a single global KV-memory store across layers, reducing its stated cache requirement to 890 bytes per token from 3,514 bytes in the prior Flash model. He says the compression could materially lower local deployment costs for a model with more than 500 billion parameters, but does not make it lightweight: V4.1 Flash can still consume more than 100 million tokens in a single run and falls short in his fluid-physics test despite strong benchmark results.
Shared KV memory sharply reduces context-cache requirements
DeepSeek V4.1 Flash uses 890 bytes of global KV cache per token, according to the comparison presented by Károly Zsolnai-Fehér. That is roughly four times lower than the 3,514 bytes shown for the preceding V4-Flash model, and 437 times below DeepSeek-V1’s 389,120 bytes in November 2023.
| Model | Date shown | Global KV cache per token |
|---|---|---|
| DeepSeek-V1 | 2023.11 | 389,120 bytes |
| DeepSeek-V3.2 | 2025.12 | 48,068 bytes |
| DeepSeek-V4-Flash | 2026.04 | 3,514 bytes |
| DeepSeek-V4.1-Flash | 2026.06 | 890 bytes |
For Zsolnai-Fehér, the consequential constraint is VRAM: the cache holds context, and retaining that context requires memory. The comparison does not make V4.1 Flash small in the ordinary parameter-count sense. He says the model has more than 500 billion parameters and that he has “no chance” of running it at home.
He estimates that DeepSeek 4.0 Pro might cost about $300,000 to run locally, while V4.1 Flash could run for roughly a quarter of that. That is still a substantial requirement, he says, but he sees a clear direction in the compression trend and speculates that comparable systems could run in a pocket-sized device within a year.
CSA2 replaces layer-by-layer memory with a shared store
Károly Zsolnai-Fehér attributes the compression to a technique called CSA2. He describes the change through a conventional multilayer neural network: as information moves through its layers, each layer has its own KV memory. V4.1 Flash instead uses shared global memory across layers.
The accompanying comparison depicts a 40-layer network. In the conventional design, all 40 layers have their own KV memory; in V4.1 Flash, they draw on a single shared global KV block. “Not everyone has to remember everything,” Zsolnai-Fehér says. The technical difficulty is that different layers need different views of the same history.
The model is presented as an encoder–decoder design. The encoder creates the shared global memory, while the decoder reads from it. Its diagram includes CSA2 stages labeled “Reuse,” “Full,” and “Reindex,” as well as sliding-window attention.
That arrangement is the explanation offered for the smaller cache: rather than maintaining separate context memory at every layer, the architecture creates a common memory that can be used across them. Zsolnai-Fehér notes that the model is open and accompanied by a free research paper, while qualifying that he is explaining it as a student rather than an expert.
Strong results on two benchmarks coexist with a visible failure
The displayed benchmark comparison gives DeepSeek-V4.1-Flash strong results on two tests, while Károly Zsolnai-Fehér cautions that it does not outperform competitors on everything. It scores 74.2 on DeepSWE v1.1, slightly ahead of Opus5 at 74.0 and GPT5.6-Sol at 73.0. On CyberGym, it records 88.1, against 80.0 for Kimi-K3 and 84.5 for GLM-5.3, Opus5, and GPT5.6-Sol.
| Model | DeepSWE v1.1 | CyberGym |
|---|---|---|
| DeepSeek-V4.1-Flash | 74.2 | 88.1 |
| Kimi-K3 | 67.5 | 80.0 |
| GLM-5.3 | 66.9 | 84.5 |
| Opus5 | 74.0 | 84.5 |
| GPT5.6-Sol | 73.0 | 84.5 |
The examples shown alongside those scores include low-poly skiing and wizard games, an interactive particle field, a rotatable 3D drum-brake model, and a recreated fantasy-game menu. Zsolnai-Fehér treats the menu reproduction as evidence of native visual understanding: the system can take an image of an iconic game menu and write a game intended to reproduce it.
His honey-coiling experiment provides the counterweight. The task was to recreate a research-paper simulation of viscous honey falling and coiling. GPT-6 Astra produced what he calls an “absolutely stunning” result. Claude Opus 5.1 was less visually refined, in his view, though its physics was still formidable. DeepSeek V4.1 Flash produced a dark, solid form rather than the target’s flowing, coiling behavior.
On that visual-physics reproduction, V4.1 Flash did not match the other outputs shown. Zsolnai-Fehér expects it to improve with further work, but presents this as a present limitation: “I am here to show you the truth, not just believe the headlines.”
Less cache memory does not mean parsimonious token use
The operational catch is that V4.1 Flash “likes to think a lot,” according to Károly Zsolnai-Fehér. One displayed run cost $1.48 while consuming 101,257,961 tokens. He describes the dollar cost as not especially expensive, but calls the token count a lot.
The distinction is important to his account of the model. A smaller KV cache reduces the memory required for each token of retained context; it does not mean the system will use few tokens on a task. V4.1 Flash can therefore impose a lower context-cache burden while still generating an enormous token bill.
Someone with adequate hardware can run the model without API charges, Zsolnai-Fehér says. He does not have that hardware and uses an API or Lambda instead. His broader view is that DeepSeek’s open papers and compression work help lower the cost of AI systems over time, with potential value for doctors and scientists.