On the afternoon of September 8, 2026, DeepSeek released a temporary
endpoint named deepseek-v4.1-flash-expires-on-0910 in its official
community group. Two days later, it was
officially launched. DeepSeek cut cache-hit input pricing for the
Flash series by roughly 60%, while announcing that Flash would take over
requests previously routed to V4 Pro. The official announcement featured
the usual buzzwords: native multimodal, stronger, faster, and cheaper.
At first glance, it was easy to assume this was just another routine
price cut.
Released alongside the update announcement was a 51-page technical report titled Pushing the Limits of KV Cache Compression. The report spent virtually no space hyping massive leaps in model capabilities; instead, it scrutinized every detail of cache compression. The comparative data in the text laid out the bottom line: global KV cache was compressed to about one-fourth of the previous generation, and persistent KV cache was reduced to about one-eighth. Scaling the context window 256-fold from 4K all the way to 1 million tokens, compute during the decode phase increased by only a quarter, keeping the entire compute curve nearly flat.
Every time an agent running long-horizon tasks executes a tool call, the system must re-read all accumulated dialogues, code files, and error messages from scratch. The parameter scale consumed by the model per inference round remains constant, yet the context history it carries snowballs with every turn.
To avoid the overhead of re-parsing long text from scratch each time, systems convert each processed segment of context into intermediate states and store them in high-speed GPU memory (VRAM)—this is the resident KV cache. While this working memory eliminates substantial amounts of redundant forward computation, it shifts the bill to storage media. High-speed VRAM is both expensive and capacity-constrained; once it overflows, the system must spill data to SSDs or host memory. When the next tool call returns results, the bus must haul the data back into VRAM. VRAM footprint, disk persistence, and bus transfer: these three expenses are tightly interlocked.
In long-context environments, this triple burden multiplies. Dialogue history and execution logs only grow, often exhausting VRAM after just a few turns, turning disk spilling from a stopgap into the default state. Whenever a session resumes after an interruption or cache misses require recomputation, the system has to retrieve this data and compute it all over again. At this point, the center of gravity of the bill quietly shifts toward how to store read content efficiently and retrieve it intact for the next invocation, while the expenditure on model inference compute itself recedes into the background.
The previous-generation V4 focused primarily on tackling the compute bottleneck introduced by long contexts. With the rollout of sparse attention mechanisms, models no longer needed to compute across the entire text token by token; by selecting only tightly coupled local context for forward passes, the compute expenditure plummeted. However, the system bottleneck did not simply vanish—it merely shifted. DeepSeek provided direct evidence in the report’s introduction: once forward compute costs dropped, what truly drove up overall latency and cost was the capacity consumed by persistent storage and the time spent transferring data across machine buses.
According to Amdahl’s Law, speeding up only one component of a system leaves the remaining parts holding back overall acceleration. The more a single component is optimized down, the smaller the marginal return from continuing to polish it, and the bottleneck naturally migrates to the next link. Today, compute optimization in the decode phase has crossed its point of diminishing returns; squeezing compute along the old path can hardly yield further cost reductions. Previously uncompressed high-speed VRAM capacity, persistent disk overhead, and interconnect bandwidth between nodes have now become the critical levers governing total serving cost.
The battle over inference costs has thus slid from compute toward the memory hierarchy, relegating compute optimization to a secondary priority. The seemingly scattered engineering trade-offs in DeepSeek’s report—whether cross-layer sharing or switching to low-bit storage—all align along this central axis, targeting the specific pain points of VRAM capacity, external disk spilling, and bus transfer.
How much space cache occupies is a simple multiplication problem: how many bytes a single entry takes, how many entries the sequence is divided into, and how many layers must each retain a copy. Multiplying these three numbers yields the total cache volume. These are the only three places where optimizations can intervene, and modifying any one of them saves space proportionally in the final total.
The entry dimension has historically seen the most intervention. Approaches like GQA and MLA share dimensions across different attention heads to shrink individual entries. The additional move this time targets precision: main KV entries were converted from the previous generation’s 8-bit precision to 4-bit, nearly halving their size. This step is safe because the 4-bit format is used strictly for storage; cache entries are dequantized back into high-precision floating-point numbers before entering attention computation. By taking no low-precision risks on the compute side and compressing volume only during transfer and idle storage, underlying chips require no specialized low-precision matrix multiplication units, rendering precision loss negligible.
The sequence dimension is likewise familiar territory. Merging multiple consecutive tokens into a single entry shortens the sequence, reducing the number of entries—which is where the term ‘compression’ in the cache scheme’s name originates.
What remained largely untouched was the third factor: layers. Historically, every layer maintained its own copy of the global KV cache, even though adjacent layers captured highly overlapping global receptive fields filled with redundancy. Eliminating this redundancy required first determining which information cannot be shared. The report splits context into two halves: fine-grained linguistic features evolve across network depth and concentrate in the local, most recent window, necessitating layer-by-layer retention; the global view, by contrast, handles coarse-grained retrieval and localization where adjacent layers differ minimally, allowing cross-layer sharing. The entire compression scheme targets only the global branch, leaving local details fully preserved.
Sharing does not mean getting it for free. If every layer simply reused the exact same global memory and attended to the exact same positions, the division of labor enabled by network depth would disappear. The report employs grouped reuse. The first two layers use local attention only; the encoder’s remaining 18 layers are divided into three groups, where the first layer of each group computes global memory from scratch and the subsequent five layers reuse it; the decoder is divided into five groups, where the lead layer of each group either computes from scratch or selects a new set of attention positions, while the following three layers inherit both memory and positions. Very few layers compute from scratch; most save redundant storage through reuse. Tightening all three multipliers together produced the result of reducing global KV to roughly one-fourth of the previous generation.
Beyond resident VRAM overhead, running long contexts incurs two unavoidable hard costs: the prefill compute consumed by processing massive inputs, and the persistent storage required for multi-turn session persistence. The technical report carried out targeted redesigns for each of these physical resources.
Agent workloads are characterized by repeatedly re-reading long texts while outputting only a handful of tool-call tokens per turn, consuming vast compute resources during the prefill phase. DeepSeek split the 40-layer network evenly into an encoder for the first half and a decoder for the second half. The global KV states required by the decoder are mapped directly from the encoder’s final layer output, rather than being repeatedly computed layer by layer through the network. This nearly halved the prefill compute load and established an asymmetric parameter architecture: only 8B parameters are activated per token during input ingestion, while the full 16B parameters are engaged during token-by-token output generation. The compute saved directly targets the agent’s most expensive overhead in high-frequency interactions.
For persistent storage across multi-turn interactions, the team adopted a different engineering trade-off. Previously, to reuse states across turns, the sliding-window portion of the KV cache also had to be written entirely to disk, consuming both storage space and bandwidth. Test data revealed that the sliding window’s effective retrieval range in practice was narrower than theoretical assumptions. Based on this finding, the report eliminated physical disk spilling for this sliding-window cache; subsequent session wake-ups require only light replay of data from the most recent window to achieve approximate reconstruction. Spending a negligible amount of local recompute time avoided massive disk writes, reducing persistent storage volume to roughly one-eighth of the previous generation.
Prefill compute slashed by nearly half, in-VRAM global KV cut to one-fourth, and external persistent KV reduced to one-eighth—these three modifications alleviated burdens on compute, VRAM, and secondary storage respectively. The entire strategy follows a clear cost logic: first break serving costs down into concrete physical dimensions like VRAM, compute, and external storage; pinpoint the core elements that dominate expenditure under specific workloads; and then identify structural redundancies that can offset them at the lowest possible cost.
This online release was accompanied by explicit traffic routing maneuvers: DeepSeek lowered the cache-hit input unit price by up to roughly 60%, while announcing that requests bound for Pro would be redirected wholesale to Flash and billed at Flash rates, positioning Flash to take over the vast majority of routine workflows. With only one day of advance notice and no migration window running old and new models in parallel, the announcement quickly drew backlash from developers. Teams with prompts and production pipelines tuned for V4 Pro worried that swapping models on the backend would destabilize existing tasks; research teams were concerned about reproducibility; and others were frustrated that requests to Pro returned Flash results under the Pro name. DeepSeek subsequently adjusted the schedule, postponing Pro’s deprecation to September 14 at 12:00 Beijing Time, when traffic would be uniformly routed to Flash and billed accordingly. This aligns with the engineering trade-offs reflected in the technical report: model design priorities are shifting from merely chasing parameter scale toward precision matching of specific workload patterns. Flash’s lightweight architecture did not simply slash total model parameters; the key lay in tailoring activated parameters and caching mechanisms to workloads defined by long inputs and repetitive context reads.
Evaluation dimensions in actual model selection have changed accordingly. Rather than chasing score differentials on benchmark leaderboards, deployers need first to audit the actual workloads of their own applications: what is the ratio of long inputs to short outputs, how high of a cache hit rate can the system sustain, and do sessions require frequent cross-session persistence and reloading? An automated execution pipeline characterized by heavy reads and light writes yields a vastly different optimal solution under this physical cost formula than an interactive human-in-the-loop chat system emphasizing real-time back-and-forth.
A closer look at these on-paper gains, however, reveals several question marks in the chain of evidence. All the throughput multipliers and reduction ratios mentioned above originate from DeepSeek’s official technical report—vendor-reported figures that have not been independently verified by third parties. Furthermore, the earlier testing was conducted only on a temporary endpoint with an explicit expiration deadline. Third-party testing has already observed that while multimodal understanding improved, the model tends to spawn numerous sub-agents during complex reasoning tasks, leading to a surge in total token consumption—which is not equivalent to the per-call cost reduction highlighted in the report.
The report itself did not gloss over potential technical blind spots. The authors acknowledged that several aggressive design choices introduce unresolved performance boundaries: cross-layer reuse may introduce positional selection bias, and eschewing disk spilling in favor of approximate reconstruction via window replay risks performance degradation in extreme long-context scenarios, warranting further stress-testing on long-context sparse matching and cache recovery stability. The report also noted that existing public benchmarks are largely saturated; even if benchmark scores are comparable, that does not mean the model has truly matched top closed-source models on complex higher-order reasoning and long-tail corner cases.
Bringing together these engineering implementations and caveats, the core of V4.1 Flash lies in breaking down the long-context serving bill item by item and shifting the optimization focus toward the memory hierarchy. Just how much cost this paradigm can save in real-world production clusters remains to be validated by neutral third-party stress tests and the test of time across complex workloads.
This is the first piece in a two-part series on the memory frontier, covering the serving side: how the KV cache a model carries during inference gets shrunk. The companion piece turns to capacity, looking at how static knowledge itself gets moved off the GPU: Moving Knowledge Off the GPU: DeepSeek Engram and a Model’s Second Sparsity Axis.