The most interesting number of this launch is not the size of the model.

// the whole thing

Before going in piece by piece, this is the whole machine.

Four decisions explain almost the whole story:

1. The prompt stops walking all 40 layers.
2. Most layers stop keeping their own global KV.
3. The global KV drops from FP8 to FP4.
4. The local memory stops being persisted for hours.

// 01 · input-heavy inference

Why an agent changes inference.

An agent reads files, runs code, calls tools, receives results, fails, reads the error again and carries on. At every step it drags most of what came before along with it.

When you send a prompt to a model two things happen, simplifying. First it reads it: prefill. Then it generates the answer token by token: decode.

So that it does not recompute the whole context on every token, the model keeps intermediate representations of what it read. The first time round you can think of them as working notes. The real name is KV cache.

In a short conversation this matters little. On a long agent trajectory it does not.

1. prompt
2. read repo
3. tool result
4. edit
5. test
6. error
7. read error
8. edit
9. ...

Every result is appended to the next request. After enough steps, the model can receive hundreds of thousands of tokens and generate only a few hundred.

Two different costs show up there: computing the input, which is prefill compute, and storing and moving its memory, which is the KV cache.

Sparse attention has cut the first problem a great deal. In doing so, the second weighs more: the active cache occupies HBM, reusable prefixes need storage outside the GPU, and moving all that state consumes bandwidth.

V4.1 Flash is built around that second half.

// 02 · CED

Reading the prompt with half the model.

V4.1 Flash has 40 Transformer layers, but the prompt no longer walks all of them the same way.

You can think of the first 20 as the reader and the other 20 as the writer. Technically DeepSeek calls them causal encoder and decoder.

They are not two independent models. They still form a single autoregressive architecture of 40 layers. What changes is where the prompt goes.

For global attention, each decoder layer projects the KV it needs from the final representation of the encoder. It does not need to walk the whole prompt again layer by layer.

That is where one of the strangest numbers in the model comes from: 8B active parameters per token at prefill, 16B at decode. Reading uses less model than writing.

On an agentic workload that makes sense: the call can carry far more input than output.

// 03 · CSA2

Sharing the memory between layers.

Cutting prefill solves one part. The other is how much memory the model holds while it works.

V4.1 introduces Compressed Sparse Attention 2, CSA2.

There are three ways to compress attention: make each entry of the memory smaller, store or query fewer positions, or stop every layer from keeping an independent copy of very similar information. CSA2 pushes the third one in particular.

A Full layer builds its global KV and does the complete search for the positions to attend to. A Reindex layer reuses the global KV of an earlier Full layer, but scores the positions again with its own query. A Reuse layer reuses both the global KV and the Top-K selection.

Sharing memory does not force every layer to look at exactly the same information. The Reindex layers keep the ability to change the selection.

The 40 layers split into 4 Full, 4 Reindex, 30 Reuse and 2 that only do SWA. The 30 Reuse layers reuse both the global KV and the selection computed by another layer. They still have their own query and their own local SWA state.

This is what lets an architecture that is more complex on paper have a very short execution in some layers. DeepSeek reports paths of 15 kernels in prefill and 11 in decode for the Reuse layers.

// 04 · FP4

Storing the global KV in four bits.

After cutting the number of independent caches, DeepSeek cuts the size of each one.

V4 Flash stored its main KV in FP8. V4.1 takes the global KV down to FP4.

Not all of the memory goes to four bits. The KV belonging to Sliding Window Attention is more sensitive to quantisation and stays in FP8.

The quantisation is introduced during post-training through Quantization-Aware Training. The model learns under the same numeric conditions it will later have to work with.

DeepSeek uses E2M1 with an E4M3 scale for every 16 channels. It applies the quantisation after RoPE and removes an additional global scale that other NVFP4 formats do use.

// 05 · cache hierarchy

Separating the memory that lasts hours from the memory that lasts minutes.

V4 persisted two memories with very different reuse patterns.

The global KV can still be useful hours or days later. The SWA KV describes the recent local state of a session and usually loses its value much sooner.

In V4 both could end up occupying persistent storage for a long time. In V4.1 they are separated.

The global KV stays in persistent storage, with a guaranteed life of at least 72 hours in the design described. The SWA moves to a distributed pool built from approximately 10% of the host DRAM of each machine, and lives for minutes.

The interesting part shows up when that local memory has already expired. V4 had proposed rebuilding it. Doing that exactly was too expensive for production.

V4.1 uses Encoder SWA Bounded Replay: it replays only the last 128 tokens. It does not rebuild exactly the same state. It bounds the cost of recovery.

A miss stops opening a large recomputation and gets a bounded cost instead.

Along with the rest of the changes, the persistent cache lands at around 1/8 of V4 Flash. Part of the improvement comes from storing the memory better. Part comes from not storing it.

// 06 · checkpoint

V4 Flash → V4.1 Flash.

After the four decisions, the change can be summed up like this.

There is a less obvious change behind the table. V4.1 almost doubles the backbone, from 284B to 552B, but the active path does not grow in the same proportion.

More total capacity does not mean paying for all that capacity on every token.

// 07 · compute, memory, bill

Compute, memory and the bill.

The four decisions attack different resources.

Less compute when reading.

CED makes the long context go mainly through 20 layers during prefill.

Less HBM per context.

CSA2 shares KV between layers and FP4 reduces the size of the global KV.

Less persistent storage.

The local memory stops living for hours, and Bounded Replay makes rebuilding it approximately affordable.

Less indexing work.

The deep Reindex layers search inside 16,384 candidates, not the whole context.

Less overhead in the Reuse layers.

DeepSeek reports 15 kernels in prefill and 11 in decode for that path.

More reusable prefixes on the same infrastructure.

If each prefix takes less room, more of them fit. If more fit, the chances of a cache hit go up.

From 4K to 1M

From 4K to 1M tokens the context grows 256×. The cost of decoding a token, measured by DeepSeek in precision-weighted FLOPs, grows around 25%.

The metric weights BF16 = 1, FP8 = 0.5 and FP4 = 0.25. It is not end-to-end latency and it is not an invoice. It is useful for seeing the goal: that the cost per generated token should stop growing in proportion to the length of the context.

Where it shows up in price

DeepSeek cut its rates with the launch. The largest cut is on cached input, which is exactly the part that matters most when an agent resends a growing trajectory and much of that context has already passed through the system.

The 890 bytes are not an abstract metric: they end up changing how much context can be kept reusable and how much it costs to use it again.

// 08 · model + scaffold

The benchmarks do not tell a single story.

V4.1 Flash does not win everything.

On several agentic and software benchmarks it competes with very large closed systems. On harder reasoning and expert-knowledge tasks there are still clear differences.

On Codeforces it reaches 3,471, against 3,348 for V4 Pro and 3,289 for V4 Flash.

DeepSeek also publishes perplexity tests on internal corpora, company documentation, private repositories and academic material, much less exposed to contamination than public benchmarks. The base model of V4.1 Flash improves on that of V4 Pro across all three reported sets.

Slide the table to see every column.

Reasoning effort at maximum. A dash means DeepSeek reports no figure.

There is another important variable: the harness.

The architecture that makes context cheap and the harness that decides how to use it are two different layers of the same system.

// 09 · what stayed the same

What has not changed.

V4.1 introduces plenty of new mechanisms, but CED should not be read as if DeepSeek had turned the model into a classic encoder-decoder architecture.

• It is still an autoregressive model.
• It is still a MoE.
• It still uses local attention through SWA.
• It still uses sparse attention for long context.
• The decoder is not a second independent model.
• CED changes how the prompt is processed and reused inside the 40-layer stack.

// 10 · other changes

Other pieces that changed.

The four decisions above explain the bulk of the context economics. V4.1 also changes other parts of the system.

• Engram

  Adds approximately 196B parameters of conditional memory across two modules.

  It memorises patterns of 2, 3 and 4 tokens through hash tables. Because the memory address can be computed directly from the input, those embeddings can be prefetched from host memory over RDMA while the Transformer carries on working.

  More parametric capacity without keeping all of it resident in HBM.

• DSpark

  Replaces the previous MTP approach to speculative decoding.

  A draft model proposes several tokens and an additional head estimates the probability of acceptance per position. The system combines that confidence with real throughput curves to decide how much speculation is worth it under load.

  The goal is not to always propose more tokens. It is to maximise real throughput.

• Single-Pass mHC

  DeepSeek reorganises certain dependencies of its mHC residual connections so that operations can be fused into a Mega-mHC kernel.

  The intended consequence is less activation traffic and fewer trips to memory.

• Native vision

  V4.1 Flash carries vision natively.

  Before handing the visual representation to the language model, a 3×3 pixel-unshuffle reduces the number of visual tokens by approximately nine times.

  Another way of cutting context before it reaches the expensive part.

// 11 · deployment topology

EPD: encoder, prefill and decode stop scaling together.

DeepSeek introduces Encoder-Prefill-Decode disaggregation, EPD.

1. visual encoding
2. prefill
3. decode

The three phases have different hardware profiles. Prefill looks for massive processing throughput. Decode is far more sensitive to memory bandwidth and to latency. Visual encoding introduces a different load again.

EPD lets them be scaled independently and lets part of the work overlap.

For anyone consuming an API this is almost invisible. For anyone serving the model, it can change the whole topology of the deployment.

// 12 · run it

Running it on Helmcode.

V4.1 Flash is available on Helmcode now, on European infrastructure and with zero log retention.

It replaces V4 Flash in the same slot on the plans and keeps the model id, so an existing integration can receive the new architecture without changing the client.

curl https://api.helmcode.com/v1/chat/completions \
  -H "Authorization: Bearer sk-your-key-here" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-flash",
    "messages": [
      {
        "role": "user",
        "content": "Explain RAG in one sentence."
      }
    ]
  }'

You need an active Helmcode or NaN subscription and an API key from your dashboard.

If you are choosing between the models included in your plan, V4.1 Flash makes sense when agentic work, long documents or the million-token window are what weigh. For RAG, classification, short code and other workloads, the choice may be a different one. see_the_model_guide →