DeepSeek V4 Flash 0731 284B
DeepSeek V4 Flash 0731 284B doesn't use the standard quantization ladder — it ships as fixed builds needing 92.5 GB at UD-IQ1_S or 108.5 GB at UD-Q2_K_XL or 116.6 GB at UD-IQ3_XXS or 173.8 GB at UD-Q4_K_XL or 181.4 GB at UD-Q8_K_XL. 11 GPUs we track can run at least one build fully in VRAM at 8k context.
11 GPUs run this natively · 3 with CPU offload
- UD-Q2_K_XL total
- 108.5 GB
- at 8k context
- Smallest GPU
- 128 GB
- NVIDIA DGX Spark (128GB), at UD-Q2_K_XL
- KV cache, full context
- 9.2 GB
- 43 layers cache, ~10× fewer entries than tokens
- Inputs
- Text
- MIT, released July 2026
- MoE routing
- 6 of 256 experts
- 13B of 284B active per token
- Reasoning effort
- low / high / max
- high by default; moves scores and token spend
DeepSeek V4 Flash 0731 284B is a Mixture of Experts (MoE) model with 284B total parameters but only 13B active per token developed by DeepSeek. Published July 31, 2026 under MIT, this is the checkpoint that turns DeepSeek V4 Flash from a preview into a release. Nothing about its shape changed, so its model size and VRAM requirements are identical to the preview's: 284B total parameters with 13B active, 43 layers, 256 experts routing 6 per token, a 1M-token context window and 384K maximum output, exactly as in the April preview. What changed is post-training, aimed squarely at agents, plus a DSpark speculative-decoding draft head bolted onto the output — the reason HuggingFace's page reports 304B where DeepSeek, OpenRouter and Artificial Analysis all say 284B. Attention is the hybrid the V4 family introduced: Compressed Sparse Attention layers fold every four token positions into one cached entry and attend sparsely over the result, Heavily Compressed Attention layers fold 128 positions into one and attend densely over the much shorter history, and both keep a 128-token uncompressed window so recent tokens stay at full resolution. Reasoning effort is selectable at low, high, or max.
To run DeepSeek V4 Flash 0731 284B locally: The short answer on VRAM requirements: about 96GB for the build most people should run, and roughly 82.5GB as the absolute floor. This is the rare frontier-scale MoE with a genuine local story, and the reason is the attention stack rather than the weights. Because CSA and HCA store roughly one cache entry per ten token positions, a completely full 1M-token context costs about 9GB of KV cache — an all-attention model of the same shape would want ten times that, and the cache would dominate the footprint instead of rounding off it. The weights are the binding constraint, and they do not shrink the way a normal model's do: DeepSeek stores the routed experts, about 96% of the parameters, natively in MXFP4, so Unsloth's GGUF builds repack those tensors bit-for-bit rather than requantizing them. Real downloads run 82.5GB at UD-IQ1_S to 161.9GB at UD-Q8_K_XL, and that top build is lossless rather than merely good — there is no 500GB FP16 download to avoid, and no 40GB build to hope for. In practice the hardware requirement is a 128GB unified-memory machine running UD-Q2_K_XL, and the best GPU for the job is whichever of those has the most bandwidth: a 128GB Mac Studio, an M4 Max or M5 Max MacBook Pro, an NVIDIA DGX Spark, or an AMD Strix Halo mini-PC all clear the capacity bar, while a 256GB or 512GB M3 Ultra Mac Studio adds both headroom for the larger builds and roughly three times the memory bandwidth of a Spark. No single consumer GPU qualifies — an RTX 4090 (24GB), RTX 5090 (32GB) or RTX PRO 6000 (96GB) cannot hold the weights and KV cache together — so the multi-GPU route means pooling VRAM across several cards or offloading the expert tensors to system RAM. Expect bandwidth-bound throughput in the low tens of tokens per second on that class of hardware: one write-up reports roughly 6 tok/s on a 128GB GB10, and another 20-30 tok/s from a ~104GB build spread across five RTX 3090s. As a MoE model, inference speed depends on active parameters (13B) rather than total size.
The agentic jump is the story, and it is unusually large for a re-post-train. On DeepSeek's own nine-benchmark table the 13B-active Flash now beats the 49B-active DeepSeek V4 Pro preview on all nine — worth dwelling on, since V4 Pro is a 1.6T model that needs an order of magnitude more memory to run: DeepSWE went from 7.3 to 54.4, Cybergym from 38.7 to 76.7, DSBench-Hard from 25.8 to 59.6, and Terminal-Bench 2.1 from 61.8 to 82.7. Artificial Analysis independently scores it 50 on its Intelligence Index — ten points above the preview, one point behind GPT-5.6 Luna at max effort — with GPQA Diamond 91 and Humanity's Last Exam 37. Read the coding and terminal numbers with the usual harness caveat: DeepSeek's 82.7 on Terminal-Bench 2.1 is its own run, and Artificial Analysis's independent pass on the same suite lands at 79. Two things temper the enthusiasm. It takes text only — there is no image path, and the request thread on the repo asking for one is still open. And the headline pricing that makes it interesting as an API (roughly $0.09-$0.14 per million input tokens) is the thing you give up by running it yourself.
DeepSeek V4 Flash 0731 VRAM at 1M context: 9 GB of KV cache, not 92 GB
On most models, long context is where a local setup falls apart: the KV cache grows with every token, and at a million tokens it dwarfs the weights. That is normally what puts a 1M-context model out of reach of consumer hardware, whatever its parameter count. DeepSeek V4 attacks the problem from an unusual direction. Most efficient-attention designs make each cached entry narrower — fewer KV heads, or a compressed latent. V4's Compressed Sparse Attention and Heavily Compressed Attention instead make the cache shorter, by folding runs of token positions into a single entry before storing anything: four positions per entry in the CSA layers, 128 in the HCA layers, with a 128-token uncompressed window kept at both so recent tokens stay sharp.
KV cache only, at FP16. Weights and activation overhead sit on top of these figures.
Filling the entire 1,048,576-token window costs about 9.2 GB of KV cache. The same stack storing one entry per token would want 92.3 GB — more than the weights themselves, and enough to put the advertised context out of reach of any machine that could hold the model. That ratio is not this site's estimate: DeepSeek publishes V4-Pro at 10% of DeepSeek V3.2's KV cache at 1M context and V4-Flash at 7%, and those two figures agree on the same underlying 10x compression once you account for Flash's 43 layers against V3.2's 61. The practical consequence for anyone sizing hardware is that context here is nearly free once you have paid for the weights. Going from an 8k session to the full million-token window moves the UD-Q2_K_XL total from 108.5 GB to 118.8 GB — a 10 GB difference, where a conventional 284B model would have needed a different class of machine entirely to reach the same window.
Available builds
DeepSeek V4 Flash 0731 284B skips the standard FP32–Q2_K quantization ladder entirely — it ships as 5 fixed, downloadable builds instead. Sizes below assume 8k of context.
| Build | Bits/weight | Weights | KV cache | Total | Quality vs FP16 |
|---|---|---|---|---|---|
| UD-IQ1_S | 2.32 | 82.5 GB | 0.07 GB | 92.5 GB | — |
| UD-Q2_K_XL | 2.73 | 96.8 GB | 0.07 GB | 108.5 GB | — |
| UD-IQ3_XXS | 2.93 | 104.0 GB | 0.07 GB | 116.6 GB | — |
| UD-Q4_K_XL | 4.37 | 155.1 GB | 0.07 GB | 173.8 GB | ~96.3%* |
| UD-Q8_K_XL | 4.56 | 161.9 GB | 0.07 GB | 181.4 GB | ~100%* |
*Vendor-reported on the vendor's own benchmark suite — not yet independently verified by a third-party leaderboard. KV cache figures assume 8k context at FP16.
Benchmarks
Estimated, not measured: derived from the base model's real score times the best build's vendor-reported quality retention (see the chart above) — not independently verified, and not a leaderboard result for DeepSeek V4 Flash 0731 284B itself.
DeepSeek V4 Flash 0731 benchmarks: a 13B-active model near the top of Terminal-Bench
Terminal-Bench 2.1 measures agentic work in a real command line, and it is the benchmark the 0731 re-post-train moved most: from the preview's 61.8 to 82.7, without changing a single architectural parameter. Plotted by total size against the other open-weight models tracked here that report it, V4 Flash sits second, below Kimi K3 — a model roughly ten times its total size — and above everything else, including releases with four times its parameters. Only 13B of those 284B parameters are active per token, so the compute gap is wider still than the horizontal axis suggests. Worth holding lightly: 82.7 is DeepSeek's own run, and Artificial Analysis's independent pass on the same suite scores it 79.
GPUs that run DeepSeek V4 Flash 0731 284B natively (11)
- NVIDIA DGX Spark (128GB)UD-IQ3_XXS · 11.1 t/s
- AMD Instinct MI300XUD-Q8_K_XL · 139.1 t/s
- AMD Strix Halo (128GB)UD-IQ3_XXS · 10.4 t/s
- Apple M5 Max (128GB)UD-IQ3_XXS · 30.8 t/s
- Apple M4 Max (128GB)UD-IQ3_XXS · 27.4 t/s
Show 6 more
- Apple M3 Ultra (512GB)UD-Q8_K_XL · 26.4 t/s
- Apple M3 Ultra (256GB)UD-Q8_K_XL · 26.4 t/s
- Apple M3 Max (128GB)UD-IQ3_XXS · 20.1 t/s
- Apple M2 Ultra (192GB)UD-Q8_K_XL · 25.8 t/s
- Apple M1 Ultra (128GB)UD-IQ3_XXS · 40.1 t/s
- Intel Data Center GPU Max 1550UD-IQ3_XXS · 133.6 t/s
Plus 3 GPUs that run it with CPU offload (slower)
- NVIDIA H100 80GBUD-IQ1_S · 21.9 t/s
- NVIDIA A100 80GBUD-IQ1_S · 20.4 t/s
- NVIDIA RTX Pro 6000UD-IQ3_XXS · 10.5 t/s
Notes
The official DeepSeek V4 Flash release, superseding the April preview checkpoint. Architecturally identical to it — 284B total parameters / 13B active, 43 layers, 256 experts with 6 routed per token, hybrid Compressed Sparse Attention and Heavily Compressed Attention, a 1M-token context window and 384K max output — so the VRAM requirements are unchanged and every gain here comes from re-post-training for agentic work, not from a new design. On DeepSeek's own nine-benchmark agentic table the 13B-active Flash now beats the 49B-active V4-Pro preview on all nine, with the largest jumps on DeepSWE (7.3 to 54.4), Cybergym (38.7 to 76.7) and Terminal-Bench 2.1 (61.8 to 82.7). Artificial Analysis scores it 50 on its Intelligence Index, ten points above the preview and one behind GPT-5.6 Luna (max). Reasoning effort is selectable at low/high/max and materially moves both scores and output-token spend. The checkpoint stores its routed experts — about 96% of the model — natively in MXFP4 and everything else in FP8 or BF16, so it does not have a conventional quantization ladder; see the build table on this page.
How to run DeepSeek V4 Flash 0731 284B locally
llama.cpp (Unsloth dynamic GGUF, DeepSeek's own sampling)
./llama-server \
-hf unsloth/DeepSeek-V4-Flash-0731-GGUF:UD-Q2_K_XL \
--jinja -c 32768 -ngl 99 \
--temp 1.0 --top-p 1.0 --min-p 0.0llama.cpp
# Long context: the KV cache stays small, so raise -c freely
./llama-server \
-hf unsloth/DeepSeek-V4-Flash-0731-GGUF:UD-Q2_K_XL \
--jinja -c 262144 -ngl 99 \
--temp 1.0 --top-p 1.0 --min-p 0.0
# Discrete GPU with less VRAM than the weights: keep the experts in system RAM
./llama-server \
-hf unsloth/DeepSeek-V4-Flash-0731-GGUF:UD-Q2_K_XL \
--jinja -c 32768 -ngl 99 \
-ot ".ffn_.*_exps.=CPU" \
--temp 1.0 --top-p 1.0
# Agentic / tool-calling work: DeepSeek suggests top-p 0.95 instead of 1.0
./llama-server \
-hf unsloth/DeepSeek-V4-Flash-0731-GGUF:UD-Q2_K_XL \
--jinja -c 131072 -ngl 99 \
--temp 1.0 --top-p 0.95LM Studio: Search for 'DeepSeek V4 Flash 0731' and take the UD-Q2_K_XL build; make sure Jinja chat templates are on or the reasoning-effort field won't be applied. Thinking runs at high effort by default — low/high/max is a request-level setting, and it changes output-token spend as much as it changes quality. Two things to check before assuming a load failure: mainline llama.cpp only gained DeepSeek V4 support in PR 24162, with a follow-up fix for quantized KV caches, so an older build won't recognize the architecture at all; and the file you want is a repack of MXFP4 experts, so don't be alarmed that the '8-bit' build is barely larger than the 4-bit one.
Why this quantization? There is no ladder to climb here. DeepSeek stores the routed experts — roughly 96% of the model — natively in MXFP4 and everything else in FP8 or BF16, so Unsloth repacks those tensors bit-for-bit instead of requantizing them, and every real build lands between 82.5GB and 161.9GB rather than spanning the usual FP32-to-Q2_K range. UD-Q2_K_XL at 96.8GB is the pick for a reason that only shows up at long context: it is the largest build that still leaves room for a completely full 1M-token window inside a 128GB unified-memory machine, totalling 118.8GB against roughly 120GB usable. UD-IQ3_XXS (104GB) is the better choice if you only ever work at short context, and UD-Q8_K_XL (161.9GB) is genuinely lossless rather than a rounding-up of the 4-bit build — worth it if you have the memory, since it is only about 7GB larger than UD-Q4_K_XL.
Who is DeepSeek V4 Flash 0731 284B for?
Owners of a 128GB-class unified-memory machine — a 128GB Mac Studio, an M4 Max or M5 Max MacBook Pro, an NVIDIA DGX Spark, an AMD Strix Halo mini-PC — or roughly 96GB of pooled VRAM, who want to run a frontier-scale agentic model locally at a million tokens of context. It is one of very few models at this capability level where running it on your own hardware is a real option rather than a thought experiment.
Best for
- Long-horizon coding and terminal agents — this is what the 0731 re-post-train specifically targeted
- Million-token context work where the KV cache would normally be the blocker: the compressed attention keeps a full window at roughly 9GB
- Self-hosted agentic deployments under MIT, with no revenue or attribution strings attached
- Speculative decoding via the attached DSpark draft head on runtimes that support it, for latency-sensitive serving
Not ideal for
- Any single consumer GPU — an RTX 4090, RTX 5090 or RTX PRO 6000 can't hold it, and the smallest build in existence is 82.5GB with no quantization below it
- Image or video input, which the model doesn't accept at all
- Latency-sensitive single-turn chat: bandwidth-bound decode on 128GB-class hardware lands in the low tens of tokens per second, and thinking is on by default
- Anyone who only wants the capability rather than the self-hosting — first-party API pricing is around $0.09-$0.14 per million input tokens, which is hard to beat by buying hardware
Should you run DeepSeek V4 Flash 0731 locally?
If you have a 128GB unified-memory machine, this is the most capable model on this site that will actually run on it — and unusually, run at full context rather than on a token budget you have to ration. UD-Q2_K_XL totals 118.8 GB with the entire million-token window filled, against roughly 120 GB usable on a 128GB Mac Studio, an M4 Max or M5 Max MacBook Pro, an NVIDIA DGX Spark, or an AMD Strix Halo mini-PC. A 256GB or 512GB M3 Ultra Mac Studio clears it with room for the higher-quality builds. Expect throughput in the low tens of tokens per second, since all of these are bandwidth-bound: one community write-up reports about 6 tok/s on a 128GB GB10, well under this site's bandwidth-model estimate, while another gets 20-30 tok/s spreading a ~104 GB build across five RTX 3090s. No single consumer GPU is in the running — an RTX 4090, RTX 5090 or RTX PRO 6000 cannot hold the weights, and below the 128GB tier there is no rescue quantization, because the smallest GGUF anyone has built is 82.5 GB and DeepSeek ships the experts natively in MXFP4 with nothing left to strip. The honest counterargument is economic rather than technical: DeepSeek serves the same weights at roughly $0.09 to $0.14 per million input tokens, so buying hardware to run DeepSeek V4 Flash 0731 locally makes sense for privacy, offline operation, or an agent that would otherwise burn a great many tokens. Those are good reasons; saving money on inference usually is not one of them.
Frequently asked questions
- What are the VRAM requirements for DeepSeek V4 Flash 0731 284B?
- DeepSeek V4 Flash 0731 284B doesn't use the standard quantization ladder — it ships as 5 fixed builds: UD-IQ1_S (92.5 GB), UD-Q2_K_XL (108.5 GB), UD-IQ3_XXS (116.6 GB), UD-Q4_K_XL (173.8 GB), and UD-Q8_K_XL (181.4 GB). These figures assume 8k of context; VRAM scales linearly with context length due to the KV cache.
- How many parameters does DeepSeek V4 Flash 0731 284B have?
- DeepSeek V4 Flash 0731 284B has 284 billion total parameters, but only 13 billion are active per token thanks to its Mixture of Experts (MoE) architecture. This makes inference significantly faster than the total parameter count suggests.
- What quantization levels does DeepSeek V4 Flash 0731 284B come in?
- DeepSeek V4 Flash 0731 284B skips the usual FP16-to-Q2_K ladder entirely. It's only available as: UD-IQ1_S at 2.32 bits/weight (92.5 GB total); UD-Q2_K_XL at 2.73 bits/weight (108.5 GB total); UD-IQ3_XXS at 2.93 bits/weight (116.6 GB total); UD-Q4_K_XL at 4.37 bits/weight (173.8 GB total, ~96.3% of FP16 quality per the vendor); UD-Q8_K_XL at 4.56 bits/weight (181.4 GB total, ~100% of FP16 quality per the vendor).
- Can DeepSeek V4 Flash 0731 284B run on a small GPU?
- No. Even the smallest build, UD-IQ1_S, needs 92.5 GB — far beyond any single consumer GPU, and there is no lower-precision build below it. The smallest machine this site tracks that runs it is the NVIDIA DGX Spark (128GB).
- What GPU do I need to run DeepSeek V4 Flash 0731 284B locally?
- Builds range from 92.5 GB at UD-IQ1_S to 181.4 GB at UD-Q8_K_XL, so the answer depends on which one you pick. Budget at least 96 GB of VRAM or unified memory for the smallest, and 184 GB to run the largest — unlike a standard quantization ladder, there is nothing smaller to fall back to.
- How much VRAM does DeepSeek V4 Flash 0731 need at full 1M context?
- About 118.8 GB in total for the recommended UD-Q2_K_XL build: 96.8 GB of weights, 9.2 GB of KV cache for the entire 1,048,576-token window, and activation overhead on top. The striking part is how little of that is context — an 8k session totals 108.5 GB, so filling the window a hundred and twenty times over costs only about 10 GB more. That is what the hybrid CSA/HCA attention buys, and it is why the full context window is reachable on hardware that can hold the weights at all.
- Can DeepSeek V4 Flash 0731 run on a 128GB Mac Studio?
- Yes, at UD-Q2_K_XL. That build needs 96.8 GB of weights, and a 128GB Mac Studio leaves roughly 120 GB after macOS, so it fits with the KV cache for a full 1M-token context included — 118.8 GB in total. The same applies to a 128GB M4 Max or M5 Max MacBook Pro, an NVIDIA DGX Spark, and an AMD Strix Halo mini-PC. A 256GB or 512GB M3 Ultra Mac Studio also runs the larger UD-IQ3_XXS and UD-Q4_K_XL builds comfortably.
- Can DeepSeek V4 Flash 0731 run on an RTX 4090 or RTX 5090?
- No, not on one card. The smallest GGUF build in existence is an 82.5 GB download — 92.5 GB once loaded with KV cache and activation overhead — against 24 GB on an RTX 4090 and 32 GB on an RTX 5090, and there is no lower-precision build to fall back to because DeepSeek stores the experts natively in MXFP4. You can reach it by pooling VRAM across several cards — one community report runs a ~104 GB build across five RTX 3090s at 20-30 tokens per second — or by keeping the expert tensors in system RAM with llama.cpp's -ot flag on a machine with enough of it.
- How many tokens per second does DeepSeek V4 Flash 0731 generate locally?
- On 128GB-class unified memory, expect the low tens of tokens per second — decode is bandwidth-bound, and only 13B of the 284B parameters are read per token. This site's estimates for UD-Q2_K_XL at 8k context are 12 tok/s on a DGX Spark, 29.4 tok/s on a 128GB M4 Max and 44.1 tok/s on a 256GB M3 Ultra. Treat those as an upper bound: one community write-up measured roughly 6 tok/s on a 128GB GB10, about half the bandwidth-model estimate.
- What is the difference between DeepSeek V4 Flash 0731 and the original DeepSeek V4 Flash?
- Architecturally, nothing — both are 284B total with 13B active, 43 layers, 256 experts routing 6 per token, and a 1M-token context window, so their VRAM requirements are the same. The 0731 build is a re-post-train aimed at agentic work, plus an attached DSpark speculative-decoding draft head that makes the checkpoint about 9 GB larger. The gains are large: Terminal-Bench 2.1 went from 61.8 to 82.7, DeepSWE from 7.3 to 54.4, and Artificial Analysis's Intelligence Index from 40 to 50.
- Does DeepSeek V4 Flash 0731 work with llama.cpp, Ollama, and LM Studio?
- Yes, through Unsloth's GGUF builds, but the runtime has to be recent. Mainline llama.cpp only added DeepSeek V4 support in pull request 24162, with a follow-up fix for quantized KV caches, so an older build won't recognize the architecture at all. LM Studio and Ollama both inherit support from llama.cpp once updated. For serving rather than local chat, vLLM runs the official FP4/FP8 checkpoint directly with expert parallelism.
- Does DeepSeek V4 Flash 0731 support image input?
- No. It is a text-only model despite the multimodal V4-Pro sibling — DeepSeek's model card, Artificial Analysis's listing, and the still-open feature request on the model repository all agree there is no image path.