DeepSeek V4.1-Flash-1017: What Changed, and the Memory It Takes Locally

DeepSeek released DeepSeek-V4.1-Flash-1017 on 17 October 2026. It replaces the September V4.1-Flash on DeepSeek’s website, app and API, and its weights are on Hugging Face under the MIT licence. Within a week it was the most-trending model on the site.

This guide covers what actually changed, what it takes to run the weights on your own hardware, and when the API is the more sensible route. BFWR has not run this model. Benchmark figures are DeepSeek’s own, file sizes are read from the repositories, and the hardware fits are computed from our own database.

Quick answer

• What it is: new weights for the same model. DeepSeek calls it “a minor update to” V4.1-Flash, and the configuration, tokenizer and inference code are byte-identical to the September release.
• Size: 763 billion parameters and 510.3 GB of official weights. It is a Mixture-of-Experts model with a 1-million-token context and image input.
• Running it locally: the smallest community file is 233 GB, and 122 GB of it must sit in memory even with the rest left on the SSD. In practice that means a Mac Studio with 192GB or more, or a multi-GPU server.
• Software: no mainline support in llama.cpp yet, and Ollama offers it only as a cloud model. vLLM supports it.
• API: deepseek-flash now serves 1017 at the same price as before, $0.30 per million input tokens at peak and half that off-peak.

What changed in 1017

DeepSeek’s model card describes the release as “delivering substantial improvements across reasoning, coding, agentic tasks, and visual benchmarks”, and says it also shortens task execution time and output length. Its change log says the same thing and names the harnesses it was tuned for: “We specifically optimized for DeepSeek Harness, Tencent CodeBuddy, WorkBuddy, and other platforms.” DeepSeek gives no figure for how much shorter or faster the outputs are.

The card’s benchmark table compares 1017 with the September checkpoint. These are DeepSeek’s numbers, not independent results:

The card does not say which reasoning effort or sampling settings produced these scores. The September card said its results used the maximum effort setting, so treat the comparison as indicative.

What did not change

The files tell a clear story. config.json, the tokenizer and the reference inference code are identical in the two repositories. Both ship 48 weight shards with the same names and the same total of 510,296,708,312 bytes, but none of the 48 has the same contents. So this is the same architecture with retrained weights, which is also how vLLM’s maintainers describe it.

That matters for running it: anything that already supported the September V4.1-Flash supports 1017 with a new download, and none of the memory arithmetic changes.

The architecture in brief

The 1017 card does not restate the architecture, so these details come from the September card, which still applies because the configuration is identical:

• 763 billion parameters in total. The oMLX project’s breakdown splits that into a 551.9B language backbone, 196.6B of “Engram” n-gram lookup tables, a 0.5B vision encoder and a 14.2B draft model for speculative decoding.
• Few active parameters. DeepSeek says the model activates 8B parameters per token during prefill and 16B during decoding, using 384 routed experts plus one shared expert, with 6 routed experts per token.
• A small KV cache. DeepSeek puts it at 890 bytes per token, which keeps long contexts affordable. The context window is 1,048,576 tokens.
• A mixed native format. The official checkpoint stores dense weights in FP8 and the routed experts in FP4, which is why it is “only” 510 GB rather than the 1.5 TB that 763B parameters at 16 bits would take.

Can you run it locally?

Yes, but only on large machines, and not with the usual tools yet.

The official repository is not a GGUF file and does not load in Ollama or LM Studio. Its own inference code runs tensor-parallel across several GPUs. For a single machine, unsloth publishes GGUF quantizations. Their important property is that the Engram tables do not have to be in memory: unsloth’s guide says “Engram’s 110.6–202.8 GB table can stay on SSD via mmap”, loading rows on demand. So each file splits into a part that can stay on disk and a part that cannot:

Two things stand out. Q4 and Q8 are almost the same size, because unsloth keeps the experts in their original FP4 form in both and the labels describe only some of the tensors. And unsloth’s guide says its estimates “allow roughly 5–10 GB above non-Engram weights”, before any context.

Which machines hold it

Taking the in-memory part plus 10 GB, and comparing it with the GPU-usable memory the BFWR hardware database assumes (on Macs, the default 75% of RAM):

• 1-bit (UD-IQ1_S, about 132 GB needed): Mac Studio M2 Ultra 192GB, M5 Ultra 256GB and 512GB, and M3 Ultra 512GB.
• 2-bit (UD-IQ2_XXS, about 175 GB): Mac Studio M5 Ultra 256GB, and the two 512GB models.
• 3-bit and 4-bit (233.5 to 297.9 GB in memory): only the 512GB Mac Studios (M5 Ultra and M3 Ultra).
• 128GB machines such as the DGX Spark, a Strix Halo box or a 128GB MacBook Pro: unsloth’s card says the 1-bit file needs “a 128GB+ RAM device”, but its in-memory part alone is 122.4 GB. That leaves almost nothing for the operating system or context, and it exceeds the GPU-usable memory of all three, so treat it as an experiment, not a setup.

On a 512GB Mac Studio the GPU limit can be raised further; our Mac VRAM optimizer explains how. On NVIDIA hardware, vLLM’s recipe says “8×80 GB is the smallest NVIDIA node that serves this checkpoint”, and only with the Engram tables moved to host memory.

The software gap

• llama.cpp: support is not merged. The pull request that adds it, ggml-org #30817, was still an open draft on 24 October. unsloth’s files need its own llama.cpp build or that pull request.
• Ollama: the library lists only deepseek-v4.1-flash:cloud and deepseek-v4.1-flash:1017-cloud. Both run on Ollama’s servers, not yours, so they are not a local option.
• vLLM: supported in releases from 0.31.0, and its recipe now defaults to the 1017 checkpoint.
• MLX: mlx-community publishes conversions made with oMLX, from 313.27 GB (oQ2e) to 432.03 GB (oQ4e).

We found no published speed measurement for 1017 on a single machine, so this guide gives none. Our experience with other new architectures, such as Qwen3.8-Flash-Next, is that early local builds run well below what memory bandwidth alone would predict.

Settings DeepSeek recommends

• Two modes: thinking, the default, and chat, which skips the reasoning block.
• Reasoning effort is a number. The encoding notes say “Reasoning effort is a numeric budget (1–100)”, with low mapped to 50, high to 75 and max to 100. The default is high.
• Sampling: the card recommends temperature 1.0, top_p 1.0 and a maximum output of at least 256K tokens.

Or use the API

For most people the API is the realistic way to use this model. DeepSeek’s change log says “The API calling method and pricing remain unchanged — simply use deepseek-flash to access the latest model.” On the pricing page, read on 24 October, deepseek-flash is listed as DeepSeek-V4.1-Flash-1017:

Peak hours are 01:00–04:00 and 06:00–10:00 UTC on weekdays, and the footnote now adds “excluding Chinese public holidays”, which count as off-peak in full. Two other things are new on the page: Search and Fetch APIs at $0.75 per 1,000 successful requests, and server-side tool calls that are free for now, with the page noting “per-request billing starts at 00:00 Beijing time on November 1, 2026.”

At these rates, a 233 GB download and a five-figure Mac only make sense if the data cannot leave your machine. Our DeepSeek API pricing vs local guide works through the break-even, and the API pricing calculator compares it with other providers.

The licence

The weights are MIT-licensed and ungated, as the earlier V4 releases were. You can download, modify and use them commercially without a revenue threshold or an attribution clause. That is less common than it sounds among very large open models: Qwen3.8-Flash-Next carries a community licence with conditions, while GLM-5.3-Flash is also MIT.

FAQ

Is DeepSeek V4.1-Flash-1017 a new model?

No. It is a new checkpoint of the same model, with identical configuration and file layout and retrained weights. DeepSeek calls it a minor update.

Can I run it with Ollama?

Not locally. Ollama lists it only as a cloud model. Locally you need unsloth’s GGUF files with its llama.cpp build, vLLM on a multi-GPU server, or an MLX conversion on a large Mac.

Will it run on a 128GB machine?

Probably not usefully. Even the 1-bit file needs about 122 GB in memory with the Engram tables left on the SSD, which is more than the GPU can address on a DGX Spark, a Strix Halo box or a 128GB Mac.

Did the API price change?

No. DeepSeek moved deepseek-flash to the 1017 checkpoint without changing any price.

Related guides and tools

• DeepSeek API pricing vs running it locally
• How to run GLM-5.3-Flash locally, another very large MIT model
• Meta Muse Spark Open locally, the other giant open release of October
• Best Mac for local LLMs
• Open model directory, including the frontier models too large for the main list

Sources

• DeepSeek-V4.1-Flash-1017 on Hugging Face (model card, config, encoding notes) and the September V4.1-Flash card
• DeepSeek API change log and pricing page
• unsloth GGUF files and unsloth’s guide
• llama.cpp pull request #30817
• vLLM recipe
• Ollama library tags
• mlx-community oQ4e conversion (parameter breakdown)

Updated 24 October 2026. Files, prices and support status were read on that date; the hardware fits are computed from the BFWR hardware database.