Split View: DeepSeek V4 Flash가 실제로 바꾸는 것 — 리더보드가 아니라 능력당 단가의 문제

What DeepSeek V4 Flash Actually Changes — A Cost-per-Capability Question, Not a Leaderboard One

• Introduction — The Day the Preview Became a Public Beta, While the Model Itself Stayed Put
• The Specs — A Model Where Only 13B of 284B Lights Up
• Who Measured the Published Scores, and on What Harness
• The Real Line Item on the Price Sheet Is Not the Headline, It Is the Cache-Hit Price
• Recomputing in Cost per Capability
• Flash Is a Tier Name, Not a Latency Story
• Routing Rules — And What We Still Do Not Know
• Closing — Leaderboards Flip in a Month, but the Shape of a Price Sheet Lasts

Introduction — The Day the Preview Became a Public Beta, While the Model Itself Stayed Put

On July 31, 2026, DeepSeek moved its V4-Flash API into public beta. The official changelog puts it precisely: this release "keeps the model architecture and size of DeepSeek-V4-Flash-Preview and only redoes post-training." Parameters, context, and price are all unchanged. What changed is one layer of post-training, plus native support for the Responses API and the Codex framework.

The published scores, however, moved quite a lot. 82.7 on Terminal Bench 2.1, and 70.3 on Toolathlon verified. People in the Hacker News thread who lined these up against the preview-era figures pointed out that they went from 56.9 to 82.7 and from 51.8 to 70.3 respectively. The claim is that at the same weight count, post-training alone moved agentic benchmarks by more than 20 points.

This post is not going to argue about where those scores rank. Leaderboards flip within a month, and for most teams the question actually on the table is not "what place did it come in" but "which slice of my traffic can I move here, how much smaller does the invoice get, and how much worse does quality get." So here we compute in cost per capability, and we state every single time which numbers are vendor self-measured.

The Specs — A Model Where Only 13B of 284B Lights Up

Start with the physical facts. DeepSeek V4 Flash is a sparse MoE with 284B total parameters, of which only 13B activate per token. Context is 1,048,576 tokens and maximum output is 384K tokens. It is text-only, with no vision and no audio. These specs cross-check between OpenRouter's model page and DeepSeek's official pricing doc.

V4 Pro, the higher model in the same family, is reported to have 1.6T total parameters with roughly 49B active per token. That pair of numbers is the key to understanding how the two models relate — Flash is less a distilled or trimmed-down Pro than a separate architecture that cut active parameters to about a quarter in order to drive serving cost down structurally. The price follows exactly that ratio. On output, Flash is $0.28 per 1M tokens and Pro is $0.87, a gap of about 3.1x.

This is where a misunderstanding often creeps in. The 13B active figure describes compute, not memory footprint. If you are considering self-hosting, all 284B parameters still have to sit somewhere, and even squeezed to 4-bit that is in the 140GB range. Small active parameters do not mean "it runs on a small GPU"; they mean "it produces far more tokens on the same GPU." Blur that distinction and your self-hosting estimate comes apart entirely. The arithmetic on the local side is worked through as formulas in How Much VRAM to Run an LLM Locally.

Who Measured the Published Scores, and on What Harness

Here are the 0731 scores the changelog published. Terminal Bench 2.1 82.7, NL2Repo 54.2, Cybergym 76.7, DeepSWE 54.4, Toolathlon verified 70.3, Agent Last Exam 25.2, Automation Bench (Public) 25.1, DSBench-FullStack 68.7, DSBench-Hard 59.6.

These numbers come with conditions attached, and those conditions matter. The changelog spells out the measurement setup as "DeepSeek Harness minimal mode, max effort level, top_p 0.95, temperature 1.0." In other words, they are vendor self-measurements taken on the vendor's own harness at maximum reasoning effort. That is exactly the point people raised in the HN thread. Agentic benchmarks are extremely sensitive to scaffolding, and the same model moves by double digits when the harness changes. The moment you line these up against numbers another vendor published on its own harness and start assigning ranks, that table stops meaning anything.

What about independent measurement? Artificial Analysis scores V4 Flash 0731 at an Intelligence Index of 50 at maximum reasoning effort. On the same index, GPT-5.6 Sol is 59, Terra 55, and Luna 51. So on a composite intelligence indicator alone, Flash sits in roughly the same place as OpenAI's cheapest tier. On the coding side, third-party aggregations put Flash at 79.0% and Pro at 80.6% on SWE-bench Verified — but that is secondary material citing llm-stats-style aggregations, and I could not verify the original measurement conditions. Better not to take it at face value; measure it on your own tasks.

One independent measurement is especially practical. Artificial Analysis records that this model burned 210M tokens to complete the index, against a median of 62M across all models. It spends a great many thinking tokens before it produces an answer. That registers as a strength in benchmark scores and as output tokens on the invoice. We come back to it below.

The Real Line Item on the Price Sheet Is Not the Headline, It Is the Cache-Hit Price

Here is the per-1M-token price for each model according to the official pricing docs. The OpenAI side reflects the July 30 cut, and the cache-hit price is the published 90% discount applied to the input price.

The column worth staring at in this table is not the headline number, it is the rightmost one. DeepSeek charges 2x input for output, while the OpenAI family charges 6x. The shape of the price sheet itself is different.

And the leftmost column is more dramatic still. Flash's cache-hit input is $0.0028 per 1M tokens, one fiftieth of the cache-miss price. Compared with GPT-5.6 Luna's cache-hit price it is roughly 7x cheaper. One user in the HN thread reported spending 323M tokens across 3,467 API requests over 30 days and paying $4.55 — a number like that does not appear unless the workload has a very high cache-hit rate. A coding agent that repeatedly sends a long system prompt and a fixed codebase context is exactly that shape.

Two traps to watch. First, a cache discount rate is not an invoice reduction rate — if output already eats a large share of the cost, a 90% discount on the input side will not take 90% off the total. That calculation is worked through in detail in How to Actually Cut Your LLM API Bill. Second, DeepSeek's pricing doc pre-announces a peak and off-peak differential plan. The policy doubles the rate between 9am and noon and between 2pm and 6pm Beijing time, and the doc states that the effective date has not yet been officially announced. Those windows overlap the Korean business day, so you must build them into any estimate.

Recomputing in Cost per Capability

Let us run the actual arithmetic by putting the same workload on both models. After the cut, GPT-5.6 Luna and DeepSeek V4 Flash sit at essentially the same place on the Intelligence Index — 51 against 50 — which makes them a good pair for holding capability fixed and comparing only price.

Workload A — input-heavy (long-document summarization, RAG answers)
  50,000 input tokens / 500 output tokens per request

  Luna     : 50,000 x 0.20 / 1e6 = 0.01000
           +    500 x 1.20 / 1e6 = 0.00060  ->  0.01060 dollars
  V4 Flash : 50,000 x 0.14 / 1e6 = 0.00700
           +    500 x 0.28 / 1e6 = 0.00014  ->  0.00714 dollars
  Flash is about 1.5x cheaper

Workload B — output-heavy (reasoning, coding agents)
  2,000 input tokens / 10,000 output tokens per request (thinking tokens included)

  Luna     :  2,000 x 0.20 / 1e6 = 0.00040
           + 10,000 x 1.20 / 1e6 = 0.01200  ->  0.01240 dollars
  V4 Flash :  2,000 x 0.14 / 1e6 = 0.00028
           + 10,000 x 0.28 / 1e6 = 0.00280  ->  0.00308 dollars
  Flash is about 4.0x cheaper

Same two models, and the gap widens from 1.5x to 4x. Looking at headline input price alone gives you 0.14 against 0.20, a 30% difference, but the actual invoice difference is decided by the workload's input-output mix. A price sheet with a 2x output-to-input multiple gets more favorable as output grows longer, and one with a 6x multiple does the opposite.

Here the earlier observation comes back around. Flash is a model that spends a lot of thinking tokens, which means it naturally drifts toward workload B. When a price sheet with cheap output meets a model that produces a lot of output, the two offset each other, so the conclusion that cheap output means you can let it think as much as it likes is dangerous without your own measurements. Benchmark scores measured with reasoning effort pinned at max and the cost at the effort level you would actually run in production are two different stories. How far the scores drop when you lower the effort is something the vendor has not published, and I could not verify it either.

Flash Is a Tier Name, Not a Latency Story

One misunderstanding the name creates is worth heading off. Other vendors' Flash tiers generally mean "fast response," but DeepSeek's Flash is not a latency grade — it is the name of a model family with small active parameters. Whether responses are actually fast is a completely separate question, and one that varies enormously by provider.

Look at Artificial Analysis's per-provider aggregation and you find output speeds scattered from the low 100s of tokens per second into the high 200s even though the same weights are being served, with very large provider-to-provider variance in time to first token as well. A separate benchmark reports a median throughput of 164.7 tokens per second and a median TTFT of 1,924 milliseconds. In reasoning mode, another point matters: "first token" and "first answer token" are not the same thing — thinking tokens stream first, so the delay the user actually feels before seeing an answer is far longer than TTFT. If you plan to put this model behind a real-time conversational UI, measure the time to the first answer token, not TTFT.

One more item. The official API documents a concurrent request limit of 2500 for Flash and 500 for Pro. That is the practical ceiling when you push batch-style work through it, so it belongs in your capacity planning.

Routing Rules — And What We Still Do Not Know

Compressing the numbers so far into decision rules gives this.

• Traffic with long outputs and a large repeated prefix has a clear reason to come here. Code review, bulk classification, log summarization, and agents for internal tooling all fall in this bucket. It is the one regime where the cache-hit price and the output price work in your favor at the same time.
• Traffic with long inputs and short outputs narrows the gap to around 1.5x. If you are already locked in with another vendor and migration has a cost, the case for moving is weak.
• Traffic where the quality ceiling dominates the outcome should not be moved. On SWE-bench Pro and long-horizon agent tasks the gap to the top-tier models is still real, and in workloads where the cost of a single failure vastly exceeds the token bill, comparing unit prices is the wrong frame to begin with.
• Traffic under data governance constraints needs a separate judgment regardless of price. The HN thread returned repeatedly to concerns about where the codebase ends up, and to the point that a zero-retention policy is not offered to individual subscribers. Because the weights are published under the MIT license, self-hosting is an available option, and that is this model's real differentiator. The hardware cost of standing up 284B, however, comes right back at you.

Let me also write down clearly what I could not verify. The score deltas relative to the preview (Terminal Bench 56.9 to 82.7 and so on) do not come from a single table in the official changelog; the community stitched together announced figures from two points in time, and I could not confirm that both values came from the same harness. The score and cost curve at lower reasoning effort, the real effective length of the 1M context (whether performance holds all the way to the last token), and the effective date of the peak pricing plan are all unpublished as well. And an agent score measured on a vendor's own harness is, until that harness is published, not a comparable number but a vendor claim.

Closing — Leaderboards Flip in a Month, but the Shape of a Price Sheet Lasts

The information from this release that will still matter later is not the score 82.7, it is the structure of the price sheet. A price sheet with a 2x output-to-input multiple and one with a 6x multiple pull in different workloads even at identical capability. And the line item where the cache-hit price is one fiftieth of the cache-miss price splits the invoices of teams that can pin a prefix and teams that cannot by nearly an order of magnitude.

So instead of rereading the leaderboard, open your own logs. The median input and output tokens per request, the prefix reuse rate, and the cost of a single failure — with those three numbers, which model to route to falls out of the arithmetic. A benchmark is just one of the inputs to that calculation, and even then it is usable only after you have confirmed who measured it and on what harness.