DeepSeek V4.1 Flash In-Depth: 552B MoE, Asymmetric Causal-Encoder-Decoder Architecture, 437x KV Cache Compression
1. Introduction: When the “Smallest” Model Dethrones Its Own Flagship
On September 10, 2026, DeepSeek officially released DeepSeek V4.1 Flash. The name is deceptively familiar — this is not a minor update to V4 Flash, but the smallest member of an entirely new architecture family. Even more shocking, DeepSeek simultaneously announced that V4.1 Flash surpasses V4 Pro on every measurable dimension: performance, cost, speed, and total runtime. Starting September 14, V4 Pro will be phased out, with all deepseek-v4-pro requests routed to V4.1 Flash at Flash pricing.
A “small” model killing its own flagship — and slashing API prices to boot. This article dissects the architecture, KV cache compression, benchmarks, pricing strategy, multimodal capabilities, and ecosystem impact of this landmark release.
┌─────────────────────────────────────────────────────────────────────┐
│ DeepSeek Model Family Evolution │
├──────────────┬──────────────┬──────────────┬───────────────────────┤
│ DeepSeek │ DeepSeek │ DeepSeek │ DeepSeek │
│ V3 Series │ V4 Preview │ V4 Flash │ V4.1 Flash ★NEW │
│ (671B MoE) │ (1M ctx) │ (Official) │ (New Architecture) │
├──────────────┼──────────────┼──────────────┼───────────────────────┤
│ Legacy Arch │ 1M Context │ Cost-Opt │ Causal-Encoder- │
│ 671B MoE │ Experimental │ Production │ Decoder Asymmetric │
│ │ │ │ 552B MoE │
├──────────────┼──────────────┼──────────────┼───────────────────────┤
│ │ │ │ 8B in / 16B out │
│ │ │ │ KV Cache 437x smaller │
│ │ │ │ Native Multimodal │
└──────────────┴──────────────┴──────────────┴───────────────────────┘
2. The Causal-Encoder-Decoder (CED) Architecture: Decoupling Read from Write
2.1 Design Philosophy
Traditional autoregressive LLMs (GPT, Llama, etc.) use a monolithic Decoder-Only architecture: one set of weights handles both reading and writing. The same compute budget is shared between the Prefill and Decode phases. For short contexts this is fine, but at million-token scale, the Prefill complexity grows as O(N·L) and becomes the dominant bottleneck.
DeepSeek V4.1 Flash’s Causal-Encoder-Decoder (CED) architecture breaks this paradigm entirely:
┌──────────────────────────────────────────────────────────────────────┐
│ DeepSeek V4.1 Flash Causal-Encoder-Decoder Architecture │
├──────────────────────────────────────────────────────────────────────┤
│ │
│ ┌────────────────────────────────────────────────────────────┐ │
│ │ Encoder (20 layers) │ │
│ │ Input Activation: 8B params — Responsible for "Reading" │ │
│ │ │ │
│ │ Layer 1: CSA2 Full Mode ── Compute own KV + Top-K idx │ │
│ │ Layer 2: CSA2 Reindex Mode ── Reuse KV, new Query→Top-K │ │
│ │ Layer 3: CSA2 Reuse Mode ── Full inheritance, zero FLOPs│ │
│ │ ... │ │
│ │ Layer 20: Outputs H_{L/2} hidden state │ │
│ └────────────────────┬───────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌────────────────────────────────────────────────────────────┐ │
│ │ Engram Memory Module (196B params) │ │
│ │ Multi-head hashing + Context-aware gating │ │
│ └────────────────────┬───────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌────────────────────────────────────────────────────────────┐ │
│ │ Decoder (20 layers) │ │
│ │ Output Activation: 16B params — Responsible for "Writing" │ │
│ │ │ │
│ │ Global KV projected from Encoder H_{L/2} │ │
│ │ Hierarchical Sparse Indexer: Block-level candidate pool │ │
│ │ Sliding Window Attention: Local context fusion │ │
│ └────────────────────────────────────────────────────────────┘ │
│ │
└──────────────────────────────────────────────────────────────────────┘
The CED architecture reduces Prefill complexity from O(N·L) to approximately O(N·L/2 + n_win·L/2), where n_win is the sliding window size. For agent workloads with tens to hundreds of thousands of input tokens, compute is nearly halved.
2.2 Why 8B/16B Asymmetric Activation is Perfect for Agent Workloads
Agent-style tasks have a dramatically skewed token consumption pattern:
- Input side: Code repository prefixes, tool return values, multi-turn conversation history — tens to hundreds of thousands of tokens
- Output side: One tool call, a code diff, a concluding sentence — tens to hundreds of tokens
The input-to-output ratio can reach 100:1 or even 1000:1. If 99% of compute is spent on “reading,” there is no reason to burden the read path with the same parameter count as the write path.
The following code simulates the cost advantage of the asymmetric architecture:
package main
import (
"fmt"
"math"
)
type ModelArch struct {
Name string
InputActiveB float64
OutputActiveB float64
TotalParamsB float64
}
func main() {
ced := ModelArch{
Name: "DeepSeek V4.1 Flash (CED)",
InputActiveB: 8,
OutputActiveB: 16,
TotalParamsB: 552,
}
standard := ModelArch{
Name: "V4 Pro (Decoder-Only)",
InputActiveB: 37,
OutputActiveB: 37,
TotalParamsB: 1016,
}
inputTokens := 100000
outputTokens := 200
fmt.Println("=== Agent Workload Compute Cost Comparison ===")
fmt.Printf("Input: %d tokens, Output: %d tokens (ratio %.0f:1)\n",
inputTokens, outputTokens, float64(inputTokens)/float64(outputTokens))
fmt.Println()
// Prefill phase
cedPrefill := ced.InputActiveB * float64(inputTokens)
stdPrefill := standard.InputActiveB * float64(inputTokens)
fmt.Printf("Prefill Compute (B·token):\n")
fmt.Printf(" V4.1 Flash (CED): %.2f B·tok (Encoder %dB × %dtok)\n",
cedPrefill, int(ced.InputActiveB), inputTokens)
fmt.Printf(" V4 Pro: %.2f B·tok (Active %dB × %dtok)\n",
stdPrefill, int(standard.InputActiveB), inputTokens)
fmt.Printf(" CED Savings: %.1f%%\n",
(1-cedPrefill/stdPrefill)*100)
fmt.Println()
// Decode phase (per output token)
cedDecode := ced.OutputActiveB * float64(outputTokens)
stdDecode := standard.OutputActiveB * float64(outputTokens)
// Total
cedTotal := cedPrefill + cedDecode
stdTotal := stdPrefill + stdDecode
fmt.Printf("Total Compute:\n")
fmt.Printf(" V4.1 Flash: %.2f B·token\n", cedTotal)
fmt.Printf(" V4 Pro: %.2f B·token\n", stdTotal)
fmt.Printf(" Total Savings: %.1f%%\n", (1-cedTotal/stdTotal)*100)
// Sensitivity analysis
fmt.Println()
fmt.Println("=== Input/Output Ratio Sensitivity ===")
ratios := []float64{10, 100, 500, 1000, 5000}
for _, ratio := range ratios {
inTok := 100000
outTok := int(math.Ceil(float64(inTok) / ratio))
cost := ced.InputActiveB*float64(inTok) + ced.OutputActiveB*float64(outTok)
stdCost := standard.InputActiveB*float64(inTok) + standard.OutputActiveB*float64(outTok)
fmt.Printf(" Ratio %4.0f:1 → CED saves %5.1f%%\n", ratio, (1-cost/stdCost)*100)
}
}
The results are clear: at a typical 100:1 input-output ratio, the CED architecture uses approximately 55% of the total compute compared to a standard Decoder-Only architecture. The advantage grows with the ratio.
2.3 Compressed Sparse Attention 2 (CSA2)
CSA2 is the attention mechanism at the heart of the CED architecture, compressing KV cache across three dimensions:
┌──────────────────────────────────────────────────────────────────────┐
│ CSA2 Three-Dimensional Compression Strategy │
├──────────────────────────────────────────────────────────────────────┤
│ │
│ Dimension 1: Entry Size │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ Projection-based information sharing across heads │ │
│ │ Each head doesn't store independent KV │ │
│ └──────────────────────────────────────────────────────┘ │
│ │
│ Dimension 2: Sequence Dimension │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ Multiple tokens compressed into single KV entry │ │
│ │ Top-K sparse attention: K entries selected per query│ │
│ └──────────────────────────────────────────────────────┘ │
│ │
│ Dimension 3: Layer Dimension │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ Cross-layer KV reuse: Full → Reindex → Reuse │ │
│ │ Full Mode: Compute own KV + Top-K indices │ │
│ │ Reindex: Reuse KV, new Query for different Top-K│ │
│ │ Reuse: Full inheritance from prior layer │ │
│ └──────────────────────────────────────────────────────┘ │
│ │
└──────────────────────────────────────────────────────────────────────┘
The following Python code demonstrates CSA2’s three operating modes:
import numpy as np
from dataclasses import dataclass
from typing import Optional, Tuple
@dataclass
class CSA2Config:
d_model: int = 7168
n_heads: int = 64
d_kv: int = 128
n_shared_layers: int = 3
top_k: int = 32
block_size: int = 64
class CSA2Attention:
"""Compressed Sparse Attention 2 Implementation"""
def __init__(self, config: CSA2Config, layer_idx: int):
self.config = config
self.layer_idx = layer_idx
# Main KV projections
self.W_k_main = np.random.randn(config.d_model,
config.d_kv * config.n_heads) * 0.02
self.W_v_main = np.random.randn(config.d_model,
config.d_kv * config.n_heads) * 0.02
# Indexer KV projections (for sparse indexing)
self.W_k_idx = np.random.randn(config.d_model, config.d_kv) * 0.02
self.W_q_idx = np.random.randn(config.d_model, config.d_kv) * 0.02
# Shared KV cache (cross-layer reuse)
self.shared_kv: Optional[Tuple[np.ndarray, np.ndarray]] = None
self.shared_indices: Optional[np.ndarray] = None
def get_mode(self) -> str:
"""Determine CSA2 mode based on layer index"""
group_size = self.config.n_shared_layers
pos_in_group = (self.layer_idx - 1) % group_size
if pos_in_group == 0:
return "full"
elif pos_in_group == 1:
return "reindex"
else:
return "reuse"
def forward_full_mode(self, x: np.ndarray) -> Tuple:
"""Full Mode: compute own KV and generate Top-K indices"""
batch, seq_len, _ = x.shape
# Main KV computation
K_main = (x @ self.W_k_main).reshape(
batch, seq_len, self.config.n_heads, self.config.d_kv)
V_main = (x @ self.W_v_main).reshape(
batch, seq_len, self.config.n_heads, self.config.d_kv)
# Indexer KV
K_idx = x @ self.W_k_idx
Q_idx = x @ self.W_q_idx
# Hierarchical indexing: block-level candidate pool
n_blocks = seq_len // self.config.block_size
block_scores = np.zeros((batch, n_blocks))
for b in range(n_blocks):
start = b * self.config.block_size
end = min(start + self.config.block_size, seq_len)
block_scores[:, b] = np.max(
Q_idx[:, :, None, :] @ K_idx[:, start:end, :, None],
axis=(1, 3)
).mean(axis=1)
# Select Top-K blocks, then fine-grained scoring within pool
top_blocks = np.argsort(-block_scores, axis=1)[:, :self.config.top_k]
indices = []
for b in range(batch):
pool = np.concatenate([
np.arange(tb * self.config.block_size,
min((tb + 1) * self.config.block_size, seq_len))
for tb in top_blocks[b]
])
scores = Q_idx[b] @ K_idx[b, pool].T
top_idx = pool[np.argsort(-scores.max(axis=0))[:self.config.top_k]]
indices.append(top_idx)
indices = np.stack(indices)
self.shared_kv = (K_main, V_main)
self.shared_indices = indices
return K_main, V_main, indices
def forward_reuse_mode(self) -> Tuple:
"""Reuse Mode: full inheritance, zero computation"""
assert self.shared_kv is not None
assert self.shared_indices is not None
return (*self.shared_kv, self.shared_indices)
3. KV Cache Compression: A 437x Revolution
3.1 The Global KV Cache
DeepSeek’s KV cache evolution from V1 to V4.1 Flash tells a remarkable story:
┌──────────────────────────────────────────────────────────────────────┐
│ DeepSeek KV Cache Evolution (bytes per token) │
├──────────────────────────────────────────────────────────────────────┤
│ │
│ DeepSeek V1 ████████████████████████████████████████ 390KB │
│ │
│ DeepSeek V2 ██████████████████ 150KB │
│ │
│ DeepSeek V3 ██████ 55KB │
│ │
│ DeepSeek V4 Preview ██▌ 22KB│
│ │
│ DeepSeek V4 Flash █▍ 12KB│
│ │
│ DeepSeek V4.1 Flash ▏ 890B│
│ └── 437x Compression! │
│ │
│ From 390KB to 890B → 437x reduction │
└──────────────────────────────────────────────────────────────────────┘
V4.1 Flash’s global KV cache requires only 890 bytes per token — 1/4 of V4 Flash. This is achieved through three synergistic optimizations:
(1) CSA2 Architectural Compression: Cross-layer KV reuse dramatically reduces redundant storage. Through the Full/Reindex/Reuse three-level pattern, approximately one-third of the 40 layers fully inherit KV and indices from preceding layers, requiring zero additional storage.
(2) FP4 Precision Quantization: DeepSeek extends quantization-aware training (QAT) to the main KV cache using the OCP-standard MXFP4 format. 4-bit precision means a 4x reduction compared to FP16, with near-zero performance degradation thanks to training-time adaptation.
import numpy as np
class MXFP4Quantizer:
"""
OCP-standard MXFP4 KV Cache quantizer
4-bit floating point format with shared exponents per group
"""
def __init__(self, group_size: int = 32):
self.group_size = group_size
def quantize(self, kv_tensor: np.ndarray) -> tuple:
"""Quantize FP32 KV cache to MXFP4 format"""
original_shape = kv_tensor.shape
flat = kv_tensor.flatten()
n_groups = (len(flat) + self.group_size - 1) // self.group_size
padded = np.zeros(n_groups * self.group_size)
padded[:len(flat)] = flat
groups = padded.reshape(n_groups, self.group_size)
exponents = []
mantissas_4bit = []
for group in groups:
max_abs = np.max(np.abs(group))
if max_abs == 0:
exponents.append(0)
mantissas_4bit.extend([0] * self.group_size)
continue
exp = max(-14, min(15, int(np.floor(np.log2(max_abs)))))
exponents.append(exp)
scale = 2.0 ** (-exp)
mantissa = np.clip(np.round(group * scale), -8, 7).astype(np.int8)
mantissas_4bit.extend(mantissa.tolist())
return (np.array(exponents, dtype=np.int8),
np.array(mantissas_4bit, dtype=np.int8),
original_shape)
def dequantize(self, quantized: tuple) -> np.ndarray:
"""Restore MXFP4 to FP32"""
exponents, mantissas_4bit, original_shape = quantized
n_groups = len(exponents)
mantissa_array = np.array(mantissas_4bit).reshape(n_groups, self.group_size)
scales = 2.0 ** exponents.astype(np.float32)
deq = mantissa_array.astype(np.float32) * scales[:, np.newaxis]
total_elements = int(np.prod(original_shape))
return deq.flatten()[:total_elements].reshape(original_shape)
def compression_ratio(self, orig_bytes: int) -> float:
"""Calculate compression ratio"""
orig_elements = orig_bytes // 4
n_groups = (orig_elements + self.group_size - 1) // self.group_size
compressed = orig_elements * 0.5 + n_groups * 1
return orig_bytes / compressed
# Test: Simulate KV cache quantization
if __name__ == "__main__":
np.random.seed(42)
kv_cache = np.random.randn(1, 4096, 128).astype(np.float32)
quantizer = MXFP4Quantizer(group_size=32)
quantized = quantizer.quantize(kv_cache)
deq = quantizer.dequantize(quantized)
mse = np.mean((kv_cache - deq) ** 2)
snr = 10 * np.log10(np.var(kv_cache) / mse)
print(f"=== MXFP4 KV Cache Quantization Test ===")
print(f"Original size: {kv_cache.nbytes / 1024:.1f} KB")
print(f"Quantization MSE: {mse:.6f}")
print(f"SNR: {snr:.2f} dB")
print(f"Compression ratio: {quantizer.compression_ratio(kv_cache.nbytes):.1f}x")
(3) SWA Bounded Replay: This is the key deployment-layer innovation. Traditional Sliding Window Attention (SWA) requires persistent local cache storage on SSD for context reuse. V4.1 Flash leverages findings from PowerAttention research — the effective receptive field of SWA is much smaller than its theoretical limit. When a request resumes, only the most recent n_win tokens need to be “replayed” to approximately reconstruct the required states. This reduces persistent KV cache (SSD) footprint to 1/8 of V4 Flash.
3.2 Hierarchical Sparse Indexer
To maintain sparse attention performance at million-token context lengths, V4.1 Flash introduces a Hierarchical Sparse Indexer in the Decoder:
┌──────────────────────────────────────────────────────────────────────┐
│ Hierarchical Sparse Indexer │
├──────────────────────────────────────────────────────────────────────┤
│ │
│ Query Input │
│ │ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ Step 1: Block-level Scoring │ │
│ │ Divide context into blocks, quick score → Top blocks │ │
│ │ Complexity: O(N/block_size) │ │
│ └──────────────────────┬───────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ Step 2: Fine-grained Scoring within Candidate Pool │ │
│ │ Only score tokens within selected blocks │ │
│ │ Complexity: O(top_blocks × block_size) │ │
│ └──────────────────────┬───────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ Step 3: Final Top-K Selection │ │
│ │ Select final Top-K KV entries from candidate pool │ │
│ │ Complexity: O(top_k) │ │
│ └──────────────────────┬───────────────────────────────┘ │
│ │ │
│ ▼ │
│ Result: Per-query compute cost independent of context length │
│ 10K ctx ↔ 1M ctx: decode latency remains nearly constant │
└──────────────────────────────────────────────────────────────────────┘
This design means V4.1 Flash’s per-token decode latency remains nearly constant regardless of context length. Community benchmarks show approximately 400 tokens/s even at 1M context.
4. Benchmark Performance
4.1 Key Results
V4.1 Flash achieves state-of-the-art results across diverse benchmarks:
| Benchmark | Domain | V4 Pro | V4.1 Flash | Delta |
|---|---|---|---|---|
| GPQA Diamond | Science QA | - | 90.9 | New SOTA |
| Codeforces | Competitive Programming | - | 3471 | Surpasses larger models |
| MathArena Apex | Math Reasoning | - | 65.6 | - |
| Terminal-Bench 2.1 | Terminal Tasks | 87.9 | 90.6 | +2.7 |
| CyberGym | Cybersecurity | 83.3 | 88.1 | +4.8 |
| DeepSWE v1.1 | Software Engineering | 62.0% | 74.2% | +12.2% |
benchmarks = {
"GPQA Diamond": {"V4 Pro": 85.0, "V4.1 Flash": 90.9, "GPT-6 Astra": 92.1},
"Terminal-Bench 2.1": {"V4 Pro": 87.9, "V4.1 Flash": 90.6, "Claude 5": 89.2},
"CyberGym": {"V4 Pro": 83.3, "V4.1 Flash": 88.1, "Grok 3": 85.7},
"DeepSWE v1.1": {"V4 Pro": 62.0, "V4.1 Flash": 74.2, "Claude 5 Opus": 72.5},
}
print("=== Multi-Model Benchmark Comparison ===")
print(f"{'Benchmark':<20} {'V4 Pro':<10} {'V4.1 Flash':<15} {'Competitor':<15} {'Flash Δ':<10}")
print("-" * 70)
for bench, scores in benchmarks.items():
v4p = scores["V4 Pro"]
flash = scores["V4.1 Flash"]
comp = list(scores.values())[2]
delta = flash - v4p
best = max(scores.values())
medal = "🥇" if flash == best else "🥈"
print(f"{bench:<20} {v4p:<10.1f} {flash:<8.1f} {medal:<3} {comp:<12.1f} {'+'if delta>0 else ''}{delta:.1f}")
# Performance-per-dollar analysis
print()
print("=== Performance-Per-Dollar Efficiency ===")
efficiency = {
"V4.1 Flash": {"Terminal-Bench": 90.6, "Cost(base=1)": 1.0, "Eff/Unit": 90.6},
"V4 Pro": {"Terminal-Bench": 87.9, "Cost(base=1)": 4.0, "Eff/Unit": 22.0},
"GPT-6 Astra Mini": {"Terminal-Bench": 89.5, "Cost(base=1)": 3.0, "Eff/Unit": 29.8},
}
for name, data in efficiency.items():
print(f" {name:<25}: Eff/Unit = {data['Eff/Unit']:.1f}")
4.2 Controllable Reasoning Effort
V4.1 Flash introduces a unique capability: Controllable Reasoning Effort. By setting a scalar effort value (1-100) in the system prompt, users can explicitly trade off inference cost for accuracy:
package main
import (
"bytes"
"encoding/json"
"fmt"
"net/http"
"time"
)
type ChatRequest struct {
Model string `json:"model"`
Messages []Message `json:"messages"`
MaxTokens int `json:"max_tokens"`
Effort int `json:"effort"`
}
type Message struct {
Role string `json:"role"`
Content string `json:"content"`
}
type ChatResponse struct {
Choices []struct {
Message Message `json:"message"`
} `json:"choices"`
Usage struct {
PromptTokens int `json:"prompt_tokens"`
CompletionTokens int `json:"completion_tokens"`
TotalTokens int `json:"total_tokens"`
} `json:"usage"`
}
func main() {
apiKey := "YOUR_DEEPSEEK_API_KEY"
// Demonstrate different reasoning effort levels
testCases := []struct {
name string
effort int
prompt string
}{
{"Low Effort: Quick Q&A", 10, "Explain KV cache in one sentence."},
{"Medium Effort: Code Gen", 50, "Implement a concurrent KV cache in Go."},
{"Max Effort: Math Proof", 100,
"Prove that n³ + 2n is divisible by 3 for all positive integers n."},
}
for _, tc := range testCases {
req := ChatRequest{
Model: "deepseek-flash",
Messages: []Message{
{Role: "system", Content: fmt.Sprintf(
"Reasoning effort level: %d.", tc.effort)},
{Role: "user", Content: tc.prompt},
},
MaxTokens: 8192,
Effort: tc.effort,
}
body, _ := json.Marshal(req)
httpReq, _ := http.NewRequest("POST",
"https://api.deepseek.com/chat/completions",
bytes.NewBuffer(body))
httpReq.Header.Set("Content-Type", "application/json")
httpReq.Header.Set("Authorization", "Bearer "+apiKey)
client := &http.Client{Timeout: 60 * time.Second}
resp, err := client.Do(httpReq)
if err != nil {
fmt.Printf("%s - Error: %v\n", tc.name, err)
continue
}
defer resp.Body.Close()
var result ChatResponse
json.NewDecoder(resp.Body).Decode(&result)
fmt.Printf("▶ %s (Effort=%d)\n", tc.name, tc.effort)
fmt.Printf(" Input tok: %d | Output tok: %d\n",
result.Usage.PromptTokens, result.Usage.CompletionTokens)
}
// Effort vs token cost curve
fmt.Println("\n=== Effort vs Output Tokens ===")
for e := 1; e <= 100; e += 10 {
estTokens := 50 + int(float64(e)/100.0*200)
fmt.Printf(" Effort %3d: ~%4d output tokens (%.1fx baseline)\n",
e, estTokens, float64(estTokens)/50)
}
}
5. Pricing Strategy & API Migration
5.1 API Pricing
V4.1 Flash’s new pricing took effect on September 10, 2026 at 04:00 UTC, maintaining peak/off-peak pricing:
| Item | Peak (¥/1M tokens) | Off-Peak (¥/1M tokens) | vs V4 Flash |
|---|---|---|---|
| Cache Hit Input | 0.04 | 0.02 | ↓ 60% |
| Cache Miss Input | 2 | 1 | ↓ 33.3% |
| Output | 8 | 4 | ↓ 11.1% |
Peak hours: Mon-Fri 09:00-12:00 & 14:00-18:00 Beijing time. All other hours are off-peak.
5.2 V4 Pro Retirement Timeline
┌──────────────────────────────────────────────────────────────────────┐
│ V4 Pro Retirement & Migration Timeline │
├──────────────────┬───────────────────────────────────────────────────┤
│ 2026/09/10 │ V4.1 Flash released │
│ 12:00 CST │ New model name: deepseek-flash │
│ │ New pricing effective │
├──────────────────┼───────────────────────────────────────────────────┤
│ ~2026/09/14 │ V4 Flash / V4 Flash Vision Exp retired │
│ │ deepseek-v4-flash/v4-flash-vision-exp → V4.1 Flash│
├──────────────────┼───────────────────────────────────────────────────┤
│ 2026/09/14 │ V4 Pro decommissioned │
│ 12:00 CST │ deepseek-v4-pro → V4.1 Flash at Flash pricing │
├──────────────────┼───────────────────────────────────────────────────┤
│ Future │ Route ends when V4.1 Pro launches │
└──────────────────┴───────────────────────────────────────────────────┘
def calculate_savings(cache_hit_input: int, cache_miss_input: int,
output_tokens: int, is_off_peak: bool = False):
"""Calculate cost savings migrating from V4 Pro/Flash to V4.1 Flash"""
old_prices = {"cache_hit": 0.10, "cache_miss": 3.0, "output": 9.0}
new_prices = {
"cache_hit": 0.04 if not is_off_peak else 0.02,
"cache_miss": 2.0 if not is_off_peak else 1.0,
"output": 8.0 if not is_off_peak else 4.0,
}
old_cost = (cache_hit_input * old_prices["cache_hit"] +
cache_miss_input * old_prices["cache_miss"] +
output_tokens * old_prices["output"])
new_cost = (cache_hit_input * new_prices["cache_hit"] +
cache_miss_input * new_prices["cache_miss"] +
output_tokens * new_prices["output"])
return {"old": old_cost, "new": new_cost,
"savings": old_cost - new_cost,
"pct": (1 - new_cost / old_cost) * 100}
# Typical agent scenario: 100M cache hit + 10M miss + 1M output
result = calculate_savings(100, 10, 1, is_off_peak=False)
print(f"Peak: ¥{result['old']:.2f} → ¥{result['new']:.2f} (save {result['pct']:.0f}%)")
result_off = calculate_savings(100, 10, 1, is_off_peak=True)
print(f"Off-Peak: ¥{result_off['old']:.2f} → ¥{result_off['new']:.2f} (save {result_off['pct']:.0f}%)")
6. Multimodal and Agent Capabilities
6.1 Native Visual Understanding
V4.1 Flash natively supports multimodal visual understanding, replacing the experimental V4 Flash Vision Exp. Developers can now process both text and images through a single unified API:
import base64
import requests
def analyze_image(api_key: str, image_path: str, prompt: str) -> str:
"""Analyze an image using DeepSeek V4.1 Flash"""
with open(image_path, "rb") as f:
img_b64 = base64.b64encode(f.read()).decode("utf-8")
ext = image_path.split(".")[-1].lower()
mime = {"jpg": "image/jpeg", "jpeg": "image/jpeg",
"png": "image/png"}.get(ext, "image/png")
payload = {
"model": "deepseek-flash",
"messages": [{
"role": "user",
"content": [
{"type": "text", "text": prompt},
{"type": "image_url",
"image_url": {"url": f"data:{mime};base64,{img_b64}"}}
]
}],
"max_tokens": 4096,
"effort": 75,
}
resp = requests.post(
"https://api.deepseek.com/chat/completions",
headers={"Authorization": f"Bearer {api_key}"},
json=payload, timeout=120
)
return resp.json()["choices"][0]["message"]["content"]
# Multimodal Agent: Code understanding from IDE screenshot
def agent_from_screenshot(api_key: str, screenshot_path: str) -> dict:
"""Analyze code from IDE screenshot, then generate improvements"""
analysis = analyze_image(api_key, screenshot_path,
"This is an IDE screenshot. Identify the language, extract the key logic, "
"find bugs or performance issues, and suggest concrete fixes.")
# Agent next step: auto-generate fixed code
payload = {
"model": "deepseek-flash",
"messages": [
{"role": "system", "content": "Senior software engineer."},
{"role": "user", "content": f"Based on this analysis, generate refactored code:\n\n{analysis}"}
],
"max_tokens": 8192, "effort": 80,
}
resp = requests.post("https://api.deepseek.com/chat/completions",
headers={"Authorization": f"Bearer {api_key}"}, json=payload, timeout=120)
result = resp.json()
return {
"analysis": analysis,
"refactored_code": result["choices"][0]["message"]["content"],
}
6.2 DeepSeek Harness v0.1.5
Updated alongside V4.1 Flash, Harness v0.1.5 introduces several key Agent capability enhancements:
"""
DeepSeek Harness v0.1.5 Key Features
"""
# Feature 1: KV Cache Persistence with System Prompt Updates
print("=== KV Cache Persistence: System Prompt Updates ===")
print()
print("Traditional: System prompt changes → Full re-prefill → KV Cache discarded")
print("Harness v0.1.5: Keep global KV Cache, incrementally update prompt portion")
print()
print(" Traditional: N×100K token prefill for N updates = ~2-5s each")
print(" Harness v0.1.5: 1×100K + (N-1)×incremental ≈ ~0.1s per update")
print()
# Feature 2: Agent Teams
print("=== Agent Teams Collaboration ===")
print()
team = {
"Coordinator (Main Agent)": {
"Role": "Task decomposition, assignment, progress tracking",
"Tools": ["Task queue", "State monitor", "Conflict detector"]
},
"Agent 1 (Code Analyzer)": {
"Role": "Static analysis, vulnerability scanning",
"Tools": ["AST parser", "SAST analyzer"]
},
"Agent 2 (Test Generator)": {
"Role": "Generate test cases, execute, report coverage",
"Tools": ["Testing framework", "Mock generator"]
},
}
for agent, info in team.items():
print(f" {agent}:")
print(f" Role: {info['Role']}")
print(f" Tools: {', '.join(info['Tools'])}")
print()
# Feature 3: Thinking Modes
print("=== Thinking Modes ===")
modes = {
"auto": "Model decides whether to think (default)",
"low": "Fast responses, minimal reasoning",
"high": "Deep reasoning for complex tasks",
"max": "Maximum reasoning, up to 2.5x more output tokens",
}
for mode, desc in modes.items():
print(f" {mode:8s}: {desc}")
7. Open Source and Ecosystem
7.1 Model Weights & Technical Report
DeepSeek V4.1 Flash weights are open source on Hugging Face:
- Model weights: https://huggingface.co/deepseek-ai/DeepSeek-V4.1-Flash
- Technical report: DeepSeek_V41_Tech_Report.pdf
Self-hosting a 552B MoE is not trivial — DeepSeek explicitly states it requires 2,000 GPUs + storage cluster. For most teams, the API is the only rational choice.
7.2 Ecosystem Partners
- Tencent WorkBuddy (including CodeBuddy): Fully integrated with V4.1 Flash
- OpenCode: Official partner, full integration support
# CodeBuddy + DeepSeek V4.1 Flash integration example
def codebuddy_review(code: str, language: str = "python") -> dict:
"""Integrated code review via CodeBuddy + DeepSeek V4.1 Flash"""
payload = {
"model": "deepseek-flash",
"messages": [
{"role": "system", "content": (
"CodeBuddy reviewer. Focus on: performance, security, correctness. "
"For each issue: severity, line number, description, suggested fix.")},
{"role": "user", "content": f"```{language}\n{code}\n```"}
],
"max_tokens": 8192,
"effort": 85, # High effort for code review
"temperature": 0.1,
}
return payload # Sent through WorkBuddy platform
8. Architecture Generation Gap & Future Outlook
8.1 Why Flash Surpasses Pro
| Dimension | V4 Pro (Old Arch) | V4.1 Flash (New Arch) |
|---|---|---|
| Paradigm | Decoder-Only | Causal-Encoder-Decoder |
| Total Params | 1,016B MoE | 552B MoE |
| Active Params/tok | ~37B | 8B(in) / 16B(out) |
| KV Cache (per tok) | ~12KB | 890B |
| Context | 1M | 1M |
| Max Output | 128K | 384K |
| Multimodal | ❌ | ✅ Native vision |
| Concurrency Limit | 500 | 2,500 |
| Reasoning Control | ❌ | ✅ 1-100 adjustable |
With fewer total parameters, V4.1 Flash achieves greater intelligence — proving the CED architecture direction is correct. Asymmetric compute coupled with extreme cache compression paves the way for larger models (V4.1 Pro).
8.2 The Flash Family Roadmap
┌──────────────────────────────────────────────────────────────────────┐
│ DeepSeek New Architecture Family (Projected) │
├──────────────────────────────────────────────────────────────────────┤
│ │
│ 2026/09/10 V4.1 Flash ★ Released │
│ ├── Smallest member, proof of concept │
│ ├── 552B MoE, 8B in / 16B out │
│ └── Validates CED + CSA2 + FP4 │
│ │
│ 2026 Est. V4.1 Pro ☆ Planned │
│ ├── Scaled-up parameters │
│ ├── Projected: ~1T+ MoE │
│ ├── Active: ~16B in / 32B out │
│ └── Stronger reasoning │
│ │
│ 2027 Est. V4.1 Ultra ☆ Conceptual │
│ ├── Extreme scale │
│ └── Potential new modalities │
│ │
└──────────────────────────────────────────────────────────────────────┘
8.3 Key Takeaways for AI Engineering
Asymmetric compute is the architecture for the Agent Age: As AI workloads shift from “dialogue” to “agent” (long input, short output), read-write decoupled CED architectures will become mainstream.
KV cache compression defines the economic model: V4.1 Flash proves that aggressive KV cache compression translates directly to API pricing advantages. For agent scenarios where cache-hit charges dominate, smaller KV cache means lower costs and higher concurrency.
Open source ≠ self-hostable: Weights are released, but a 552B MoE requires 2,000 GPUs to run. The API remains the primary access path — though open weights prevent vendor lock-in.
“Small” is relative: V4.1 Flash is called “Flash” (implying light weight), yet its 552B total parameters are anything but small. The industry is moving from “total parameters” to “active parameters × inference cost” as the true measure of model size.
Key Links: