DeepSeek V4 Flash: 28 Cents a Million

Two Things Happened, and Only One of Them Is About China Being Cheap

On July 30th, OpenAI quietly cut GPT-5.6 Luna’s price by 80%, from $1/$6 per million tokens down to $0.20/$1.20. The next day, DeepSeek shipped V4 Flash 0731 at $0.14 input and $0.28 output. Same headline everyone ran with, and it’s real, but it’s not the interesting part.

The interesting part is that DeepSeek took the exact same model, same 284B total parameters, same 13B active, same architecture down to the layer, and redid only the post-training stage. No new pretraining run. No parameter count change. And on agentic coding benchmarks it went from scoring like a toy to scoring like something you’d trust with a terminal. DeepSWE jumped from 7.3 to 54.4. Terminal Bench 2.1 went from 61.8 to 82.7. That’s not a scaling story, it’s a post-training story, and it says the fastest lever left in this industry might not be more GPUs. It might be better RL on the weights you already trained.

None of that makes V4 Flash the frontier. It’s near-frontier, and near-frontier is a real category with a real gap attached. DeepSeek’s own numbers admit as much once you read the right column, and the independent scoreboard is blunter still.

Same Weights, New Brain: What Post-Training Actually Bought

DeepSeek-V4-Flash-0731 shipped July 31st as a public beta. It’s a 284B parameter MoE with 13B active per token, 1M token context, MIT-licensed, weights up on Hugging Face as deepseek-ai/DeepSeek-V4-Flash-0731, with GGUFs from Unsloth if you want to run it yourself. Text only, no vision. It natively speaks the Responses API format, which is the bit that makes it drop into Codex-style tooling without a translation layer.

The architecture is the same pair of attention tricks the Flash line has used since the preview, worth naming correctly since the report is specific about it. Compressed Sparse Attention (CSA) compresses KV entries 4x along the sequence dimension using softmax-gated pooling with a learned positional bias, and a lightning indexer (FP4, ReLU-scored, multi-head dot product) decides which compressed blocks are worth attending to. Heavily Compressed Attention (HCA), not “highly”, goes further and consolidates whole sets of tokens into single compressed entries. Interleave CSA and HCA layers, reserve dense uncompressed attention for the most recent tokens, and you get a KV cache that’s roughly 2% the size of a standard transformer running grouped-query attention with 8 heads in bf16. At 1M context, Flash burns about 10% of the FLOPs and 7% of the KV cache that DeepSeek V3.2 needs for the same window. We’ve covered both mechanisms in more depth already: see the MoE primer and the KV cache quantization piece. Flash also leans on multi-token prediction heads and speculative decoding (see our writeup on why that trick works) plus custom MoE kernels for CUDA and Ascend.

None of that changed between the preview and 0731. What changed was training the same weights on better agentic trajectories. Look at the delta:

• DeepSWE: 7.3 to 54.4
• Cybergym: 38.7 to 76.7
• AutomationBench (Public): 10.8 to 25.1
• Terminal Bench 2.1: 61.8 to 82.7
• NL2Repo: 39.4 to 54.2
• Toolathlon-Verified: 49.7 to 70.3
• Agents’ Last Exam: 15.8 to 25.2
• DSBench-FullStack: 37.0 to 68.7
• DSBench-Hard: 25.8 to 59.6

That DeepSWE move, roughly seven and a half times the original score, is the one that should make you sit up. This is the same weights being asked to do agentic tool-use tasks, and the only thing that moved is how it was trained to use its own capability. If your mental model of “how do models get better” is still “wait for the next pretraining run,” this is the counter-example. Post-training is doing more of the lifting than scaling right now, at least for this class of model.

The Table DeepSeek Wants You to See, and the Asterisk Glued to It

DeepSeek published a head-to-head against GLM-5.2 (753B parameters) and Anthropic’s Opus-4.8. Read it in two directions.

Flash-0731 beats GLM-5.2 on every comparable row, and GLM-5.2 is 2.6x its size, a good result for a model running 13B active parameters. But look at the Opus column: Flash loses all nine rows. The gaps run 0.5 on Agents’ Last Exam (a tie in practice), 2.1 on AutomationBench, 2.3 on Terminal Bench, 2.9 on DSBench-FullStack, 3.6 on DeepSWE, 5.9 on Toolathlon, 6.4 on Cybergym, and then two cliffs: 15.5 behind on NL2Repo and 12.1 behind on DSBench-Hard. That’s a spectrum, not two tidy buckets. On seven of the nine you’d shrug and take the cheaper model. On repo-scale code generation and DeepSeek’s own hard set, Opus is still comfortably ahead, and those happen to be the two rows where you’d most want the expensive model to earn its keep.

Now the asterisk, and weight it heavily: DeepSeek ran this entire table themselves, using “DeepSeek Harness minimal mode,” a harness that hadn’t even been publicly released at test time, at max effort, top-p 0.95, temperature 1.0. Two of the nine benchmarks, DSBench-FullStack and DSBench-Hard, are DeepSeek’s own private internal test sets that nobody outside the company can rerun. A vendor grading its own model on its own harness against its own private test set isn’t a scandal, everyone does some version of this, but it means this table tells you what DeepSeek wants you to conclude, not what an independent party measured.

The Independent Scoreboard: 50, and Five Months Late

Artificial Analysis runs its Intelligence Index v4.1 across nine evals (GDPval-AA v2, tau3-Banking, Terminal-Bench v2.1, SciCode, Humanity’s Last Exam, GPQA Diamond, CritPt, AA-Omniscience, AA-LCR) on every major model, using the same harness for all of them. That’s the number to trust more than any vendor’s own table.

• Claude Opus 5 (max): 61
• Claude Fable 5 (with fallback): 60
• GPT-5.6 Sol (max): 59
• Kimi K3 (max): 57
• Claude Opus 4.8 (max): 56
• GPT-5.6 Terra (max): 55
• Grok 4.5 (high): 54
• Claude Sonnet 5 (max): 53
• GPT-5.6 Luna (max): 51
• GLM-5.2 (max): 51
• Gemini 3.6 Flash: 50
• DeepSeek V4 Flash 0731: 50
• Qwen3.7 Max: 46
• DeepSeek V4 Pro (max): 44
• DeepSeek V4 Flash (older, max): 40

Sit with that ordering. The re-post-trained Flash scores above DeepSeek’s own flagship, V4 Pro, by six points, and ten points above the previous Flash release. A “cheap tier” model just leapfrogged the company’s “expensive tier” model purely on post-training, confirming the benchmark deltas above.

The framing that matters for planning: OpenAI was already sitting at 51 on this same index back on March 5th with GPT-5.4 (xhigh). DeepSeek reached 50 on July 31st. So the cheap open-weights option landed at a level the US frontier had already passed about five months earlier, and five months is the generous reading, since OpenAI necessarily crossed 50 at some point before it posted a 51. That’s a useful way to think about every open-weights release going forward: check the index number, then check when the last closed model passed that same number, and you have your actual lag rather than a vibes-based one.

Cost Per Task Is Not Cost Per Token, and Your Cache Strategy Is the Real Lever

Artificial Analysis also tracks a weighted cost-per-task metric across the whole Intelligence Index suite, in dollars, not per million tokens:

• DeepSeek V4 Pro (max): $0.04
• gpt-oss-120b (high): $0.06
• MiniMax-M3: $0.12
• Nemotron 3 Ultra: $0.23
• Muse Spark 1.1 (xhigh): $0.26
• Grok 4.5 (high): $0.31
• GLM-5.2 (max): $0.47
• Gemini 3.5 Flash: $0.59
• Kimi K3: $0.95
• GPT-5.6 Sol (max): $1.04
• Claude Fable 5 (with fallback): $2.75

Notice that’s V4 Pro at $0.04, not Flash, and it’s dollars to clear a whole benchmark task, not dollars per million tokens. Mixing those two units up is how you end up telling someone DeepSeek costs “three cents a million tokens” when the real per-token price is $0.14/$0.28. Keep them separate. Fable 5 costs 69 times what V4 Pro costs per task while scoring 16 index points higher: that’s the premium you’re paying for the top of the curve, and whether it’s worth it depends entirely on how much a wrong answer costs you. Kimi K3 sits at index 57 for $0.95 a task against Pro’s 44 for $0.04, a completely different trade than the Flash numbers above imply.

The actual token pricing for Flash-0731 is $0.14 per million input, $0.28 per million output, with cached input at $0.003 per million and a cache TTL noticeably longer than Anthropic’s or OpenAI’s short windows. That caching discount is close to free money for agent loops, but only if your loop respects the one rule that makes prefix caching work: append-only. The cache keys off a shared prefix. The moment you go back and edit, reorder, or summarize earlier turns, you invalidate every cached token after that point and pay full price for the whole rebuilt context. This is the single most actionable thing in this article, so build your agent loop like this:

# Append-only history keeps the cached prefix intact.
# Never mutate history[i] for i < len(history) - 1.
# Shown on the Chat Completions surface; the same rule applies
# verbatim if you drive it through the Responses API instead.

history = [system_prompt]

def step(user_input):
    history.append({"role": "user", "content": user_input})
    response = client.chat.completions.create(
        model="deepseek-v4-flash-0731",
        messages=history,
    )
    # Append the new turn, never rewrite an old one.
    history.append({"role": "assistant", "content": response.choices[0].message.content})
    return response

# BAD: history[2]["content"] = summarize(history[2]["content"])
# This busts every cached token after index 2, forever, for this session.

# GOOD: if context is getting long, START A NEW SESSION with a
# fresh, compact system prompt instead of rewriting the old one.

If your framework “helpfully” compresses or reorders history to save tokens, check whether it’s quietly costing you the cache discount that made the model cheap in the first place.

Why It’s Actually Cheap: Real Architecture, Plus a Thumb on the Scale

Two things are true at once here, and treating either one as the whole story is dishonest.

Architecturally, this thing runs 13B active parameters out of 284B total, quantizes experts down to INT4/FP4, and holds a KV cache at roughly 2% of a standard transformer’s footprint. That’s less silicon per query, period, no matter who’s running it or what electricity costs them.

Structurally, there’s more going on. DeepSeek runs on Huawei Ascend silicon, sidestepping Nvidia’s margin entirely. Chinese local governments offer electricity subsidies to datacenters running domestic AI chips (no reliable public figure exists for the size of that subsidy, so don’t trust anyone who quotes you a specific percentage). Parent company High-Flyer Quant holds a “High and New Technology Enterprise” designation, carrying its own tax breaks and research subsidies. High-Flyer is a quantitative hedge fund, not a VC-backed lab burning runway toward an IPO, so the pressure to hit near-term profit on the API business is lower than for a company that raised at a valuation assuming it eventually profits from inference. There’s a flywheel too: a cheap, widely used API generates real agentic interaction logs, which feed straight back into the next round of post-training. The DeepSWE jump above didn’t come from nowhere.

Sort it out this way: the architecture would make this cheap anywhere, on any hardware, under any tax regime. The specific number, $0.28 per million output tokens, is architecture plus subsidy plus a price war that kicked off the day before this model shipped. Build your cost model around the architecture being durable. Don’t assume 28 cents is a permanent floor: some share of that number is subsidy and wartime pricing rather than physics, and nobody outside DeepSeek can tell you how big that share is.

Running It Yourself

At INT4/Q4 quantization you’re looking at roughly 160GB for the weights, a real self-hosting proposition if you’ve got the iron. The throughput figures below come from early community testing on a model that’s only days old, so treat them as ballpark rather than gospel:

• Dual RTX 6000 Pro or DGX Spark class hardware (128-192GB VRAM): 170-225 tok/s decode, 6k-8k tok/s prefill
• A 192GB DDR5 workstation or dual Xeon setup with CPU offload via llama.cpp: 18-20 tok/s decode, slow but usable for background agent work
• AMD’s Strix Halo (128GB or 192GB unified memory) is shaping up as the budget option, since unified memory skips the need for a stack of discrete GPUs

llama-server \
  --model DeepSeek-V4-Flash-0731-Q4_K_M.gguf \
  --ctx-size 131072 \
  --n-gpu-layers 999 \
  --flash-attn on \
  --cache-type-k q4_0 \
  --cache-type-v q4_0 \
  --host 0.0.0.0 --port 8080

Forget the tok/s numbers for a second. The figure worth noticing is the KV cache: early measurements put a full 1M-token window at roughly 6GB, so bump --ctx-size up to 1048576 if you’ve got headroom after the weights. That’s CSA and HCA compression paying off in a way that matters for anyone running this on a homelab box instead of a datacenter rack. A million tokens of context used to be a fantasy for local hardware, and now it’s a rounding error on your VRAM budget.

Where It Falls Over

There’s no free lunch here, and you should know the failure modes before you wire it into anything you depend on. These come from early community reports rather than DeepSeek’s own docs, so calibrate accordingly.

Under heavy context pressure, or when system prompts start contradicting each other, it will sometimes switch to Chinese mid-response without being asked to. It’s verbose even when you explicitly tell it to be concise, which gets expensive fast given you’re paying for output tokens. And on codebases past roughly 150k lines, it takes shortcuts and starts refactoring code nobody asked it to touch, unless you constrain the task hard with explicit scope boundaries. None of these are dealbreakers, but all three are the kind of thing that looks fine in a demo and bites you in a real repo at 2 AM.

What to Actually Do With This

Use it for the volume work: agentic coding loops, terminal automation, high-throughput tool-calling tasks where the per-call cost matters more than squeezing out the last few points on the hardest problems. Don’t reach for it on the tasks where DSBench-Hard showed the biggest gap, the genuinely difficult, ambiguous problems where you need the model that’s still ahead by double digits. And build your agent loop append-only from day one, because the $0.003 cached rate is doing more for your bill than the headline price is.

The bigger story here isn’t the price tag. It’s that DeepSeek took a model that already existed, changed nothing but how it was trained after the fact, and moved it from irrelevant to independently-verified-at-50 without touching a single weight’s architecture. If that’s repeatable, and there’s no reason yet to think it isn’t, the next few point jumps in this index might come from labs mining better training data out of their own model’s usage logs, not from anyone building a bigger cluster.

Related Reading

• Mixture of Experts (MoE) for Self-Hosters, Demystified
• Give Your AI Agent a Cheap Intern
• KV Cache Quantization: Free LLM Context, Almost
• Speculative Decoding: Faster LLMs With a Tiny Sidekick
• API vs Self-Hosted LLMs: The Real Cost