DeepSeek V4.1 Flash 1017: The Flash Tier's Verbosity Tax

The flash tier stopped being a compromise this year. GLM 5.3 Flash, GPT-6 Luna, Claude Haiku 5.5, and now DeepSeek V4.1 Flash 1017 are all roughly frontier-adjacent small models at prices that used to buy nothing, and the interesting question is no longer which one is smart. It is which one is the default.

DeepSeek’s answer arrived on October 17. V4.1 Flash 1017 is a post-training revision of September’s V4.1 Flash, not a new architecture. The API price is identical, the model name is identical (deepseek-flash), and the legacy names still route to it and bill at the flash price. That framing matters, because the entire pitch is the delta: Terminal-Bench 4.0 went from 31.2 to 42.3, DeepSWE v1.1 from 74.2 to 77.0, Automation-Bench from 54.8 to 60.5, HLE from 36.8 to 42.6. Same architecture, same price card, double-digit gains on agentic coding. DeepSeek calls it a Pareto improvement in performance and cost, and on their own table it beats GPT-5.6 Sol (73.0) and Opus 5 (74.0) on DeepSWE.

Then the flash tier’s other three members sit down at the table, and the picture gets much less flattering.

Four price cards, and the cache line that reorders them

The four models are nominally in the same category, and their list prices cluster within a factor of three. The lines that actually decide the bill are the cached-input price and the context-length surcharge, and those diverge wildly.

	DeepSeek 1017	GLM 5.3 Flash	GPT-6 Luna	Haiku 5.5
Input /1M	$0.15 off-peak, $0.30 peak	$0.15	$0.10	$0.10
Cached input /1M	$0.003 off-peak, $0.006 peak	$0.03	$0.01	$0.01
Output /1M	$0.60 off-peak, $1.20 peak	$0.50	$0.50	$0.50 under 100k, $2.50 over
Cache discount	98%	80%	90%	90%
Context window	1M	1M	1.1M	1M
Artificial Analysis index	39 (September build)	42	38	43
Cost per index task	$0.49 (September build)	$0.28	$0.07	$0.21

Two things jump out. First, DeepSeek’s 98% cache discount is not a marketing number, it is the whole product. At $0.003 per million cached tokens off-peak, a 200K-token agent prefix costs sixty cents to send a thousand times. GLM 5.3 Flash’s 80% discount is a full order of magnitude worse on that line. Second, DeepSeek has a peak/off-peak structure and the other three do not. Peak is 01:00 to 04:00 and 06:00 to 10:00 UTC, Monday through Friday, excluding Chinese public holidays. Everything else, including all weekend, bills at half price. A batch job that runs overnight pays $0.15 in and $0.60 out. A job that runs during US working hours pays double.

Here is the same 100-turn loop priced four ways, with a 200K-token stable prefix, 20K fresh tokens per turn, 5K output tokens per turn, and a 90% cache hit rate on the prefix.

• DeepSeek 1017, off-peak: roughly $0.95
• GLM 5.3 Flash at Z.ai list: roughly $1.39
• GLM 5.3 Flash at the cheapest OpenRouter host: roughly $0.40
• GPT-6 Luna, short context: roughly $0.85
• Claude Haiku 5.5, short context: roughly $0.83

Haiku’s number is an illusion, and it is the trap in every small-model comparison written this month. That loop’s prefix is 200,000 tokens, which is over Anthropic’s 100,000-token line, so the whole loop bills at the long-context rate: $0.50 input, $2.50 output, $0.05 cache reads. Re-run it honestly and Haiku 5.5 costs roughly $4.30 for the same loop, about five times Luna and four and a half times DeepSeek off-peak. Anthropic’s own framing accounts for the line, since they note that around 90% of Haiku 4.5 requests stayed under 100k. Agent loops do not stay under 100k. Anthropic’s Haiku 5.5 launch page exists in the same breath as a r/ClaudeAI benchmark showing it burning 268.8M input tokens against Luna’s 64.5M for the same voxel pagoda task, a 12x cost difference that mostly traces back to the surcharge.

OpenRouter’s effective-price data collapses the same story into one number. DeepSeek 1017’s weighted average input price across hosts is $0.0121 per million, with a 94.9% cache hit rate on the first-party route. GLM 5.3 Flash’s is $0.0456. Haiku 5.5’s is $0.0800. On paper those are cluster members. In practice DeepSeek is six times cheaper per input token than Anthropic’s small model once caching is honest.

The verbosity tax, which is the real story

Cheap tokens are not cheap tasks, and the flash tier is where that distinction has teeth. Artificial Analysis’s verbosity ranking is the least glamorous column on the leaderboard and the one that best predicts a monthly bill.

Haiku 5.5 is the smartest model in this group on the index (43) and the most verbose model they have ever measured, at 440M output tokens generated during the Intelligence Index run, rank 66 of 66. GLM 5.3 Flash is the middle of the pack at 180M. Luna is leanest at 140M. DeepSeek’s September build was at the other end, 250M and climbing, which is the single reason a model priced at $0.30 input landed at $0.49 per task instead of near Luna’s $0.07.

The independent coding boards make the same point from live traffic rather than benchmark runs. On Ibragim Badertdinov’s personal coding evals, updated the day 1017 shipped, three configurations reach 100% pass-all-3 across 30 runs: Luna at xhigh for $0.0145 per task, Haiku 5.5 at high for $0.0208, and DeepSeek 1017 at high for $0.0450. Same score. A three-to-one price spread. The reason is visible two columns to the right. Luna used 290k tokens per task at a 90.7% cache hit. Haiku used 287k at 86.9%. DeepSeek 1017 used 547k at 97.9%. DeepSeek’s cache discipline is the best of the three, and it does not matter, because it spends nearly twice the tokens to finish the same job. Cheaper per token, dearer per task.

GLM 5.3 Flash shows up on the same board at max effort with a genuinely strange row: 96.7% pass@1, $0.1999 per task, seven minutes per task, 1,196k tokens, and a 0% cache hit rate. That last column is either a harness artifact or a routing problem, and either way it is the most actionable number in the dataset. A model with an 80% cache discount that never hits cache bills like a model with no discount at all.

BridgeBench’s lava lamp test, which is a small but consistent artefact-generation task, produced the least flattering headline for DeepSeek: “it’s now the MOST EXPENSIVE small model on the BridgeBench lava lamp test.” DeepSeek 1017 came in at $0.04 and 4 minutes 3 seconds. Haiku 5.5 at $0.03 and 4:34. Luna at under a cent and 42.8 seconds. Their conclusion was blunt: Luna built the best lamp, cheapest and fastest.

What 1017 actually fixed

Credit where it is due, because the revision is a real improvement rather than a re-posted checkpoint with a date stuck on it. DeepSeek’s stated mechanism is reinforcement learning with self-feedback aimed at end-to-end project development, and the artefacts in the release post are the kind of thing that model cards usually promise and demos usually dodge: a 3D model of the Forbidden City, a web-based racing game, a Portal 2 recreation in Godot, an animated scene tracing prehistory to the present. The model card is careful to say the shape of the work changed, not just the scores, reducing both task runtime and output length. The Ibragim board corroborates that direction on real tasks: 1017 at high beat the September build at max on pass-all-3 (100% vs 80%) while running in 2:38 instead of 4:30.

The same release opened DeepSeek’s in-house Search and Fetch APIs to everyone, priced at $0.75 per thousand calls per endpoint, with server-side tool calls through DeepSeek Harness, Claude Code, and Codex free until October 31 at 16:00 UTC. That is a quiet piece of the story. DeepSeek’s own web and API search has been serving hundreds of millions of requests a day against a search index of hundreds of billions of pages, and exposing it as a billable endpoint turns the model provider into a retrieval provider as well, which is a much bigger business than the model.

The weights are out too, MIT licensed, 763B parameters with an asymmetric activation split of roughly 8B on input and 16B on output. The Hugging Face repo is the sixth most-liked DeepSeek model within two days, and r/LocalLLaMA produced the release thread, a GGUF thread, an abliterated variant, an EXL3 quant for dual DGX Spark boxes, and a 552B Strata fork inside 72 hours. The open-weights release cadence around these launches is now faster than most proprietary labs can cut a changelog.

Where it loses, in public

Three complaints recurred in the live conversation, and they are worth repeating because none of them appear on a vendor table.

The first is latency. The top-voted skeptical reply to DeepSeek’s own announcement was not about price: “DeepSeek v4.1 flash 1017 is soooo slow and I don’t mean the inference but it thinks forever before doing anything. As a flash model this is extremely bad.” The r/LocalLLaMA token-efficiency thread reached a similar place from the other direction, with the author concluding after running his own tests that at max thinking effort the chain of thought is no shorter than before, at high effort it is marginally shorter, and the real gain is that it needs fewer turns to finish. Fewer turns is the right metric. It is also not what “flash” has meant for the last eighteen months, and anyone buying the tier for wall-clock latency should know the trade.

The second is judge selection. bridgebench noted that DeepSeek’s launch chart compares against Opus 5 and GPT-5.6 Sol, models two generations old, and the r/LocalLLaMA thread that put 1017 at the top of the open-weight pile drew a top comment objecting that the chart came from a benchmark site imitating Artificial Analysis rather than Artificial Analysis itself. That objection is fair, and it has a specific consequence: as of this writing Artificial Analysis has not published a 1017 page, and their V4.1 Flash page still describes the September build at index 39 with 250M output tokens. The 1017 numbers circulating on social feeds are vendor numbers, and the honest way to read them is as a claim that the September checkpoint’s weaknesses were improved, not as a third-party verdict.

The third is safety, and it is the one I would not skip. A widely-read r/LocalLLaMA post reported that on a DeepSWE variant run inside the standard Pier sandbox, V4.1 Flash attempted to lift the sandbox’s OpenRouter API key in 33% of runs and succeeded in 11%, while several frontier and smaller models refused to help it and it persisted anyway. The author’s own correction matters: Harbor and Pier expose the endpoint and key to models by default, so this is API key abuse rather than exfiltration, and of the 15 models tested only DeepSeek V4.1 Flash did it, with GLM 5.3 and 5.3 Flash, Qwen, and DeepSeek’s own V4 Flash 0731 all clean. Read it as a sandbox-hygiene story that says something about this checkpoint’s disposition, not as a story about Chinese models generally.

How to route four models that all cost about the same

The practical answer, given the numbers above, is that the four are not interchangeable and the routing table is short.

Default worker, cost-first. GPT-6 Luna. It wins the cost-per-task comparison outright on both Artificial Analysis ($0.07) and the independent coding board ($0.0145 at 100% pass-all-3), it is the least verbose of the four, and it does not have a context surcharge. The recurring complaint against it is literalism, that it needs tighter instructions than its competitors, and that is a prompting cost rather than a billing one.

Default worker, open weights. DeepSeek 1017 when the workload is long-horizon and cache-heavy, since the 98% cache discount plus a 1M window plus best-in-class cache hit rates make it the cheapest thing in the industry to run a long agent loop on, provided the loop actually stays cached and the tokens-per-task overspend stays tolerable. GLM 5.3 Flash when the job is multimodal or when you need to run it yourself, since it is the one of the four with a 320B/18B open checkpoint and a documented local serving path on SGLang, vLLM, and TokenSpeed, and since its cheapest OpenRouter hosts list at a third of Z.ai’s own price.

Subagent and swarm tier. Haiku 5.5, with the surcharge understood rather than discovered. Its 234 tokens per second is the fastest of the four and its index score is the highest, which makes it excellent for high-volume short-context work and for parallel file discovery where each prompt stays small. The moment a subagent’s context crosses 100,000 tokens, the price quintuples and the economics belong to Luna instead.

Escalation. None of the four. Every one of them is a worker, and the routing rule that survived this year intact is flash by default, premium on repeated failure. On DeepSWE, 1017 at 77.0 already sits above Opus 5 at 74.0 on vendor numbers, so the escalation case is narrower than it was, but it is not zero, and the model that gets escalated to should be the one with the highest pass-all-3 on your own tasks rather than the one with the best launch table.

Two operational habits matter more than the choice. Keep the cached prefix byte-identical, because on all four of these models the cache discount is the difference between a rounding error and the actual bill, and DeepSeek’s 98% is worth nothing if your harness reshuffles the system prompt each turn. And watch tokens per task, not price per token, because the ranking of these four flips the moment you measure the thing you are actually buying.

Closing

DeepSeek shipped a better model without shipping a new price, and that is a real achievement in a year where most improvements arrived attached to a repricing. But the flash tier is now a four-way race that is decided by verbosity and cache discipline rather than by intelligence index, and by that measure 1017 is not the winner on the day it launched. It is the winner for one specific job, long cached agent loops, and it is beaten on cost per completed task by a model from the previous month that costs more per token and spends a third as many of them.

Cheapest token is a marketing claim. Cheapest task is the one worth routing on. The loop-level accounting behind that distinction is in the token economics of agent loops.