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

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 Flash that is $0.0028 per million against $0.14 on a miss, a 50x difference that rewards a stable prefix.

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

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 for where that distinction bites.

Three benchmarks say frontier, one says why it fails

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.

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 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:

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. Artificial Analysis logged 230M output tokens from Flash across its Intelligence Index run against a 98M median for the field, and rates 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 at $3 / $15, or $2 / $10 through 2026-08-31 - roughly 36x Flash’s output rate at the introductory price and 54x at the standard one, 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.

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.0028 against $0.14 is a 50x spread on input, larger than the headline price advantage. Prompt caching mechanics covers how to keep that prefix intact.

This is the same argument as choosing the right Claude tier, 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.

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:

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 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 is the harness to score it in.