Chip guide · with community benchmarks

NVIDIA GB10 for inference: what 128 GB unified memory buys you

GB10 is NVIDIA's Grace-Blackwell superchip: an ARM64 Grace CPU and a Blackwell GPU sharing one 128 GB memory pool. We run it in production and rent it as a dedicated DGX Spark, with clearly-labelled community benchmarks for the hardware class below.

128 GB unified · CPU + GPU ARM64 Rentable as DGX Spark, from €0.85/hour gb10.axforge.ai

Rent a DGX Spark Check availability Run this on a dedicated AxForge GB10, from €0.85/hour, full SSH access, hosted in Málaga, Spain (eu-es-1).

The chip

What GB10 is

Design	Grace-Blackwell superchip: Grace CPU + Blackwell GPU on one package
Memory	128 GB unified, shared CPU/GPU: one pool, no separate VRAM
CPU architecture	ARM64 (Grace)
Ships in	NVIDIA DGX Spark, the rentable product
At AxForge	Serves AxForge serverless inference from Stockholm, Sweden (eu-se-1), and is rentable as dedicated DGX Spark machines from Málaga, Spain (eu-es-1)

Unified memory changes the sizing question. On a conventional GPU, the model must fit in VRAM. On GB10, weights, KV cache and the host share one 128 GB pool, so model weights up to roughly 100 GB can load on a single chip without sharding across devices, with room left for cache and the system. For the 7B to 35B models we serve, that means the whole model plus a 262,144-token context fits with headroom.

Community data

The wider GB10 picture: SparkBench

Not our numbers: SparkBench measures models on a single GB10 at 4k context with its PBM methodology, and ranks decode throughput after a fixed context fill. Useful for comparing what the chip can do across model families and runtimes.

Model	Architecture	Quant / optimization	Workload	Speed @ 4k
Qwen3.6-35B-A3B	35B / 3B active MoE	NVFP4 + MTP	Agents / general / reasoning	86.3 t/s
Mellum2 12B MoE Opus Thinking	12B / 2.5B active	Q4	Code / reasoning	83.8 t/s
Ornith 1.5 35B-A3B	35B / 3B active MoE	NVFP4 + MTP	Agents / code / reasoning	70.8 t/s
Qwen3-Coder-Next	80B / 3B active MoE	NVFP4	Agents / code	58.9 t/s
Ornith 1.0 35B	35B / 3B active	NVFP4	General	46.5 t/s
Qwen3-Coder-30B-A3B-Instruct	30B / 3B active MoE	Q4_K_M	Agents / code	42.1 t/s
Qwen AgentWorld 35B-A3B	35B / 3B active	—	General	29.6 t/s
Laguna S 2.1	118B / 8B active MoE	NVFP4 + DFlash	Agents / code	29.1 t/s
Qwen3.6 27B Aeon	27B dense	NVFP4 + DFlash	General	26.0 t/s
Qwen3.8-27B MTP	27B dense	NVFP4 + MTP	Agents / general / reasoning	25.1 t/s
DeepSeek V4 Flash 0731	180B / 13B active	EXL3D / SparkInfer	Code / reasoning	23.4 t/s
Gemma 4 26B-A4B-IT	26B / 4B active MoE	—	Multimodal / reasoning	23.0 t/s
Laguna XS 2.1	33B / 3B active	DFlash	Agents / code	21.4 t/s
Step-3.7-Flash	198B / 11B active	IQ4_XS	Agents / multimodal	20.5 t/s
Gemma 4 12B IT	12B dense	Q4_K_M	General / multimodal	19.8 t/s
Gemma 4 12B Coder	12B dense	Q4	Code	19.1 t/s
Qwen3.6-27B	27B dense	FP8 + DFlash	Agents / reasoning	17.3 t/s
Qwythos 9B Claude Mythos	9B dense	—	General	12.6 t/s

Community results vary by runtime, quantization, context length and serving configuration. We run this hardware in production; until our own tuned benchmark run is published, these labelled community tables carry the picture.

Community data

Model size vs speed: the MoE effect

From a llama.cpp size sweep on GB10 (Q4_K_M, batch size 1), the clearest demonstration of how the chip behaves across model sizes:

Model	Params	Decode @ 512	Decode @ 2048	Prompt proc @ 512	PP @ 16k
Qwen3 1.7B	1.7B	161.4 t/s	146.1	11,947	5,208
Ministral 3B	3.4B	91.9	86.6	6,961	3,166
Qwen3 8B	8.2B	43.7	42.0	3,167	1,862
Ministral 8B	8.5B	41.7	40.1	3,020	1,868
Ministral 14B	13.5B	26.4	25.7	1,853	1,284
Qwen3 30B-A3B MoE	30.5B / ~3B active	89.3 t/s	83.8	2,541	2,059
Qwen3 32B dense	32.8B	10.7 t/s	10.5	762	481

30B MoE ≈ 8× a 32B dense

Almost the same parameter count, but 89 vs 11 tokens/s. GB10 has plenty of compute but roughly 273 GB/s of LPDDR5X memory bandwidth: dense decode is bandwidth-limited, while a sparse MoE only reads its active experts per token.

Software moves the numbers

Older llama.cpp runs put Qwen3 30B-A3B at ~44 to 46 t/s shallow-context; newer builds of the same setup reach ~61 t/s, and optimized NVFP4/MTP stacks go higher still. A six-month-old GB10 benchmark understates the same box today.

Community data

Context depth and concurrency change the answer

From the official llama.cpp DGX Spark benchmark set, Qwen3-Coder 30B-A3B (Q8) shows the same model and machine producing very different, equally correct numbers:

Context depth	Single-stream decode
~0	61.1 t/s
4k	54.8 t/s
8k	48.0 t/s
16k	40.2 t/s
32k	30.2 t/s

Decode slows as the KV cache grows. "60 t/s" and "30 t/s" can both be true for the same model, at different context depths.

Concurrent batches	Aggregate decode @ 4k
1	53.5 t/s
2	62.8 t/s
4	83.8 t/s
8	120.4 t/s
16	165.0 t/s
32	216.8 t/s

Aggregate throughput across many streams, not 216 tokens/s for one user. A dedicated machine cares about single-stream speed; an API serving many users cares about both.

The shape of the machine

What runs well on 128 GB unified memory

Boiling all of the above down: GB10 is not "small = fast, big = slow". A 35B MoE can be eight times faster than a 32B dense model on it. Large-model capacity at workstation economics, not an H100 replacement, and not trying to be.

Model type	Typical GB10 experience
1 to 4B dense	Very fast, ~90 to 160+ t/s
7 to 9B dense	Fast, ~30 to 45 t/s
12 to 14B dense	Good, ~20 to 30 t/s
27 to 32B dense	~10 to 25 t/s, heavily optimization-dependent
30 to 35B MoE, ~3B active	Excellent, ~40 to 90 t/s
~80B MoE, ~3B active	Can still reach ~60 t/s
100 to 200B MoE	Fits and runs depending on quant, often ~20 to 30 t/s
>100B dense	Fits only with aggressive quantization; tends to be slow

Ranges assembled from the labelled community sources above, 2026-09. Your model, quantization and serving stack decide where in the range you land, and an engineer can scope it with you.

Data & privacy

Production GB10, EU rules

Our GB10 systems run in the EU: eu-se-1 · Stockholm for serverless inference and RTX 3060 rentals, eu-es-1 · Málaga for dedicated DGX Spark workloads. On a dedicated machine: your model, your traffic, our hardware. Prompts are never persisted. Only operational metadata is kept for billing and operations. Full policy at axforge.ai/privacy.

FAQ

NVIDIA GB10: common questions

What is the NVIDIA GB10?

GB10 is NVIDIA's Grace-Blackwell superchip: a Grace ARM64 CPU and a Blackwell GPU sharing 128 GB of unified memory in one pool. It powers the NVIDIA DGX Spark.

How much memory does GB10 have?

128 GB of unified memory, shared between CPU and GPU. There is no separate VRAM pool. Weights, KV cache and the host share the same 128 GB.

How fast is GB10 for LLM inference?

Community benchmarks (SparkBench, llama.cpp) span roughly 10 tokens/s for 30B-class dense models up to ~90 tokens/s for 30 to 35B MoE at 4k context, with small dense models faster still. Architecture, quantization and serving stack dominate. See the labelled tables on this page.

Can I rent GB10 in the cloud?

Yes, as a dedicated NVIDIA DGX Spark from AxForge, hosted in Málaga, Spain (eu-es-1) with full SSH access, by the hour, week, month or year: €1.19/hour on demand · €0.95/hour by the week · €0.91/hour by the month · €0.85/hour by the year.

Does GB10 run large models without sharding?

The 128 GB unified pool means model weights up to roughly 100 GB can load on a single GB10 without sharding across devices, leaving room for KV cache and the system. Production workloads on our nodes are 7B to 35B class models.

Is GB10 an ARM platform?

Yes. The Grace CPU is ARM64, so software must be built for ARM64. Our own serving stack runs on it in production.

NVIDIA GB10 for inference: what 128 GB unified memory buys you

What GB10 is

The wider GB10 picture: SparkBench

Model size vs speed: the MoE effect

Context depth and concurrency change the answer

What runs well on 128 GB unified memory

Run this on a dedicated AxForge GB10, from €0.85/hour

Production GB10, EU rules

Which models fit a GB10

NVIDIA GB10: common questions

Need a machine scoped to your workload?

All GPUs