DeepSeek V4 Flash Is Now Official: What Changed in the 0731 Build

The DeepSeek-V4-Flash-0731 checkpoint shipped on July 31, 2026 — the same 284B-parameter CSA+HCA backbone, re-post-trained for agents, now outscoring the V4-Pro preview on every agentic benchmark DeepSeek publishes. Here is what the release actually contains, what it costs, and how to run it.

July 31, 2026 · ~12 min read

---

Today DeepSeek promoted V4-Flash from preview to official release.

The headline is deliberately counterintuitive: a model with 13B activated parameters now beats the 49B-active V4-Pro preview on all nine agentic benchmarks DeepSeek publishes — at a fraction of the cost to run.

If you build agents, eval harnesses, or long-context pipelines on top of V4, this release changes your default model choice.

TL;DR — The July 31 release promotes DeepSeek-V4-Flash-0731 to production-candidate status on the deepseek-v4-flash API and publishes MIT-licensed open weights the same day. Architecture and size are unchanged from the preview — it was only re-post-trained, with the DSpark speculative-decoding module attached and native Responses API / Codex support added. In this post, we break down what "official" actually means here, whether to migrate now or wait for V4-Pro, how the 98% cache-hit discount becomes your real cost driver, and how to serve the open weights yourself.

This analysis is grounded in primary sources: the official API changelog (2026-07-31), the DeepSeek-V4-Flash-0731 model card on Hugging Face, the official pricing page, the Codex integration docs, and independent third-party evaluation from Artificial Analysis. By the end, you will know exactly what "official" means in this release, whether to migrate your workloads now or wait for V4-Pro, how the caching economics work, and how to serve the open weights yourself.

What "official release" means (and what it doesn't)

The July 31 update upgrades the deepseek-v4-flash API to a new production-candidate build, labeled DeepSeek-V4-Flash-0731. The API calling convention is unchanged — you keep using model="deepseek-v4-flash". DeepSeek's own changelog is explicit about scope:

The official release of the DeepSeek-V4-Flash API is now in public beta... DeepSeek-V4-Flash-0731 keeps the same model architecture and size as DeepSeek-V4-Flash-Preview, and was only re-post-trained.

The full release picture, from the changelog and the model card:

• What changed: a re-post-training pass focused on agentic capabilities, plus native Responses API support and explicit adaptation for Codex.
• What did not change: architecture, parameter count, context window, and pricing. The official build has the same structure as DeepSeek-V4-Flash-DSpark — it ships with the DSpark speculative-decoding module attached.
• What is still preview: the deepseek-v4-pro API and the APP/WEB models. DeepSeek states the V4-Pro official release "will follow soon," with Responses API and Codex support for Pro expected in early August 2026.
• Weights are out, same day: the DeepSeek-V4-Flash-0731 repository appeared on Hugging Face at 07:30 UTC today, MIT-licensed, superseding the preview checkpoint.
• Context: the legacy deepseek-chat / deepseek-reasoner identifiers were retired on 2026-07-24, per the April announcement. There is no legacy path anymore — V4 identifiers are the only ones that work.

This is a "正式版" (official release) in the strict sense: a production-candidate checkpoint promoted out of the preview line, rolled out through public beta API serving. The architecture analysis we published for the V4 GA line remains valid — this release does not revise it.

Architecture: unchanged weights, changed behavior

If you have read the V4 technical report, the model configuration needs no relearning. The model card confirms the family specs:

Note: we verified every row of this table against the model card and the Hugging Face repository API — the configuration matches the V4 family specs from the technical report, and the measured disk size (166,886,535,336 bytes) matches the 166.9 GB listed here.

The interesting part is what a post-training-only release does to behavior. Agentic competence is largely a policy problem, not a parametric one: which tool to call, when to stop reading, how to structure a long multi-step trajectory. A re-post-training pass reshapes that policy directly — reward signal, not new world knowledge — so it can move agentic benchmarks by tens of points while the 284B backbone stays untouched. The official table below shows deltas of exactly that magnitude — and the reasoning effort control was also expanded to three explicit levels (low, high, max), matching the reasoning_effort semantics that agent harnesses like Codex expect.

Rule of thumb: if a V4 release note says "architecture unchanged, re-post-trained only," expect large swings on agentic and tool-use benchmarks, modest swings on knowledge benchmarks, and no change in serving cost.

Benchmarks: the agentic leap

That rule of thumb gets its first test right here. The official model card publishes nine agentic benchmarks, each compared against the V4-Flash preview, the V4-Pro preview, GLM-5.2, and Opus 4.8:

† internal test sets. Public-benchmark Code Agent tasks were run with the minimal mode of DeepSeek Harness (framework to be released), max reasoning effort, temperature=1.0, top_p=0.95.

Three observations:

1. Flash-0731 beats V4-Pro-Preview on all nine benchmarks — by 8.7 to 41.6 points. The flagship's preview checkpoint is no longer the agentic leader in the family.
2. The gains concentrate exactly where post-training can deliver them. DeepSWE (+47.1 over preview), Cybergym (+38.0), and DSBench-Hard (+33.8) are long-horizon tool-use tasks. On knowledge and factual precision, expect much smaller movement — this is not a new pretraining run.
3. Against the closed frontier, the ceiling is Opus-4.8. Flash-0731 trails it by 0.5 to 15.5 points across rows, which places it in frontier-adjacent territory at a fraction of the price.

Independent verification is consistent. Artificial Analysis measured the 0731 build at 50 on its Intelligence Index — a 10-point jump over the April Flash, and 6 points ahead of V4-Pro. Its GDPval-AA v2 (real-work agentic) Elo rose from 1189 to 1559, Terminal-Bench 2.1 hit 79% (+17 points), and hallucination rate dropped 12 points. Critically, the model is also more token-efficient: 206M output tokens to complete the eval suite vs. 234M for the preview (−12%), which compounds the price advantage. Artificial Analysis places the 0731 build one Intelligence Index point behind GPT-5.6 Luna (max) — at roughly 60% lower cost per task on DeepSeek's first-party API.

The harness caveat: why you should not skip this

Agentic benchmark scores are framework-dependent. DeepSeek evaluated public Code Agent tasks with its own (unreleased) Harness framework in minimal mode at max effort. The sibling V4 GA analysis already flagged DeepSWE as a contamination-conscious benchmark — and harness choice alone can shift these numbers by 10+ points. Do not treat the official table as a transfer guarantee. Re-run your own agent workloads against the API and the weights before you commit a migration.

Rule of thumb: if you have not run it on your own task set, treat any agentic leaderboard — official or third-party — as a prior, not a verdict.

Which model should your pipeline call now?

The caveat matters most at the moment of choice — and for most teams the practical question is which identifier the pipeline should call now: Flash official, V4-Pro preview, or the retired V3.2 line. The table below is the decision surface:

Rules of thumb:

• Agent-heavy stack (Codex-style, terminal agents, tool orchestration, RAG pipelines with long tool schemas) → switch to deepseek-v4-flash today. It is cheaper, faster, more concurrent, and currently beats the Pro preview at the task class you actually run.
• Knowledge-sensitive generation (factual QA, report writing, retrieval-critical work) → keep V4-Pro preview for now, pair with RAG, and re-evaluate when the V4-Pro official release lands. The V4 family's SimpleQA-style gap to the closed frontier is a known weakness.
• If you are still on V3.2-era identifiers → you are already migrated or broken. The legacy endpoints returned HTTP 400 after July 24; deepseek-v4-flash (non-thinking default) and deepseek-v4-pro (premium) are the only paths.
• Self-hosting on limited GPUs → Flash is the only realistic V4 option. INT4 quantization brings Flash-class serving to consumer-adjacent hardware (~100 GB, 2×RTX 6000 Ada at reduced context); Pro does not fit that class.

Using the API: pricing, caching, and a 30-second check

Here the details matter more than the headline price. Pricing is unchanged from the preview, per both the official pricing page and Artificial Analysis:

The cache-hit price is a 98% discount — the most aggressive in the industry, per Artificial Analysis' comparison — and it is automatic. This is the number that dominates agentic cost: an agent loop re-sends the same system prompt, tool definitions, and repository context on every turn. A 200K-token cached prefix at $0.0028/M costs $0.00056 per turn of prefix, versus $0.028 at the uncached rate — 50× cheaper, which is exactly the 98% discount. If your workload has any reuse at all, the caching economics — not the headline output price — are your real cost driver.

Rule of thumb: for agent workloads, model the cache-hit price first; the headline output price is the smaller number.

Two pricing facts to plan around:

1. Peak/off-peak pricing is coming. DeepSeek announced a time-of-day policy: 2× prices during peak hours (09:00–12:00 and 14:00–18:00 Beijing Time, UTC+8), daily. The effective date is still "to be announced," so today's prices are the baseline. Action: keep time-flexible batch work out of those Beijing-time windows once the policy takes effect — peak hours cost 2×.
2. Responses API and Codex are Flash-only for now. deepseek-v4-pro gains them in early August 2026. Action: target Flash for new automations.

The 30-second validation: one curl call, no SDK

# normal response = you're already on the official build
curl -s https://api.deepseek.com/chat/completions \
  -H "Authorization: Bearer $DEEPSEEK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"deepseek-v4-flash","messages":[{"role":"user","content":"Reply with the exact build tag you are running."}]}'

Then run the three-step migration check:

1. Validate — the curl call above (30 seconds).
2. A/B on three real tasks — one agentic, one long-context, one knowledge.
3. Measure cached-token spend — the 98% discount decides whether Flash beats Pro.

The Python equivalent, if your stack already uses the OpenAI SDK:

from openai import OpenAI

client = OpenAI(base_url="https://api.deepseek.com", api_key="<your-key>")
r = client.chat.completions.create(
    model="deepseek-v4-flash",  # official build — no code change required
    messages=[{"role": "user", "content": "Explain what changed in V4-Flash-0731"}],
)
print(r.choices[0].message.content)

Codex integration

For Codex, DeepSeek ships a one-click setup script that backs up ~/.codex/config.toml, writes the model catalog, and validates before writing:

bash <(curl -fsSL https://cdn.deepseek.com/api-docs/codex-deepseek-setup-en.sh)

The catalog declares a 1M-token context window, low/high/max reasoning levels, and parallel tool calls — deepseek-v4-flash is listed as "Latest frontier agentic coding model."

Running the open weights yourself

Prefer not to pay per token? The open weights are out, MIT-licensed, same day. The official weights are live: deepseek-ai/DeepSeek-V4-Flash-0731, MIT license, 166.9 GB of safetensors (48 shards), created 07:30 UTC on release day. The repo has the DSpark speculative-decoding module attached, which is why it is ~9 GB larger than the 158 GB preview.

Serving is a solved problem on recent engines — the model card documents a vLLM recipe targeting a single 4×GB300 node:

vllm serve deepseek-ai/DeepSeek-V4-Flash-0731 \
  --trust-remote-code --kv-cache-dtype fp8 --block-size 256 \
  --data-parallel-size 4 --enable-expert-parallel \
  --moe-backend deep_gemm_mega_moe \
  --attention-config '{"use_fp4_indexer_cache": true}' \
  --speculative-config '{"method":"dspark","num_speculative_tokens":7,"draft_sample_method":"greedy"}'

Practical hardware guidance, consistent with the V4 GA deployment analysis:

Three deployment cautions for the 0731 build specifically:

• The DSpark draft module only pays off with the speculative config enabled; serving it as a plain dense model wastes ~9 GB of residency for nothing. Speculative decoding works by having the small draft module propose tokens that the main model verifies in parallel — 7 per step in the official recipe — so the payoff is decode speed, not quality.
• FP4 expert weights and the FP4 indexer cache require a recent vLLM (the recipe above needs the deep_gemm_mega_moe backend); older engines will reject or dequantize the checkpoint. Rule of thumb: check deep_gemm_mega_moe support in your serving engine before you download 167 GB.
• Recommended sampling per the card: temperature=1.0, top_p=0.95 for agentic scenarios (top_p=1.0 otherwise); reserve 384K max output for high/max reasoning effort.

When something goes wrong: symptom, root cause, fix

For hands-on V4-family deployment walkthroughs — including the V4 GA architecture breakdown this release builds on — see the V4 deployment guides on wan27.org, and for a release-focused companion guide covering the same 0731 build, read DeepSeek V4 Flash official release: what changed and how to use it.

What this means for the research community

Taken together, the same-day API rollout and weight release make this release unusually testable.

• Reproducibility is the point. Official weights + MIT license means every number in this article is independently checkable on your own GPUs. The API rollout and the weight release happened the same day — there is no excuse for benchmarking the API and calling it verification.
• Harness awareness is now a first-class evaluation skill. DeepSeek's own numbers are conditional on its Harness framework (to be released). Until then, third-party runs (Artificial Analysis) are the better transfer signal, and your own task set is the best one.
• Fine-tuning is open and cheap relative to the family. The MIT license permits commercial fine-tuning; the Muon-optimized training trajectory differs fundamentally from AdamW-era checkpoints (V3.2 and earlier), so fine-tuning recipes tuned for those models may not transfer directly.
• Watchlist for the next month: V4-Pro official release ("soon"), Responses API + Codex for Pro (early August), DeepSeek Harness release, and the peak/off-peak pricing effective date.

Frequently asked questions

Q: Is DeepSeek-V4-Flash-0731 the same as the preview weights? No. Same architecture and size, but re-post-trained for agentic performance, with the DSpark speculative-decoding module attached. It is a new repository that supersedes the preview.

Q: Are the official open weights available? Yes — on Hugging Face since release day, MIT license, 166.9 GB.

Q: Why does a 13B-active model beat the 49B-active V4-Pro preview on agentic benchmarks? Because the Pro preview has not been re-post-trained for this release, and the official Flash is a new post-training run aimed at exactly the agentic task class. Agentic competence is largely policy, and the evaluation is harness-conditional — treat the margin as real but workload-dependent.

Q: When does the V4-Pro official release ship? DeepSeek says "soon." The Pro API and APP/WEB models are unchanged for now; Responses API and Codex support for Pro land in early August 2026.

Q: Do I need to change my API code? Only if you still call deepseek-chat or deepseek-reasoner — those were retired on 2026-07-24. model="deepseek-v4-flash" already serves the official build.

Q: What does it cost? $0.14 per 1M input tokens (cache miss), $0.0028 (cache hit — 98% off), $0.28 per 1M output tokens. A 2× peak-hours surcharge (09:00–12:00, 14:00–18:00 Beijing time) is announced but not yet effective.

Q: Can I use it with Codex? Yes, Flash is natively adapted: Responses API format plus the official setup script. Pro support arrives in early August.

Q: Can I fine-tune it? Yes — MIT license, commercial use included. Note the Muon-based training trajectory when porting recipes from AdamW-era models.

Key takeaways

The DeepSeek V4 Flash official release is the most consequential open-model update of the summer for anyone building agents: a 13B-active model that outruns the family's flagship preview on every published agentic benchmark, ships with native Codex support, and costs $0.14/$0.28 per million tokens with a 98% cache-hit discount — with the same-day MIT-licensed weights to verify every claim.

• Migrate agent-heavy workloads to deepseek-v4-flash now; nothing in the family beats it at that task class today.
• Keep V4-Pro preview for knowledge-critical work and re-evaluate when its official release lands.
• Model the 98% cache-hit discount — it dominates agentic cost.
• Verify on your own task set: harness choice moves these numbers by double digits.

That is the release in one line: a smaller model, a sharper agentic policy, and open weights that let anyone check the claim.

Start with the smallest real test: call model="deepseek-v4-flash" with your most representative agent prompt, compare it against your current model on three real tasks, and check your token spend with caching enabled — then read the practical DeepSeek V4 deployment guides before you scale out.

References

• DeepSeek API updates — 2026-07-31 changelog
• DeepSeek-V4-Flash-0731 model card
• DeepSeek API pricing
• Codex integration guide
• Responses API guide
• Artificial Analysis evaluation (X)
• DeepSeek V4 collection on Hugging Face
• DeepSeek V4 Flash official release guide (wan27.org)