Home / DGX Spark Cluster
October 10, 2026

DGX Spark cluster — two nodes, 256 GB of memory, real benchmarks

256 GB unified memory QSFP56 · 200 Gb/s 2× GB10 Grace Blackwell Scales to 4 nodes

A single DGX Spark has 128 GB of unified memory — enough for models up to roughly 120 billion parameters, but not for the largest open models. A DGX Spark cluster fixes that: two units linked by one 200 Gb/s QSFP cable act as one 256 GB pool. No server rack, no liquid cooling, no data center — two small boxes and one cable.

We run such a cluster every day. Ours is built from two ASUS Ascent GX10 units — the same NVIDIA GB10 platform as DGX Spark — and this page is based on our own setup and measurements: how the two nodes are connected, what we run on them with vLLM, how fast a 230-billion-parameter model actually is, and how to scale to three or four nodes.

Node 1 · gx1
SoCGB10 Grace Blackwell
RAM128 GB UM
NICConnectX-7
Rolehead node
200 Gb/s
QSFP56 DAC
Node 2 · gx2
SoCGB10 Grace Blackwell
RAM128 GB UM
NICConnectX-7
Roleworker node
Shared memory pool (tensor parallel) 256 GB

The model is split across both nodes with tensor parallelism — every layer is computed on both units at the same time.

Why connect two DGX Spark units?

With local AI, memory is always the limit. On a single DGX Spark (128 GB) we comfortably run models up to about 120 billion parameters in 4-bit quantization, such as GPT-OSS 120B, with room left for context. The most interesting open models of 2026 — MiniMax M2.7 (230B), GLM 5.3 Flash (320B) or the large DeepSeek variants — simply don't fit.

Two units double the pool to 256 GB. NVIDIA's own scaling table lists one 128 GB unit for models up to 200B parameters, two units (256 GB) for up to 400B and four units (512 GB) for up to 700B. Those are NVIDIA's ceilings; in practice you also need memory for the context window and for several users at once, which is why our own sizing is more conservative.

2× memory

256 GB of unified memory — model weights, KV cache and the system in one pool, without swapping.

2× compute

Tensor parallelism splits every layer across both GPUs — they compute at the same time, not one after the other.

0 cloud

All traffic between the nodes goes over a dedicated cable — your data never leaves the desk.

Two GB10 units (DGX Spark platform) side by side, linked with a QSFP56 cable — an AI cluster on a desk
Our cluster: two units, one cable, 256 GB.
QSFP56 200G DAC cable, 1 m — the passive copper cable that links the two ConnectX-7 ports
QSFP56 200G DAC — one cable instead of a network.

How to connect two DGX Sparks: ConnectX-7 and a QSFP cable

Every DGX Spark has a built-in NVIDIA ConnectX-7 network card rated at 200 Gb/s, with two QSFP ports. Two units connect directly, without a switch: we use a passive copper QSFP56 200G DAC cable. The link gets its own isolated subnet (link-local addressing), so cluster traffic never mixes with the office network and never touches the internet. NVIDIA describes the whole procedure step by step in its official playbook Connect Two DGX Sparks for Distributed Workloads.

On top of that link runs NCCL, NVIDIA's GPU-to-GPU communication library — the same one data centers use. Drivers, CUDA and NCCL come with NVIDIA DGX OS on both nodes. The inference engine (vLLM in our case) splits the model across the two nodes with tensor parallelism and synchronizes activations over the QSFP link for every token. That is why the bandwidth and latency of this one cable decide how fast the whole cluster is.

One thing the link is not: NVLink. Inside each GB10 chip, NVLink-C2C connects the CPU and the GPU; between units, the connection is ConnectX-7 networking. More on that in the FAQ below.

200
Gb/s link
<1 ms
node-to-node latency
~4 min
to sync 131 GB of weights
0
switches, routers, clouds

Measured in our deployment (June 2026): ping under 1 ms, model weights copied at ~540 MB/s over the QSFP link.

Scaling to three or four nodes

According to NVIDIA, ConnectX networking can link up to four DGX Spark systems. Each topology has its own official playbook:

  • Two nodes — one QSFP cable between the units, no switch.
  • Three nodes — a ring without a switch: three QSFP cables, each from one unit's Port 0 to the next unit's Port 1.
  • Four nodes — a managed switch with QSFP56 ports rated at 200 Gb/s or more, one cable per unit. NVIDIA's Sync Cluster Assistant supports two to four systems; NVIDIA's manual instructions also cover larger setups.

Four nodes give you 512 GB of unified memory — room for the largest open models with less aggressive quantization, or for several models at once: one for chat, one for code, one for document analysis. A DGX Station is a different class of machine: one tower with 748 GB of coherent memory, 252 GB of it HBM3e at 7.1 TB/s, and a 1,600 W power draw. A cluster wins on memory per dollar; a Station wins on speed — we compare the two in DGX Station vs a DGX Spark cluster.

Configuration Total memory Connection NVIDIA's figure What we run / examples
1× DGX Spark 128 GB — up to 200B up to ~120B at 4-bit (e.g. GPT-OSS 120B)
2× DGX Spark our setup 256 GB one QSFP56 DAC cable, no switch up to 400B MiniMax M2.7 (230B), GLM 5.3 Flash (320B)
3× DGX Spark 384 GB ring of three cables, no switch not listed —
4× DGX Spark 512 GB 200G QSFP switch up to 700B largest open models, or several models at once

NVIDIA's figures: DGX Spark product page, checked October 10, 2026. Our column is what we run or recommend in practice.

What we run on it: vLLM across both nodes, llama.cpp on single units

DGX Spark + vLLM is our default for the cluster. vLLM splits the model across both nodes with tensor parallelism over the QSFP link; NVIDIA publishes a playbook for exactly this setup (Serve LLMs with vLLM Across DGX Sparks). Our MiniMax M2.7 benchmarks below were measured this way, with 4-bit AWQ weights and a 131K-token context window.

Day to day, the cluster serves GLM 5.3 Flash, Zhipu AI's 320-billion-parameter mixture-of-experts model — our main working model. It also served as the judge in our blind quality test of Bonsai 2 27B.

DGX Spark + llama.cpp: we use llama.cpp on single units, where it shines for smaller and heavily compressed models. Our Bonsai 2 27B measurements, for example, ran on one ASUS GX10 with PrismML's build of llama.cpp. NVIDIA has a separate playbook for serving models with llama.cpp on DGX Spark.

Currently on the cluster (October 2026)

Model Prose / code, tok/s
DeepSeek V4 Flash47.3 / 56.3
GLM 5.3 Flash — vLLM, all MIT24.3 / 32.3
GLM 5.3 Flash — TensorFold36.0 / 67.0
Qwen3.8-Flash-Next37.9 / 57.4

Measured by us, one conversation, apps running alongside; DeepSeek from the August 18, 2026 series. Full comparison: Best LLM for 2× DGX Spark: DeepSeek vs GLM vs Qwen.

DGX Spark cluster benchmark: MiniMax M2.7 (230B) on two nodes

Measured in August 2026; MiniMax no longer runs on the cluster.

The best proof of what the cluster can do is a real deployment. MiniMax M2.7 has 230 billion parameters and does not fit on a single unit at all. On our two nodes it generates 33–36 tokens per second in typical use, with a 131K-token context window — everything in memory, zero swap.

33–36
tokens/s generation
131K
tokens of context
597K
tokens of KV cache (FP8)
0 GB
swap — all in memory
Generation speed vs. context length
Context Speed (tokens/s) Time per token (ms) Time to first token (s)
1K42.523.30.3
4K40.424.31.0
16K33.927.64.5
32K28.331.88.7
64K24.740.126.8
~128K17.556.576

Measured by ailone: MiniMax-M2.7, AWQ 4-bit, vLLM, cluster of 2× ASUS GX10, one request at a time, 131K window.

Which models fit in 256 GB

Capacity decides whether a model runs at all; memory bandwidth decides how fast it answers. Sizes below are for the 4-bit formats in which such models are usually run locally.

One unit is enough

Models up to ~120B

Fit on a single 128 GB DGX Spark. You don't need a cluster.

Runs on our cluster

MiniMax M2.7 (230B), GLM 5.3 Flash (320B)

Both run on our two nodes; MiniMax at 33–36 tokens per second.

Fits on two units

DeepSeek V4 Flash (284B)

About 156–175 GB in common 4-bit formats (community estimates) — too big for one Spark, fits on two with room for context.

Doesn't fit

DeepSeek V4 Pro (1.6T)

The official weights take at least ~800 GB — more than four Sparks. It would only fit with heavier compression, which usually costs answer quality.

DGX Spark cluster FAQ

Is there a 256 GB DGX Spark?

No. A single DGX Spark has 128 GB of unified memory (NVIDIA also lists a 64 GB version sold through partners). 256 GB means two units linked with a QSFP cable — NVIDIA lists this configuration as 2× DGX Spark with 256 GB, for models up to 400 billion parameters.

Does DGX Spark support NVLink between units?

No. NVLink-C2C works inside the GB10 chip, where it connects the CPU and the GPU into one coherent memory pool. Separate units talk over ConnectX-7 networking at 200 Gb/s through a QSFP cable, with NCCL handling GPU-to-GPU communication on top of that link.

Can I connect a DGX Spark and an ASUS GX10?

Both have the same ConnectX-7 200 Gb/s network card, but the NVIDIA materials we found describe linking identical DGX Spark units, not devices from different vendors. We haven't tested a mixed setup ourselves — our own cluster is two ASUS GX10 units. If you're planning a cluster, the simplest route is two identical units.

How many DGX Sparks can you cluster?

NVIDIA says ConnectX networking can link up to four DGX Spark systems: two with one direct cable, three in a ring without a switch, and four through a managed QSFP switch rated at 200 Gb/s or more. NVIDIA's Sync Cluster Assistant supports two to four systems.

How fast is a 230B model on two DGX Sparks?

In our measurements, MiniMax M2.7 (230B, 4-bit AWQ, vLLM) generates 42.5 tokens per second with a short context, 33–36 in typical use, and 17.5 at around 128K tokens of context, serving one request at a time.

Sources