aihomelabreviews

One Mac Out, Two Sparks In: My AI@Home Cluster

In March I wrote why I chose a Mac Studio with an M4 Max and 128 GB of RAM over the Framework Desktop for my local AI setup. For a while it was exactly the right machine: fast, silent, and idle draw of just a few watts. But a funny thing happens once you get used to agentic workflows — the models keep growing, and the machine stays the same size.

So the Mac Studio is gone. In its place: two ASUS Ascent GX10 — ASUS’s take on the NVIDIA DGX Spark — running as a two-node cluster. This post is the honest record of why, what it unlocked, what it cost, and what got worse.

ASUS Ascent GX10 — compact desktop AI supercomputer based on NVIDIA DGX Spark

The setup

Each GX10 is a 1.2-liter box built around NVIDIA’s GB10 Grace Blackwell superchip: a 20-core Arm CPU and a Blackwell GPU sharing 128 GB of coherent unified memory, with about 1 petaFLOP of FP4 compute and a ConnectX-7 port on board. The ConnectX port is the part that makes the cluster interesting: I coupled the two machines directly through their CX7 ports at 200 GbE, so they act as one system with a single pool of model memory. No infiniband switch, no adapters — one cable between two small boxes on a shelf.

Mac Studio M4 Max 2× ASUS Ascent GX10
Unified memory 128 GB 256 GB
Memory bandwidth 546 GB/s 273 GB/s per node, 200 GbE link
Peak AI compute — ~1 PFLOP FP4 per node
Idle power a few watts ~100 W combined
Peak power ~160 W up to ~290 W measured

The obvious question: the Spark’s memory bandwidth (273 GB/s) is half of the M4 Max’s. Isn’t that a downgrade? For dense models, decode speed, yes — and I’ll get to that. But for the models I actually want to run, something else matters more.

What the cluster unlocks

Twice the memory is not twice — it’s a different class of model. With 256 GB pooled, I can now load the big MoE models that simply did not fit on the Mac:

  • GLM 5.3 Flash — a 320B-parameter MoE model (18B active per token)
  • DeepSeek V4 Flash — again firmly in “frontier-ish” territory

The mechanism is exactly what the spec sheet suggests: parameter count barely matters for prefill (reading your prompt), but it decides what fits — and what fits decides which model you can use at all. Agentic workloads are prefill monsters: every tool call re-sends the whole conversation, long tool-call chains mean huge prompts, and this is precisely where the Spark architecture shines. Official llama.cpp benchmarks show it beating even an M2 Ultra on long-context prompt processing by 2–4× on MoE models.

The pleasant surprise was the “smaller” models: Qwen 3.8 Flash runs faster on the cluster than it did on the Mac. That sounded backwards to me too — half the memory bandwidth, faster? — but with only a fraction of the weights active per token, the bottleneck moves from raw bandwidth to how much of the pipeline you can keep busy, and across two nodes there is a lot more room to keep busy.

The catch: power and thermals

This is the least flattering section. The Mac Studio idled at a handful of watts — you genuinely could not measure it on a power bill. The two GX10 draw around 100 W combined at idle, 24/7, and I’ve measured peaks of up to 290 W under load. Roughly estimated, the idle difference alone is on the order of €25 per month at German electricity prices, versus about €2 for the Mac.

Thermals are the follow-up problem. In the default stacked configuration the bottom unit breathes in the top unit’s exhaust, and under sustained agentic load both get uncomfortably warm. I’m considering a 3D-printed fix — a spacer/stand that gives each unit its own airflow — and I’ll report back once it exists. This is a homelab, after all; a custom printed part is basically tradition.

What it cost

Timing matters, and I got lucky. GPU pricing has been all over the place (NVIDIA’s own reference price for the Spark went from $3,999 to $4,699, and partner boxes have been volatile), but the second-hand market for Apple silicon is famously kind. I sold the Mac Studio at a good price, caught the GX10s at a good moment, and the cluster ended up costing me effectively about €1,300 more than the Mac had.

For double the memory, a cluster-capable interconnect, and the full CUDA stack on my desk: a price point I could justify. Six months ago it would not have existed.

First days: three models, all excellent

The first week was mostly joyful benchmarking-by-vibes — roughly 250 million tokens went through the cluster in those days, most of it the agentic tax of re-sending conversation context on every tool call. All three models are excellent and, crucially, all three work agentically — tool calling, long chains, vision — which is the whole point of this machine. The difference to the models I was running on the Mac is not incremental; tasks that needed workarounds now just run.

My current setup is GLM 5.3 Flash (320B parameters, 18B active) served from a 4-bit EXL3 checkpoint using Entrpi’s recipe for exactly this two-Spark cluster — not because it “won” some contest, but simply because the recipe works and I stopped fiddling. One installer, and you get an OpenAI-compatible API with a KV-cache pool of ~1.3 million tokens, measured on this exact hardware at ~32 tokens/s for single-stream chat, 70+ tokens/s on structured output, first token in ~0.4 s — plus a speculative-decoding drafter that does a lot of quiet heavy lifting. The recipe even survives a restart in about four minutes.

One thing that genuinely surprised me: the community around these Spark clusters is very engaged. Recipes for the best quantization, drafter, and serving configuration get benchmarked, argued about, and updated constantly — the Entrpi repo I run is itself a community derivative with measured quality gates (math_500, GPQA-diamond), not some hand-waving README. Buying into this ecosystem six months after launch feels early-adopter in the best sense.

Pros and cons, six weeks of DGX Spark thinking condensed

Pro

  • 256 GB of pooled unified memory — the 200B+ MoE class finally runs locally, private and unmetered
  • Direct CX7 200 GbE coupling makes two boxes behave like one system — no switch, no exotic networking
  • Excellent prefill/long-context performance — the ideal profile for agentic workloads
  • Full NVIDIA software stack (CUDA, DGX OS, NIM) — everything works, and the same code scales up to data-center DGX later
  • Community recipes like the one above squeeze remarkable performance out of 4-bit quantized MoE models
  • Compact, quiet (so far), stackable — two of them take less desk space than the Mac Studio’s ego

Contra

  • Idle power ~100 W combined vs. a few watts — running this 24/7 has a real electricity bill attached
  • Peak load needs cooling attention — the stacked chassis shares airflow, hence my 3D-printing plans
  • 273 GB/s memory bandwidth — for dense models, token generation is notably slower than on Apple silicon; the Spark is a capacity king, not a decode king
  • Memory is soldered — 128 GB is what you get forever; no upgrade path, unlike a DIY multi-GPU box
  • Software is still settling — llama.cpp/vLLM performance improved substantially post-launch and will keep improving, but today’s numbers are bought with today’s patience
  • It’s an Arm box — occasional friction with x86-only Docker images and packages

Verdict

Is this a replacement for a Mac Studio? For my workload — long-context agentic agents on big MoE models, running around the clock on my own terms — it is a strict upgrade, and the effective €1,300 made it an easy decision. If your workload is dense-model chat or you count every watt at idle, the calculus flips and Apple silicon still wins.

What I can say for sure: the “personal AI supercomputer” marketing line is less silly than it sounds, as long as you buy two.

Related posts: why I originally picked the Mac Studio · the Framework Desktop detour. The GLM 5.3 Flash cluster recipe I run lives at Entrpi/glm-5.3-flash-exl3-2x-spark.