DeepSeek V4.1-Flash-1017: The 20-Cent Coding Task and What MIT Open Weights Do to Your AI SaaS Margins (2026)

Quick answer: DeepSeek released V4.1-Flash-1017 on Saturday, October 17, 2026 — a snapshot update to the Flash model it shipped in September. Per DeepSeek's own Pass@1-vs-cost chart, reported by The Decoder the same day, the cost of a finished coding task on this model dropped to just under $0.20 at top effort, down from roughly $0.50 on the previous snapshot, while benchmark scores went up. The weights are MIT-licensed on Hugging Face. API pricing is $0.15/M input and $0.60/M output off-peak (the default rate outside two weekday windows), doubling to $0.30/$1.20 during peak hours. The same announcement quietly opened DeepSeek's Search and Fetch APIs to all developers at $0.75 per 1,000 requests.

You're reading this on a directory's blog, so here's the honest part first: SaaSCity makes money from startups listing themselves, and we write about AI model news because the founders who read it are the same people deciding which model line item eats their margin. Nothing below is written to sell you a listing. It's written because the price-per-task number that just moved is the number that decides whether your AI feature is a product or a liability.

What actually shipped on October 17

DeepSeek's own changelog calls it a minor update, and structurally it is: same Flash tier, same API endpoint, same 1M context window. But two things changed under the hood that matter more than the "minor" label suggests.

First, routing. As of the DeepSeek API changelog, the model name deepseek-flash now serves V4.1-Flash-1017 by default. The legacy names deepseek-v4-flash and deepseek-v4-flash-vision-exp are retired, and any request still pointed at them gets transparently routed to the new snapshot at the same Flash price. If your app has been calling the old model string, it already upgraded itself sometime over the weekend. Worth checking your logs if you run anything latency-sensitive, since output length shifted too — more on that below.

Second, the actual model behavior. The Hugging Face model card describes "substantial improvements across reasoning, coding, agentic tasks, and visual benchmarks," paired with a line that's easy to skim past and shouldn't be: the update "reduces task execution time and output length." Translation for anyone paying a per-token bill — the model does the same job in fewer billed tokens. That's not a benchmark flex, that's a line item on your invoice getting smaller every time a task runs.

This is four Flash snapshots since the April preview; we covered the last one in July, when the only change was post-training and it was still enough to beat DeepSeek's own bigger Pro model. The pattern holding here is that DeepSeek treats Flash as a model that ships often, not a model that ships once.

The benchmarks, and where they actually lose

DeepSeek put out comparison numbers against Claude Opus 5, GPT-5.6 Sol, Kimi K3 and GLM-5.3. Every number below is DeepSeek's own test run — Terminal-Bench 4.0 on the Claude Code harness, DeepSWE v1.1 on Mini-SWE-V2 — not an independent lab's. Worth saying plainly, and worth saying before you build a procurement decision on it.

Benchmark	V4.1-Flash-1017	Prev. V4.1-Flash	Opus 5	GPT-5.6 Sol
DeepSWE v1.1	77.0	74.2	74.0	73.0
Terminal-Bench 4.0	42.3	31.2	51.8	39.9
Agents' Last Exam	35.4	31.8	28.6	26.7
Automation-Bench v1.0.6	60.5	54.8	50.3	—
ProgramBench	29.1	20.3	37.0	—
NL2Repo-Bench	68.2	65.4	75.3	—
Humanity's Last Exam (no tools)	42.6	36.8	56.3	—
Apex Bench v1.1	72.1	64.6	—	—

So no, it isn't a clean sweep, and DeepSeek doesn't pretend it is. The cheap model wins on DeepSWE, Automation-Bench and Agents' Last Exam — three agentic, task-completion-style tests. Opus 5 still wins comfortably on Terminal-Bench 4.0, ProgramBench, NL2Repo-Bench and Humanity's Last Exam, all of which lean harder on raw reasoning depth and single-shot code generation rather than iterative agent loops. If your product needs a model that reasons through a gnarly refactor in one pass, this release doesn't change your vendor choice. If your product runs an agent loop that completes many small tasks and gets graded on whether the task finished, the math below is the part that should change your choice.

Cost per task, not cost per token

Here's the number that actually matters for a SaaS margin, and it's not in the benchmark table.

The Decoder's report on DeepSeek's Pass@1-vs-cost chart puts V4.1-Flash-1017 at roughly 77% on DeepSWE for just under $0.20 per task at top reasoning effort, and above 72% for around $0.15-0.20 at the low-effort setting. The previous Flash snapshot cost about $0.50 to clear a comparable task. Closed-model competitors on the same chart sit between $2 and more than $10 per task. Again — DeepSeek's chart, DeepSeek's harness, not an independent measurement. But the direction matches the model card's claim about shorter outputs, and it matches the pattern from the July release, where post-training alone cut the hallucination rate without the per-token rate moving at all.

If you're running an AI feature at scale, cost per token was never the number you should have been tracking. Cost per finished task is. A model that costs more per token but finishes in a third of the turns can still be cheaper, and a model that's "free" per token but needs five retries to pass a task is the expensive one in disguise. This is the same framing we used looking at Claude Haiku 5.5's margin math for SaaS teams — the sticker price on the API docs page is the least useful number in the decision.

The actual price sheet

Here's what you'll pay calling the API directly, per DeepSeek's own Models & Pricing page for deepseek-flash (model version DeepSeek-V4.1-Flash-1017); OpenRouter and Vercel's AI Gateway list the same off-peak numbers as corroboration:

Rate	Input, cache miss ($/M)	Input, cache hit ($/M)	Output ($/M)
Off-peak (default)	$0.15	$0.003	$0.60
Peak	$0.30	$0.006	$1.20

Peak hours are 01:00-04:00 UTC and 06:00-10:00 UTC, Monday through Friday, excluding Chinese public holidays. Every other hour is off-peak, including weekends and Chinese public holidays in full. If your workload is a batch job, a nightly re-indexing run, or anything that doesn't need to happen the instant a user clicks a button, scheduling it outside those windows is a lever that costs you nothing but a cron change and saves half the bill. Nobody talks about this because "schedule your batch jobs for off-peak" sounds too simple to be a real optimization. It is a real optimization. It's just boring.

The cache-hit rate deserves the same attention. At $0.003 per million tokens off-peak (doubling to $0.006 at peak), a cache hit costs about 2% of the off-peak input rate. Any agent loop that replays a large shared system prompt or shared context window across turns — which describes most production agent architectures — should be structuring prompts specifically to maximize cache hits, not treating caching as a nice-to-have the SDK handles for you.

MIT weights: negotiating power even if you never self-host

The part that gets underrated in most coverage of this release: the weights are MIT-licensed, full stop. Self-host, fine-tune, redistribute, strip the branding — no usage restriction in the license text.

Most founders reading this will never run a self-hosted inference stack. That's fine. The practical value of MIT weights isn't that you're about to spin up your own GPU cluster — it's that you now have a hard price ceiling to hold over any vendor you're negotiating with. If your current provider raises rates, or changes terms, or has an outage during your busiest week, "we could self-host the open-weights alternative this weekend" is a real sentence, not a bluff, because the weights, the license and the inference recipes already exist. That changes every renewal conversation you have, even if you renew on the same terms. This is the exact dynamic we walked through with Xiaomi's MiMo-V2.6 release and what open weights do to model economics — the option value of a credible exit is worth something whether or not you ever exercise it.

The second story nobody's covering yet: a $0.75 search API

Buried in the same release notes is a product launch that got a fraction of the attention: DeepSeek opened its own Search and Fetch APIs — its web search engine and its page-reader tool — to every developer, not just internal use.

Pricing is $0.75 per 1,000 successful requests. Empty or failed calls cost nothing. Each endpoint caps at 5 queries per second per account. And if you're already calling DeepSeek through the server-side tools baked into DeepSeek Harness, Claude Code, or Codex, those calls are free until billing kicks in on October 31, 2026 at 16:00 UTC (00:00 Beijing time Nov 1) — about two weeks of a genuinely free on-ramp if you're already in that ecosystem.

For anyone building an agent that needs live web results — research assistants, competitive-monitoring tools, anything that needs to ground an answer in something newer than a training cutoff — this is a vendor that now covers both the model and the retrieval layer, from one account, at a published price. We'd normally compare that rate to a competitor's search API price here, but we haven't independently verified a current competitor number worth quoting, so we won't guess at one. Check your own provider's current rate before assuming this undercuts it.

Hacker News noticed the model, not the search API

The model card hit the front page of Hacker News as the #1 story, with 893 points and roughly 670 comments at the discussion thread. That's a big number for a model release — most snapshot updates don't clear the front page at all, let alone take the top slot.

The Search API pricing got its own separate thread that pulled 295 points on its own, here — a smaller number, but still a real conversation, which tells you developers noticed the retrieval play even if the headlines didn't lead with it.

The caveats worth keeping in your back pocket

None of this is a reason to switch blindly. A few things to hold onto before you move production traffic:

• Every benchmark number above is DeepSeek's own test run. Terminal-Bench 4.0 specifically was run on the Claude Code harness, not an independent evaluation. Treat the within-DeepSeek comparisons (this snapshot vs. the last one) as solid, and the cross-vendor comparisons as directional.
• Opus 5 still wins on half the benchmarks that matter for single-shot reasoning. If your workload looks like that, this release doesn't move your decision.
• Data residency and compliance are unresolved for regulated buyers. If you're shipping to EU enterprise customers or US customers with contractual data-location requirements, a model served from DeepSeek's infrastructure needs its own legal review before it touches production — that hasn't changed with this release.
• Self-hosting MIT weights is still real infrastructure work. The negotiating power is real even if you never deploy it, but don't confuse "the weights are free" with "running them is free."

What this means for your margins this week

Run the numbers on what you're actually paying per completed task right now, not per token. If a chunk of your AI feature is agentic coding, tool-calling loops, or anything where the task either finishes or it doesn't, a sub-$0.20 cost per task at this quality level is worth a real evaluation against your current spend — not a full migration on day one, but a side-by-side test on your own workload this week.

And if you're building the kind of tool that gets switched between providers on a weekend because the economics moved — which, per this release, they just did again — getting found by the people making that switch matters as much as the switch itself. SaaSCity is a free, gamified startup directory with a live city map and actual human editorial review, built for exactly this kind of fast-moving AI tooling. List for free and add the badge for a dofollow backlink and a Monday launch slot, or skip the line with Quick Pass ($19.99, live within 24 hours) or Premium ($99.99, a written launch post with three dofollow links). The site sits around DR 47-56 at last Ahrefs check — a real number for a product that otherwise has zero search presence on day one.

DeepSeek just moved the price of a shipped coding task down again, for the second time in three months, with the weights sitting right there under MIT if anyone wants to check the math themselves. The question worth asking isn't whether this model is "the best." It's whether the vendor line item you haven't questioned since you set it up still deserves the price you're paying.