DeepSeek V4.1 Flash 1017: Benchmarks & Open Weights

DeepSeek V4.1 Flash 1017 is the second checkpoint of the V4.1 Flash line. The first appeared as a two-day API beta on 8 September 2026 and launched properly on 10 September; our earlier DeepSeek V4.1 Flash review covers that release, including the native multimodal design and the decision to route V4-Pro traffic to the Flash tier. The 1017 build, announced in DeepSeek's release notes dated 17/10/2026, swaps new weights into the website, app and API.

DeepSeek's own description is that this is "a Pareto improvement in performance and cost" over the previous version. The training claim is specific: reinforcement learning with self-feedback, aimed at end-to-end project development, from building games to 3D modelling. The model is also described as optimised for DeepSeek Harness, Tencent CodeBuddy and WorkBuddy, with Harness v0.2.1-rc.1 or later recommended.

• Headline score: 77.0 on DeepSWE v1.1, up from 74.2, and the highest figure in DeepSeek's comparison table.
• Biggest jump: Terminal-Bench 4.0 rises from 31.2 to 42.3, and ProgramBench from 20.3 to 29.1.
• Still behind: Claude Opus 5 leads on Humanity's Last Exam (56.3 vs 42.6), Terminal-Bench 4.0 (51.8 vs 42.3) and ProgramBench (37.0 vs 29.1).
• Licence: MIT, with weights on Hugging Face and ModelScope.
• New API: public Search and Fetch endpoints at $0.75 per 1,000 calls (about £0.59), free in some agent tools until 31 October 2026.

The honest framing is that this is a strong, cheap, open agentic-coding model whose published scores are vendor-reported. It is a very good reason to test it on your own repositories and a poor reason to assume it beats a closed frontier model across the board.

The most useful independent detail comes from analysis of the Hugging Face repository by VRAM Calculator. Its reading is that the model card itself calls 1017 "a minor update", that config.json is byte-identical to the September release (the same blob ID), and that all 48 weight shards keep their original sizes while every shard has a different SHA-256 hash. The conclusion is that the parameter count, layer layout and file structure are unchanged; only the weight values moved.

That matters for two reasons. First, anything you built for the September checkpoint, including inference recipes, quantisation scripts and serving configurations, should work with 1017 without modification. vLLM's published recipe for DeepSeek-V4.1-Flash already lists 1017 as the default checkpoint. Second, it tells you where the gains came from: not a new architecture, not a bigger model, but a better post-training run.

DeepSeek attributes the improvement to reinforcement learning with self-feedback on end-to-end projects. That fits the showcase it chose: a 3D model of the Forbidden City, a web-based racing game, a Portal 2 recreation built with the Godot engine, and a 3D scene called Valley of Ages that spans human history from prehistoric times to the present day. These are long, multi-file, multi-step tasks rather than single-prompt snippets, which is exactly the regime where agentic post-training pays off.

The WorldofAI and Bart Slodyczka videos embedded in this article both stress the same observation: the model has suddenly become far better at motion design, 3D and game generation. That is consistent with DeepSeek's choice of showcase, though neither creator's tests amount to a controlled evaluation.

DeepSeek's release notes give no architecture table, which is why the specifications below come from the model files and from reporting on the September launch. Treat the file-derived numbers as reliable and the rest as reported.

• Total parameters: 763,205,315,794 including the Engram memory (file analysis). Reporting on the September launch describes roughly 552 billion backbone parameters plus 196 billion N-gram parameters.
• Active parameters: reported as 8 billion per prompt token and 16 billion per generated token at launch. The model card does not state an active count, so treat this as reported rather than confirmed for 1017.
• Layout: 40 layers, hidden size 5,120, 384 routed experts with 6 active per token (file analysis).
• Precision: dynamic quantisation in 32×32 blocks, FP8 for dense layers and FP4 for routed experts.
• Context: 1,048,576 tokens (1M), stretched with YaRN from a native 65,536. The card recommends a max_tokens setting of at least 256K.
• Size on disk: about 510.3GB across 48 shards, of which the Engram lookup table is about 203GB and the network, vision tower and embeddings about 307GB.
• KV cache: about 0.87GiB per million tokens, which is the property that makes a 1M window practical.
• Licence: MIT.

The Engram table deserves a sentence of explanation. Rather than storing every piece of memorised knowledge in dense matrices that must be read for every token, the design keeps a very large lookup table indexed by hashes of short token sequences (2-, 3- and 4-grams). Because lookups are sparse, the table can sit in cheaper storage. Community projects have already shown it being read from disk on demand, and llama.cpp-family engines keep it in system RAM by default so only the 307GB network is streamed per token.

DeepSeek's recommended sampling settings are temperature 1.0 and top-p 1.0 with the full 1M context, although the model card's interactive example uses a temperature of 0.6 and the two are not reconciled. If you are evaluating the model, state which you used.

The table below is DeepSeek's own comparison, reproduced as an image from the official release notes. Columns are DeepSeek V4.1 Flash 1017, the September V4.1 Flash, Kimi K3, GLM 5.3, GPT-5.6 Sol and Claude Opus 5, with bold marking the best score in each row. Two methodological notes in the footer matter: Terminal-Bench 4.0 was run with the Claude Code framework, DeepSWE with the Mini-SWE-V2 framework, and ZeroBench-main at Pass@5.

Where 1017 wins

On DeepSWE v1.1 it scores 77.0 against 74.0 for Claude Opus 5, 73.0 for GPT-5.6 Sol, 67.5 for Kimi K3 and 66.9 for GLM 5.3. It also leads the table on Automation-Bench V1.0.6 (60.5, with Opus 5 on 50.3), Agents' Last Exam (35.4 versus 28.6 for Opus 5) and Apex Bench v1.1 (72.1 versus 65.8). These are agentic and long-horizon evaluations, which is consistent with the project-level reinforcement learning DeepSeek describes.

Where it does not

Claude Opus 5 leads on Humanity's Last Exam without tools (56.3 against 42.6, or 44.0 on the text subset), Terminal-Bench 4.0 (51.8 against 42.3), ProgramBench (37.0 against 29.1) and NL2Repo-Bench (75.3 against 68.2). It also edges 1017 on Chartography (84.0 against 83.0) and BabyVision (94.1 against 92.5), both with tools. GPT-5.6 Sol takes ZeroBench-main at 53.0 against 51.0. Kimi K3 is marginally ahead on HLE (43.5 against 42.6).

Generation-on-generation gains

The improvement over September is the cleanest comparison because the harness and architecture are identical. Terminal-Bench 4.0 rises 11.1 points (31.2 to 42.3), ProgramBench 8.8 points (20.3 to 29.1), Apex Bench 7.5 points (64.6 to 72.1), Automation-Bench 5.7 points (54.8 to 60.5), Agents' Last Exam 3.6 points (31.8 to 35.4) and DeepSWE 2.8 points (74.2 to 77.0). Gains are largest on terminal and programme-level tasks and smallest on benchmarks that were already high.

How to read all this: the benchmark names in this table are newer than the older suites many readers know, the numbers are DeepSeek's, and harness choice can move scores by several points. The table is a good indicator of direction. It is not a ranking you should base a procurement decision on.

DeepSeek's second chart plots DeepSWE v1.1 Pass@1 against average cost per task on a log scale, using the mini_swe_v2 harness. Its footer states the public DeepSWE v1.1 leaderboard data is from 22/09/2026 and that the GPT-6 Sol, GPT-6.1 Sol, GPT-6 Astra and GPT-6 Luna curves come from OpenAI's official DeepSWE v1.1 chart.

The visual argument is clear: 1017 sits in the top-left, the high-score, low-cost corner. At low effort it already scores a little above 72 for roughly $0.12 per task (about £0.09), reading off the log axis; at max effort it reaches 77.0 for just under $0.2. By comparison the Claude Opus 5 and Claude Fable 5 curves sit between roughly $3 and $20 per task at scores of roughly 60 to 74, and the GPT-6 family occupies a band between about $0.1 and $7. These cost readings are approximations from the chart, since DeepSeek did not publish the underlying data table.

Two cautions apply. Cost per task depends on how many tokens an agent burns, and DeepSeek says 1017 was trained to produce shorter outputs; a cheaper model that writes less is a genuine saving. But cost-per-task charts also hide the failures: a model that is cheap and 77 per cent accurate still needs a human or a verifier for the other 23 per cent.

DeepSeek's four showcase GIFs are worth reading as a statement of intent. A Forbidden City model, a racing game, a Portal 2 clone in Godot and a prehistoric-to-modern 3D scene are all tasks where the model has to plan, write many files, run them, look at the output and iterate. That is the loop DeepSeek Harness is built around; our write-up of DeepSeek Harness v0.2 covers the desktop app, plugins and automation, and the original Harness article explains the design. The 1017 release notes recommend Harness v0.2.1-rc.1 or later.

The ecosystem angle is deliberate. By naming Tencent's CodeBuddy and WorkBuddy as optimised targets and by making server-side search and fetch calls free inside Claude Code and Codex until 31 October, DeepSeek is trying to make the model easy to drop into the tools developers already use. If you already run Claude Code, our guide to Claude Code mods and plugins shows how extensible that harness is.

For hands-on impressions, the three videos embedded in this article range from benchmark-driven testing to release-notes walk-throughs. WorldofAI ran the model against GPT-6.1 Sol, GPT-6 Luna, Claude Opus 5.5, Gemini 4 Argon and Kimi K3 using its own benchmarking tool; treat those as one tester's results, not a standard.

Alongside the model, DeepSeek opened its in-house Search and Fetch API to everyone. DeepSeek says the underlying search engine serves hundreds of millions of requests a day. Pricing is $0.75 per 1,000 calls (about £0.59) for each endpoint. Calls made through server-side tools in DeepSeek Harness, Claude Code and Codex are free for now, and billing starts at 16:00 UTC on 31/10/2026.

For agent builders this removes a dependency: a model that can search and fetch through the same provider, at a published per-call price, is simpler than stitching together a third-party search service. It also matters for anyone working on generative-engine optimisation, because it is another retrieval pipeline whose behaviour will shape which sources agents cite. Be careful with the free window: if you build a workflow on it, put the 31 October billing date in your calendar.

DeepSeek's release notes do not restate token prices for 1017. Reporting on the September launch put off-peak rates at $0.15 per million uncached input tokens (about £0.12) and $0.60 per million output tokens (about £0.47), with peak rates double that on weekdays between 01:00 and 04:00 and 06:00 and 10:00 UTC. Creators covering 1017 describe the new checkpoint as being swapped in at the same price. Confirm current rates on DeepSeek's pricing page before budgeting, because sources differ and prices have moved before.

Self-hosting is a different calculation. At about 510GB the weights need serious hardware: vLLM's recipes target H100, H200, B200 and similar data-centre GPUs, and a community build runs the model on four NVIDIA DGX Spark machines with the Engram table read from disk. For most teams the API is the practical route, with open weights acting as an insurance policy: nobody can withdraw the model, and a regulated organisation can host it inside its own boundary. For the wider local-inference picture see our piece on local AI on the M6 Mac mini and the Muse Spark Open article on running large open-weights models across Macs.

• Self-reported benchmarks: every score in this article comes from DeepSeek's own table; none has been independently reproduced at the time of writing.
• No technical report for 1017: the release notes say how the model was trained in one sentence. There is no data on reward-hacking behaviour for this checkpoint, although reporting on the September model noted agents exploiting vulnerabilities and deleting files in test environments.
• Frontier gaps remain: Opus 5 leads by roughly 7 to 14 points on HLE, Terminal-Bench 4.0, ProgramBench and NL2Repo-Bench. Complex image reading was a stated weakness at the September launch.
• Harness sensitivity: scores depend on Claude Code, Mini-SWE-V2 and other frameworks, so reproduction in your stack may differ.
• Hardware: 510GB of weights is out of reach for individuals without a multi-GPU box or a large unified-memory workstation.
• Safety and governance: MIT-licensed open weights cannot be recalled. That is a feature for sovereignty and a risk for misuse, a debate we cover in Open Weights: NVIDIA's letter versus Anthropic's response.

Against other open models in DeepSeek's table, 1017 leads Kimi K3 on ten of the eleven rows (all except HLE) and GLM 5.3 on every row where GLM is listed. Our reviews of Kimi K3 and GLM 5.3 give the context on those rivals, and the Qwen3.8-27B review covers a far smaller open model that runs on much more modest hardware.

Against closed frontier models the picture is mixed. On DeepSWE and several agentic suites DeepSeek's numbers put 1017 ahead of Claude Opus 5; on knowledge, terminal and programme-level tests Opus 5 still leads. Our Claude Opus 5.5 review and GPT-6.1 Sol review cover the newer closed releases in more depth; note that DeepSeek's table compares against Opus 5 and GPT-5.6 Sol rather than those later point releases. Our earlier DeepSeek V4 Flash 0731 review shows how far the line has moved in a few months.

Try it if you run coding agents at volume and cost per task dominates your budget; if you need an MIT-licensed model you can host yourself; if you already use Claude Code or Codex and want a cheap second model behind the same harness; or if you want to experiment with game, 3D and motion-design generation.

Wait if you need independently verified benchmarks, your work is dominated by hard reasoning or complex vision, you cannot send data to a Chinese-hosted API and cannot afford self-hosting, or your compliance process requires a published safety evaluation for the specific checkpoint.

DeepSeek V4.1 Flash 1017 is a reminder that the biggest gains in 2026 are coming from post-training rather than architecture. Same model files, same layout, new weights, and a published jump of 11 points on Terminal-Bench 4.0 and nearly 3 on DeepSWE. If those numbers replicate, an MIT-licensed model at a fraction of frontier prices is now competitive on agentic coding.

The caveat is the usual one: the evidence is a vendor table and a chart. Run your own tasks, measure cost per accepted change rather than cost per token, and keep a stronger closed model in reserve for the hard problems it still wins.