gpt-oss 120B on a 128GB Box: DGX Spark (ASUS Ascent GX10) vs Ryzen AI Max+ 395 tok/s Table

On the ASUS Ascent GX10, a GB10 box with 128 GB of unified memory, gpt-oss 120B generates at about 55-61 tok/s. NVIDIA reports 55.37 tok/s in llama.cpp on the NVIDIA Developer Blog. A community run in llama.cpp discussion #16578 reached 60.57 tok/s on a newer build.

gpt-oss 120B is the open-weight model people actually want to run at home in late 2026. It is a 117B-parameter mixture-of-experts model with about 5.1B parameters active per token, according to OpenAI's model card on Hugging Face. OpenAI ships it in native MXFP4, and the llama-bench runs in this article load a 59 GiB file (about 63.4 GB in decimal units, per the ggml-org GGUF repo). That single number decides the buying question. An ASUS TUF Gaming GeForce RTX 5090 32GB has 32 GB of GDDR7, so the model does not fit. To keep the whole model in fast memory you need a box with 96-128 GB of unified memory. In practice that means a GB10 machine such as the GX10 or the DGX Spark, or a Ryzen AI Max+ 395 (Strix Halo) mini PC such as the Beelink GTR9 Pro or the BOSGAME M5.

This article covers one model on one memory tier. Every throughput figure below comes from a named, linked source. SpecPicks did not benchmark these machines itself. This is a synthesis of published runs, current as of November 2026.

Key takeaways - GB10 decode: 55-61 tok/s on gpt-oss 120B MXFP4. NVIDIA's figure is 55.37 tok/s (NVIDIA Developer Blog). The best community run is 60.57 tok/s (llama.cpp #16578). - Strix Halo decode: 47-49 tok/s on the same model. A GMKtec EVO-X2 measured 47.49 tok/s in the same llama.cpp thread, and an August 2026 build reached 49.0 tok/s (See Hiong). - Prefill is where GB10 pulls away. It processed prompts at 1,956 tok/s against 1,000 tok/s on Strix Halo in the same tester's runs, about 2x faster. - Software moves the GB10 number by about 30%. One contributor measured 45.87 tok/s on stock DGX OS and 60.57 tok/s on Fedora 43 with a newer llama.cpp build, on the same hardware (llama.cpp #16578).

gpt-oss 120B on GB10: what does every published run show?

All rows use the native MXFP4 weights in llama.cpp. Prefill is pp2048 and generation is tg128 or tg32, both at zero context depth unless noted.

Across the four zero-depth runs the median generation rate is about 57 tok/s, and three of the four fall between 55 and 61. The stock-OS run is the outlier. We found no public F16 or Q8_0 GGUF rows for gpt-oss 120B on GB10 that list a build number, so the table only includes MXFP4 runs. The running list of every row we track for this chip is on the NVIDIA GB10 (DGX Spark) benchmark page.

The GX10 uses the same GB10 superchip and the same 128 GB of LPDDR5X as NVIDIA's own DGX Spark. These figures carry over to it, with small differences from chassis cooling and storage.

How much memory does gpt-oss 120B need at each quant?

We left out F16 and Q8_0 rows. We could not find a public file listing that states their size with a source we would cite, and we would rather show no row than guess at one. The practical point stays the same either way. The MXFP4 file already needs most of a 96 GB machine. A 128 GB box runs it with room for a long context window, and a 64 GB box cannot hold it resident.

Why does the Spark's OS and kernel move generation by about 30%?

The most useful row in the GB10 table is the pair from a single contributor in llama.cpp #16578. On stock DGX OS with llama.cpp build 6816 they measured 45.87 tok/s. On Fedora 43 with NVIDIA's 6.17.1 kernel and build 6922 they measured 60.57 tok/s. The hardware and the model file were the same in both runs. What changed was the kernel, the driver stack and about a hundred llama.cpp commits, and together those gave 32% more generation speed.

Two takeaways for owners:

1. Update llama.cpp before you judge your box. CUDA kernels for Blackwell's consumer-class GB10 were still being tuned in late 2025, and the later ggml-org build 7941 holds 58.72 tok/s on stock tooling (ggml-org bench).
2. Compare like with like. A 46 tok/s screenshot and a 60 tok/s screenshot can both be honest numbers from the same GB10 box. Look up the build number before you treat a forum figure as evidence that one OEM box beats another.

How does context depth change tok/s on GB10?

The JetsonHacks llama-bench sweep is the clearest published depth curve for the Spark. It shows gpt-oss 20B dropping from 79.7 tok/s at zero depth to about 56 tok/s at a 32k-token context. For the 120B model, the cleanest same-tester data comes from the #16578 thread, which pairs a GB10 with a Strix Halo box on the same test:

Sources: GB10 figures from the CUDA run in #16578. Strix Halo figures from a GMKtec EVO-X2 on ROCm in the same thread. Both runs use tg32 and pp2048 with flash attention on.

GB10 loses about a third of its generation speed between an empty context and 32k tokens. The decode gap between the two chips shrinks from 28% to 15% over that range, while the prefill gap grows from about 2x to about 2.9x. For agent loops and long-document RAG, where every turn re-reads a large prompt, the growing prefill gap matters more than the shrinking decode gap. We found no published 120B run beyond 32k on either chip. If you plan to work at 64k-128k, extrapolate from this curve with care.

Prefill vs generation: why is GB10 strong on prompt processing and bandwidth-bound on output?

Generation is a memory-bandwidth problem. Each new token reads every active weight once. gpt-oss 120B activates about 5.1B parameters per token, which is roughly 2.8 GB of MXFP4 weights per token before KV-cache reads. GB10's LPDDR5X runs at about 273 GB/s (per the JetsonHacks notes and IntuitionLabs), so the theoretical ceiling is about 97 tok/s. Real runs land at about 60% of that. Strix Halo's 256-bit LPDDR5X-8000 bus peaks at about 256 GB/s (AMD), which explains why its decode rate trails GB10 by a margin close to the bandwidth gap plus software maturity.

Prefill is a compute problem. The whole prompt is processed in large matrix multiplies, so tensor throughput matters more than bandwidth. That is where Blackwell's tensor cores and CUDA kernels give GB10 its roughly 2x lead over Strix Halo's RDNA 3.5 iGPU on ROCm. If your typical prompt is short and your outputs are long, as in chat, the two boxes feel similar. If your prompts are long, as with code-base context, RAG chunks or tool transcripts, GB10 returns the first token much sooner.

Spec delta: ASUS Ascent GX10 vs Beelink GTR9 Pro vs BOSGAME M5 vs RTX 5090

Bandwidth sources: GB10 from IntuitionLabs, Strix Halo from AMD, RTX 5090 from TechPowerUp. The live price buttons on each product page show current pricing.

Ryzen AI Max+ 395 128GB: how close does Strix Halo get on the same model?

Published Strix Halo runs of gpt-oss 120B MXFP4 on a single box:

• 47.49 tok/s decode, 999.59 tok/s prefill. GMKtec EVO-X2, ROCm (HIP), llama.cpp build 03792ad (llama.cpp #16578).
• 49.0 tok/s decode, 165.9 tok/s prompt processing. GMKtec EVO-X2, llama.cpp b10440 on ROCm 7.x with an 8,192-token context. This was measured with llama-cli, so the prefill figure is not comparable to llama-bench's pp2048 (See Hiong, August 2026).
• 33.12 tok/s decode. Framework Desktop mainboard on an earlier 2025 software stack (Jeff Geerling).

The spread from 33 to 49 tok/s mostly reflects ROCm and llama.cpp releases, the same kind of effect as GB10's 46-to-61 OS gap. On current builds, Strix Halo reaches about 80% of GB10's decode speed and about half its prefill speed. The Beelink GTR9 Pro and BOSGAME M5 are the purchasable 128 GB configurations in our catalog. Both use the same Ryzen AI Max+ 395 and the same 128 GB memory tier as the EVO-X2 in those runs, so expect similar results once the iGPU is allocated enough memory. For the full platform breakdown see our Ryzen AI Max+ 395 Strix Halo 128GB mini PC guide.

Where does an RTX 5090 fit if 32 GB cannot hold the model?

It fits as a partial host. With llama.cpp's MoE offload flags, you keep the attention layers and some experts on the card and stream the rest from system RAM. Each token then waits on dual-channel DDR5 and PCIe, not on the card's 1,792 GB/s. The result depends far more on your CPU and memory than on the GPU. Our gpt-oss-120b RTX 3060 offload test write-up shows the pattern on a smaller card. We found no sourced, fully documented RTX 5090 offload run for gpt-oss 120B to put in a table, so we give no tok/s figure here.

The 5090 still wins by a wide margin on models that fit. It runs gpt-oss 20B at 298.2 tok/s per Hardware Corner, against 79.7-83.4 tok/s on GB10. See RTX 5090 vs RTX Spark: 32 GB vs 128 GB and the RTX 5090 benchmark page.

Perf per dollar and per watt at launch MSRP only

All prices are launch MSRPs, not street prices.

Per dollar. NVIDIA's DGX Spark Founders Edition launched at $3,999, and NVIDIA raised the list price to $4,699 in February 2026, per IntuitionLabs. At 60.57 tok/s that is about 15.1 tok/s per $1,000 at the launch price, or 12.9 at the raised list price. We found no sourced launch MSRP for the GX10, GTR9 Pro or M5 configurations, so we do not compute a ratio for them. Use the live price widget on each product page and divide 60.57 (GB10) or 47.49 (Strix Halo) by the price in thousands. The RTX 5090 card listed at $1,999 at launch (TechPowerUp), but it cannot run this model resident, so a gpt-oss 120B ratio would not mean much.

Per watt. GB10 has a 140 W SoC TDP, per Tom's Hardware. That works out to about 0.43 tok/s per SoC watt. AMD lists Strix Halo at a configurable 45-120 W. At its 120 W ceiling, 47.49 tok/s works out to about 0.40 tok/s per watt. These are chip-TDP ratios, not wall-power measurements. Both boxes are within about 10% of each other on this metric, and both are in a different class from a 575 W RTX 5090 plus a host PC.

Common pitfalls

1. Leaving the Strix Halo iGPU allocation at the default. A small default VRAM split leaves gpt-oss 120B half on the CPU path. Raise the GPU memory allocation in BIOS or through the kernel's GTT settings before loading the model.
2. Comparing Ollama numbers to llama-bench numbers. On GB10, LMSYS measured gpt-oss 20B at 49.7 tok/s in Ollama at batch 1, against 83.4 tok/s for the same model in a later llama.cpp build. Runtime choice alone can swing results by 40%.
3. Benchmarking at zero context and deploying at 32k. The depth table above shows a 33% decode drop on GB10 and 25% on Strix Halo. Size your expectations to your real context length.
4. Trusting a stock-image result. The 45.87 vs 60.57 tok/s pair shows that an un-updated OS image can cost about a quarter of your throughput.

When NOT to buy a 128 GB box for this

Skip both if your workload fits in 32 GB, such as gpt-oss 20B, Qwen 30B-class MoE at 4-bit, or anything under about 27B dense. A discrete RTX 5090 is 3-4x faster on those models. Also skip them if you need multi-user serving throughput. A single GB10 or Strix Halo box is a batch-1 developer machine, not a serving node.

Verdict matrix

• Get the GX10 (or another GB10 box) if prompts are long (RAG, coding agents, document Q&A), you want CUDA and NVIDIA's container stack, or you may move work onto DGX cloud hardware later. It has the fastest published gpt-oss 120B decode in this class and about 2-2.9x Strix Halo's prefill.
• Get a Ryzen AI Max+ 395 box (GTR9 Pro or M5) if your workload is mostly chat with short prompts, you want an x86 machine that also runs Windows and ordinary desktop software, and about 80% of GB10's decode speed is enough.
• Get an RTX 5090 if gpt-oss 120B is an occasional experiment and your daily models fit in 32 GB. You keep 3-4x the speed on those, and you accept slow, RAM-bound offload on the big one.

Recommended pick

For someone buying a machine specifically to run gpt-oss 120B well, the ASUS Ascent GX10 is the pick. The deciding spec is prefill. Both boxes hold the model in 128 GB, and decode differs by only 15-28%, but GB10 processes prompts about twice as fast at every context depth in the same-tester table, and that gap reaches 2.9x at 32k tokens. If your prompts are short and you want a general-purpose x86 desktop, the Beelink GTR9 Pro is the alternative.

Related guides

• gpt-oss 20B on the Surface Laptop Ultra: RTX Spark vs DGX Spark
• DGX Spark vs Mac Studio M3 Ultra
• Strix Halo clustering for local LLMs
• Ryzen AI Max+ 395 Strix Halo 128GB mini PC guide
• RTX 5090 vs RTX Spark N1X: 32 GB vs 128 GB

Live price comparison

See current prices side by side: ASUS Ascent GX10 vs Beelink GTR9 Pro.

Citations and sources

All sources accessed November 2026.

• NVIDIA Developer Blog — How NVIDIA DGX Spark's performance enables intensive AI tasks
• llama.cpp GitHub discussion #16578 — DGX Spark and Strix Halo llama-bench results
• ggml-org — official DGX Spark llama.cpp benchmarks
• JetsonHacks — DGX Spark llama.cpp bench notes
• OpenAI — gpt-oss-120b model card
• ggml-org — gpt-oss-120b GGUF
• AMD — Ryzen AI Max+ 395 specifications
• See Hiong — Running llama.cpp on AMD Strix Halo (August 2026)
• Jeff Geerling — Clustering four Framework mainboards
• IntuitionLabs — NVIDIA DGX Spark review
• TechPowerUp — GeForce RTX 5090 specs
• Tom's Hardware — RTX Spark / GB10 power budget
• Hardware Corner — RTX 5090 LLM benchmarks

This article is an editorial synthesis of the published measurements above. SpecPicks did not run these benchmarks itself, and every figure is attributed to its source.