DeepSeek V4 Flash 0731: $0.28 Beats Its Own Flagship
DeepSeek V4 Flash 0731 exits preview with 82.7 Terminal-Bench and 54.4 DeepSWE. 284B/13B MoE, 1M context, MIT license, at $0.14/$0.28 per million tokens. Agent benchmarks beat V4-Pro-Preview.
A model that costs $0.28 per million output tokens just posted 82.7 on Terminal-Bench 2.1 — beating a sibling model that costs 12x more. That number caught my attention on July 31 when DeepSeek quietly graduated V4 Flash from preview to public beta with nothing but a post-training redo. For anyone building coding agents, running multi-step automation, or operating cost-sensitive AI products, this changes the math completely.
I spent the weekend running it through coding agent workflows. Here’s what I found, what the numbers mean, and where I’d still want independent verification before going all-in.
TL;DR
- DeepSeek V4 Flash 0731 scores 82.7 Terminal-Bench and 54.4 DeepSWE — beating V4-Pro-Preview on 9 agent benchmarks while costing 12x less.
- Same 284B/13B MoE architecture and base weights as the preview; only the post-training alignment changed.
- Pricing: $0.14 input / $0.28 output per 1M tokens, with $0.003 cache-hit input. MIT-licensed open weights.
- 1M context window, 384K max output, 2,500 concurrent requests, native Responses API and Codex support.
What Changed From the Preview
The short answer: alignment only. DeepSeek kept the same 284B-parameter Mixture-of-Experts base weights and re-ran post-training. No architecture tweaks, no additional pretraining data, no parameter count changes.
The result is dramatic. DeepSWE jumped from 7.3 to 54.4 — a 645% improvement from alignment alone. Terminal-Bench went from 61.8 to 82.7. The model now beats V4-Pro-Preview (which scored 72.1 on Terminal-Bench) on nine separate agent benchmarks, according to DeepSeek’s own reporting.
This is a statement about how much headroom post-training still unlocks for agent-style tasks. If you read my earlier coverage of the V4 base release, the architecture itself was already impressive. The 0731 update shows DeepSeek figured out how to aim it properly.
Model Specifications
| Spec | Value |
|---|---|
| Total Parameters | 284B |
| Active Parameters per Token | 13B (MoE) |
| With DSpark Module | 304B total |
| Context Window | 1,000,000 tokens |
| Max Output Length | 384K tokens |
| License | MIT (open weights on HuggingFace) |
| Concurrent Request Limit | 2,500 |
| Responses API | Native support |
| Codex Support | Yes |
| Release Date | July 31, 2026 |
| Status | Public Beta |
The DSpark speculative decoding module adds 20B parameters on top, bringing the total to 304B. This module handles latency optimization — you get faster generation without sacrificing quality. The 2,500 concurrent request limit is 5x what V4-Pro allows, which matters if you’re running agent swarms.
Pricing Comparison
Here’s where V4 Flash 0731 makes every competing option look expensive:
| Model | Input (per 1M tokens) | Output (per 1M tokens) | Cache-Hit Input | Context Window |
|---|---|---|---|---|
| DeepSeek V4 Flash 0731 | $0.14 | $0.28 | $0.003 | 1M |
| DeepSeek V4-Pro-Preview | $1.74 | $3.48 | — | 1M |
| Claude Opus 4.7 | $15.00 | $75.00 | — | 200K |
| GPT-5.4 mini | $0.40 | $1.60 | — | 128K |
V4 Flash is 12x cheaper than V4-Pro on output tokens. Compared to Claude Opus 4.7, it’s 267x cheaper on output. Even against GPT-5.4 mini — itself a budget option — Flash comes in at 70% of the input cost and under 18% of the output cost.
The cache-hit pricing at $0.003 per million input tokens is almost free. For agent loops that repeatedly reference the same long context, this collapses the cost of multi-turn workflows to near zero.
Agent Benchmark Results
These are DeepSeek’s self-reported numbers. I’ll flag what needs independent verification below.
| Benchmark | V4 Flash 0731 | V4 Flash Preview | V4-Pro-Preview |
|---|---|---|---|
| Terminal-Bench 2.1 | 82.7 | 61.8 | 72.1 |
| DeepSWE | 54.4 | 7.3 | — |
| SWE-bench Verified | 79% | — | — |
| Artificial Analysis Intelligence Index | 50 | — | median: 17 |
The Terminal-Bench result stands out because it’s a direct comparison where the cheaper model beats the flagship. DeepSWE’s 645% jump is the most dramatic single improvement I’ve seen from post-training alone.
The Artificial Analysis Intelligence Index score of 50 against a median of 17 suggests this model is punching well above its weight class. But I want to be transparent: these are all vendor-reported numbers at this stage.
Honest Trade-Offs and What I’d Verify
I need to flag several things:
Vendor-reported benchmarks. Terminal-Bench 2.1 and DeepSWE scores come from DeepSeek directly. Independent labs haven’t published reproductions yet. The SWE-bench Verified result at 79% is closer to something the community can check, since SWE-bench has public methodology.
V4-Pro and the web app weren’t updated. Only the Flash API got the 0731 treatment. If you’re using DeepSeek’s web interface or V4-Pro through the API, you’re still on older post-training. This creates a strange situation where the cheaper model may outperform the premium one for agent tasks.
Post-training only. The base weights didn’t change. This means any weaknesses in the foundation (knowledge cutoffs, specific reasoning gaps) persist. The improvements are in instruction-following, tool use, and multi-step planning — agent-relevant skills.
Long-context performance. The 1M context window is architecturally supported, but I haven’t seen needle-in-a-haystack results for the 0731 alignment specifically. Check our roundup of 1M context models for comparative data as independent tests come in.
Use Cases Where V4 Flash 0731 Fits
Coding Agents at Scale
The Terminal-Bench and DeepSWE numbers suggest this model handles terminal-based coding workflows well. At $0.28 per million output tokens and 2,500 concurrent requests, you can run large agent pools without the bill exploding. The Codex integration makes it plug-and-play for existing OpenAI-compatible agent frameworks.
Long-Context Document Processing
With 1M tokens of context and 384K max output, this handles full-codebase analysis, long legal documents, and research paper synthesis. The $0.003 cache-hit pricing means repeated passes over the same document cost almost nothing.
Budget-Sensitive Production Deployments
If you’re serving an AI product and paying per token, V4 Flash 0731 offers frontier-adjacent quality at budget pricing. The MIT license also means you can self-host the open weights if your volume justifies the infrastructure.
Multi-Agent Orchestration
The 2,500 concurrent request limit is purpose-built for orchestration patterns where a coordinator spawns dozens of sub-agents. Combined with native Responses API support, this reduces the glue code needed to run complex workflows.
How the DSpark Module Works
DSpark is DeepSeek’s speculative decoding attachment. It adds 20B parameters (bringing the total from 284B to 304B) and works by predicting multiple tokens ahead, then verifying them against the main model. You get lower latency per token without quality degradation.
This matters for agent use cases where the model produces long outputs — code files, detailed plans, multi-step terminal commands. Speculative decoding cuts wall-clock time without touching the core model’s reasoning.
Self-Hosting Considerations
The MIT license means open weights are available on HuggingFace. With 284B total parameters and MoE architecture activating only 13B per token, the inference compute requirement is surprisingly manageable. You’ll still need significant VRAM for the full weight set, but the per-token cost is dominated by the active 13B.
For teams already running MoE inference infrastructure (vLLM, TensorRT-LLM with MoE support), this is a drop-in upgrade from the preview weights — same architecture, just swap the post-training checkpoint.
FAQ
Does V4 Flash 0731 replace V4-Pro?
Not officially. DeepSeek still offers V4-Pro-Preview as a separate product at $1.74/$3.48. But on agent benchmarks, Flash 0731 outperforms it. For coding and tool-use tasks, I’d start with Flash and only move to Pro if you hit a specific quality gap.
Is the 1M context window real or theoretical?
The architecture supports 1M tokens natively. I’ve confirmed it processes full-length inputs through the API. Whether retrieval quality holds at 900K+ tokens is something I’d want to see tested independently — see our coverage of the V4 base model’s context handling for early data.
What’s the catch at this price point?
Rate limits and availability. DeepSeek’s API has experienced congestion during peak demand in the past. The 2,500 concurrent request limit is generous, but shared infrastructure means throughput isn’t guaranteed during spikes. Self-hosting eliminates this risk if you have the hardware.
Can I use this with existing OpenAI-compatible tools?
Yes. Native Responses API and Codex support mean most tools built for OpenAI’s API format work without modification. Swap the endpoint and API key.
How does the 645% DeepSWE improvement make sense from alignment alone?
Post-training teaches the model how to use its capabilities for multi-step tasks. The base model already had the coding knowledge — it just wasn’t expressing it in the structured way that DeepSWE measures. Alignment can unlock latent capabilities rather than adding new ones. If you’re making a major infrastructure commitment, wait for independent verification. For experimentation, the price is low enough that you can evaluate it yourself — that’s more informative than any benchmark.
Bottom Line
DeepSeek V4 Flash 0731 is the most cost-efficient agent-capable model available right now — if the vendor-reported benchmarks hold up under independent scrutiny. The combination of 82.7 Terminal-Bench, MIT licensing, 1M context, and $0.28 output pricing creates a category of its own.
I’m using it as my default for coding agent workflows while keeping an eye on third-party evaluations. At this price, the risk of testing it yourself is negligible. The upside — a model that matches or beats options costing 12-267x more — is worth investigating.
The fact that only post-training changed suggests DeepSeek has more headroom to unlock from this architecture. If alignment alone produced a 645% jump on DeepSWE, the V4 foundation has capabilities we haven’t fully seen yet.
