Nvidia DGX Spark vs. AMD Strix Halo: Buy the Intake, Not the Output

Every comparison of these two machines leads with token generation, and token generation is the one number that cannot separate them. Both boxes carry 128GB of unified memory. Both feed that memory across a bus in the 256 to 273 GB/s range. Decode throughput is model bytes divided by memory bandwidth, so a decode tie is not a discovery about silicon, it is division. The gap between these machines opens somewhere else: prefill.

The Tie Everyone Quotes Is Arithmetic

Run the numbers before you run the benchmark. A 4-bit quantized model of roughly 60GB has to be pulled through the memory bus once per generated token. Divide 273 GB/s by 60GB and you get a ceiling. Divide 256 GB/s by the same 60GB and you get a ceiling that sits about seven percent lower. That is the whole story of decode on these two boxes, and it was knowable from the product pages before a single review shipped.

The field measurements land where the arithmetic said they would. Georgi Gerganov's llama.cpp runs on the 120-billion-parameter gpt-oss model put the DGX Spark at 38.55 tokens per second against 34.13 for the Ryzen AI Max+ 395. Independent testing by KyzoroX on a 30B model landed at 84 tokens per second for the Spark and 73 for the AMD box. Two different models, two different testers, one consistent result: a spread of ten to fifteen percent on a number people treat as the deciding factor.

Nobody buys a car by comparing two engines that share a fuel line. Yet that is the shape of nearly every DGX Spark review published this year. The reviews are not wrong. They are measuring the axis on which these machines were built to be identical.

Where the Silicon Diverges

Compute is the axis AMD and Nvidia did not agree on. The DGX Spark's GB10 Grace Blackwell package delivers around 100 FP16 TFLOPS. The Radeon 8060S inside Strix Halo has a theoretical peak near 59 FP16 TFLOPS from its 40 RDNA 3.5 compute units, and the llm-tracker.info measurement work found real throughput of 36.9 BF16 TFLOPS once hipBLASLt was in the loop, against 5.1 without it. Call the delivered gap a factor of two to three in Nvidia's favor before software maturity enters the conversation.

That gap has nowhere to show itself during decode. Decode leaves the matrix units idle between memory fetches. Prefill is the phase that saturates them, because processing a prompt is one enormous batched matrix multiply across every token at once.

Here is what the measured prefill numbers look like next to the measured decode numbers:

• Prompt processing: roughly 340 tokens per second on Strix Halo against 1,700 to 2,100 on the DGX Spark, a five to six times spread across multiple independent test runs.
• Token generation: 34 versus 38, or 73 versus 84, depending on the model. Call it a tie with a rounding error attached.
• Sticker price: Nvidia moved the Spark to $4,699 in June 2026 citing the LPDDR5X shortage, while AMD's Ryzen AI Halo box landed at $3,999 with native Windows 11.

Six times on one axis. Ten percent on the other. The buying advice that emerged from this data was "they tie, so save the money," which requires ignoring the larger of the two numbers.

Agents Read Far More Than They Write

Chat inflated the value of decode, and chat is no longer the workload. A conversational turn might feed 500 tokens of context and stream back 400 tokens of prose. Close to a one-to-one ratio. The user watches every token arrive, which makes generation speed feel like the product.

An agent loop inverts that ratio and hides the output. A coding agent working through a repository carries a system prompt, a tool schema block, retrieved file contents, and the full transcript of prior steps. Call it 40,000 tokens of context on each iteration. It emits a 200-token tool call. Then it does it again, with the tool result appended. That is a read-to-write ratio near 200 to 1, repeated dozens of times inside a single task, and nobody is watching the tokens appear because a machine consumes them.

Put the measured numbers into that loop. On Strix Halo, 40,000 tokens of prefill at 340 tokens per second costs 118 seconds before the model emits anything. On the Spark, the same prefill at 1,800 tokens per second costs 22 seconds. The 200 output tokens take 2.7 seconds on one box and 2.4 on the other. Multiply across twenty agent steps and the decode difference contributes six seconds while the prefill difference contributes thirty-two minutes.

Prefix caching softens this, and any serious deployment should use it. Cached prefixes only help when the prefix holds still, though, and agent context does not hold still. Retrieved documents rotate. Tool results append. Subagents spawn with fresh system prompts. The cacheable fraction of an agentic context window is smaller than the cacheable fraction of a chat session, which is the opposite of what the total token count would suggest.

EXO Labs Turned the Asymmetry Into a Product

The strongest evidence that prefill and decode are separate purchases came from people who stopped treating them as one machine. EXO Labs paired two DGX Sparks with an M3 Ultra Mac Studio over 10-gigabit Ethernet and split the phases: Spark handles prefill, Mac handles decode, and the KV cache streams between them layer by layer. On Llama 3.1 8B with an 8,192-token prompt generating 32 tokens, the Spark prefilled 3.8 times faster than the Mac, the Mac decoded 3.4 times faster than the Spark, and end-to-end latency fell from 6.42 seconds to 2.32.

Read that result as a hardware taxonomy rather than a benchmark. EXO's scheduler profiles each device for compute throughput and memory bandwidth as separate properties, then assigns phases accordingly. The framework does not have a category for "good at inference." It has a prefill slot and a decode slot, and it fills them from different boxes because no single box in the test was strong at both.

Nvidia is building the same split into the datacenter. Rubin CPX pairs compute-dense parts for prefill with bandwidth-optimized parts for decode. When the roadmap and the open-source scheduler agree that inference is two workloads, a comparison chart with one throughput column is a chart with a missing axis.

AMD Is Attacking the Prefill Gap, Not the Decode Tie

AMD's own engineering choices confirm which number matters. The Ryzen AI Max+ 395 ships a 50-TOPS XDNA 2 NPU alongside the iGPU, and AMD's Lemonade server puts that NPU to work on prompt processing while the Radeon 8060S handles token generation. AMD reports the arrangement cuts time-to-first-token by roughly half on this hardware.

Nobody spends silicon area and driver engineering to close a gap they consider settled. AMD built a second accelerator into the package and pointed it at prefill. That is a company reading its own benchmark results correctly while the review cycle reads them backward.

The Register's recommendation of Strix Halo for local inference holds up under its own framing. Price is real, bandwidth is comparable, and the AMD box doubles as a workstation that runs Windows and drives a display. All three points are true and none of them touch throughput on a 40,000-token context.

The Questions That Should Replace the Throughput Chart

Reframe the purchase around workload shape and the decision resolves without a tie-breaker. Three questions do the work:

• What is your read-to-write ratio? Chat and drafting sit near one-to-one, and the AMD box gives you that experience for less money. RAG over document sets, long agent runs, and repository-scale code assistance run at 50-to-1 or worse, and every point of that ratio compounds the prefill gap.
• Does anything wait on the first token? A human reading generated prose tolerates a slow start. A CI pipeline gated on an agent's verdict, a batch job over ten thousand documents, or an interactive tool call inside a loop does not.
• Is inference the endpoint or the rehearsal? The Spark exists to make Blackwell behavior reproducible on a desk before it ships to a cluster. If your production target is a datacenter GPU, the Spark's value is fidelity to that target, which no token count captures.

The counter-cases are just as clean, and they favor AMD more often than Nvidia's positioning admits:

• Short prompts, long outputs, one user. The bandwidth tie is real and you keep $700.
• The machine has to be a computer between inference sessions. Strix Halo runs Windows 11, drives multiple displays, and games. The Spark ships HDMI-only on an ARM64 base with datacenter drivers.
• CPU-side work in the pipeline. Linpack double-precision on Strix Halo hits 1.6 TFLOPS against roughly 708 GFLOPS on the Spark.
• Budget certainty over ecosystem certainty. ROCm improves each quarter and llama.cpp covers most local model formats, but new tooling still ships CUDA-first.

A Note on the Number Nobody Prints

Divide bandwidth by capacity and both machines look strange. The Spark offers about 2.1 GB/s of bandwidth per gigabyte of memory. Strix Halo offers about 2.0, and closer to 1.7 at the ~215 GB/s that rocm_bandwidth_test measures in practice. An RTX 5090 offers 56. These boxes were engineered to hold models that they cannot stream at speed, which is a deliberate tradeoff and a sane one, because a model you cannot load runs at zero tokens per second.

The tradeoff has a consequence people skip. When capacity outruns bandwidth by that margin, the compute engine is the only remaining lever, and the compute engine only engages during prefill. Nvidia priced that lever at $700. Whether it is worth $700 depends on a property of your workload that no reviewer can measure for you.

Common Questions

Is the DGX Spark faster than Strix Halo for local LLMs?

For token generation, barely. Measured spreads run ten to fifteen percent across a 30B model and a 120B model, because both machines share nearly identical memory bandwidth. For prompt processing the Spark runs five to six times faster, which is where its compute advantage cashes out.

Which box is better for running AI agents locally?

The DGX Spark, and the margin is not close. Agent loops re-read large contexts on every step and emit short tool calls, so wall-clock time concentrates in prefill rather than generation.

Does Strix Halo have a path to closing the prefill gap?

Partly. AMD's Lemonade server offloads prompt processing to the XDNA 2 NPU and reports roughly half the time-to-first-token, which narrows the gap without erasing it. The software has to mature faster than Nvidia's compute lead grows.

The Spec That Decides It

The number that should drive this purchase is not printed on either box. It is the ratio between the tokens your system reads and the tokens it writes, and an afternoon with your own logs will produce it. Below ten-to-one, take the AMD box and keep the $700. Above fifty-to-one, the Spark's prefill advantage is the entire product and the price gap dissolves inside a week of recovered wall-clock time. Stop shopping for output and start shopping for intake.