DeepSeek V4 Flash 0731: What Changed When the Architecture Didn’t

The transformer stayed the same. The policy weights, agent contract, evaluation stack, and serving package did not.

Start with the number that makes you blink. DeepSeek reports that DeepSWE went from 7.3 on V4-Flash Preview to 54.4 on V4-Flash-0731. A 47-point jump. Same 43 layers. Same 284 billion total parameters. Same 13 billion active per token. Same million-token architecture.

That result is the most interesting thing in the release — and the easiest one to get wrong.

It is a DeepSeek-reported score, run at maximum reasoning effort with an unreleased “DeepSeek Harness minimal mode.” Two of the nine launch benchmarks are internal. So it does not prove that swapping Preview for 0731 will make every coding agent seven times better. What it does show is something more useful: once a base architecture is good enough, post-training and the agent stack can move measured behavior much further than parameter counts suggest.

On July 31, 2026, DeepSeek moved the official V4-Flash API into public beta. The model name stayed deepseek-v4-flash; under it, the company now serves DeepSeek-V4-Flash-0731. Alongside the API update came MIT-licensed 0731 weights, native Responses API support, Codex adaptation, and a DSpark speculative-decoding module attached to the released checkpoint.

Strip it to one sentence: DeepSeek kept the V4-Flash core architecture fixed, replaced the post-trained weights, and built a more complete agent-serving product around them.

That distinction is the whole story. The V4 technical report explains the architecture and the original family training pipeline. It does not disclose the data, teachers, rewards, compute, or ablations behind the July 31 re-post-training. Where the sources stop, this article stops too.

The Release in One Scientific Frame

Three different things shipped under one announcement, and they are easy to blur.

1. A new checkpoint. The core transformer and mixture-of-experts (MoE) architecture are unchanged, but the post-trained weights are new.
2. A new runtime package. The downloadable release carries DSpark, a custom V4 encoding implementation, reasoning-effort controls, and current serving recipes.
3. A more agent-shaped API product. The hosted endpoint adds Responses API and Codex integration, with a July 31 operating envelope that documents pricing and 2,500 concurrent requests per account.

A checkpoint is the saved weights and behavior. A runtime package is the software that executes them. A hosted API is DeepSeek’s managed service around both. Mix them up and you get the wrong causal story — crediting the architecture for a gain that actually came from policy weights, or crediting DSpark for intelligence that actually came from post-training.

The headline facts are plain:

• Status: official V4-Flash release, still in public beta.
• Hosted model ID: deepseek-v4-flash.
• Open-weight repository: deepseek-ai/DeepSeek-V4-Flash-0731.
• License: MIT.
• Context: up to 1,048,576 tokens.
• Maximum output: up to 384K tokens for high/max configurations — a ceiling, not a normal operating point.
• Scope: Flash API only. V4-Pro API and DeepSeek App/Web were unchanged on launch day.
• Core architecture: unchanged from Flash Preview.
• Capability change: re-post-training, with the exact 0731 recipe undisclosed.

From Preview Architecture to 0731 Behavior

The July release makes more sense once you separate it from the April architecture launch.

24 Apr 2026 · V4-Pro and V4-Flash Preview announced
26 Apr 2026 · V4 technical report submitted to arXiv
24 Jul 2026 · stated retirement date for legacy API aliases
31 Jul 2026 · official V4-Flash API enters public beta as 0731
31 Jul 2026 · 0731 weights and MIT license published

My earlier piece, DeepSeek V4 Preview: The 1M-Token Model That Makes Long Context Cheap, is the architecture story. It explains why CSA, HCA, mHC, Muon, FP4-aware training, and heterogeneous KV-cache management make million-token inference less absurd.

This article picks up where that one ends. The old thesis still holds — V4 is an efficiency architecture built to make extreme context usable. The new question is sharper: what does a lab change when the architecture is already fixed but the agent is still not good enough?

DeepSeek’s public answer is post-training, protocol design, and serving integration.

The Fixed Envelope: What Did Not Change

The core model is still the V4-Flash from the technical report.

The table separates the unchanged core model from the larger released package. The core has 284B parameters, not 13B. Thirteen billion activate per token because the feed-forward layers are mixture-of-experts — but the full 284B still has to be stored, placed, and wired across devices.

Official DeepSeek product table from the April V4 launch note: Pro and Flash share the 1M-context family design at different operating points.

Each MoE layer has 256 routed experts plus one shared expert, with six routed experts picked per token. CSA and HCA stay interleaved across layers, a 128-token sliding window keeps recent detail sharp, and mHC governs residual-stream mixing.

In plain language:

• CSA keeps a searchable, medium-resolution memory of the long prefix.
• HCA keeps a cheap, coarse memory of very long history.
• The sliding window keeps the last 128 tokens exact.
• mHC stabilizes residual transport so deep stacks do not wash out the signal.

The July package adds DSpark on top of that unchanged 284B/13B core. That is why “same architecture and size” can coexist with a roughly 167 GB fused package — larger than Preview.

Because all of this stayed fixed, none of it explains the gap between Flash Preview and Flash 0731. The architecture set the envelope. The July release changed how the model behaves inside it.

Why Post-Training Can Move a Fixed Model So Far

Post-training teaches a capable base model how to behave.

Pre-training builds the general representation — language, code, facts, patterns, the ability to predict. Post-training turns that raw capability into a product policy. It teaches the model which reasoning path to prefer, how to follow instructions, when to call a tool, how to format arguments, how to recover from tool output, how long to deliberate, and which failures earn a reward or a penalty.

For agents, those behaviors are not decoration. They are the work. A coding agent fails less often because it keeps a plan across tool rounds, emits valid tool schemas, uses the environment instead of guessing, recovers after a compiler error, stops when the task is done, and spends more compute when the problem is hard.

None of that requires a new attention mechanism. All of it can be reshaped by reinforcement learning, reward design, distillation, and interface contracts. That is the scientific center of 0731.

The Family Method DeepSeek Already Documented

The V4 paper does not reveal the July recipe. It does reveal how DeepSeek thinks about turning a base model into an agent product.

1. Domain specialists first

DeepSeek trains separate specialists for target domains — mathematics, coding, agents, instruction following. Each specialist goes through supervised fine-tuning on high-quality domain data, then reinforcement learning with GRPO (Group Relative Policy Optimization), driven by domain prompts and reward signals.

This matters because one model does not have to learn every skill at once under one noisy reward. Specialists can overfit usefully to a domain before their knowledge is merged.

2. Easy rewards and hard rewards are different sciences

For easy-to-verify tasks, DeepSeek can lean on rules, unit tests, and deterministic verifiers. For hard-to-verify tasks, the report says the lab no longer relies on conventional scalar reward models alone. Instead it uses a Generative Reward Model (GRM): trajectories are scored with rubric-guided evaluation, the GRM itself is optimized with RL, and the actor can serve as both generator and judge.

Put simply: when “correct” is not a binary test, DeepSeek trains a reasoning judge rather than a number-producing critic. That is especially relevant for agent work, where partial progress, tool validity, and plan quality are harder to score than a math final answer.

3. Reasoning effort is trained, not improvised

V4 supports distinct reasoning regimes — non-think, high, and max — each produced with different RL length penalties, context windows, and response formats. Max effort is not a bigger neural network. It is a trained operating policy that spends more deliberation under stronger instructions.

This is one reason a launch score at max cannot be read as ordinary production behavior. The same weights can be asked to think little or a lot. The policy distribution shifts with the effort contract.

4. Multi-teacher on-policy distillation merges the specialists

Once the specialists exist, DeepSeek merges them with On-Policy Distillation (OPD). The student generates its own trajectories; more than ten teacher specialists provide target distributions; the student minimizes a reverse KL objective toward those teachers; and DeepSeek uses full-vocabulary logit distillation, not just a token-level KL estimate, to stabilize gradients.

Why each piece matters:

• On-policy means the student learns on states it actually visits, not on frozen teacher demos.
• Reverse KL pushes the student toward modes the teachers prefer, rather than averaging every mode indiscriminately.
• Full-vocabulary logits preserve richer teacher knowledge than supervising only the sampled token.

DeepSeek explicitly says this replaces the mixed RL stage used in V3.2. That is a major methodological claim at the family level: unify specialists by distillation over student trajectories, not by one giant mixed RL run.

5. Agent infrastructure is part of the training system

The report also describes sandbox infrastructure for agentic RL, long-context RL scaling, fault-tolerant rollout services, and FP4 integration into post-training. These are not marketing footnotes. If the training loop cannot run long tool trajectories cheaply and reproducibly, the post-training science never gets enough signal.

So the public record supports two statements at once: the family method shows how large agent gains can arise without a new transformer, and the 0731 delta cannot be pinned on one teacher, one reward, or one benchmark objective.

The Agent Protocol Is Part of the Model Product

Agent quality depends on how messages, reasoning, and tools are represented.

V4 uses a dedicated DSML tool-call format. Tool definitions are injected into the prompt; calls come back in structured DSML blocks; tool results return inside tagged user messages. The official 0731 repository does not ship a normal Jinja chat template. It ships an encoding/ folder with Python code that converts OpenAI-style messages into V4 input strings and parses the output back into messages, reasoning, and tool calls.

A checkpoint without the correct encoder is not the same product as the hosted API.

Thinking-mode tool loops follow an unusual continuity rule. When the model calls tools, clients must send the assistant’s prior reasoning content back on later requests. Without tools, older reasoning can be dropped at a new user turn. With tools, V4 preserves the full reasoning trace so the agent does not rebuild its plan from scratch after every result.

That is an engineering choice that lives between model and framework. The model was trained to expect a particular continuity contract; the surrounding system has to honor it.

Responses API support is partial by design

DeepSeek says V4-Flash now natively supports the Responses API and is adapted for Codex. That lowers migration friction. It does not mean every OpenAI Responses feature works.

The compatibility documentation is specific:

• the endpoint is stateless — no previous_response_id, conversations, storage, or background mode;
• functions and server-side web search are supported;
• the only supported custom tool is apply_patch, specifically for Codex compatibility;
• file search, code interpreter, computer use, MCP, image input, and file input are unsupported or ignored;
• parallel_tool_calls is ignored because parallel calls are always on;
• several unsupported fields are silently ignored instead of raising an error.

Silently ignored parameters are the dangerous part. A client can look successful while the intended control surface is doing nothing. Compatibility is a behavioral claim, not a status code.

There is also a subtle gap between evaluation and hosted API settings. DeepSeek’s model card says the public code-agent benchmarks used max effort, temperature=1.0, and top_p=0.95. The hosted thinking-mode documentation says temperature and top-p have no effect in thinking mode. DeepSeek does not say whether the harness used local weights, the hosted endpoint, or parameters that were accepted but ignored.

DSpark: Decode Faster, Do Not Credit It for Intelligence

The downloadable 0731 checkpoint includes a DSpark speculative-decoding module.

Speculative decoding attacks the sequential nature of generation:

DSpark draft proposes several future tokens
├── main V4 model verifies the proposed run
├── accepted tokens advance together
└── rejected tokens fall back to normal generation

The model card’s vLLM example proposes seven speculative tokens with greedy drafting. The config attaches DSpark to the final three transformer layers and records a block size of five and Markov rank 256.

This can speed up decoding when proposal acceptance is high and the runtime has efficient verification kernels. It does not make the model more knowledgeable or better with tools. DSpark is a serving optimization attached to the artifact; the re-post-trained weights are the capability change.

V4 also keeps one layer of Multi-Token Prediction from the V3 lineage. MTP and DSpark are related but not interchangeable. MTP is part of the model’s prediction and training structure; DSpark is the speculative draft mechanism the serving runtime uses. Neither guarantees a universal tokens-per-second gain. Acceptance rate, context length, batch shape, kernel support, and hardware decide the real speedup.

The Reported Benchmark Deltas

DeepSeek’s official table says 0731 beats both Flash Preview and Pro Preview on all nine reported agent benchmarks.

Official DeepSeek benchmark board from the April Preview launch. Useful historical context for the family — not the July 0731 agent table.

Official DeepSeek long-context and agent-adjacent Preview board from the April launch note.

The July model card replaces that Preview story with a denser agent comparison.

The largest absolute change versus Flash Preview is DeepSWE: +47.1 points. Cybergym rises 38.0. DSBench-Hard rises 33.8. Even Terminal Bench 2.1, where Flash Preview was already much stronger, moves 20.9 points to 82.7.

The reported deltas concentrate on tool loops, repository work, and executable tasks rather than generic knowledge. That fits the release’s agent positioning — but it does not establish which training objectives produced the pattern.

DeepSeek also places 0731 against GLM-5.2 and Opus-4.8 in the same vendor table.

The honest reading is careful. Under DeepSeek’s launch setups, Flash 0731 is reported near or above GLM-5.2 on several agent rows and below Opus-4.8 on most of them, while staying far smaller in activated parameters than the Pro line. That is a launch-table claim, not a multi-lab consensus.

Three labels belong on this table at all times.

1. The scores are vendor-reported

DeepSeek ran and published the comparison. It says the public code-agent tasks used “DeepSeek Harness minimal mode,” still unreleased on launch day. Without the harness, independent evaluators cannot reproduce the exact prompts, loop policy, tool handling, retry logic, budget, and environment.

2. The public code-agent rows use a large test-time budget

For the public code-agent tasks, DeepSeek specifies max effort. It does not establish the same settings for every internal or non-code row, nor whether comparator setups were perfectly matched. A max-effort result is not a prediction of low-effort latency, token usage, or quality.

3. Two rows are internal

DSBench-FullStack and DSBench-Hard are DeepSeek internal test sets. They may be useful internal engineering signals, but outsiders cannot inspect the tasks, contamination controls, exclusions, or scoring.

This is why “Flash beats Pro” needs careful grammar. The defensible sentence is: DeepSeek’s launch table reports 0731 ahead of V4-Pro Preview on all nine rows under the stated setups. Whether it beats Pro on your repository depends on framework, tools, task distribution, and budget.

Independent Evidence: Higher Score, Much Higher Token Use

One same-day independent measurement supports the broad story without reproducing the vendor table.

Artificial Analysis reports an Intelligence Index v4.1 score of 50 for V4 Flash 0731 at max effort, against 44 for V4 Pro max in its current comparison. It reports a weighted cost of $0.03 per Intelligence Index task for Flash versus $0.05 for Pro, and $72.02 to run the full Flash evaluation.

This is one supportive independent result. The composite spans nine evaluations — agentic business tasks, banking tool use, Terminal Bench 2.1, coding, reasoning, knowledge, physics, hallucination, and long-context reasoning. It supports the narrower claim that 0731 performs strongly for its API price on this evaluator’s setup.

It also surfaces the hidden bill: 210 million output tokens across the Flash evaluation, versus a same-class median of 100 million. Max-effort Flash is cheap per token, but it can burn a lot of them.

That is not a contradiction — it is the metric that matters. A model priced at $0.28 per million output tokens can still cost more in total if it deliberates longer, retries more often, or produces large tool traces. The relevant unit is not a token. It is a successfully completed task.

Artificial Analysis does not validate DeepSeek’s nine agent rows. It validates a narrower conclusion: one independent evaluation also finds 0731 stronger than Pro max on its composite and cheaper per weighted task. More independent, harness-matched agent runs are still needed.

Economics as a Systems Consequence

DeepSeek’s hosted pricing makes the product strategy visible.

Official DeepSeek pricing figure from the April V4 launch note. Treat live July 31 docs as authoritative for current Flash rates.

On cache-miss input and output, Flash is roughly 3.1× cheaper than Pro Preview. On cache-hit input, the gap shrinks to about 1.3×. That matters because agent loops repeatedly send long shared prefixes — instructions, repository context, tool schemas, plans, earlier turns — and DeepSeek applies automatic context caching.

The 2,500-versus-500 concurrency limits give Flash 5× more documented in-flight request headroom per account. That is not 5× throughput and not 5× speed. It is a wider account-level ceiling before HTTP 429s.

DeepSeek also says it will introduce peak/off-peak pricing: every billing item will cost 2× during 09:00–12:00 and 14:00–18:00 Beijing time. As of July 31, the effective date had not been announced.

The 1M context and 384K maximum output are just as easy to misread. The latter is a generation ceiling for high/max configurations, not an invitation to emit 384,000 tokens. Output consumes the model’s context envelope; it is not a free 384K stacked on top of 1M input.

Self-hosting makes the same systems point from the other side. Open weights make inspection and private deployment possible. They do not make a 284B MoE behave like a consumer 13B checkpoint. The vLLM recipe describes the fused 0731 checkpoint as roughly 167 GB on disk, about 7 GB larger than the Preview package because of the DSpark draft module. Runtime memory also needs KV cache, non-expert tensors, allocator workspace, activations, communication buffers, and the serving engine itself.

DeepSeek’s model card demonstrates vLLM on a single 4×GB300 node with data parallelism four and expert parallelism enabled. That is a supported example, not a minimum-hardware theorem. The attractive “13B active” arithmetic explains compute locality. The 0731 package shows the other half: cheap compute per token does not erase total-model systems engineering.

Limits and Open Questions

As of July 31, 2026, several important questions stay open.

• The official V4-Flash API release is still labeled public beta.
• DeepSeek has not disclosed the specific 0731 re-post-training recipe.
• The launch benchmark harness was not public, and two benchmark sets are internal.
• Most of the nine agent results have no independent, setup-matched reproduction yet.
• Artificial Analysis is one independent evaluator, not a consensus.
• The model is text-only; image and file inputs are not supported.
• Responses API compatibility is partial and sometimes silently ignores unsupported fields.
• V4-Pro API and DeepSeek App/Web did not receive the 0731 update.
• Official V4-Pro was still pending.
• API pricing, peak windows, and checkpoint behavior can change during beta.
• A million-token limit does not guarantee reliable reasoning over a chaotic million-token prompt.

The architecture itself stays complex, too. The V4 report admits that CSA/HCA, mHC, routing, low-precision paths, and cache policies trade elegance for efficiency. Long-context quality can fail through retrieval misses or compression; agent quality can fail through tools, prompts, parsers, or environment instability. A launch score cannot isolate those failure modes for you.

What 0731 Actually Teaches

DeepSeek V4 Flash 0731 matters precisely because it is not a new architecture.

Had the lab added more layers, more experts, or another attention mechanism, the story would be familiar: spend more pre-training compute, get a stronger model. Instead, DeepSeek held the core design constant and reported a much stronger agent after changing the post-trained weights and wrapping the model in a better tool protocol and serving surface.

That does not prove post-training is all you need. It proves that agent performance belongs to a stack:

base architecture
├── post-trained policy weights
├── reasoning-effort regime
├── message and tool encoding
├── harness, tools, and retries
├── runtime and speculative decoding
└── price, concurrency, and operational limits

Parameter count describes only part of that stack. The benchmark belongs to all of it.

So the scientific reading is double-edged. On one side, the V4 family method already explains how large gains can appear without a new transformer: domain specialists, GRPO, generative rewards, multi-teacher on-policy distillation, trained effort regimes, and an agent-native continuity contract. Those are real technologies, documented in the report, and they act directly on the behaviors agent benchmarks measure.

On the other side, the July delta remains under-identified. DeepSeek has not published the 0731 data mix, teacher mix, reward mix, compute, or ablations. The launch harness was unreleased. Two rows are internal. Independent evidence supports a strong price/intelligence case, but not a reproduction of the nine-row vendor table.

The non-obvious conclusion is therefore not “Flash suddenly became magic.” It is sharper:

Once a base model has enough long-context capacity and tool-relevant representation, the highest-leverage remaining work is often policy learning and system design — and the public evidence for that leverage can look spectacular long before the causal recipe is fully disclosed.

Read 0731 as a measurement of that leverage. Not as a new architecture story, and not as a finished scientific account of why every point moved.

Status: source record checked on July 31, 2026. V4-Flash API was in public beta; official V4-Pro was pending.

Primary sources: DeepSeek changelog, 0731 model card and MIT-licensed weights, V4 technical report, official config, Models & Pricing, Rate Limit & Isolation, Responses API, Thinking Mode, encoding reference, April V4 launch note, and vLLM deployment recipe. Independent measurement: Artificial Analysis. Research ledger: docs/research/deepseek-v4-flash-0731-source-dossier.md.