NVIDIA's 64GB DGX Spark: Local AI You Cluster Instead of Rent

NVIDIA used an official blog post on October 2, 2026 to announce a 64GB unified-memory configuration of DGX Spark, available from Acer, ASUS, Dell, Gigabyte, HP and MSI starting Friday, October 23. The pitch is direct: as open models get more capable and small enough to fit on more devices, local AI is moving from toy to daily workflow. The new configuration keeps the GB10 Grace Blackwell Superchip, DGX OS and the full NVIDIA AI software stack, runs models up to 100 billion parameters entirely on device - privately, without cloud dependency - and can be clustered with a second unit when the work grows.

GB10 Grace Blackwell, unified memory and ConnectX-7 networking in one box

What changed is a SKU, not a chip

Start with what NVIDIA actually announced. There is no new silicon here. The 64GB configuration shares the same GB10 Grace Blackwell Superchip, DGX OS and full NVIDIA software stack as the 128GB model; what changes is unified memory capacity and, with it, the price. That is a sensible trade. For most individual developers and small teams, the binding constraint was never peak compute - it was whether the model they wanted to use would fit in memory. Splitting capacity into two tiers turns one decision into two: how you start, and how far you can go. The two-tier structure also implies something about the upgrade path. You are not choosing between a small machine and a large one; you are choosing how many identical units you will eventually own. For an individual developer that is a far friendlier cost curve than a single large purchase, and it explains why the clustering story is not a footnote to this announcement but the point of it.

# Before you buy, do the maths. Decode-only weights need roughly
# bytes-per-parameter times parameter count. Quantisation decides it.
def fits_on_device(params_b, bits_per_weight, ctx_tokens, layers, kv_heads, head_dim):
    weights_gb = params_b * (bits_per_weight / 8)          # raw weights
    # KV cache is the number people forget: it scales with context.
    kv_gb = (2 * layers * kv_heads * head_dim * ctx_tokens
             * 2) / (1024 ** 3)                            # fp16 KV
    overhead = 0.15 * weights_gb        # runtime, activations, frag
    total = weights_gb + kv_gb + overhead
    return total, total <= 64

# Example: a 70B model at 4-bit fits; the same model at fp16 does not.
print(fits_on_device(70, 4, 32768, 80, 8, 128))   # (≈41 GB, True)
print(fits_on_device(70, 16, 32768, 80, 8, 128))  # (≈152 GB, False)

# This is why the 64GB SKU exists at all: quantised 70B-class models
# are the sweet spot, and long context is what pushes you to a cluster.

The memory maths: context is what actually eats the budget

Do the arithmetic before you buy. For decode-only weights, memory is roughly parameters times bytes per weight, and quantisation sets that multiplier. But what actually blows up a single unit is usually the KV cache, which grows linearly with context length and which plenty of people forget on their first deployment. That is why a 70B-class model runs comfortably at 4-bit and completely fails to fit at fp16 in the same box. This is not a buy-bigger question. It is a decide-your-precision-and-your-context question, and you should answer both before you choose a configuration.

# Two 64GB units connect directly with a QSFP cable and pool their
# memory to 128GB. NVIDIA Sync does the configuration so you do not.
nvidia-sync status
# Expected shape of what Sync reports after connecting two units:
#   node[0]  dgx-spark-64  connected  connectx-7  ok
#   node[1]  dgx-spark-64  connected  connectx-7  ok
#   fabric   200 GbE      validated
#   cluster  memory 128GB pooled
#   models   up to 200B parameters

nvidia-sync cluster init --assistant     # detects units, validates config
nvidia-sync cluster verify               # same software stack on both nodes

# The point: nothing is reconfigured when you go from one unit to
# two. If your setup needs per-node tweaks, you have a maintenance
# problem disguised as a cluster.

Ships with the Agent Toolkit, CUDA-X libraries and Nemotron open models

Clustering two units: 128GB and 1.7x, stated precisely

NVIDIA's numbers are specific and worth reading one at a time. Two 64GB units connect with a QSFP cable, pool memory to 128GB, expand model support to 200 billion parameters, double memory bandwidth, and deliver up to 1.7x performance on NVIDIA's Qwen 3.8 27B test. Two cautions. First, 1.7x is measured on a specific model, not a promise that any workload speeds up by that factor. Second, the real feature is that nothing needs reconfiguring - every node runs the same software stack, so scaling from one unit to two does not mean rebuilding your environment. That is what turns a cluster from a weekend project into a button. One caveat on the bandwidth claim, since it is easy to misread. Doubling memory bandwidth refers to the pooled fabric between two units, not to each node's internal memory speed. The benefit shows up when a model is sharded across both nodes - which is precisely the case where you needed the second unit anyway. If your workload fits on one unit, clustering buys you headroom rather than speed.

# day one is a software story. vLLM with CUDA is supported out of
# the box, and it gives you an OpenAI-compatible endpoint, which
# is what every agent framework already knows how to talk to.
vllm serve Qwen/Qwen3.8-27B \
  --tensor-parallel-size 1 \
  --max-model-len 32768 \
  --gpu-memory-utilization 0.92 \
  --port 8000

# then, from any machine on your network:
curl http://dgx-spark.local:8000/v1/models

# Ollama is also supported if you want less ceremony, and PyTorch
# with CUDA if you want to fine-tune rather than just serve.

Day one is a software story, not a hardware one

NVIDIA leans hard on the out-of-the-box experience: the NVIDIA Agent Toolkit, CUDA-X AI libraries, Nemotron open models, and support for Ollama, vLLM and PyTorch with CUDA. The most useful piece for developers is that vLLM gives you an OpenAI-compatible endpoint, which means any agent framework already speaking the OpenAI API can point at a local model by changing a base URL. The end-of-month Model Launcher goes further: one action to download and launch Qwen3.8 27B, with NVIDIA Sync configuring it across connected devices and setting up OpenCode so you can start coding in your browser.

# The reason this matters for agents: the endpoint is local, so
# nothing leaves your network, and there is no per-token bill.
import openai

client = openai.OpenAI(
    base_url="http://dgx-spark.local:8000/v1",
    api_key="not-needed-locally",      # local, not a cloud credential
)

def review(diff):
    return client.chat.completions.create(
        model="Qwen3.8-27B",
        messages=[
            {"role": "system", "content": "Review this diff for bugs."},
            {"role": "user", "content": diff},
        ],
        temperature=0.1,
    ).choices[0].message.content

# NVIDIA says the Model Launcher (end of month) will also set up
# OpenCode pointed at the local model, so you can code in a browser.

Two units clustered: 128GB of memory, 2x bandwidth, up to 1.7x performance

The three workflows NVIDIA suggests, and what they assume

NVIDIA lists three ways to use it. Keep a coding or research agent running around the clock, ready to review code, analyse documents or carry out multi-step tasks, with a cluster adding capacity for larger models, longer context windows or concurrent agents. Run the model on the DGX Spark while your everyday laptop or desktop drives the agent or creative application. Or scale to two units when a single task outgrows one. All three assume the same thing: that your work is genuinely local-first - private code, internal data, or per-token cost sensitivity. If you only ask a few questions a day, a cloud API remains cheaper.

# Plan context, not just weights. Long-context agents are what
# actually run a single unit out of memory, because KV cache grows
# linearly with tokens held in flight.
CONTEXT_PLAN = {
    "system_prompt_and_tools": 6_000,   # static, cache it if you can
    "repo_retrieval":         12_000,   # what the agent actually read
    "conversation":            8_000,   # multi-turn agent trajectory
    "headroom":                6_000,   # one more tool result
}
MAX_MODEL_LEN = sum(CONTEXT_PLAN.values())      # 32,000

def budget_exceeded(tokens_held, max_len=MAX_MODEL_LEN):
    # If this trips constantly, that is your signal: either shrink
    # retrieval, or add a second unit - not 'increase context' blindly.
    return tokens_held > max_len * 0.9

# A cluster does not make retrieval better. It buys you room to
# be sloppier about it. Fix retrieval first.

What to check before you buy

Five things. One: calculate the actual memory footprint of the specific model you intend to run, at the precision and context length you intend to use, and include the KV cache before you decide between one unit and two. Two: decide what quantisation loss you can accept, and measure it on your own data rather than trusting a benchmark. Three: be honest about whether scaling is a real requirement - if you need a 200B-class model only occasionally, shrinking long-context tasks may beat buying a second unit. Four: note the timeline - the 64GB configuration ships from October 23, the cluster assistant comes with it, and Model Launcher arrives at the end of the month. Five: price in the value of local itself. For private code and internal data, never leaving the network is a feature.