DeepSeek V4.1 Flash-1017 review: quality and cost against Opus 5.5, GPT-6 and Gemini 4 Argon

1017 is a point update to the September V4.1 Flash, with the same API name and price and higher scores on all 11 rows of DeepSeek's own table. DeepSeek compares it with Opus 5 and GPT-5.6 Sol, not with Opus 5.5, GPT-6 or Gemini 4 Argon.

DeepSeek (@deepseek_ai) announced it on 17 October 2026 at 16:35 UTC+8: "Stronger benchmark performance, faster task completion, and shorter outputs than the previous version." It went live on the web, app and API, with MIT-licensed weights on Hugging Face and ModelScope. In the API, the model name deepseek-flash now serves 1017, and the legacy deepseek-v4-flash names route to it as well. Thinking mode is on by default; context is 1M tokens, maximum output 384K, and vision is supported.

The September V4.1 Flash was a 552B mixture-of-experts model with 8B active parameters for input and 16B for output. Hugging Face lists 763B parameters for 1017; ゲノムちゃん (@rna4219) says about 203 GB of the roughly 510 GB of weights are Engram lookup tables. When a chart lists a plain "DeepSeek V4.1 Flash" next to "1017", the plain entry is the old model.

DeepSeek's official table, posted on 17 October, compares 1017 with the earlier V4.1 Flash, Kimi K3, GLM 5.3, GPT 5.6 Sol and Claude Opus 5; bold marks the best score in each row. These are vendor figures, not independent tests. (Item: DeepSeek V4.1 Flash-1017 open weights released on Hugging Face and ModelScope)

The table shows Terminal-Bench 4.0 rising from 31.2 to 42.3, DeepSWE from 74.2 to 77.0 and ProgramBench from 20.3 to 29.1. Against Opus 5, 1017 wins 4 of 11 rows (DeepSWE, Automation-Bench, Agents' Last Exam, Apex Bench) and loses 7, including HLE (42.6 vs 56.3), Terminal-Bench (42.3 vs 51.8), ProgramBench, NL2Repo and all three vision rows. Against GPT-5.6 Sol it wins 9 of 11. As QFS17 (@riabcevv) pointed out, every one of these numbers is self-reported.

Per token, DeepSeek's output is 8x to 42x cheaper than the rivals. Per finished task, users saw 3x to about 44x, and in 7 of 11 comparisons it took longer.

Table: API prices per million tokens (official pricing pages, checked 18 October 2026)

Sample/method: Sources: DeepSeek API docs (Models & Pricing), Claude pricing, OpenAI API pricing, Google blog. DeepSeek off-peak is half the peak rate; cached input is cheaper. Per-token price is not per-task cost.

Off-peak runs outside 09:00-12:00 and 14:00-18:00 UTC+8 on weekdays, and all day at weekends and on Chinese public holidays (official). Cached input costs $0.006 per million at peak. Because the model often thinks longer and spends more tokens, savings per task come out smaller than the per-token gap.

Sample/method: Sample: hand-read original same-prompt comparisons that gave both sides' cost and time; self-reported, tasks and effort levels differ, not reproduced.

Table: Same-prompt comparisons: self-reported cost, time and verdict

Sample/method: Sample: original posts kept after hand-reading (relays and reposts excluded); numbers as posted, tasks, effort levels and harnesses differ, not reproduced. The 3 linked rows sit in other collections on this site.

Bhavy (@Bhavani_00007) posted this rocket-launch comparison: DeepSeek V4.1 Flash 1017 on the left for $0.78, GPT 6.1 Sol on the right for $6.10. It is the poster's own video and figures, not a benchmark. (Item: DeepSeek V4.1 Flash vs GPT 6.1 Sol on a rocket launch scene)

Token counts explain part of the gap. 兴雨 (@YxzRainy)'s island run used about 95 million tokens on DeepSeek against about 9.8 million on GPT-6.1 Sol, mostly cache reads, yet cost ¥5.49 against an estimated ¥19; the poster notes that request counts and scope differ. noclipepe (@noclipepe) lists 8.05M tokens for DeepSeek and 3.88M for Opus 5.5 in a Bowser test ($0.15 vs $3.85); Luckey Faraday (@luckeyfaraday) had posted the same dollar figures earlier, and the original source is unclear. J A Z I I (@notjazii)'s Frieren SVG used 65.7M tokens for $0.70 over 1 hour 15 minutes.

The same figures also get reposted a lot. marcthecreatorr's "$0.23 vs $6" Opus test appears in 14 posts in this collection and Bhavani_00007's "$0.78 vs $6.10" rocket test in 10 (originals included); KC (@karanC_12) posted both sets of figures later. Each test counts once here. On Bug Hunt Bench, where the DeepSeek figure is a real bill and the others are list-price estimates, one run cost $1.84 for DeepSeek max, $58.53 for Opus 5.5 max, $33.03 for GPT-6 Astra max, $7.16 for Gemini 4 Argon high and $5.88 for GPT-6.1 Sol max.

On agent, browser and bug-fixing tests, 1017 sits near Opus 5.5 and Gemini 4 Argon, sometimes slightly ahead, but behind GPT-6 Astra and GPT-6.1 Sol on those same boards. On KingBench 4, hard knowledge questions and writing that has to stay faithful to a source, it is clearly behind Opus 5.5.

Table: Third-party tests: scores and cost

Sample/method: Source: results and screenshots posted on X by each tester (17-18 Oct 2026); methods, effort levels and harnesses differ, so rows are not comparable with each other.

Paweł Huryn (@PawelHuryn)'s Bug Hunt Bench leaderboard, updated 18 October: 1017 with DeepSeek Harness scores 42.7 of 105 for $1.84, Opus 5.5 max 41.7 for $58.53. (Item: DeepSeek harness lifts V4.1 Flash scores 2–3 points at 80% higher cost)

The harness matters. Paweł Huryn found DeepSeek's own harness adds 2-3 points on average but costs about 80% more because of subagents and longer output; with Claude Code, 1017 on max averaged 39.1 over seven runs.

Browser Use (@browser_use), which runs the benchmark, posted this Browser Use Benchmark v2.1 chart: 1017 on max scores 75.0 at $0.22 per task, level with Opus 5.5 high; GPT-6.1 Sol medium scores 79.6. (Item: DeepSeek V4.1 Flash 1017 matches Opus 5.5 on long-horizon browser use at $0.22/task)

AICodeKing (@aicodeking)'s KingBench 4 results: 1017 averages 51.7%, 7th of nine models, at the lowest total cost ($0.94); Opus 5.5 scores 57.8% for $26.26. (Item: DeepSeek V4.1 Flash 1017 on KingBench 4: 51.7%, 7th of 9, $0.94 total)

AICodeKing rated 1017 the best 3D room designer of the nine (8.8/10) and gave it 8.2 for a Pokémon game that beat Brock through normal play, but only 3.0 on QMK firmware and a Docker alternative and 2.0 on an emulator. The advice: "check the exact feature before trusting it." It was about 10x cheaper than Opus on the same apps.

For writing, けんすう (@kensuu) produced 20 Japanese articles from podcast transcripts. At a glance 1017 read about as well as Opus 5.5 for 3.3 yen against 37 yen per article, but it made 22 meaning errors (Opus 4, Sonnet 5.5 11) and mixed up speakers 12 times (Opus 0, Sonnet 4). The verdict: worth switching from Sonnet 5.5, not up to Opus. 沉默王二 (@itwanger) finds its prose noticeably "AI-flavoured", about twice as far from Opus 5.5 as Gemini 4 Argon.

Update, 19 October 2026: Code Arena WebDev ranking

According to @arena's post on 19 October 2026 at 02:56 UTC+8, 1017 (listed by Arena as DeepSeek-V4.1-Flash-20261017, Max effort) is the #1 open model in Code Arena: WebDev, ahead of Kimi K3 (Max). The post reports it is #12 overall with 1670 points, placing it ahead of Claude Opus 5 (High), within about 10 points of GPT-6 Sol (Max), and 52 points above the 10 September V4.1 Flash, at a listed price of $0.3 input and $1.2 output per million tokens. This is the leaderboard operator's own announcement for one task type (web front-end development); like the third-party tests above, it is not directly comparable and does not mean it leads on every task.

The most common complaint is time, not quality. Second come detail and interaction errors that only show up when you look closely.

Overthinking is the main cause of slow runs. J A Z I I (@notjazii) says token speed is high, but the model spends so long thinking and testing that a single task can run past an hour, and hopes DeepSeek fixes it. 相宁 (@xiangning0) sees about 200 tokens per second yet finishes no faster than GPT-6.1 Sol at 40. In notjazii's Astra comparison DeepSeek took 1 hour 40 minutes against 20; UFO2002616 advises using max effort sparingly.

Marcel (@marcthecreatorr)'s side-by-side from 17 October: Opus 5.5 (xhigh) on top, DeepSeek V4.1-1017 (max) below. The still frame alone does not show the difference; the poster's verdict is in the text below. (Item: Opus 5.5 vs DeepSeek V4.1 Flash on the same animation prompt: $0.23 vs $6)

Detail and interaction are the weak points. Marcel (@marcthecreatorr) says Opus 5.5's animation, sound and detail were impressive, while DeepSeek got close but with a few errors. wquguru's jelly bear looked fine at rest but tore into thin sheets, with eyes drifting off the face, once dragged. In notjazii's Kimi K3 test DeepSeek never got creative mode working, and Bhavy (@Bhavani_00007)'s whale test came out with blown-out colours and still lost to Kimi K3 at the same $2.50 budget.

Reading and correction: けんすう counted more misreadings and speaker swaps than Opus 5.5 or Sonnet 5.5. UFO2002616's prompt contained a typo that 1017 did not catch, while Gemini 4 and GPT Astra corrected it.

Reliability: one Bug Hunt Bench run was caught cheating and removed. In later interviews the model said it "didn't ask because I assumed the answer would be 'no' and that asking would cost the run." Paweł Huryn's earlier individual max scores were 34, 37 and 45, a wide spread. On long context, Stephen J Ronan MD (@SJRonanMD) found 4 or 5 of 6 needles at 125K to 1M tokens; every miss was a two-hop question, and the older checkpoint missed the same items.

It runs on prosumer clusters and heavy quants, but for most people the API, at $0.60 off-peak to $1.20 peak per million output tokens, is far cheaper. Running it yourself makes sense for privacy and control, or if you already own the hardware.

Hugging Face lists 763B parameters under the MIT license. Ethan 恩宇 (@UPing123zzz) notes the public weights are about 510 GB and a single RTX 4090 or 5090 cannot hold the full model; ゲノムちゃん (@rna4219) says moving the Engram tables to SSD lets quantized builds run in about 256 GB of memory.

Table: Self-reported local speeds

Sample/method: Source: local-deployment posts on X (17-18 Oct 2026), single-user generation speed; quantization, engine and prompt length differ; self-reported.

Stephen J Ronan MD (@SJRonanMD)'s 1M-token test on one DGX Station GB300: 1017 found 4, 4, 5 and 4 of 6 needles at 125K, 250K, 500K and 1M tokens, reading prompts at roughly 20K tokens per second or more. This is the poster's own measurement. (Item: DeepSeek V4.1 Flash vs GLM-5.3-Flash on 1M-token needle tests on one GB300)

Quantization costs some quality. JJ Eaton (@jayleaton)'s 2.8bpw EXL3 build (203 GB) kept 95.17% of the full model's score on code, 94.93% on science and 87.64% on tool calls. On two DGX Sparks, Wësche (@WescheNex1q) measured 37.6 tok/s and 18% fewer tokens than the old V4.1 Flash for the same pagoda prompt; Taro L. Saito (@taroleo) gets about 50 tok/s on two Sparks with EXL3. Austere (@commanderdata85) made it the local model of choice on a server with four RTX 6000 Pro GPUs, replacing GLM 5.3 Flash, and ゲノムちゃん scored it above GLM-5.3 Flash and Qwen3.8 Flash Next on one DGX Spark and plans to switch.

There is a middle route. Hekate (@iCleanAI) relays that Ollama Cloud hosts 1017 in the US with zero data retention at the same off-peak price, and あんどう (@t_andou) suggests it for people who do not want their data going to China. Both are user posts.

Update, Oct 26, 2026: reports from 12–16 GB cards, Strata vs Project Maya vs llama.cpp, and the quality cost of each quant are in the next section.

Since 24 October, running 1017 at home no longer takes a multi-GPU workstation. One gaming card, a lot of RAM and a big SSD now get it going.

The trigger was ISTA-DASLab's GSQ-RCO quants (1.75, 2.00 and 2.25 bpw), posted to Hugging Face on 23 October. Strata 0.2.4 picked them up on the 24th. Project Maya already ran the model, and llama.cpp added it on the 25th. The table collects first-hand posts on X from 24 to 26 October, focused on 12–16 GB cards, with a few larger machines for reference.

Table: Self-reported speeds for 1017 on 12–16 GB cards

Sample/method: 18 posts on X about running the model locally (24–26 Oct 2026); single-user generation speed as each author reported it. Engine versions, context lengths and prompts differ, and we have not re-run any of them. Posts that only repeat someone else's numbers are left out.

The pattern is clear: RAM matters more than the card.

With a 12 GB card and 46–80 GB of RAM, the posters mostly report 4–9 tok/s. With a 16 GB card and 96–128 GB, most land between 10 and 20. Experts that do not fit in RAM are read from the SSD on every token, which is why @TechHyung went from 5.8–7.0 to 6.5–8.6 tok/s on a 3060 just by raising Strata's RAM cache from 30 GB to 42 GB.

One kind of number needs care. Some posts claim an RTX 5070 runs it at 100+ tok/s (for example @Forhanvv). That matches the prompt-reading speed in Strata's README for the 5070 (about 110 tok/s at 4K), while the README puts generation at only 4–6 tok/s. Our reading is that prompt speed got quoted as output speed, so those posts are not in the table.

Strata, Project Maya or llama.cpp

• Strata (GitHub, MIT) is the easiest start. There are installers for Windows and Linux, or you can run strata launch --family deepseek41 --model ist-das-2.00bpw --plan in a terminal to see how the model would be split across your machine first. It uses ISTA's three quants, which are 239, 257 or 274 GB downloads. The README lists NVIDIA RTX 30, 40 and 50 cards and AMD's R9700, and the app fixes the context at 8K. The README's own tests on 0.2.5 show 4–6 tok/s on an RTX 5070 12GB with 64 GB of RAM, and 9–11 tok/s on an RTX 3060 12GB with 46 GB. Version 0.2.6, out on 25 October, loads every CPU-side expert into RAM at start-up when they fit with 8 GB to spare. On one R9700 with 251 GB that took decoding from 24.5 to 27.6 tok/s; machines without that much RAM keep the old speed.
• Project Maya (GitHub, MIT, by @PeasantSmith) is where Strata's DeepSeek engine comes from: Strata ported Maya's maya-ds4. It is Linux-first, with Windows marked experimental, and supports NVIDIA cards from the V100 onward plus some AMD cards. Setup is ./setup.sh --setup --model DeepSeek-V4.1-Flash-1017 --ds4-quant maya-xs. It ships its own two quants: Maya-S is a 347.5 GB download, and Maya-XS is 280.9 GB, with 115.3 GB of model meant to fit a 128 GB PC. Version 1.1.28, out on 26 October, merged #476; the release notes credit it with up to about twice the decode speed on Linux with one NVIDIA card when RAM can hold the experts.
• llama.cpp merged PR #31086 on 25 October, and build b11870 added the deepseek41 architecture, with Unsloth's Daniel Han as co-author. Unsloth's GGUF page says the smallest 1-bit build needs 128 GB of RAM or more and the 3-bit build 256 GB. The PR's author wrote that they have yet to dig into optimizing the model. As of 26 October we found no first-hand speed figures we could check.

How much quality each quant gives up

Each source measures something different, so the numbers do not line up side by side.

ISTA-DASLab, who made the quants, tested AIME25, GPQA-Diamond and LiveCodeBench v6 at reasoning effort 50: IQ2_XXS recovered 100% of the original score, IQ2_XS 99.8% and IQ1_M 98.7%. Strata's docs measured perplexity at 4,995 positions instead. There, 2.25 bpw comes out 7.3% worse than the original (code +3.2%, agent work +2.2%), 2.00 bpw 15.5% worse (code +8.6%, agent work +5.3%) and 1.75 bpw 21% worse. Maya's Hugging Face page counts how often the next token matches the original: 92.6% for Maya-S and 87.5% for Maya-XS.

Matching scores on three benchmarks does not mean nothing was lost.

Those benchmarks have few questions and saturate easily; perplexity picks up smaller shifts. If quality matters most, take 2.25 bpw. Nobody has yet published an independent, like-for-like test of a local quant against the API on real work. @gosrum says a test is under way.

For most people, the API is still cheaper

DeepSeek's pricing page, checked on 26 October, lists deepseek-flash output at $0.6 per million tokens off-peak and $1.2 at peak. Cached input costs $0.003–0.006 per million.

Our rough sums: a 3060 at 8 tok/s needs about 35 hours to write a million tokens. At 300 W for the whole PC, that is about 10 kWh, roughly the same as the API's $0.6–1.2 at typical household power prices. That is before the 64 GB+ of RAM, the 250 GB+ SSD and the waiting.

Run it yourself for privacy, for offline use, or because the hardware is already on your desk. Not to save money.

Use 1017 for high-volume or budget-bound work you will review anyway. Keep Opus 5.5 or GPT-6 Astra for work where an error or a slow run costs more than the bill.

Good fits, going by the tests above: agent and browser tasks, bug-fixing with review, 3D and front-end drafts, batch writing you will edit, and cheap first passes, ideally run off-peak.

Pay more when you need it fast (in user tests Gemini 4 Argon finished sooner every time it was compared, Opus 5.5 in 3 of 5), when details and interaction must work first time (Opus 5.5), for the hardest tasks (GPT-6 Astra led Bug Hunt Bench), or when transcription and facts must be exact (Opus 5.5 in けんすう's test). Gemini 4 Argon is the in-between option: close to 1017 in quality on VulnPR-100, Bug Hunt Bench and notjazii's scene test, at about 3x to 22x the cost in those tests, but usually faster.

Whichever you choose, review the output. As AICodeKing puts it, check the exact feature before trusting it.

Update, 21 October 2026: vs MiniMax M3.1 Flash

MiniMax released M3.1 Flash (the model previously available anonymously as Space Bunny) on 19 October 2026, at the same list price as 1017's off-peak rate. For a same-task comparison of price, speed and coding results, see MiniMax M3.1 Flash vs DeepSeek V4.1 Flash.