DeepSeek V4.1 Flash: What Changes When the Cheaper Model Retires the Flagship

A model name with an expiry date

On the afternoon of September 8, DeepSeek posted a notice of under 100 words in its official user group. There was no keynote, no teaser, and the website docs hadn't changed. The notice carried one model name:

deepseek-v4.1-flash-expires-on-0910

The suffix 0910 was the expiry date. Two days later, at noon on September 10, the official release went live under a headline as dull as a weekly status update: Stronger, Faster, More Accessible.

The interesting part sat in the body. DeepSeek said extensive testing showed V4.1 Flash had comprehensively surpassed V4 Pro on performance, cost, speed and total latency, and that it planned an orderly deprecation of V4 Pro. In plain terms, Flash outgrew Pro and Pro is on its way out.

The practical consequence has a date on it. After 12:00 PM Beijing time on September 14, every request addressed to deepseek-v4-pro is silently redirected to V4.1 Flash and billed at Flash rates, until a V4.1 Pro eventually ships. If your production code has deepseek-v4-pro hardcoded, you had less than four days after the announcement.

A new architecture, not a fresh coat of paint

It's tempting to read V4.1 Flash as one more post-training pass on V4 Flash. That's wrong. The July 31 update of V4 Flash was explicitly described as keeping the architecture and size of the preview model and only being re-post-trained, meaning the same skeleton with another round of training. This release rebuilds the foundation.

The model is a 552B mixture-of-experts with a causal encoder-decoder layout, and its defining trait is asymmetry between input and output:

• Reading input (prefill) activates 8B parameters. Out of the 552B expert pool, each input token touches only about 1.45% of the weights.
• Writing output (decode) activates 16B parameters, exactly double the input side.

The logic holds up. Reading a block of code, scanning a screenshot or absorbing tool output is mostly ingestion, not deep multi-step reasoning. The expensive thinking occurs while generating. By putting most of the compute on the output side, inputs travel a light path and outputs use the full one.

That suits agent workloads well, since their token distribution is badly lopsided. Tens of thousands of tokens of context, tool returns and repository prefixes produce only a few dozen to a few hundred tokens of actual decisions. Making input cheaper hits the costliest part of the pipeline.

The technical report names several mechanisms behind this:

• CSA2 (Compressed Sparse Attention 2) reuses the KV cache across layers and applies Top-K indexing in three modes: Full, Reindex and Reuse.
• KV cache precision falls from FP8 in the previous generation to FP4.
• DSpark is part of decoding. A lightweight speculative module drafts tokens, and the main model verifies them.

The efficiency, in short, is structural and doesn't come from fiddling with parameters.

Where the savings really come from: a 437x cache reduction

Asymmetric activation is a new trick, but squeezing the KV cache is the thing DeepSeek is best known for. The official history of that effort is the setup for a concrete hardware gain compared with the prior generation: HBM demand falls to a quarter, and SSD storage needs fall to an eighth.

Agent developers gain the most. Agents rely on huge contexts and frequent calls, and system prompts, tool schemas and chat history get resubmitted on every round trip. Cache hit rates often go beyond 99%, so most of an API bill is cached input and not output tokens.

The price changes mirror that:

• Cache-hit input goes from $0.0075 to $0.003 (down 60%).
• Cache-miss input goes from $0.225 to $0.15 (down 33%).
• Output goes from $0.675 to $0.60 (down 11%).

The deepest cut lands exactly where the KV cache work pays off.

There's an engineering lesson in the numbers, too. A provider that optimizes this hard for SSD footprint evidently treats SSD as an active, primary caching tier, a pattern DeepSeek has followed for a long time. And once the per-step KV cache gets this small, it stops saturating GPU memory bandwidth. Reading weights becomes the main bottleneck, which probably explains why community benchmarks see output speed stay flat as context length grows.

Benchmarks: real wins and honest losses

The headline gains are in practical agent evaluations. Terminal-Bench 3.0 jumped from 7.6 to 30.0, nearly four times higher. DeepSWE rose from 54.4 to 74.2. Both measure how well an agent executes real-world tasks, so the post-training clearly aimed at operational usefulness.

Still, "wins everywhere" needs a footnote. Across the comparison board:

• It takes first place on three tests: CyberGym at 88.1, Automation-Bench at 54.8 and DeepSWE v1.1 at 74.2. On DeepSWE the lead over Opus 5 (74.0) is only 0.2 points.
• On GPQA Diamond it scores 90.9 and trails three rivals: GPT-5.6-Sol (94.1), Opus 5 (93.4) and GLM-5.3 (92.9).
• On HLE it scores 36.8, which is last on the board, while GPT-5.6-Sol reaches 56.3.
• Terminal-Bench 3.0 and 4.0 land at 30.0 and 31.2, well short of Opus 5 at 43.3 and 51.8.

It doesn't beat its own predecessor everywhere either. V4 Pro scored 92.4 on GPQA Diamond, and V4.1 Flash gets 90.9, which is 1.5 points lower.

So "comprehensively surpassing" describes a balance across quality, cost, throughput and latency, not a higher score on every single metric. A more exact reading: on agent workloads the model matches or beats the old flagship at roughly a third of the running cost. For most production business use, that's the trade that counts. If you're building research or reasoning products, though, the 36.8 on HLE deserves a closer look.

What it does to your bill

The pricing in force from September 10, 2026 at 12:00 PM Beijing time is quoted per 1M tokens. Peak hours are 01:00 to 04:00 and 06:00 to 10:00 UTC, Monday through Friday. Everything else, weekends included, is off-peak, and off-peak rates are exactly half of peak.

Three conclusions follow:

• Against the old Flash, cache-hit input is 60% cheaper, uncached input 33% cheaper and output 11% cheaper. Since hit rates are normally very high, real invoices drop by far more than the 11% output cut suggests.
• Against V4 Pro, peak output falls from $3.96 to $1.20, under a third of the former price, while benchmarks improve on top.
• Off-peak pricing halves the cost of batch inference run at night or on weekends.

As a worked example, a task with 1M cached input tokens, 100K uncached input tokens and 10K output tokens costs about $0.0368 before and about $0.024 off-peak now. That's a cut of roughly 34.7%.

The context matters too. Only a month earlier DeepSeek had raised prices with the V4 Pro launch, setting peak output at $3.96. Cutting it to $1.20 a month later shows how fierce infrastructure competition has become.

Migrating

Moving over takes nothing more than changing the model identifier in a normal client setup:

from openai import OpenAI
client = OpenAI(
    api_key="YOUR_DEEPSEEK_KEY",
    base_url="https://api.deepseek.com",
)
resp = client.chat.completions.create(
    model="deepseek-flash",   # Points to V4.1 Flash
    messages=[{
        "role": "user",
        "content": [
            # Native multimodal: interleaved text and images without a separate vision model
            {"type": "text", "text": "Inspect this error screenshot and identify which layer threw the exception."},
            {"type": "image_url", "image_url": {"url": "https://..."}},
        ],
    }],
)

The capabilities and limits to know:

• The context window is 1M tokens, maximum generation is 384K tokens, and JSON Schema output, function and tool calling and the Responses API are all supported.
• Thinking mode is on by default, with low, high and max effort levels.
• Concurrency is capped at 2,500 for deepseek-flash, against 500 for deepseek-v4-pro.

Some timelines and failure points need attention:

• Old model names work only as a temporary bridge. deepseek-v4-flash and deepseek-v4-flash-vision-exp are retired, but both still route to V4.1 Flash at Flash prices.
• September 14 at 12:00 PM Beijing time is a hard cutover. From then on, deepseek-v4-pro requests go silently to Flash, billed as Flash, and there's no public way to opt out.
• Don't use the preview tag deepseek-v4.1-flash-expires-on-0910 any more, because it has already expired. The identifier to use is deepseek-flash.
• In the consumer apps, Fast, Expert and Vision modes merge into one Smart Mode. The model judges task complexity itself and turns on vision whenever it sees an image.

Risks to check before cutover

Silent routing in production

The stated reason is reasonable, since keeping an older, slower and pricier Pro around no longer makes sense. But production systems get tuned to the failure modes of one specific model. Retry rules, prompt fallbacks and monitoring alarms were calibrated against how V4 Pro behaves, and a higher average benchmark score doesn't promise the same behavior on your own prompts. Structured output is the weak point, since JSON and function-call schema adherence can drift. Run full regression tests on production-like traffic before September 14 rather than waiting for alerts to fire.

Language drift

Preview testers reported two language consistency bugs. English prompts sometimes came back in Chinese. Worse, workflows with web search tended to answer in whatever language dominated the retrieved pages. If your users mostly speak English, test this case specifically. Some developers kept appending "Answer in English!" to force compliance, and a workaround like that doesn't belong in the user layer of production software.

Open weights are not easy deployment

The weights are on Hugging Face under the permissive MIT license, with no extra operational limits: commercial use, fine-tuning, redistribution and even training competing models are allowed. It replaces the custom DeepSeek License of earlier versions with a standard open-source framework, and the technical report PDF is published alongside.

Self-hosting a 552B MoE is still a serious infrastructure job, though. DeepSeek itself said teams wanting high-throughput internal deployments should prepare a cluster of about 2,000 GPUs plus dedicated storage. For most engineering teams this is downloadable weights and not software they can run locally. The upside is that a KV cache of 890 bytes per token eases memory pressure a lot, which leaves room for community optimizations later.

What comes next

V4.1 Flash is the entry point of a new architecture family, which DeepSeek says is meant to scale to larger parameter counts. The next milestone is the still-unreleased V4.1 Pro, built on the same design at a bigger size. If Flash already leads on DeepSWE, CyberGym and Automation-Bench, the Pro model will probably focus on closing the roughly 20-point gap on HLE.

The product side is notable as well. Merging Fast, Expert and Vision into one pathway takes model selection away from users, since the system decides reasoning depth and multimodal activation on its own. Gemini went this way earlier and DeepSeek has followed. Users benefit, but middleware builders should read it as a warning: any product whose value comes only from helping people choose models is losing that value fast.

As for V4 Pro, a model that got a price increase and then was deprecated by its own lighter sibling within thirty days says plenty about the sector. Patience for a flagship now lasts about a month.