DeepSeek V5 Leak: surpass everything with 10X less cost

The Architecture Rumored as V5 Has Already Shipped

For months, developer backchannels, semiconductor supply chain reports, and GitHub commit trackers buzzed with leaks of an impending DeepSeek V5. The rumors anticipated another theatrical whole-integer benchmark clash, engineered to decisively unseat Western frontier models like OpenAI’s GPT-6 Astra and the unreleased Claude 5 frontier family. Industry commentators fixated on speculative parameter counts, synthetic data recipes, and multi-token speculative decoding schemes.

They were looking in the wrong place. On September 10, 2026, DeepSeek officially released DeepSeek-V4.1-Flash under an MIT open-weights license. Rather than staging a theatrical V5 media rollout, DeepSeek quietly replaced the foundation of its production infrastructure under a continuous versioning label. Within days, the company began routing all traffic previously destined for its flagship DeepSeek-V4-Pro directly to V4.1-Flash, billing users at entry-tier rates.

What superficial analysis took for an incremental update was, in reality, the most aggressive architectural restructuring of an open-weight foundation model to date. DeepSeek abandoned the monolithic decoder-only paradigm, introduced asymmetric parameter execution, compressed Key-Value memory by 75%, and established a unit-economic moat that closed-source cloud providers cannot match without bleeding cash.

Beyond V3 and R1: The Causal Encoder-Decoder Shift

Every major frontier LLM of the past five years—from GPT-4o and OpenAI o1 to DeepSeek’s own foundational work in DeepSeek-V3 and DeepSeek-R1—relies on a decoder-only architecture. In a decoder-only model, every single token in a prompt passes through the exact same set of parameter weights as the generated response tokens. Whether the model is digesting a 200,000-token codebase during the prefill phase or generating a two-word confirmation during decode, the computational machinery is identical.

In modern production software, that uniformity creates an enormous efficiency tax. As we documented when dissecting how local decision models dismantle cloud API queueing, production workflows are overwhelmingly input-heavy. Autonomous coding swarms, retrieval-augmented generation pipelines, and repository auditors ingest massive context documents to generate precise, structured patches. The prompt-to-generation ratio frequently reaches 50:1 or 100:1. Activating 40 to 50 billion parameters across thousands of input tokens burns GPU High Bandwidth Memory (HBM) and compute cycles on structural ingestion where deep autoregressive reasoning is completely unnecessary.

DeepSeek shattered this model by implementing a Causal Encoder-Decoder (CED) architecture. Built across a 40-layer transformer pipeline, CED partitions the network into 20 causal encoder layers and 20 decoder layers:

• Asymmetric Parameter Activation: During the input prefill phase, the causal encoder processes the prompt by activating only 8 billion parameters per token. During autoregressive token decode, the network routes activations through specialized experts to deploy 16 billion parameters per token.
• Sparsity Across a 552B Backbone: While the overall model encompasses 552 billion total parameters across its routed and shared experts, the execution path remains exceptionally lean. The model maintains broad domain competence without ever forcing the cluster to evaluate redundant parameter matrices.
• The Economic Impact on Agent Loops: Consider a task that reads 100,000 repository tokens to output a 1,000-token code patch. On a standard MoE activating 49 billion parameters uniformly, the job requires evaluating 4.95 trillion parameter-token passes. Under DeepSeek’s CED, the 100,000 prefill tokens consume 8B passes and the 1,000 output tokens consume 16B passes—totaling just 816 billion parameter-token passes. That represents an immediate 83.5% reduction in compute FLOPs for the exact same programmatic output.

Solving the 1M Token Memory Wall: CSA2, Engram Memory, and 890 Bytes Per Token

Context window sizes in frontier AI have long suffered from a deceptive bottleneck: compute is cheap, but memory is brutal. In standard Multi-Head Attention (MHA) at 16-bit precision, maintaining a 1-million-token context requires between 200 GB and 400 GB of pure VRAM solely to store Key-Value (KV) activations. To serve a single user querying a large document archive, hosting providers are forced to split the cache across multiple 80GB GPUs, driving operational costs through the roof.

In V2 and V3, DeepSeek introduced Multi-Head Latent Attention (MLA) within DeepSeek’s open-source architecture, compressing Key and Value states into a low-rank latent vector with a compression dimension of d_c = 512. While MLA reduced the KV cache footprint from ~10 KB down to ~3.6 KB per token, long-context serving remained constrained under high concurrency.

In V4.1-Flash, DeepSeek achieved an engineering breakthrough that dropped the KV cache footprint to 890 bytes per token—an unprecedented four-fold compression over V3:

1. Compressed Sparse Attention 2 (CSA2): Rather than calculating all-to-all attention across all 1 million tokens, CSA2 combines local dense sliding windows with dynamic, clustered sparse attention across distant spans. Irrelevant token blocks are completely bypassed in memory reads without sacrificing associative recall.
2. Native FP4 KV Quantization: DeepSeek moved beyond post-training quantization by pre-training attention projections to natively produce 4-bit floating-point KV vectors. Fine-grained tile scaling protects against outlier activation clipping, maintaining full numerical stability.
3. Engram Conditional Memory: Repetitive boilerplate syntax, programming language grammars, and recurring prompt structures are offloaded to an integrated non-volatile memory index, freeing active KV cache slots from redundant allocations.

The real-world consequence is transformative: an entire 1-million-token context stream requires only 890 Megabytes of memory. While our comparative analysis on 120B MoE memory bandwidth on Apple M5 Ultra and Ryzen AI Max demonstrated the extreme memory constraints of local deployment, compressing the cache by 75% allows a single consumer GPU or Mac Studio to hold active contexts that previously demanded a multi-GPU cluster.

Training Stability Across 32 Trillion Tokens: Muon, mHC, and FP4 Precision

Scaling Mixture-of-Experts architectures across tens of trillions of tokens introduces extreme mathematical failure modes. In standard AdamW optimization, distributed token routing leads to unbalanced gradients, expert representation collapse, and catastrophic loss spikes that force cluster resets.

DeepSeek achieved continuous training stability across more than 32 trillion tokens by re-engineering its optimization primitives:

• The Muon Optimizer: Developed originally by researcher Keller Jordan and adapted for massive cluster scales by DeepSeek, Muon replaces standard coordinate-wise gradient scaling with matrix-level orthogonalization via iterative Newton-Schulz steps. By forcing update matrices onto an orthogonal manifold, Muon eliminates directional gradient skew and delivers 1.4x to 1.8x faster convergence relative to AdamW.
• Manifold-Constrained Hyper-Connections (mHC): As network depth increases, residual connection signals can explode or vanish across asymmetric encoder-decoder pathways. DeepSeek implemented mHC, bounding residual signal propagation within constrained geometric spaces to stabilize deep layer interactions without heavy normalizations.
• Hybrid Precision Partitioning: The shared attention backbone and routing gates are trained in FP8 mixed precision with 128-element tile scaling. Meanwhile, individual expert feed-forward networks are stored and computed in FP4. Because experts are sparse, this architecture retains full dynamic range in reasoning while keeping total model weights within manageable cluster memory pools.
• DualPipe Communication Overlap: In large-scale MoE clusters, cross-node token dispatch (all-to-all communication) is the primary throughput bottleneck. DualPipe breaks execution into fine-grained forward and backward computation chunks, perfectly overlapping network all-to-all dispatch with local matrix multiplication to eliminate pipeline bubbles.

The 160,000 Huawei Ascend 950DT Cluster in Inner Mongolia

While Western commentary focused on whether export controls would cut off DeepSeek’s access to NVIDIA Hopper and Blackwell hardware, the real industrial shift was taking place in northern China. Institutional filings and semiconductor supply chain data reveal that DeepSeek founder Liang Wenfeng has executed an aggressive migration toward sovereign domestic hardware.

DeepSeek is anchoring this transition in Ulanqab, Inner Mongolia, building out a dedicated high-density computing facility powered by Huawei Ascend 950DT accelerators. Confirmed cluster deployment plans exceed 160,000 units, creating one of the largest unified AI supercomputing installations in the world. As we explored in our investigative audit of the physical power limits halting Western mega-clusters like Stargate, Inner Mongolia’s abundant wind, solar, and coal generation solves the cooling and thermodynamic constraints that choke Western data centers.

The migration follows a clear three-phase execution plan:

1. Phase 1 — High-Throughput Inference Offload (Active): The Ascend 950DT cluster is already serving live inference for DeepSeek-V4-Pro and V4.1-Flash. The Ascend architecture features specialized matrix math units tailored for low-precision FP4 and FP8 execution, providing the physical foundation for DeepSeek’s rock-bottom API pricing.
2. Phase 2 — The DSec Software Abstraction Layer (Active): To bypass the friction of migrating away from NVIDIA’s CUDA ecosystem, DeepSeek engineered DSec (DeepSeek Elastic Compute). As analyzed in our breakdown of DeepSeek’s distributed compute allocation, DSec acts as an automated kernel synthesis and cluster orchestration sandbox, translating PyTorch and custom triton-style kernels directly into Huawei CANN instructions without manual low-level rewrites.
3. Phase 3 — Full Domestic Pre-Training (Q4 2026 – Q1 2027): Liang Wenfeng has signaled to strategic partners that domestic cluster training runs will begin between late 2026 and the first quarter of 2027. This run will produce the flagship DeepSeek-V4.1-Pro and culminate in the true, fully domestic-silicon DeepSeek V5.

Surpass Everything with 10X Less Cost: The 2026 Frontier Economic Moat

In 2026, raw benchmark scores no longer define the competitive frontier. The true battleground is inference economics. If an enterprise wants to deploy autonomous coding agents that continuously index repositories, execute recursive verification loops, and run millions of daily transactions, paying Western cloud API rates leads to financial ruin.

By combining the Causal Encoder-Decoder architecture, 890-byte KV caching, and low-cost domestic Ascend hosting, DeepSeek has established an unassailable pricing advantage verified on DeepSeek’s official platform API schedule:

The real-world math is staggering. At $0.15 per million input tokens, DeepSeek-V4.1-Flash is 66 times cheaper than GPT-6 Astra and 16 times cheaper than Claude Sonnet 5. Even when compared against ad-discounted tiers like GPT-6 Luna on Freebuff, DeepSeek offers superior output economics and zero vendor lock-in. When prompt caching hits (the standard condition for persistent developer agents and document databases), the cost falls to $0.003 per million tokens—effectively $3.00 for an entire billion tokens.

Consider an enterprise autonomous agent workflow executing 1,000 repository refactoring runs, where each run ingests 500,000 codebase tokens and outputs 500 tokens of verified diffs:

• On OpenAI GPT-6 Astra: 500M input tokens @ $10.00 + 0.5M output tokens @ $50.00 = $5,025.00.
• On Anthropic Claude Sonnet 5: 500M input tokens @ $2.50 + 0.5M output tokens @ $12.50 = $1,256.25.
• On OpenAI GPT-5.6 Sol: 500M input tokens @ $5.00 + 0.5M output tokens @ $30.00 = $2,515.00.
• On DeepSeek-V4.1-Flash: 500M input tokens (cached @ $0.003) + 0.5M output tokens @ $0.60 = $1.80. Even on 100% cache misses during off-peak hours, the cost is $75.30.

This is not an incremental 15% discount. It is an economic shift that makes previously impossible architectures economically viable. By combining open weights with an order-of-magnitude reduction in serving costs, DeepSeek has rendered high-margin closed APIs untenable for large-scale enterprise deployments.

What Engineers Should Build Today

Waiting for an official “V5” press release to adjust your technical architecture is an expensive mistake. The fundamental mechanisms of the next-generation paradigm are already live in production:

1. Upgrade Production Serving to CED Kernels: Ensure your deployment runtimes (such as recent releases of vLLM and SGLang) have merged native Causal Encoder-Decoder kernels. This ensures your serving pipelines take full advantage of 8B parameter prefill activation rather than evaluating full decode weights.
2. Retire Complex Vector Chunking for 1M Native Windows: With KV cache memory compressed to 890 bytes per token, multi-stage RAG chunking hierarchies and vector rerankers add latency and failure points without improving retrieval quality. Load entire documentation sets and codebases directly into the context window.
3. Track the Ascend Pre-Training Window: Watch the release of DeepSeek-V4.1-Pro as the Ulanqab cluster scales up. When the official V5 designation drops in early 2027, it will represent the expansion of these proven CED and CSA2 primitives across 160,000 domestic accelerators.

Frequently Asked Questions