# DeepSeek V4 Flash is a worker tier, not an Opus killer

> DeepSeek V4 Flash scores 79.0 on SWE-bench Verified vs Opus 5's reported 96.0. Route it as a cheap executor behind a frontier planner, not as the planner.

URL: https://bartlomiejkrupa.dev/articles/deepseek-v4-flash/
Published: 2026-07-25
Updated: 2026-10-07
Tags: deepseek, open-weights, model-selection, agents, pricing, local-inference
Summary: DeepSeek V4 Flash scores 79.0 on SWE-bench Verified vs Opus 5's reported 96.0. Route it as a cheap executor behind a frontier planner, not as the planner.

> **Update (2026-10-07):** DeepSeek retired V4 Flash on 2026-09-10 when it released **V4.1 Flash**. The `deepseek-v4-flash` ID still works but is served by V4.1 Flash at the new rate - $0.15 / $0.60 per million input/output tokens off-peak, $0.30 / $1.20 at peak. Prices and benchmark scores below are V4 Flash's as measured in July 2026; the routing argument is unchanged, and the price gap to Opus is now roughly 21-42x on output rather than 89x.

DeepSeek V4 Flash scores 91.6 on LiveCodeBench and 88.1 on GPQA Diamond, which reads like a frontier model. Handed a real agentic build - a 20-endpoint workflow backend with lease management, retries, and event streaming - it scored 60/100 while Claude Opus 4.7 scored 91. Both numbers are true, and the gap between them is the entire decision. Flash implements a specification well and reasons about architecture badly. Put it downstream of a stronger planner and you get roughly 1/100th the cost per unit of quality. Ask it to produce the plan and it will confidently invent one.

Opus 4.7 is no longer the frontier. GPT-5.6 Sol arrived in late June and Claude Opus 5 on 2026-07-24, and Opus 5 bills at the same $5 / $25 that Opus 4.7 did. The cheap-executor case survives that intact, because the argument was never that Flash is close to the top. It is that the top and the bottom of the stack are doing different jobs.

## Definitions

**Mixture-of-Experts (MoE)** - an architecture that holds many specialist sub-networks but routes each token through only a few, so serving cost tracks the activated slice rather than the full parameter count.

**Activated parameters** - the subset actually computed per token. Flash is 284B total but 13B activated, which is why a 284B model serves at small-model speed and price.

**Cache hit price** - the discounted input rate charged when the provider recognizes a prompt prefix it has already processed. On V4 Flash at launch that was $0.0028 per million against $0.14 on a miss, a 50x difference that rewards a stable prefix; V4.1 Flash keeps the same 50x spread ($0.003 against $0.15 off-peak).

**Planner / executor split** - routing the architectural decision to one model and the implementation to a cheaper one, rather than paying a single tier for both.

## The specs

| Property | DeepSeek V4 Flash |
| --- | --- |
| Total / activated parameters | 284B / 13B |
| Architecture | MoE with hybrid attention |
| Context window | 1M tokens |
| Training tokens | >32T |
| License | MIT |
| Input / output per 1M | $0.14 / $0.28 at launch (now V4.1 Flash: $0.15-0.30 / $0.60-1.20) |
| Cached input per 1M | $0.0028 at launch (V4.1 Flash: $0.003-0.006) |
| Measured throughput (July 2026) | 122.2 tok/s, 1.13s to first token |

The MIT license matters more than it looks. Plenty of models marketed as open ship restrictive terms. This one does not, which is what makes the local-deployment setup covered below a production option rather than a weekend experiment. See [open-weights is not open-source](/articles/open-weights-vs-closed-api) for where that distinction bites.

## Three benchmarks say frontier, one says why it fails

| Benchmark | Flash score |
| --- | --- |
| LiveCodeBench | 91.6 |
| GPQA Diamond | 88.1 |
| MMLU-Pro | 86.2 |
| SimpleQA-Verified | 34.1 |

Three of those numbers are excellent and one is not, and the odd one out is the one that matters. SimpleQA-Verified measures whether a model knows facts and admits when it does not. At 34.1, Flash often does neither. That single weak score predicts its real-world failures better than the three strong ones do.

The gap is easy to miss, because the aggregate score looks fine. Artificial Analysis scores Flash at 40 on its Intelligence Index - top-dozen among open-weights models of its size, and priced well below any of them. A model can rank well overall and still be the wrong pick for a specific job. The next two sections are what that looks like: first against the current frontier, then on one real task.

## Against the July 2026 frontier

Each score column below is a single-methodology snapshot taken on 2026-07-25, so rows compare cleanly within a column even though the two benchmarks measure different things. Both DeepSeek entries are the max-reasoning-effort configuration. The Intelligence Index is Artificial Analysis's, which has since re-based it, so today's numbers differ. DeepSeek's SWE-bench Verified scores come from its model card; the Claude scores are as reported on BenchLM's leaderboard, since Anthropic's launch posts don't publish them.

| Model | Intelligence Index | SWE-bench Verified | Input / output per 1M |
| --- | --- | --- | --- |
| Claude Opus 5 | 60.7 | 96.0 | $5 / $25 |
| Claude Fable 5 | 59.9 | 95.0 | $10 / $50 |
| GPT-5.6 Sol | 58.9 | not on the board | $4 / $20 |
| Claude Opus 4.8 | 55.7 | 88.6 | $5 / $25 |
| Claude Opus 4.7 | - | 87.6 | $5 / $25 |
| DeepSeek V4 Pro | 44.3 | 80.6 | $0.435 / $0.87 |
| DeepSeek V4 Flash | 40.3 | 79.0 | $0.14 / $0.28 (V4.1 Flash now $0.15-0.30 / $0.60-1.20) |

Read the two score columns against each other. On SWE-bench Verified - self-contained GitHub issues with a test suite that decides the answer - Flash is 17 points behind Opus 5, close enough to argue about. On the aggregate Intelligence Index it is 20 points behind, 36th of the 167 models rated, and behind its own Pro sibling. On Kilo's coordination-heavy build in the next section, the gap against a *previous-generation* Opus is 31 points.

That ordering is the finding. The less a task looks like a benchmark item, the wider Flash's gap gets - which is an argument for the executor slot rather than against it, because an executor receives work that the planner has already made benchmark-shaped.

The price column did not move with the capability. Opus 4.7, Opus 4.8 and Opus 5 all bill $5 / $25, so a full generation of gains arrived at a flat rate, and the cost ratios in this article hold against the current frontier rather than a stale one. A Flash output token still costs 1/89th of an Opus 5 token, 1/107th of a GPT-5.6 Sol token, and 1/179th of a [Fable 5](/articles/claude-fable-5) token. Pay frontier rates on the turn where a 20-point capability gap decides the outcome, and Flash rates on the turns where it mostly does not.

## One real task, four models

Kilo, an agentic-coding tooling vendor, ran all four models against the same workflow-orchestration backend, chosen to stress coordination rather than algorithmic puzzle-solving:

| Model | Score /100 |
| --- | --- |
| Claude Opus 4.7 | 91 |
| DeepSeek V4 Pro | 77 |
| Kimi K2.6 | 68 |
| DeepSeek V4 Flash | 60 |

Flash finished last on quality. It also finished the entire run for **$0.02**. Dividing cost by score, Kilo puts Flash at roughly 30x cheaper per point than Kimi K2.6 and 100x cheaper than Opus 4.7.

Tool-calling was not the weak link. Across the run Flash read files before editing them, handled dependencies sensibly, and produced no malformed arguments, hallucinated file paths, or runaway loops. The mechanical reliability that makes a model usable in a harness is there. What is missing is judgment about timing, recovery, and coordination.

Treat this as one strong data point rather than a verdict: it is a single task, scored by a vendor running its own harness.

## Where it breaks

The benchmark and the practitioners describe the same failure from opposite directions.

Users running Flash in coding harnesses report the same split that the SimpleQA number predicts. It is, in the words of one, "great at executing clearly defined, unambiguous plans generated from other (smarter) models. A super cheap worker." The same report continues: it "LOVES to make stuff up if you're having it do reasoning."

The specific failures match that shape. One user watched it ignore the ORM the database layer was built on, write raw queries instead, and style new inputs inconsistently, despite explicit design instructions sitting in context. Another was blunter: it "talks to itself too much" and "does not check what it wrote down."

That last complaint is measurable. In its July 2026 run, Artificial Analysis logged 230M output tokens from Flash across its Intelligence Index against a 98M median for the field, and rated the model very verbose. Verbosity is not free when you pay per output token, and it compounds inside an agent loop.

All of it is the SimpleQA-Verified score showing up as behavior. A model with weak factual grounding does not fail loudly. It fills gaps with plausible inventions. When the spec is complete there are no gaps to fill, and the weakness never surfaces. When the spec is vague, the model improvises architecture.

## Calibrate against Sonnet, not Opus

The "Opus killer" framing did not survive the thread that produced it. Practitioners settled quickly on a lower and more useful anchor: "I like v4 but it's not opus level. That's a bit far. It's more like a cheaper and faster sonnet." Another described it as reminiscent of Sonnet "but without sonnet's annoying traits (finger-wagging, opinion-hedging and a huge reluctance to live-searching)." Some report it losing to Sonnet outright.

Set the expectation at Sonnet-class. Sonnet-class today means Sonnet 5.5 or [Sonnet 5](/articles/claude-sonnet-5) at $2 / $10 - roughly 17x Flash's current off-peak output rate ($0.60) and 8x its peak rate ($1.20), for a tier practitioners rate as comparable or better. At $0.14 / $0.28, Flash is still a strong trade.

One more counter-intuitive report from the same discussions: V4 Pro, the stronger reasoner, is described by several users as the *worse* instruction-follower. If that holds in your workload, the split below wins twice over: the better reasoner plans, the better instruction-follower builds.

## The routing rule

Give the architectural decision to a strong model, hand the resulting plan to Flash, and review the diff. That is [worker-tier routing](/notes/worker-tier-routing).

| Stage | Model | Why |
| --- | --- | --- |
| Plan / architecture | Frontier tier - Opus 5, Fable 5, GPT-5.6 Sol - or V4 Pro | Coordination, timing, recovery logic |
| Implementation | V4 Flash (now V4.1 Flash) | Follows a complete spec at $0.60-1.20/M output |
| Review | Strong model or human | Catches invented conventions |

The planner slot is contested and worth re-testing periodically. The practitioner who started the "Opus killer" thread moved from Flash-only, to V4 Pro for planning, to GLM 5.2 for planning over about two months. The last month brought two frontier releases that raised the top of that slot again without raising its price. The executor slot never changed. That is the durable part of this pattern: which model plans is a live question, but a cheap model implementing a strong model's plan keeps holding up.

Two conditions make this work. The plan has to be genuinely complete, because every ambiguity you leave becomes an invention. And the prompt prefix has to stay stable, because the cache-hit rate is where the economics actually live: $0.003 against $0.15 is a 50x spread on input, larger than the headline price advantage. [Prompt caching mechanics](/articles/llm-cost-optimization) covers how to keep that prefix intact.

This is the same argument as [choosing the right Claude tier](/articles/claude-model-tier-comparison), applied across vendors instead of within one. The reasoning does not change: match the tier to the job, not to the benchmark table.

## Running it locally

The 13B activated slice is what makes local serving practical at all. The memory floor is unforgiving, though.

| Setup | Result |
| --- | --- |
| Reported self-hosted footprint | ~170GB |
| Practical minimum | 128GB unified memory |
| Recommended | 192GB |
| 64GB machines | No practitioner reports of a working setup |
| Metal-native engine, 96-128GB Mac | ~47.85-57.07 tok/s |
| MLX, M4 Max 192GB | 25-35 tok/s |
| Cloud API, for reference | 122.2 tok/s |

A 128GB machine with Q8_0 KV-cache quantization has been reported reaching 400k context. Local throughput lands well below the hosted API either way, so the reason to run it yourself is a data path that never leaves your perimeter, not speed.

## Migration: the old aliases are gone

The `deepseek-chat` and `deepseek-reasoner` model names were deprecated on **2026-07-24 15:59 UTC**. Integrations still pointing at them need renaming:

DeepSeek serves an OpenAI-compatible endpoint, so the official `openai` SDK works unchanged apart from `base_url`:

```python
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEEPSEEK_API_KEY"],
    base_url="https://api.deepseek.com",
)

response = client.chat.completions.create(
    model="deepseek-v4-flash",  # was: deepseek-chat / deepseek-reasoner
    messages=[{"role": "user", "content": "Implement the plan in PLAN.md."}],
    extra_body={"reasoning_effort": "high"},
)
```

Compatibility covers the Chat Completions schema, not the wider OpenAI platform, so nothing built on the Assistants or Responses APIs ports over. DeepSeek-specific controls such as `reasoning_effort` are not in the OpenAI schema either, which is why they travel in `extra_body` rather than as top-level arguments.

Check any config, environment variable, or router table still carrying the old names.

## Next

Run the split on one real task before committing to it. Take a plan a strong model already produced, hand it to Flash for implementation, and diff the result against what your usual model produces on the same spec. If the gap is invented conventions rather than broken logic, tighten the plan and run it again.

If you are weighing the self-hosted path more broadly, [open-weights is not open-source](/articles/open-weights-vs-closed-api) covers the data-path and ops-burden trade-offs that decide it. To measure the split instead of eyeballing it, [five metrics for an agent eval pipeline](/articles/five-metrics-for-an-agent-eval-pipeline) is the harness to score it in.

Sources:
- DeepSeek-V4-Flash model card: https://huggingface.co/deepseek-ai/DeepSeek-V4-Flash
- DeepSeek-V4.1-Flash release: https://api-docs.deepseek.com/news/news260910
- Models & Pricing: https://api-docs.deepseek.com/quick_start/pricing
- We Tested DeepSeek V4 Pro and Flash Against Claude Opus 4.7 and Kimi K2.6: https://blog.kilo.ai/p/we-tested-deepseek-v4-pro-and-flash
- SWE-bench Verified leaderboard: https://benchlm.ai/benchmarks/swe-bench-verified
- Pricing: https://platform.claude.com/docs/en/about-claude/pricing