DeepSeek V4 Flash: The $0.28 Open-Weight Model That Beats Its Own Pro at Agentic Coding — No GPU Required

The cheapest way to run a serious coding agent in 2026 is now an open-weight model you can also download for free. On 31 July, DeepSeek published DeepSeek-V4-Flash-0731 to Hugging Face and moved the official V4-Flash API into public beta — and the headline is not the architecture, because the architecture did not change. The headline is that a re-post-trained DeepSeek V4 Flash now beats its own larger, more expensive sibling on every agentic benchmark DeepSeek published, at roughly a third of the output price.

That combination — near-frontier agentic coding scores, $0.28 per million output tokens, MIT-licensed weights, a 1M-token context window and no GPU required if you use the API — is why this release hit the Hacker News front page twice in a day. This guide walks through what actually shipped, the real benchmark table, the cost math that the per-token price hides, what self-hosting genuinely costs, and how to decide whether to migrate your agent stack this month.

What DeepSeek V4 Flash 0731 Actually Is

DeepSeek-V4-Flash-0731 is not a new model family. The "0731" tag marks the 31 July 2026 general-availability checkpoint that supersedes the earlier V4-Flash preview build. The model card on Hugging Face is unusually explicit about this: the architecture and parameter count are unchanged, and every gain comes from re-post-training rather than a redesign.

The specification, per the DeepSeek-V4 technical report:

• 284B total parameters, ~13B activated per token — a sparse mixture-of-experts (MoE) design.
• 1M-token context window, which is both the default and the maximum.
• 256 routed experts plus 1 shared expert per MoE layer, with 6 routed experts firing per token and hash routing in the first three MoE layers.
• Hybrid attention combining Compressed Sparse Attention (CSA) and Heavily Compressed Attention (HCA) for long-context efficiency.
• Manifold-Constrained Hyper-Connections (mHC) replacing conventional residual connections.
• More than 32T pre-training tokens, trained with the Muon optimizer.
• MIT-licensed, ungated weights — commercial and on-premise deployment is unblocked with no access request.

The Hugging Face repository reports 304B parameters rather than 284B because it ships the DSpark speculative decoding module — a draft model — attached on top of the base. On the API side, deepseek-v4-flash now natively supports the Responses API format and is adapted for Codex-style harnesses. Notably, the V4-Pro API and DeepSeek's own app and web models were not updated in this release.

The Benchmark Table, Read Honestly

Every number below is DeepSeek-reported, taken from the 0731 model card, with Code Agent tasks run at reasoning_effort: max, temperature 1.0 and top_p 0.95.

• Terminal Bench 2.1: 82.7 for Flash-0731, up from 61.8 for the preview — against 72.1 for V4-Pro-Preview, 81.0 for GLM-5.2 and 85.0 for Claude Opus 4.8.
• NL2Repo: 54.2, up from 39.4, versus 38.5 for V4-Pro-Preview and 69.7 for Opus 4.8.
• Cybergym: 76.7, up from 38.7, versus 52.7 for V4-Pro-Preview and 83.1 for Opus 4.8.
• DeepSWE: 54.4, up from a near-unusable 7.3, versus 12.8 for V4-Pro-Preview, 46.2 for GLM-5.2 and 58.0 for Opus 4.8.
• Toolathlon-Verified: 70.3, up from 49.7, versus 55.9 for V4-Pro-Preview and 76.2 for Opus 4.8.
• Agents' Last Exam: 25.2, up from 15.8, versus 16.5 for V4-Pro-Preview and 25.7 for Opus 4.8.
• AutomationBench Public: 25.1, up from 10.8, versus 12.8 for V4-Pro-Preview and 27.2 for Opus 4.8.

Three qualifications belong in the same breath as those figures.

1. The harness is not public

Code Agent tasks were run using the minimal mode of "DeepSeek Harness," which has not been released. Agent benchmarks are notoriously harness-sensitive — scaffolding, retry policy, tool definitions and timeout budgets can swing scores by double digits. Independent runs will diverge, probably downward.

2. Two of the datasets are internal

DSBench-FullStack (68.7) and DSBench-Hard (59.6) are DeepSeek's own internal test sets. They are informative about the model's trajectory and useless for cross-vendor comparison.

3. The gains are concentrated, not uniform

Look at where the deltas cluster: terminal work, repository navigation, tool-heavy and long-horizon tasks. That is exactly the profile you would expect from agentic post-training. Vision-heavy workloads and single-shot chat quality are not where this checkpoint improved, and nothing in the release claims otherwise. If your product is a coding or automation agent, this is a genuine upgrade. If it is a multimodal assistant, it mostly is not — for that, our coverage of Alibaba's Qwen3.8-Max launch is the more relevant comparison.

The DeepSWE jump from 7.3 to 54.4 deserves a sceptical note of its own. A 7x improvement on a fixed architecture almost always means the preview checkpoint was failing the harness for mechanical reasons — malformed tool calls, truncated outputs, format mismatches — rather than lacking capability. That is still a real fix, but it is a plumbing fix, not a reasoning breakthrough.

The Cost Math That the Price Tag Hides

DeepSeek's published pricing for deepseek-v4-flash:

• $0.14 per 1M input tokens on a cache miss
• $0.0028 per 1M input tokens on a cache hit
• $0.28 per 1M output tokens
• 2,500 concurrent requests, versus 500 for V4-Pro

For comparison, deepseek-v4-pro output runs $0.87 per 1M tokens. So Flash-0731 is roughly a third of the price and supports five times the concurrency — while scoring higher on every published agentic evaluation.

The number nobody puts in the headline is that cache pricing is a 50x discount on input. $0.0028 versus $0.14 per million tokens is the difference between an agent loop being an operating expense and being a rounding error. Agent loops are the ideal shape for this: the system prompt, tool schemas and repository context are re-sent on nearly every turn, and only the tail of the conversation is new. A pipeline holding a 60% cache-hit rate pays dramatically less than the sticker price suggests — the published analyses put the effective saving in the region of two-thirds of naive cost.

Two practical consequences follow:

1. Design for cache stability. Keep the prefix of every request byte-identical: fixed system prompt, fixed tool order, fixed context block ordering. Injecting a timestamp or shuffling tool definitions at the top of the prompt destroys the discount you are optimising for.
2. Budget output tokens deliberately. At high and max reasoning effort the model can emit up to 384K output tokens. Output is 100x the price of a cached input token, so verbose deliberation — not context length — is where agent bills actually come from.

The reasoning_effort parameter now takes three levels: low, high and max. Every published Code Agent benchmark score was produced at max. If you benchmark at low and compare against DeepSeek's table, you are comparing two different things. This is the same reproducibility trap we flagged when reviewing AI coding tools against real repositories.

Self-Hosting: Free Weights, Expensive Hardware

The MIT licence removes every legal barrier — no gate, no acceptable-use rider, no revenue threshold. The hardware does not cooperate quite so cheerfully.

The trap in MoE self-hosting is that sparsity saves compute, not memory. Only 13B parameters activate per token, but all 284B must be resident because routing decisions happen per token. Concretely:

• DeepSeek's own vLLM example serves the model on a single 4×GB300 node at full precision.
• Unsloth's dynamic GGUF builds put the lossless 8-bit quantisation at about 162 GB and a 3-bit build at roughly 103 GB, needing around 110 GB of combined RAM plus VRAM.
• DSpark speculative decoding is enabled with a single vLLM flag configuring the dspark method with 7 speculative tokens and greedy draft sampling. The DSpark paper reports 60–85% faster per-user generation versus an MTP-1 baseline at matched aggregate throughput.
• There is no Jinja chat template in the repository. DeepSeek ships an encoding/ folder with encode_messages and parse_message_from_completion_text helpers instead — so any integration that assumes a standard chat template will need adapting.

Realistically: the API is for everyone, from solo developers to platform teams. Self-hosting suits organisations with a serving cluster, a data-residency requirement, or one very well-specced workstation running aggressive quantisation. There is no meaningful consumer-laptop path at this size.

Should You Migrate Your Agent Stack?

A decision framework rather than a verdict:

Strong case for switching now

• You run high-volume agentic loops — code review bots, browser agents, batch document processing, CI triage — where per-run cost dominates.
• Your workload is terminal-, repository- and tool-heavy, which is precisely where the 0731 gains concentrate.
• You need open weights for procurement, air-gapped deployment or data-residency reasons.
• You need long context: 1M tokens as the default, not a premium tier.

Reasons to wait

• Your workload is vision-heavy or depends on polished conversational quality.
• You need independently verified scores; every published number is vendor-reported on an unreleased harness.
• You are sensitive to model-identifier drift — the hosted API still serves this checkpoint under the plain deepseek-v4-flash name, so a provider can swap the underlying weights beneath you. Pin versions where your provider allows it and re-run evals when they change.
• Marginal reliability differences matter more to you than throughput gains.

The migration test that actually settles it

Run your own harness before believing anyone's table, including ours. A defensible three-day evaluation:

1. Day 1 — replay. Take 100 real tasks your current agent has already completed. Re-run them through V4-Flash-0731 at max effort with identical tools. Record pass rate, turn count, wall-clock time and total token spend.
2. Day 2 — cache tuning. Freeze your prompt prefix, measure the achieved cache-hit rate, and recompute cost per completed task rather than cost per million tokens.
3. Day 3 — failure taxonomy. Classify every failure as capability, formatting or tool-plumbing. The second and third categories are usually fixable in your own scaffold, and on this checkpoint they are where the previous build was losing points.

If cost per completed task drops and the failure profile is dominated by plumbing rather than capability, migrate. If capability failures dominate, stay where you are and re-test at the next checkpoint.

What This Release Says About the Market

Three structural signals matter more than any single score.

Post-training headroom is larger than assumed. Same parameters, same shape, same DSpark configuration — and the model leapfrogged its pricier sibling on agentic work. That reframes the frontier race: capability gains no longer require a bigger pre-training run, which is good news for everyone without a hyperscaler budget and awkward news for anyone whose moat is scale alone.

The cheap tier is becoming the capable tier. Historically "Flash"-class models were the compromise you accepted for latency and price. A Flash checkpoint beating the Pro checkpoint on agentic evaluations inverts that assumption, and it lands in the same month as a free MCP server exposing 67 agent tools with no API keys. The cost floor for building an agentic product keeps dropping.

Cyber capability now arrives by default. A Cybergym score of 76.7 on an MIT-licensed, ungated model means offensive-adjacent capability is downloadable, not licensed. That is the same trend line running through specialised cyber reasoning models, and it argues for treating agent-run pipelines as production surfaces — see the OWASP Top 10 for LLM Applications for the concrete control list.

If you deploy in the EU, note also that open-weight distribution does not exempt you from downstream obligations. The EU AI Act attaches duties to the deployer of a system, not only to the model's original publisher — so the licence being permissive is not the end of your compliance analysis.

The Practical Bottom Line

DeepSeek V4 Flash 0731 is the strongest price-to-agentic-capability ratio publicly available in 2026, and the evidence for it is entirely vendor-reported. Those two facts sit comfortably together: the pricing is verifiable today from a public price list, and the benchmarks are a directional claim awaiting independent replication on a released harness.

Do this in order. Point one non-critical agent pipeline at the API this week. Freeze your prompt prefix and measure the achieved cache-hit rate. Compute cost per completed task, not cost per token. Then decide. The API path needs no GPU, no gated access request and no licence negotiation — which means the only real cost of finding out is an afternoon.

For more on choosing and stress-testing models in this category, browse our AI for Developers hub, the Generative AI News desk for release coverage, AI Agents & Automation for pipeline design, and our complete guide to the best AI tools in 2026.