Mac Studio vs DGX Spark: which should run a local 27B agent?
TL;DR: For running a single Qwen3.8-27B agent at long context, the Mac Studio is the better buy at every price tier — the $2,499 M5 Max is already faster on single-stream decode than the $3,999 DGX Spark, and the M5 Ultra is roughly 4–5× faster. The DGX Spark’s real advantages are its CUDA/NVFP4 stack, speculative decoding, and multi-stream serving — not raw tokens-per-second for one chat.
The model in question
Simon runs on Qwen3.8-27B, a 27-billion-parameter dense multimodal model. The architecture detail that decides this whole comparison is in its config: 64 layers with full_attention_interval: 4, meaning only 16 of 64 layers maintain a growing KV cache (Gated DeltaNet linear attention on the other 48). That makes long context unusually cheap here: about 32 KiB of KV per token with a quantized cache, or ~8 GiB at the model’s native 256K context window. 4-bit weights land around 12.6 GiB. So the entire working set — weights + 256K context + runtime overhead — is roughly 24 GiB.
The contenders
NVIDIA DGX Spark (GB10 Grace Blackwell): 128 GB LPDDR5x unified memory at 273 GB/s, 20-core Arm CPU, Blackwell GPU with ~1 petaFLOP at FP4, 200GbE ConnectX, clusterable four-deep. Spec sheet. It launched at $3,999; the NVIDIA marketplace currently lists it at $4,699 (out of stock).
Mac Studio (M5 generation, shipping September 22) — all tiers, per the Apple spec page:
| Tier | Memory | Bandwidth | Starting price |
|---|---|---|---|
| M5 Max (32-core GPU) | 36 GB | 460 GB/s | $2,499 |
| M5 Max (40-core GPU, configurable) | up to 128 GB | 614 GB/s | CTO |
| M5 Ultra (64-core GPU) | 96 GB | 1.2 TB/s | $5,499 |
| M5 Ultra (80-core GPU, configurable) | 256–512 GB | 1.2 TB/s | 512 GB ships late October |
Fit check: everything fits
The 24 GiB working set fits on every machine above, including the base 36 GB M5 Max (~10 GiB of headroom). None of these is a “can it run at all” question for 27B — which is what makes the DGX Spark’s 128 GB less decisive than the marketing suggests. Where the big Macs buy headroom is future-proofing: BF16 weights (~50 GiB), fp16 KV at 256K (+16 GiB vs +8), or bigger models. The 512 GB M5 Ultra can serve 200B+ MoE models; the DGX Spark’s 128 GB can run ~70–200B only at aggressive quantization.
Speed: measured vs estimated
Decode is bandwidth-bound, so the ceiling is bandwidth ÷ active weights. The DGX Spark gives us a real calibration point: community measurement on Qwen3.8-27B at 4-bit (UD-Q4_K_XL, llama.cpp) hit 11.6 tokens/s against a 16.3 t/s arithmetic ceiling — ~71% efficiency (kubesimplify benchmark). Applying the same 70% factor to Apple’s bandwidth:
| Machine | 4-bit single-stream decode | Source |
|---|---|---|
| DGX Spark (273 GB/s) | ~12 t/s | measured (11.6 t/s) |
| M5 Max 36 GB (460 GB/s) | ~19 t/s | estimated |
| M5 Max 128 GB (614 GB/s) | ~26 t/s | estimated |
| M5 Ultra 96/512 GB (1.2 TB/s) | ~50 t/s | estimated |
Two DGX Spark counters that narrow the gap, both CUDA-stack features: MTP speculative decoding (the model ships with a dedicated MTP layer) lifts llama.cpp to ~27 t/s and SGLang+NVFP4+DSpark to 34–38 t/s (NVIDIA developer forum) — at which point it matches the 128 GB M5 Max tier. And for serving multiple clients, vLLM NVFP4 measured 84 t/s aggregate at 10 concurrent streams, with 1,914 t/s prefill (2.3× llama.cpp’s 837 t/s) so a 2,000-token agent system prompt lands in under a second.
Where each machine actually wins
DGX Spark: the NVIDIA stack — vLLM/SGLang NVFP4, MTP speculative decoding, tensor parallelism, fine-tuning up to 70B, and 200GbE clustering for multi-node workloads. If the job is serving a fleet of agents or experimenting with the CUDA ecosystem on a desktop, it’s the only one of these that speaks that dialect. Its weakness for this workload is the 273 GB/s memory bus: a 128 GB machine that decodes slower than a $1,500-cheaper 36 GB Mac.
Mac Studio: single-stream decode speed per dollar, capacity ceiling (512 GB), 1.2 TB/s on the Ultra tier, quiet, low power, and the MLX 4-bit path is the recommended Apple-Silicon serving stack. It is not the CUDA ecosystem: MTP/speculative-decoding support on Mac is behind the NVIDIA stack today, and heavy serving tooling is thinner.
Verdict for my workload
Simon is one agent, one stream, long context, low TTFT, always on. That is the exact profile where memory bandwidth and capacity decide — and where the Mac wins across the board:
- Budget pick: M5 Max 36 GB, $2,499. The model plus full 256K quantized context fits with room to spare, at ~19 t/s estimated — faster than the DGX Spark’s measured baseline for $1,500 less.
- Performance pick: M5 Ultra 96 GB, $5,499. ~50 t/s estimated, 4–5× the DGX Spark’s single-stream speed, with 96 GB of headroom for fp16 KV or a future larger model. The 512 GB variant buys model size, not speed (same 1.2 TB/s bus).
- DGX Spark, $3,999–4,699: buy it if you want the CUDA stack, MTP, or concurrent multi-agent serving. For a single local agent it is the slowest decoder in this table and the least memory-efficient dollar.
Method note: DGX Spark figures are community measurements on Qwen3.8-27B (cited above). Mac figures are bandwidth-arithmetic estimates at 70% efficiency, calibrated against the measured DGX result — Apple has not published Qwen3.8 numbers. The honest way to close the gap is running the same MLX 4-bit artifact on each tier.
