DeepSeek V4.1 Flash 1017: What Changed and Why Chips Fell

DeepSeek V4.1 Flash 1017 is an updated version of DeepSeek's low-cost model, swapped in behind the same API name on October 17, 2026. DeepSeek says it scores higher, finishes tasks faster and writes shorter answers at the same price.

Two days later, Korean chip stocks fell, partly on fears that leaner models like this one will need less memory. Here's what changed, what the memory claim means and what AI teams should do now.

Key Takeaways

• DeepSeek replaced the model behind its deepseek-flash API with V4.1-Flash-1017 on October 17, keeping the same API name, the same price and the same 1 million token context.
• DeepSeek reports gains on all its listed benchmarks, such as DeepSWE rising from 74.2 to 77.0. These are its own numbers.
• The headline memory claim, about a quarter of V4 Flash's KV cache per token, dates from the September release, not this update.
• On October 19, the Kospi fell as much as 3.2%, and Samsung and SK Hynix each fell more than 4% at the low, amid memory demand fears and wider AI funding worries.
• For AI teams, the bigger lesson is version control: the same API name now serves a different model.

DeepSeek V4.1 Flash at a Glance

Detail	DeepSeek V4.1 Flash 1017
Released	October 17, 2026, replacing the September 10 checkpoint
API name	deepseek-flash (unchanged)
Size	About 552 billion parameters, roughly 8 to 16 billion active per token
Context and output	1 million token context, up to 384,000 output tokens
Off-peak price	$0.15 input, $0.60 output, $0.003 cached input, per million tokens
Peak price	Double, on weekdays from 01:00 to 04:00 and 06:00 to 10:00 UTC
Weights	Open, MIT license, about 510 GB on Hugging Face

The specs and price above come from DeepSeek's release notes as summarized by OrcaRouter and a developer's config review. Both note that the architecture is identical to the September release. Only the weights changed.

What Is DeepSeek V4.1 Flash?

DeepSeek V4.1 Flash is DeepSeek's low-cost, long-context model. It launched on September 10, 2026, as the model behind the deepseek-flash API, with open weights under the MIT license so anyone can download, run and change it.

It's a mixture-of-experts model. Of its 384 routed experts, only a handful work on each token, which keeps the active size to roughly 8 to 16 billion parameters out of about 552 billion. That's how it stays cheap to run while holding a 1 million token context window.

The 1017 update keeps all of that. Same design, same size, same price. Only the trained weights are new.

What DeepSeek Changed on October 17

DeepSeek called it a minor update. Its changelog says the model "has been upgraded" to V4.1-Flash-1017, with the same API calls and pricing. Its post claims stronger benchmark scores, faster task completion and shorter outputs.

Here are selected scores DeepSeek reported for the September and October checkpoints:

Benchmark	September	October 1017
DeepSWE v1.1 (coding)	74.2	77.0
Terminal-Bench 4.0 (agent tasks)	31.2	42.3
Humanity's Last Exam (no tools)	36.8	42.6
Automation-Bench	54.8	60.5
ProgramBench	20.3	29.1

Two caveats apply. These are DeepSeek's own numbers, and no outside lab had tested the new weights at launch. And the Terminal-Bench jump came with a change of test harness, from DeepSeek's own minimal setup to Claude Code, so part of that gain may come from the harness rather than the model.

DeepSeek also didn't publish figures for the faster runtime or shorter outputs. Shorter outputs matter for cost, since output tokens are four times the price of input. But until someone measures them, treat that as a claim.

The Memory Claim Behind the Chip Sell-Off

The part that moved markets is about memory, and it's older than this update.

When a model reads a long prompt, it keeps a working memory of what it has seen, called the KV cache. That cache lives in the GPU's high-bandwidth memory, or HBM, the expensive chips Samsung, SK Hynix and Micron make. The longer the context, the bigger the cache.

With V4.1 Flash in September, DeepSeek said its model needs about 890 bytes of global KV cache per token, roughly a quarter of V4 Flash, and about an eighth of the SSD storage. Our math: 890 bytes per token works out to under 1 GB of cache for a full 1 million token context, against roughly 3.5 GB for the older design.

If models need a quarter of the memory per token, the worry goes, data centers might buy less HBM. That's why the claim hit memory stocks rather than, say, software companies, which tend to gain when AI gets cheaper to run because they pay for it.

How DeepSeek Shrinks the KV Cache

The developer review of the model's config file shows how the memory savings work. In short, most layers don't keep a long memory at all:

• Short memory for most layers: most layers only look back over a sliding window of 128 tokens, so their cache stays tiny however long the prompt gets.
• Long memory for a few layers: only four of the model's layers keep long-range memory across the full context.
• Compression: reports credit further savings to compressing that long-range memory and storing it at low precision.

Put together, the model keeps a small, compressed long-term memory instead of a full one in every layer. That's a design choice, not a trick, and other labs use similar ideas. What DeepSeek did was push it further than most and publish the numbers.

Is the Memory Claim as Big as It Sounds?

Probably not, for three reasons.

• It's per token, not per data center. The claim is about the attention cache during inference. Model weights, training and other workloads still need large amounts of memory, and DeepSeek never said whole data centers use 75% less.
• The figure depends on how you measure it. The developer review found that this architecture's bytes per token change a lot with context length, so a single number can't describe every workload.
• Cheaper often means more. When AI gets cheaper to run, people tend to run more of it, with longer contexts and more agents. That can raise total demand for memory even as the cost per token falls.

Markets have reacted this way before. When DeepSeek's R1 model came out in January 2025, Nvidia shares fell about 17% in a day on similar efficiency fears, then recovered as AI spending kept growing. That doesn't mean the same will happen now, but it's a useful reminder that efficiency news and long-term demand don't always point the same way.

How Asian Chip Stocks Reacted to DeepSeek V4.1 Flash

The market impact came in two waves.

• September 11: the day after the original V4.1 Flash launch, Samsung fell about 3.5% and SK Hynix about 2.2% in Seoul, according to Crypto Briefing.
• October 19: after the 1017 update, the Kospi fell as much as 3.2%, and Samsung and SK Hynix each dropped more than 4% before trimming losses, NewsBytes reports. Bloomberg's gauge of Asian chip stocks reportedly hit its lowest level since July.

The backdrop matters. NewsBytes notes the Kospi had just had its worst week since October 2008, and US chipmakers had fallen for eight straight sessions on worries about the cost of AI projects. Even after the fall, the Kospi was still up more than 30% for the year, after AI spending pushed memory prices to record highs.

So DeepSeek was a trigger, not the whole story. Investors were already nervous about AI funding, and a leaner model gave them one more reason to sell. Nothing here is investment advice.

The Real Lesson for AI Teams: Silent Model Swaps

For teams building on AI, the most important part of this update isn't the benchmark or the stock market. It's that the deepseek-flash API name now points to different weights than it did in September, with no new name and no change in price.

That breaks a common assumption. If you tested DeepSeek V4.1 Flash in September and built a workflow on it, your test results now describe a model that no longer serves your requests. The new one may be better on average and still behave differently on your prompts, your output formats or your edge cases.

This isn't unique to DeepSeek. Many providers update models behind stable names. But a silent swap is a good reason to treat model versions like any other dependency:

• Pin versions where you can. Use dated model names, or self-host dated open weights such as the 1017 checkpoint, for anything that needs consistent output.
• Keep a regression test set. Re-run a fixed set of real tasks whenever a provider changes anything, even if it calls the change minor.
• Log the model version with every request, so you can trace when behavior changed.
• Watch output length. Shorter outputs can save money, or they can cut off answers your users depend on.

Our model portability lesson covers how a thin routing layer makes it easier to catch and handle changes like this one.

What DeepSeek V4.1 Flash Costs in Practice

The price is very low by frontier standards. Here's an example with our own math, for an agent task that sends 200,000 tokens of context, 150,000 of them cached, and gets 10,000 tokens back:

Part of the task	Tokens	Off-peak cost	Peak cost
Uncached input	50,000	$0.0075	$0.0150
Cached input	150,000	$0.00045	$0.0009
Output	10,000	$0.0060	$0.0120
Total per task	210,000	About $0.014	About $0.028

That's about $14 per thousand tasks off-peak, or $28 at peak. Scheduling batch jobs outside the peak windows halves the bill, and keeping long prompts cacheable matters even more, since cached input costs 50 times less than uncached input.

How DeepSeek V4.1 Flash Compares on Price

DeepSeek is cheap, but it isn't the only low-cost option. Here's how its list price compares with two small models we've covered, at standard rates:

Model	Input per million tokens	Output per million tokens	Catch
DeepSeek V4.1 Flash	$0.15 off-peak	$0.60 off-peak	Double at peak hours
Claude Haiku 5.5	$0.10	$0.50	Prompts over 100,000 tokens pay five times on the whole request
GPT-6 Luna	Same list price as Haiku 5.5	Same list price as Haiku 5.5	Check current terms

On short prompts, the US small models list slightly lower. On long prompts, DeepSeek's flat rate and cheap cached input can make it far cheaper, since Haiku 5.5's price jumps above 100,000 tokens. Our Haiku 5.5 cost breakdown shows how that step works.

List prices only tell part of the story. A model that needs fewer steps or shorter outputs can win on cost per task even at a higher rate, so test on your own work.

Should You Use DeepSeek V4.1 Flash?

It depends on the job and your rules. Here's how we'd think about it:

• Good fit: high-volume, cost-sensitive work such as document processing, data extraction and coding agents, where you can test quality on your own tasks.
• Good fit: long-context jobs, where the small KV cache and cheap cached input help most.
• Check first: regulated data. Using DeepSeek's API sends data to a China-based provider, so many companies prefer to self-host the open weights instead.
• Check first: workflows that need stable outputs over months, given the silent swap.

The weights are about 510 GB, so self-hosting needs serious GPU memory. And the rules around Chinese models are shifting: our piece on China's draft AI export controls explains why already-public open weights like these are likely to stay available. If you're comparing options, our Qwen vs DeepSeek vs Kimi comparison covers the main Chinese open models.

Self-Hosting the 1017 Weights

Because the weights are open, you can avoid both the silent-swap problem and the data question by running the model yourself. The 1017 checkpoint is published on Hugging Face as its own dated release, so you can pin exactly the version you tested.

It isn't light. The weights are about 510 GB across 48 files, so you'll need several high-memory GPUs. But the small KV cache helps here too: long contexts take far less extra memory than on older designs, which lets one server handle more users at once.

For most teams, the hosted API is the easier start. Self-hosting makes sense when data can't leave your control, when you need a fixed version for months, or when your volume is high enough to justify the hardware.

How to Test the 1017 Update

If you already use DeepSeek V4.1 Flash, here's a short plan:

• Day 1: pull 100 to 200 real requests from your logs, with the September outputs if you kept them.
• Day 2: re-run them on the current API and compare accuracy, format and output length.
• Day 3: check cost per finished task at both peak and off-peak rates.
• Day 4: decide whether to accept the new version, pin the old weights by self-hosting, or route sensitive jobs elsewhere.

If you don't use it yet, run the same test against your current model. The price gap is large enough that it's worth a few days of evaluation. Our guide to AI agent evaluation shows how to build that test set.

What to Watch Next

• Independent tests: whether outside labs confirm the 1017 benchmark gains, especially on Terminal-Bench with a fixed harness.
• Memory demand: whether HBM orders and prices actually soften, or keep rising as AI use grows.
• Chip stocks: whether the Kospi recovers once AI funding worries ease.
• DeepSeek's next move: another update under the same name would make version pinning even more important.

DeepSeek V4.1 Flash: Our Take

DeepSeek V4.1 Flash 1017 is a solid, cheap model that got better on paper, with open weights anyone can run. The memory claim that rattled chip stocks is real but narrower than the market reaction suggests, and it isn't new to this update.

For AI teams, the practical message is about control. A model that changes under the same name can quietly change your product. Pin versions, keep a test set and measure cost per task, and models like this one become a useful option rather than a surprise.

How Van Data Team Helps Teams Manage Model Changes

We help companies build AI systems that stay stable while models change underneath them. That means regression test sets built from your real work, version pinning and logging, routing that can switch models quickly, and cost tracking per task across providers.

If silent model updates or rising AI costs are on your list, our AI governance guide is a good place to start.