M5 Ultra Mac Studio vs. DGX Spark: Where Local AI Performance Holds Up

The dense model result is the easy part

Apple's M5 Ultra Mac Studio, with a 36-core CPU, an 80-core GPU with Neural Accelerators, and up to 512GB of unified memory, has become one of the most talked-about machines for running models locally. The catch is availability: buyers are looking at 13 to 15 weeks for delivery. The tested configuration costs $12,300, so the real question is whether it earns that price against the alternatives that local AI builders actually consider.

An earlier look at the maxed-out chip used Qwen 3.8 27B, a compact dense model that barely touches 256GB of memory. This round tried to fill the pool with much larger open models and to measure agentic workloads on the GPU side, which is where the Mac has the most to prove.

Agentic throughput and energy on a dense model

The first test was Artificial Analysis' AgentPerf-Local benchmark, which replays recorded inference traces across a range of agentic workloads. Most of the work is prompt processing rather than token generation, so the test rewards raw compute. Both the M5 Ultra and GB10 have plenty of that, but the M5 Ultra's 80-core GPU is a much larger block of silicon than GB10's 48 Blackwell SMs. On paper, GB10 has little chance here.

Paper specs only tell part of the story, though. The Mac's 1.2 TB/s of memory bandwidth gives it just over four times the decode bandwidth of GB10's 273 GB/s, and that gap matters for token generation. Delivered performance is what counts, and that's where the numbers got interesting.

The team ran Qwen 3.8 27B on llama.cpp on both the Mac Studio and a single Dell Pro Precision GB10 box, which is nearly identical to the DGX Spark. Native multi-token prediction (MTP) was enabled on both platforms for a decode boost. The Mac finished the agentic run in just under half the time of the GB10 system.

A fair objection is that a $10K Spark and a $12K Mac aren't a natural pair, but the price gap has narrowed. The 4TB Dell GB10 used in testing now costs around $10K, which makes a head-to-head comparison less of a stretch than it sounds.

Because AgentPerf-Local does a fixed amount of work on every machine, the team could also compare energy directly by logging wall power and converting it into task energy in kilojoules. Even with llama.cpp, the Mac used about 16% less task energy than the Spark. The Spark-like system might do better with a different inference engine, but on a like-for-like basis the Mac looks strong.

Multiplying task time by task energy gives an energy-delay product (EDP), which folds speed and energy into one number where lower is better. The Mac's EDP came in under half the Spark's. For this dense model and workload, the efficiency case is clear.

Going big with DeepSeek V4.1 Flash and GLM 5.3 Flash

Qwen 3.8 27B doesn't need 256GB, or even 128GB, so the test moved to two larger open models near the top of current capability benchmarks: GLM 5.3 Flash and DeepSeek V4.1 Flash 1017. The Mac Studio can hold quantized versions of both in its 256GB, using a four-bit quantization for GLM 5.3 and a two-bit quantization from Unsloth for DeepSeek. Neither fits on a single 128GB DGX Spark.

That's where Nvidia's clustering becomes relevant. Pairing Sparks scales local inference capacity, and any fair comparison against a 256GB Mac has to include a two-box setup. Here's the complication: GB10 pricing has moved fast. Lenovo put all of its ThinkStation PGX systems into a "coming soon" state during testing, and the Dell GB10s in the cluster were about $10K each. There's no reason to expect the broader GB10 market to get much cheaper soon.

A pair of 4TB Sparks costs well more than one Mac Studio. Even a dual-Dell cluster at roughly $20K sits at the top of the market, and $15K or more is a more typical figure, which is about 25% above the M5 Ultra configuration.

The team doesn't have end-to-end agentic tests for these bigger models yet, so it looked at prompt processing and decode speed as a directional proxy for how quickly each system would turn around an agent step. The first problem is software. Apple Silicon has a limited set of compatible inference engines, so DeepSeek V4.1 Flash ran on llama.cpp. The Mac also couldn't hold both the DeepSeek weights and the DSpark speculative decoding model at two-bit quantization, which meant leaving decode performance on the table.

The Spark cluster had no such constraint. Its DeepSeek recipe could use DSpark speculative decoding and the TensorFold inference engine, which can outperform llama.cpp.

With MLX support in place, llama.cpp on the Mac is still slow for DeepSeek V4.1 Flash next to the Spark cluster. Slower prompt processing and unaccelerated decoding put the Mac at a clear disadvantage for agentic work with this model. Where llama.cpp on the Mac needed anywhere from 10 to 25 minutes to digest the longest context lengths tested, the Spark cluster finished the same jobs in under five minutes using Mia's AI Lab community recipe. TensorFold also decodes much faster. For running DeepSeek V4.1 Flash locally today, a pair of Sparks is the clear choice.

The community two-Spark recipe does require some setup and cluster management, but for owners of those systems it's a real asset.

GLM 5.3 Flash runs considerably better on llama.cpp than DeepSeek does. Even so, the Spark cluster posts much faster prompt processing across the board. The M5 Ultra's bandwidth advantage gives it higher tokens per second on decode, but any single agentic turn would probably still finish sooner on the Spark cluster.

GLM 5.3 Flash also doesn't need a separate drafting model for MTP, so the Mac could use that decode boost without the memory pressure seen with DeepSeek. The Spark cluster ran GLM on another Mia's AI Lab recipe.

A TensorFold serving recipe does exist for GLM 5.3 Flash on Apple Silicon, and it changes the Mac's numbers. Using an MLX-specific four-bit quantization with TensorFold, prompt processing gets much closer to the Spark cluster's, and decode throughput is roughly three times faster on average. That's a clear demonstration of how much performance depends on the engine and the model format, not just the silicon.

Hardware potential versus software maturity

A single M5 Ultra Mac Studio can deliver excellent local AI performance and efficiency against a single DGX Spark when the software stack cooperates. That's the key condition. The M5 Ultra's performance isn't guaranteed for every model and engine, and the largest, most capable models are exactly the ones you'd buy 256GB to run.

Prompt processing on the Mac can move quickly with llama.cpp on smaller models like Qwen 3.8 27B. For bigger models, though, you need a high-performance serving recipe. TensorFold runs GLM 5.3 Flash very well, but it doesn't support DeepSeek V4.1 Flash yet. Memory bandwidth is only one piece of AI inference performance, and as earlier testing on the M4 Max Mac Studio showed, the full hardware-software stack determines what you actually get.

MLX development and support still have ground to cover before they match the maturity, speed of model support and range of inference engines available on Nvidia hardware. The Spark's real advantage is community momentum: the software ecosystem around it has reached the point where a new model is usually runnable soon after its weights hit Hugging Face, provided you have enough Sparks clustered to hold it.

Supply pressure cuts against both options. Memory and NAND shortages have pushed 128GB GB10 boxes to high prices, with two 4TB Sparks landing between $15K and $20K+ depending on the partner system and storage. Those numbers may keep climbing, which makes a single Mac Studio look more appealing, provided Apple's pricing holds.

If you need a well-rounded, quiet compact workstation with a fast CPU and a capable GPU, and local AI is one of several jobs, the Mac Studio is hard to beat. If you can wait for MLX and engine support to catch up, and you're comfortable with narrower model options, the Mac's performance headroom is worth the lead time. But if you're spending more than $10K specifically to build a local inference setup today, for yourself or a small office, a pair of Sparks gives you the memory, compute and broad model compatibility that justify the cost. You'll give up some raw speed to get it. The open question is how fast MLX and TensorFold close the DeepSeek gap, because that will determine whether the Mac stays a single-box alternative for the biggest models.