The Complaints Are Valid. The Leap Is Real.

The criticism isn't just deflated hype. Several gaps are specific and well-founded — the kind that don't get better with more benchmark slides.

In January 2026 — three months before V4's release — DeepSeek and Peking University published Conditional Memory via Scalable Lookup: A New Axis of Sparsity for Large Language Models, introducing a module called Engram. The community immediately read it as V4's secret sauce. The V4 technical report makes no mention of Engram whatsoever.

That absence is worth unpacking.

Standard Transformers — including MoE variants — have no native primitive for knowledge lookup. Every "memory" is simulated through computation: attention attends over all positions, experts activate dynamically, but there's no deterministic retrieval path. Engram proposed a third axis of sparsity alongside MoE: a conditional memory bank that routes known n-gram patterns directly to their embeddings, bypassing attention entirely.

The implementation stores n-gram sequences (up to order 4) as compressed suffix representations hashed into a vocabulary of 2.26 billion slots. When a known sequence appears in context, Engram retrieves its embedding in O(1) time and modulates it through a lightweight context-aware gate against the current hidden state — a scalar operation, not multi-head attention. The memory bank is too large for GPU VRAM, but the paper showed that offloading to host DRAM costs only a 2.8% throughput penalty, because n-gram access follows Zipfian distribution and can be prefetched during the preceding layer's compute.

The paper also discovered a Sparsity Allocation Law: dedicate ~20–25% of your sparse parameter budget to the Engram memory module and keep the rest for computation, and you outperform pure MoE at the same total parameter count. The optimum was stable across both compute regimes tested.

These are not free gains from extra parameters or compute. Engram replaces wasted attention on static patterns with direct lookup — same budget, better output. The long-context NIAH jump from 84.2% to 97.0% at 1M tokens is especially striking given that V4's own reported MRCR-1M score is 83.5%. Engram, at the 27B scale, already outperforms V4-Pro on this dimension.

DeepSeek offered no public explanation. The paper itself provides a signal: the tiered cache hierarchy — hot n-grams in DRAM, rare patterns on NVMe SSD — is described as a promising direction rather than a demonstrated result. At 1.6T parameter scale, the Engram bank would be substantially larger than the 27B prototype. A 2.8% throughput hit at 27B may not hold at 10× the scale while serving tens of thousands of concurrent requests.

The AI benchmark ecosystem has a saturation problem. HumanEval — the de facto coding eval for years — now clusters every frontier model between 88–92%. At that level, the differences are within noise, and the comparisons become marketing rather than measurement.

DeepSeek's benchmark comparisons are curated. They foreground wins (coding, agentic, long context) and omit losses (SimpleQA, MMLU-Pro, factual recall). That's not deception — every lab does this — but reading the headline numbers without the full table gives you a distorted picture.

The more reliable signal comes from task-grounded evals: SWE-bench Verified tests real GitHub issues, not synthetic problems. LiveCodeBench uses competitive programming with time-controlled data cutoffs. Codeforces Rating is a live arena that's extremely hard to overfit. On all three, V4 performs. The skepticism should be applied to the cherry-picked leaderboard presentation, not the underlying results on harder evals.

V4's genuine breakthrough isn't in a benchmark cell. It's in how the model computes attention at long contexts — and what that does to the cost of serving it.

Traditional transformer attention scales quadratically with context length. At 1M tokens, the KV cache becomes the bottleneck: it grows so large that you either run one user at a time or you can't serve the context at all. This is why "1M context" in most models is a theoretical claim, not a practical one.

V4 ships a hybrid attention architecture that combines two mechanisms: Compressed Sparse Attention (CSA) for routine positions, and Heavily Compressed Attention (HCA) for cross-window aggregation. Together they reduce KV cache to 10% of V3.2's footprint at 1M tokens, while retaining 27% of the single-token inference FLOPs.

This matters enormously for deployment economics. If you're serving a coding agent that uses 200K tokens of context per session, V3.2 lets you handle maybe four simultaneous users before GPU memory is exhausted. V4, with the same budget, handles roughly forty. That's not a 10% improvement — it's a different product category.

Pair this with FP4 quantization for MoE expert weights (a first for a model this size) and you compound the memory savings further. The 49B active-parameter profile means a 1.6T-parameter model runs inference at the cost of a ~50B dense model — which is already well within reach of a single 8×H100 node.

Manifold-Constrained Hyper-Connections (mHC) replace standard residual connections. This sounds esoteric but has a practical effect: it improves gradient flow through the very deep MoE stack, which directly enables the 32T+ token pre-training run without instability. You don't get to train on 32 trillion tokens without solving the propagation problem first.

The Muon optimizer — a second-order momentum method that approximates gradient whitening — is the other training-side novelty. It converges faster and more stably than AdamW at large batch sizes, which is what you need when training a 1.6T model across thousands of GPUs. These are infrastructure choices, not headline features, but they're what makes the training compute efficiency claims credible.

With the benchmark hygiene caveat applied, here's the honest performance picture. V4 dominates on coding and agentic evals — the categories where the evals are hardest to game. It trails on general knowledge and factual recall, where Gemini is the clear leader.

At $1.74 per million input tokens, V4-Pro costs roughly 35% of Claude Opus 4.6's standard rate and less than half of Gemini 2.5 Pro's output cost. For output tokens — where most of the billing accrues in agentic workloads — the gap is even starker: Opus charges $25 per million output tokens versus V4's $3.48, a 7× difference.

The cross-200K pricing structure is where V4's architectural advantage translates most directly into cost advantage. Anthropic and Google both apply premium rates once you exceed 200K input tokens. V4 has no such cliff — its architecture was designed for 1M context from the start, so the pricing doesn't penalize you for using it. A coding agent session consuming 500K tokens costs the same per-token rate as one consuming 50K.

For a typical agentic coding workload — say $500/month on Opus 4.6 at standard context — the equivalent V4-Pro spend is roughly $70/month. That's not a rounding error; it's a budget category shift. For companies running thousands of agent sessions daily, V4's economics make production deployments that were previously cost-prohibitive suddenly viable.

Prices above reflect third-party API (OpenRouter). Direct DeepSeek API pricing in CNY is marginally lower at current exchange rates; either way, the order-of-magnitude gap versus Anthropic's frontier pricing is structural, not promotional.

V4 is the first open model that was explicitly designed for agentic workflows from the architecture level up — not retrofitted with an agent wrapper afterward. The 1M context default, the hybrid attention that makes that context cheap to serve, the native integration with Claude Code and OpenClaw, the built-in thinking modes: these are coherent choices, not a feature checklist.

The Think / Think-High / Think-Max triad gives developers explicit control over reasoning depth at inference time. Non-Think mode returns fast results for routine tasks; Think-Max enables extended chain-of-thought for problems at the model's reasoning boundary (requiring at least a 384K token context window). That's a practical API design, not a marketing tier.

DeepSeek-V4-Flash (284B total / 13B active) is the quiet story in the V4 release. At 13B active parameters, it's comparable in inference cost to a mid-sized dense model — but it nearly matches the Pro variant on simple agentic tasks. For pipelines that chain dozens of agent steps, the economics of Flash are compelling: you're paying for a 13B model and getting something that routes, plans, and executes at near-Pro quality on structured tasks.

Yes, it's still too large for a consumer GPU. But for teams serving these models in the cloud, Flash closes the gap between "bleeding edge" and "affordable at scale."

The geopolitical subtext of V4 is impossible to ignore. Huawei confirmed its Ascend AI processors can run V4 natively — and Beijing has been actively pushing Chinese companies toward domestic chips to reduce Nvidia dependence. A model this capable, running on domestically-produced hardware, changes the calculus around AI sovereignty.

For the global open-source ecosystem, the implications are different but also significant. V4 with an MIT license means it can be fine-tuned, distilled, and deployed without restriction. The gap between "open" and "closed" keeps narrowing: V4 beats Opus on LiveCodeBench, matches it on SWE-Verified, and does so with a weight file anyone can download.

If you were building a multimodal application or hoping to run a local LLM on a gaming rig, V4 is not your answer — and your disappointment is legitimate. DeepSeek made a choice to go deep on coding and agentic efficiency rather than broad on modalities and accessibility. That's a valid strategy, but they should have communicated it instead of letting expectations run ahead.

If you're deploying coding agents or long-context document pipelines at scale, V4 is the most interesting infrastructure development in months. Not because of benchmark numbers, but because the KV cache math changes what's economically feasible. Going from 4 to 40 concurrent users on the same hardware isn't a talking point — it's the difference between a pilot and a production deployment.

The leap is real. It's just not the leap people expected.

The API is a model-name swap with one new parameter for thinking mode control. If you're using the OpenAI-compatible endpoint, the change is minimal.