Best Models for NVIDIA DGX Spark: 1 to 4-Spark Setups

Bottom Line (August 2026)

• 1 Spark — Qwen 3.6 35B-A3B NVFP4 for speed (~106 tok/s at 256K context). For coding, Qwen3.8-27B NVFP4 for quality and Qwen3-Coder-Next NVFP4 for speed. See Best Coding Model for DGX Spark.
• 2 Sparks — the sweet spot. DeepSeek V4 Flash DSpark at the full 1M context (~42 tok/s at 1M, 44–63 tok/s at working contexts). Omni options: Inkling-Small and MiMo-V2.5.
• 3 Sparks — GLM-5.2 NVFP4+AQLM (~380K context) with the community vision build, or DeepSeek V4 Flash on two units + a free Spark for ComfyUI and small models.
• 4 Sparks — unpruned GLM-5.2 (744B) at up to 1M context, ~42 tok/s peak. The strongest local intelligence on a desk, for about $27.8k of hardware ($6,950 per Spark since October 2026, up from $4,699).

All numbers below are single-stream decode rates from community recipes and NVIDIA forum reports, mostly via vLLM with NVFP4 quantization. Batch throughput is much higher — the Spark’s real advantage over a Mac shows up under concurrency.

The Hardware, Briefly

One DGX Spark is a GB10 Grace Blackwell chip with 128GB of unified LPDDR5X at ~273 GB/s. That bandwidth is the constraint: dense 70B-class models decode slowly. The winners on this box are MoE models with small active parameter counts (3B–15B active) quantized to NVFP4 — Blackwell’s native 4-bit floating-point format, which keeps quality close to FP8 at half the memory.

The second thing that defines the platform: each Spark has a 200 Gb/s ConnectX QSFP port. Two units connect back-to-back with one cable and run tensor-parallel as a 256GB machine. Three and four-unit RoCE clusters are now routine in the community. No Mac can do this.

1× DGX Spark (128GB)

Our pick: Qwen 3.6 35B-A3B NVFP4. At ~106 tok/s with the full 256K window it is faster than most cloud APIs feel, and it is the best agentic driver for OpenClaw at this tier. For coding, the picks are different. See the next section.

Best Coding Model for DGX Spark

On one Spark, run Qwen3.8-27B for quality and Qwen3-Coder-Next for speed. Both fit at NVFP4 with room for context. Send tight edit-and-run loops to Coder-Next. Send hard refactors and reviews to Qwen3.8-27B. That split is the routing one Spark owner settled on after testing four candidates in September 2026 (“Coding models on DGX-Spark, state of the art of September 2026”).

Where the numbers come from. Speeds are community reports, not our measurements. The Qwen3.8-27B and Coder-Next speeds are from that write-up (vLLM and SGLang nightlies). The Qwen3.6-35B-A3B figure is one owner’s single-stream result with vLLM and DFlash, corrected down from an initial 109 tok/s (NVIDIA forum). The DeepSeek V4 Flash figure is a ds4-server benchmark at -c 131072 from the same thread. SWE-bench Pro scores are vendor-reported, from the model cards for Qwen3.8-27B, Qwen3-Coder-Next, Qwen3.6-35B-A3B and DeepSeek V4 Flash (Max reasoning mode).

Why Qwen3.8-27B and not DeepSeek V4 Flash. Two reasons.

• V4 Flash does not fit one Spark at 4-bit. Its model card lists 284B parameters, with FP4 experts and FP8 for most of the rest. At 4 bits per weight, 284B parameters is at least 142 GB before any context. The Spark has 128GB. So one Spark runs it only as a 2-bit GGUF, and its 52.6 SWE-bench Pro score was measured on the full model, not on that file. Owners in the forum thread still call the 2-bit build the strongest model a single Spark can hold. One also reports that ds4 “seems to crash” too often for serious use.
• Qwen3.8-27B has the higher vendor score and fits at 4-bit. 61.7 against 52.6 on SWE-bench Pro, in about 21 GB. That leaves most of the 128GB for context and for a second model.

Why keep Coder-Next as well. It is about three times faster on code in the same write-up, and the author measured a 21K-token repository prefill in under six seconds. Its vendor score is 17 points lower, so give it the boilerplate, not the hard bugs.

Settings that matter more than the model. The same write-up reports two. Keep the vLLM GPU memory fraction at 0.80 or lower: the author “lost zero boots” there. For Claude Code-style agents, make non-thinking the server default with --default-chat-template-kwargs '{"enable_thinking": false}'. The author also found that the same Coder-Next model ran six times slower depending on who made the quant, so start from a GB10-calibrated NVFP4 checkpoint.

With two Sparks, the coding answer changes. See the 2× section below.

For coding agents on other hardware, see Best GPU for Running a Local Coding Model and Which Coding Agent Should You Use?.

2× DGX Sparks (256GB) — The Sweet Spot

Our pick: the DeepSeek V4 Flash DSpark checkpoint. This is a purpose-built recipe — FP4 experts plus an NVFP4 MLA KV cache — that holds the entire 1M-token context in memory across two Sparks with tensor parallelism. Practical notes from the recipe threads: MTP speculative decode is what gets you into the 55–63 tok/s range on code, and the current patch level matters (without it you get roughly half speed at unchanged quality).

If you want one setup that also sees and hears, run MiMo-V2.5 Omni or Inkling-Small instead — both hold 1M context at NVFP4 KV on two Sparks, something no single consumer box can do with an omnimodal model.

3× DGX Sparks (384GB)

Two good patterns:

1. GLM-5.2 NVFP4+AQLM across all three — ~380K context with MTP serving, and a community vision-enabled build (a small trained projector maps a frozen vision tower into GLM’s token space; the text backbone is byte-identical to upstream). This is the strongest intelligence-per-desk before you go to four units. MiMo-V2.5 Omni also scales to TP=3 at 1M context, ~39 tok/s.
2. DeepSeek V4 Flash on two units + the third Spark free for ComfyUI, image models, embeddings, and small agent models. You keep DSpark coding speeds and gain a dedicated media/agent box. For an OpenClaw multi-agent setup this is the configuration we would run.

4× DGX Sparks (512GB)

Unpruned GLM-5.2 — 744B total / ~40B active — at up to 1M context. The 4x recipe (NVFP4 compact KV at 58% the size of FP8, sparse MLA, MTP-5 speculative decode) reports ~42 tok/s peak decode, ~30 tok/s at 64K context, ~819 tok/s prefill — with no pruning, unlike earlier 4x attempts. That is a frontier-class model, fully private, on roughly $27.8k of hardware — four Sparks at the $6,950 list price since October 2026 — drawing less power than one space heater.

The alternative at 4 units is DeepSeek V4 Flash on two Sparks plus any 2x setup on the other pair — for example an omni model, or a dedicated image/video pipeline.

Spark vs Mac Studio at This Money

The honest comparison, since both live at the 128GB tier:

• Mac Studio has ~2x the memory bandwidth (546 GB/s on M4 Max vs ~273 GB/s) — dense models decode faster, and it is quieter and simpler. Capacity changed on 25 August 2026: Apple replaced the line. The new M5 Max Mac Studio configures to 128GB, the same as the Spark, and the M4 Max and M3 Ultra are discontinued. See Best Local LLMs for 128GB RAM.
• DGX Spark wins on CUDA (NVFP4, vLLM, TensorRT, ComfyUI), on batch/concurrent throughput, and — decisively — on clustering. There is no path from one Mac Studio to a 512GB tensor-parallel machine. There is from one Spark.

Buy the Mac if you will only ever run one box and 64-96GB is enough for your models. Buy the Spark if the 2x sweet spot or the 4x GLM-5.2 endgame is where you are headed.

See Also

• Can I Run Ripple-65B Locally? — the dense 65B Ricursive aimed at the Spark: NVFP4 57.2 GB, and why it needs the DFlash2 draft model to pass 5 tok/s
• Best Local LLM for RTX Spark — the laptop version of this memory class: measured tok/s and the 96GB GPU split
• Can I Run Ling-3.1-flash Locally? — why one Spark misses the 122 GiB IQ1_S file, and the experimental 107.81 GiB route
• Best Local LLMs for 128GB RAM — the Mac-side view of this memory tier
• Best Local LLM by GPU (hub) — per-GPU picks
• Best Local LLM for RTX 5090 — the 32GB VRAM alternative
• Mac Studio vs RTX Workstation for Local LLMs — the broader platform question
• Why Is My Local LLM So Slow? — bandwidth math explained
• Best Local Models for OpenClaw — model-first guide
• Is the DGX Spark Worth $6,950? — the purchase decision this page assumes you already made
• DGX Spark Price: Every GB10 Box Compared — the $6,950 list price, its 2026 increases, and every OEM GB10 box beside it
• Jetson Thor vs DGX Spark — why NVIDIA’s robotics box matches this one on memory bandwidth