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.

DeepSeek reports that DeepSWE rose from 7.3 on V4-Flash Preview to 54.4 on V4-Flash-0731. The 47.1-point increase came with the same 43 layers, 284 billion total parameters, 13 billion active parameters per token, and million-token architecture.

The result has important qualifications. DeepSeek ran the benchmark at maximum reasoning effort with an unreleased “DeepSeek Harness minimal mode,” and two of the nine launch benchmarks are internal. The score therefore describes DeepSeek’s complete evaluation setup, not an isolated change in model weights or a guaranteed improvement in other coding agents.

On July 31, 2026, DeepSeek moved the official V4-Flash API into public beta. The stable model name, deepseek-v4-flash, now points to DeepSeek-V4-Flash-0731. The company also published MIT-licensed weights, added native Responses API support and Codex adaptation, and attached a DSpark speculative-decoding module to the downloadable checkpoint.

One Release, Three Changes

The announcement combines three distinct layers:

1. Checkpoint: new post-trained weights on the existing V4-Flash architecture.
2. Runtime: DSpark, V4-specific encoding, reasoning-effort controls, and updated serving recipes.
3. Hosted service: Responses API and Codex integration, current pricing, and a documented limit of 2,500 concurrent requests per account.

This distinction matters because the layers do different work. The checkpoint determines learned behavior; the runtime executes it; the hosted API supplies the surrounding service. DSpark can reduce decoding time, but it cannot explain an improvement in tool use. Likewise, an agent benchmark includes the harness and tools rather than measuring the transformer alone.

The launch configuration supports up to 1,048,576 context tokens and up to 384K output tokens in high/max modes. The latter is a ceiling within the context envelope, not a typical output length. The release covered Flash only: V4-Pro API and DeepSeek App/Web were unchanged, and the official Pro release remained pending.

The sequence of releases helps separate the claims. DeepSeek announced V4-Pro and V4-Flash Preview on April 24 and submitted the technical report two days later. The July 31 update published the 0731 weights and replaced the Flash API checkpoint. It did not introduce another attention mechanism or a larger MoE. The architecture described in April and the behavior measured in July therefore belong to different stages of the product’s development.

The Architecture Stayed Fixed

The April V4 Preview established the model’s technical envelope. The July checkpoint retains it.

V4-Flash is a 284B-parameter mixture-of-experts model, even though only 13B parameters activate for each token. Each MoE layer contains 256 routed experts and one shared expert, with six routed experts selected per token. The full weights still have to be stored and distributed across devices.

Its long-context design interleaves Compressed Sparse Attention (CSA) and Heavily Compressed Attention (HCA). CSA preserves a searchable representation of the long prefix; HCA stores older history more coarsely; a 128-token sliding window retains exact recent detail. Manifold-Constrained Hyper-Connections (mHC) manage the residual stream through the 43-layer network.

The fused 0731 package is roughly 167 GB, about 7 GB larger than Preview because it includes DSpark. This is another reason not to read “13B active” as “a 13B deployment.” Active parameters approximate per-token compute; total weights, the draft module, KV cache, workspace, and communication buffers determine the deployment footprint.

The July artifact adds one serving component without altering that distinction. DSpark is attached near the end of the network as a draft mechanism, while the main V4 layers still verify the output. Its roughly 7 GB weight increase affects storage and decoding; it does not turn the core into a different 291B architecture. Treating the fused package and the transformer as the same object would blur a deployment change with a learned capability change.

What Post-Training Can Change

Pre-training gives a model broad representations of language, code, and facts. Post-training shapes the policy used to answer instructions and operate tools: which reasoning path to choose, when to call a tool, how to format arguments, how to recover from errors, and when to stop.

Those decisions dominate agent tasks. A coding system must maintain a plan across tool calls, inspect the environment instead of guessing, react to compiler or test output, and complete the task within a budget. Attention mechanisms set capacity; reinforcement learning, distillation, reward design, and message protocols can substantially alter how that capacity is used.

The V4 report documents the family method, though not the specific 0731 recipe. DeepSeek first trains specialists for mathematics, coding, agents, and instruction following with supervised fine-tuning and GRPO reinforcement learning. Tasks with deterministic answers can use rules or tests. Harder trajectories are scored by a Generative Reward Model, which applies rubrics instead of producing only a conventional scalar reward.

The specialists are then merged through On-Policy Distillation. The student generates trajectories from states it actually visits, while more than ten specialist teachers provide full-vocabulary target distributions. DeepSeek uses a reverse-KL objective and says this process replaces the mixed reinforcement-learning stage used for V3.2. On-policy data reduces the mismatch between teacher demonstrations and situations the student encounters during its own tool loops; full-vocabulary targets carry more information than supervising only the sampled next token.

V4 also trains separate non-think, high, and max reasoning regimes with different length penalties, context windows, and response formats. Max effort is a learned policy with a larger deliberation budget, not a larger network. A max-effort launch score therefore says little about ordinary latency or token consumption.

The report further describes sandboxed agent training, long-context reinforcement learning, fault-tolerant rollout services, and FP4 integration. These systems make long tool trajectories feasible at training scale. They offer a plausible account of how a fixed architecture can improve on agent tasks, but DeepSeek has not said which parts changed for 0731.

Tool Protocol and Runtime

V4 uses a dedicated DSML tool-call format. Its repository supplies Python encoding code rather than a conventional Jinja chat template: the encoder converts OpenAI-style messages into V4 input and parses the response into messages, reasoning, and tool calls. Running the weights with a different message contract may not reproduce the hosted service.

Thinking-mode tool loops also have a continuity requirement. After a tool call, clients must send the assistant’s previous reasoning content back with the next request. This preserves the plan across results. On a new user turn without tools, older reasoning can be discarded.

Native Responses API support reduces integration work, but the compatibility layer is partial. It is stateless and does not support previous_response_id, conversations, storage, or background mode. Functions and server-side web search work; apply_patch is the only supported custom tool. File search, code interpreter, computer use, MCP, images, and file input are unsupported or ignored. Some unsupported fields are silently ignored, so a successful HTTP response does not prove that every requested control took effect.

There is also an unresolved evaluation detail. The model card lists temperature=1.0 and top_p=0.95 for public code-agent benchmarks at max effort, while the hosted thinking-mode documentation says those settings have no effect. DeepSeek does not specify whether the harness used local weights, a different endpoint, or parameters accepted but ignored by the service.

The attached DSpark module addresses decoding speed. It drafts several future tokens for the main V4 model to verify together; the model-card example proposes seven. Performance depends on proposal acceptance, context length, batch shape, kernels, and hardware. DSpark does not add knowledge or tool skill and should not be credited for the capability gains.

What the Benchmarks Show

DeepSeek reports 0731 ahead of both Flash Preview and Pro Preview on all nine agent benchmarks in its launch table.

The largest increases over Flash Preview are DeepSWE, +47.1 points; Cybergym, +38.0; and DSBench-Hard, +33.8. Terminal Bench 2.1 rises by 20.9 points to 82.7. The pattern is concentrated in repository work, executable tasks, and repeated tool use, consistent with the agent-focused release.

The evidence remains vendor-controlled. The public code-agent rows used the unreleased DeepSeek Harness at max effort. DSBench-FullStack and DSBench-Hard are internal sets whose tasks, contamination controls, and scoring cannot be inspected. Comparator settings may also differ. The defensible claim is limited: DeepSeek’s setup reports 0731 ahead of V4-Pro Preview on all nine rows.

In the same vendor table, 0731 is reported near or above GLM-5.2 on several rows and below Opus-4.8 on most. Activated-parameter counts make Flash look unusually efficient, but they do not normalize reasoning tokens, prices, tool budgets, or evaluator behavior. Comparisons across providers remain comparisons of configured systems. A model can lead one row by spending more test-time compute or by fitting a harness more closely.

The missing harness is particularly consequential for repository benchmarks. Loop policy determines which files are inspected, how failures are retried, when tests run, and when the agent stops. Prompt formatting and tool-result parsing can turn the same raw weights into different trajectories. Until the minimal harness is published, outsiders can test the checkpoint but cannot recreate the launch experiment exactly.

One independent measurement supports a narrower conclusion. Artificial Analysis reports an Intelligence Index v4.1 score of 50 for Flash 0731 at max effort, compared with 44 for V4 Pro max. It estimates $0.03 per weighted task for Flash versus $0.05 for Pro, with $72.02 spent on the full Flash evaluation.

That run used 210 million output tokens, against a same-class median of 100 million. Low token prices do not guarantee low task costs when the model deliberates for longer or generates large tool traces. The composite covers nine evaluations spanning agentic business work, banking tool use, Terminal Bench 2.1, coding, reasoning, knowledge, physics, hallucination, and long-context reasoning. It is broader than a coding-only test but has its own weighting choices.

Price, Scale, and Remaining Uncertainty

On cache-miss input and output, Flash was about 3.1 times cheaper than Pro Preview at launch. Cache-hit input narrowed the difference to about 1.3 times. This is relevant to agents, which repeatedly send shared instructions, tool schemas, repository context, and prior turns. DeepSeek applies automatic context caching.

Flash also had a documented 2,500 concurrent-request limit per account, compared with 500 for Pro. That is five times the number of requests allowed in flight, not five times the throughput or speed.

Open weights enable inspection and private deployment, but the 284B model remains an infrastructure project. DeepSeek’s vLLM example uses one 4×GB300 node with data parallelism four and expert parallelism. It is an example, not a stated minimum. Runtime memory must also hold the KV cache, non-expert tensors, allocator workspace, activations, communication buffers, and the serving engine. Long context can make those allocations as important as weight storage.

The pricing advantage also varies with workload shape. Agent loops with stable prefixes can benefit from automatic cache hits, while frequently changing context pays the higher miss rate. Maximum reasoning may increase output enough to offset a low per-token price. For cost comparisons, completed tasks, wall-clock time, and retry rates are more informative than the posted rate alone.

As of July 31, 2026, the API remained in public beta. Most launch results lacked independent, setup-matched reproduction; pricing and behavior could still change; and the Responses API covered only part of the OpenAI surface. A million-token limit also does not guarantee reliable reasoning over an unstructured million-token prompt.

The service was text-only, without image or file input. Unsupported Responses fields could be ignored silently, which makes compatibility testing necessary when an existing client relies on OpenAI-specific state or tools. V4-Pro and the consumer App/Web product had not received the checkpoint, so observations about 0731 should not be generalized across the entire V4 family.

A Strong Result with an Incomplete Explanation

The July release kept the V4-Flash architecture fixed while changing the checkpoint and surrounding agent stack. DeepSeek reports large gains, but the unpublished harness and internal benchmarks prevent causal attribution or exact reproduction. The evidence supports a stronger configured system in the reported tests, not an isolated post-training effect.

Status: sources 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.