DeepSeek V4-Flash-0731: Retrained, MIT-Licensed, and Benchmarking Past Pro

TL;DR: DeepSeek dropped V4-Flash-0731 on July 31, 2026 — a retrained checkpoint of the 284B-parameter MoE model that now beats its own flagship V4-Pro on nine agent and coding benchmarks. The weights ship under an MIT license on Hugging Face, the API introduces native OpenAI Responses API support for Codex CLI users, and at $0.14/M input tokens it resets the floor on agent economics. But the headline numbers come with reproducibility asterisks, and the real story isn’t benchmark tables — it’s what happens when a $0.28/M-output model starts running 20-million-token coding loops.

Introduction

DeepSeek’s release cadence has become one of the more reliable beats in AI infrastructure. On July 31, 2026, the company published DeepSeek V4-Flash-0731, a retrained version of the DeepSeek V4-Flash model first previewed in April (Source : MarkTechPost — DeepSeek Upgrades DeepSeek V4-Flash-0731 with Major Agentic and Coding Gains). The model architecture is unchanged: it’s still a 284-billion-parameter Mixture-of-Experts (MoE) design with 13 billion active parameters per token. What changed is post-training — an enhanced reinforcement-learning stage targeting instruction-following, tool-use, and agentic reasoning.

The result is a model that beats DeepSeek’s own V4-Pro-Preview on nine published benchmarks, ships with MIT-licensed weights, and costs $0.14 per million input tokens. For a field where “open weights” and “frontier performance” rarely occupy the same sentence, the 0731 release deserves a closer look.

What Changed in the 0731 Retrain

DeepSeek V4-Flash-0731 is not a new architecture. It’s the same 284B MoE backbone — 13B active parameters per forward pass — that shipped in April. The entire delta lives in post-training.

The April preview was already strong on raw reasoning (MMLU, MATH, coding benchmarks) but showed weakness on multi-turn agent tasks: tool orchestration, file-system operations, long-horizon planning. DeepSeek addressed this with an expanded reinforcement-learning phase that, according to the release notes, specifically targeted instruction-following fidelity, tool-call accuracy under extended context, and chain-of-thought reasoning over multi-step workflows (Source : TechTimes — DeepSeek Retrained V4-Flash, Beats Its Flagship Pro on Nine Agent Benchmarks).

The model maintains a 1M-token context window with 384K max output tokens — parameters identical to the April release. The difference is entirely in what the model does with that window.

Benchmark Analysis

The headline is striking: V4-Flash-0731 surpasses V4-Pro-Preview, DeepSeek’s own more expensive flagship, across nine agent and coding benchmarks. Here are the numbers.

Agent & Coding Benchmarks: April Preview vs. 0731

Benchmark	April Preview	V4-Flash-0731	Gain	V4-Pro-Preview
Terminal-Bench 2.1	56.9	82.7	+25.8	Below 82.7
DeepSWE	7.3	54.4	+47.1	Below 54.4
Cybergym	38.7	76.7	+38.0	Below 76.7
Toolathlon-Verified	49.7	70.3	+20.6	Below 70.3
NL2Repo	39.4	54.2	+14.8	Below 54.2
Agents’ Last Exam	15.8	25.2	+9.4	Below 25.2

The average gain across these six publicly named benchmarks is roughly 26 points. The largest leap — DeepSWE — saw a 47.1-point jump from 7.3 to 54.4, transforming the model from “barely functional” to “usable” on software-engineering tasks. Terminal-Bench 2.1 climbed 25.8 points to 82.7, putting it in striking distance of frontier closed-source models (Source : MarkTechPost — DeepSeek Upgrades DeepSeek V4-Flash-0731 with Major Agentic and Coding Gains).

Two additional internal benchmarks — DSBench-FullStack (68.7) and DSBench-Hard (59.6) — appear in DeepSeek’s release materials but lack external validation. They exist outside any public leaderboard or third-party reproduction framework, which limits their evidentiary weight.

Independent Corroboration

Artificial Analysis, an independent model evaluation platform, reported an approximately 10-point jump on its Intelligence Index for V4-Flash-0731 compared with the earlier April preview (Source : Artificial Analysis — DeepSeek V4-Flash). While this is a smaller gain than the agency-specific benchmark jumps, it’s directionally consistent and comes from an independent evaluator, lending credibility to the overall trend.

The Terminal-Bench Asterisk

The 82.7 Terminal-Bench 2.1 score warrants a caveat. According to DeepSeek’s own disclosure, this result was obtained using “DeepSeek Harness” in minimal mode with maximum reasoning effort — an unreleased internal scaffolding system. Terminal-Bench evaluates coding agents as complete systems (model plus harness), not models in isolation. A score obtained with a proprietary, unavailable scaffolding layer is not independently reproducible, and third-party benchmarks using standard tooling will likely produce different numbers (Source : TechTimes — DeepSeek Retrained V4-Flash, Beats Its Flagship Pro on Nine Agent Benchmarks).

This doesn’t invalidate the results — DeepSeek discloses the harness — but it does mean the gap between 0731 and competing models measured with different harnesses on the same benchmarks is not an apples-to-apples comparison.

Native Responses API and Codex CLI Integration

For developers who live in the terminal, the most consequential change in the 0731 release may not be a benchmark number but an API flag: wire_api = responses.

V4-Flash-0731 ships with native support for the OpenAI Responses API wire format. This eliminates the chat-completions translation layer that previously sat between DeepSeek’s endpoints and tooling that expects Responses API semantics — most notably OpenAI’s Codex CLI (Source : Daniel Vaughan — DeepSeek V4-Flash-0731: Native Codex Support, MIT Open Weight, Agent Economics).

For Codex CLI users, the practical implication is straightforward:

Before 0731: Using DeepSeek with Codex required proxying through chat-completions, a workaround that introduced friction with tool-call formatting, structured output schemas, and multi-turn conversation state.
With 0731: Codex talks directly to the DeepSeek API over the Responses wire format. Tool calls, structured outputs, and multi-turn loops work natively without a translation shim.

Daniel Vaughan’s configuration guide confirms that dropping a DeepSeek API key and endpoint into Codex with wire_api = responses produces functional agent loops out of the box (Source : Daniel Vaughan — DeepSeek V4-Flash-0731: Native Codex Support, MIT Open Weight, Agent Economics).

DeepSeek has also announced that V4-Pro will gain Responses API support in early August 2026, suggesting this is a platform-wide migration rather than a Flash-only feature.

Licensing and Self-Hosting

DeepSeek released the V4-Flash-0731 weights on Hugging Face under an MIT license — one of the most permissive open-source licenses available (Source : Hugging Face — DeepSeek V4-Flash-0731). The repository contains 48 Safetensors shards at approximately 160GB in FP4/FP8 mixed precision.

The MIT license imposes essentially no restrictions: you can use the weights commercially, modify them, redistribute them, and incorporate them into proprietary systems without attribution or reciprocal licensing requirements. For enterprises that have been waiting on the sidelines due to licensing uncertainty around other open-weight models, this is a meaningful differentiator.

Self-hosting is practical but non-trivial. The model requires roughly 160GB of VRAM at the distributed precision, which maps to 2×H100 (80GB) or 4×A100 (40GB) configurations. Unsloth provides optimized quantization paths and deployment guides for running DeepSeek V4-family models on consumer and prosumer hardware (Source : Unsloth Documentation — DeepSeek V4). The felloai platform also offers managed hosting with per-token pricing comparable to DeepSeek’s own API (Source : felloai — DeepSeek V4).

Agent Economics: Token Price vs. Cost Per Accepted Task

The pricing table for DeepSeek V4-Flash-0731 tells one story:

Tier	Price per Million Tokens
Input	$0.14
Output	$0.28
Cached Input	$0.0028

For comparison, GPT-4.1’s non-cached input runs at $2.00/M, Claude Opus 4 at $15.00/M input — price ratios of 14× and 107× respectively. On a raw token-cost basis, DeepSeek is in a different pricing universe.

But token price is the wrong metric for agent workloads. An agentic coding session is not a single-turn chat completion; it’s a loop. The model generates a tool call, the harness executes it, the result feeds back into context, and the cycle repeats — often dozens of times, inflating the total token count well beyond what a single-turn chat would consume.

What a Real Agent Run Costs

Consider a 20-million-token agent session at a 3:1 input-to-output blend, with 30% cache hit rate:

Total tokens: 20,000,000
Input (75% of tokens): 15,000,000 — of which 4,500,000 hit cache
Output (25% of tokens): 5,000,000

Component	Tokens	Cost
Uncached input	10,500,000	$1.47
Cached input	4,500,000	$0.01
Output	5,000,000	$1.40
Total	20,000,000	~$2.88

That’s under $3 for a full agent session that might produce a feature branch, fix a bug across multiple files, or refactor a module. The same session on Claude Opus 4 could run $150–$200. On GPT-4.1, roughly $30–$40.

The metric that should displace cost-per-token in agent economics is cost per accepted task — the total session cost divided by the number of tasks the agent completed correctly on the first attempt. A model that costs 10× more per token but succeeds on the first try more than 10× as often may still win on this metric. But DeepSeek’s pricing is aggressive enough that even a 50% first-attempt success rate at $3/session may undercut a 90% success rate at $40/session, especially for workloads where human review is cheap relative to compute.

Peak-Hour Pricing (Pending)

DeepSeek has announced peak-hour pricing at 2× the base rate during Beijing business hours, but this surcharge is not yet activated. When it goes live, it will disproportionately affect agent workloads that run during APAC daytime — a consideration for globally distributed CI/CD pipelines and autonomous coding agents.

Reproducibility: The Harness Problem

A growing body of research argues that benchmarking coding agents as if they were models — reporting a single score and attributing it to the LLM — is methodologically flawed. The Tessl position paper, presented at the SE 3.0 Workshop at KDD 2026, makes the case explicitly: a coding agent is a system comprising a model, a harness (scaffolding), and an environment. Benchmark scores conflate all three (Source : arXiv:2606.17799 — Tessl Position Paper, SE 3.0 Workshop, KDD 2026).

This complicates the interpretation of V4-Flash-0731’s benchmark results in two ways:

The DeepSeek Harness is unreleased. The 82.7 Terminal-Bench 2.1 score was obtained with proprietary scaffolding that no third party can replicate. Independent evaluations using standard harnesses (SWE-bench’s official scaffold, open-source agent frameworks) may produce materially different numbers.
Harness variance across evaluations. Even when models are compared on the same benchmark, differences in the agent harness — retry logic, tool selection, prompt formatting, context management — produce score variance that can exceed model-to-model differences. A 5-point gap between two models on Terminal-Bench may mean less than a 15-point gap caused by harness differences.

The takeaway is not that V4-Flash-0731’s benchmarks are invalid, but that they should be read as system-level measurements, not pure model evaluations. The model earned those scores inside DeepSeek’s harness; your mileage inside your harness will vary.

Implications

For Open-Source AI

DeepSeek V4-Flash-0731 under MIT license is the most capable open-weight agent model available as of August 2026. It matches or exceeds DeepSeek’s own closed-weight flagship on agent tasks while carrying none of the licensing friction that has kept enterprises cautious about Llama-family models (Meta’s acceptable use policy) or Qwen (Alibaba’s terms). For companies building internal coding agents, the self-hosting option at 160GB VRAM is within reach of a single DGX-class machine.

For Frontier Labs

The pricing pressure is real. OpenAI and Anthropic cannot compete on raw token cost — their business models don’t allow it. Their counter-play must be on reliability: first-attempt success rate, consistency across diverse tasks, and agent harness quality. If DeepSeek can push its first-attempt success rate toward parity while maintaining a 10–100× cost advantage, the “premium” tier becomes harder to justify for anyone running high-volume agent workloads.

For Agent Infrastructure

Native Responses API support is a signal. As agent tooling consolidates around the OpenAI Responses wire format as a de facto standard, providers that support it natively gain immediate compatibility with the fastest-growing segment of AI infrastructure — terminal-based coding agents. DeepSeek shipping this in July and promising it for V4-Pro in August suggests the company understands that API compatibility, not just model quality, drives adoption in the agent ecosystem.

FAQ

Q: Is V4-Flash-0731 a new model architecture?

No. It’s the same 284B MoE architecture (13B active per token) as the April 2026 preview. The changes are entirely in post-training: enhanced RL for instruction-following, tool-use, and agentic reasoning. Think of it as a major software update to existing hardware.

Q: Can I run V4-Flash-0731 on my own hardware?

Yes — the MIT-licensed weights are on Hugging Face as 48 Safetensors shards at ~160GB (FP4/FP8 mixed precision). You’ll need roughly 160GB of VRAM, which maps to 2×H100 or 4×A100 GPUs. Unsloth provides optimized quantization paths for smaller configurations.

Q: What is the Responses API and why does it matter?

The OpenAI Responses API is a wire format designed for multi-turn agent interactions — it handles tool calls, structured outputs, and conversation state natively. Codex CLI (OpenAI’s terminal coding agent) uses this format. By supporting it directly (wire_api = responses), DeepSeek eliminates the chat-completions translation layer, making it a drop-in replacement for Codex users.

Q: How should I think about DeepSeek’s pricing for agent workloads?

Don’t think in cost per token — think in cost per accepted task. A full agent session (~20M tokens at 3:1 input:output blend) runs roughly $3 on DeepSeek before cache discounts. The same session on premium models costs $30–$200. The question is whether premium models’ higher first-attempt success rates justify the 10–100× premium. For many workloads, the answer is increasingly “no.”

Q: Are the benchmark scores reproducible?

Partially. The 82.7 Terminal-Bench 2.1 score used DeepSeek’s unreleased “DeepSeek Harness” — a proprietary scaffolding layer not available to third parties. Independent evaluations on standard harnesses will likely produce different numbers. The Artificial Analysis Intelligence Index gain (~10 points) provides independent corroboration of improvement but not at the magnitude DeepSeek reports for specific agent benchmarks.