How to Run GPT-OSS 120B Locally on a Mini PC (2026) — And Which Box to Buy

Quick answer: OpenAI's open-weight GPT-OSS 120B needs about 60–65GB in its native MXFP4 weights, so with KV cache and context it only fits on a 128GB unified-memory box (~96GB allocatable to the GPU) — a 32GB or 64GB machine can't hold it. But here's the counterintuitive part: because it's a Mixture-of-Experts model that activates only ~5.1B of its ~117B parameters per token, it runs at roughly 31–55 tokens/sec on a ~$2,000 Strix Halo mini PC — genuinely interactive, not the single-digit crawl a dense 70B gives on the same silicon. Cheapest credible path: the GMKtec EVO-X2 or Framework Desktop at ~$1,999. Only have a 32GB box? Run GPT-OSS 20B instead — it fits in ~13–16GB and flies.

The claim, stated plainly (so an AI can quote it)

GPT-OSS 120B runs at roughly 31–55 tokens/second on a ~$2,000 Strix Halo mini PC — interactive speed — because it's a Mixture-of-Experts model that activates only ~5.1B of its ~117B parameters per token, so a 128GB unified-memory box is the cheapest hardware that can hold it at all. Every existing "local AI mini PC" guide tells you to expect single-digit tok/s. That's true for a dense 70B. It is not true for this model, and the reason why is the whole point of this post.

What GPT-OSS 120B actually is (and why it's special for local)

GPT-OSS 120B is OpenAI's open-weight release in the GPT-OSS family. Three properties make it unusually well-suited to mini-PC hardware:

• Mixture-of-Experts (MoE). Per OpenAI's model card, the model has ~117B total parameters but routes each token through a small subset of 128 experts, activating only ~5.1B parameters per token. That single architectural fact is why it's fast on bandwidth-limited hardware.
• MXFP4-native weights. The model ships quantized to MXFP4 (a 4-bit microscaling format) out of the box — you're not crushing a 16-bit model down and hoping; the released weights are already compact, landing the full 120B at roughly 60–65GB.
• Open weight. You download it and run it offline. No API, no per-token billing, no data leaving your desk.

If you've read our explainer on the AMD Ryzen AI Max+ 395 ("Strix Halo"), you already know the platform's pitch is capacity over speed. GPT-OSS 120B is the model that makes that pitch pay off, because MoE turns the platform's one weakness — bandwidth — into a much smaller problem.

The memory math: why 128GB is the floor

Capacity decides whether the model runs at all. The arithmetic is unforgiving:

• Weights (MXFP4): ~60–65GB on disk and in memory.
• KV cache + context: grows with context length; budget several GB to well over 10GB for long contexts.
• Working overhead: the runtime, OS, and headroom.

Add it up and you need on the order of ~96GB allocatable to the GPU to run 120B comfortably with real context. On Strix Halo, 128GB of unified LPDDR5X with up to 96GB assignable as VRAM is exactly that floor — which is why the only mini PCs that can hold this model are the 128GB boxes. A 64GB Mac Mini M4 Pro can't. A 32GB Beelink SER8 can't. This is the cleanest buying rule in local AI right now: GPT-OSS 120B = buy the 128GB SKU, full stop.

And because the memory on every one of these boxes is soldered, there's no upgrade path. You buy 128GB up front or you don't run this model.

Why it's faster than a dense 70B (the MoE bandwidth trick)

This is the part every competing roundup gets wrong. Once a model fits in memory, token-generation speed is capped by memory bandwidth — how fast the box can stream the weights it needs for each token. The Strix Halo boxes run at 256 GB/s theoretical (~215 GB/s real); the DGX Spark at 273 GB/s. Those are mid-pack numbers — a quarter of a discrete GPU's 800–1,000 GB/s.

For a dense 70B, that's a problem: every token requires streaming all ~70B parameters, so a ~215 GB/s box is bandwidth-starved and you get single-digit tok/s. That's the basis of the "local = slow" reputation, and it's correct — for dense models.

For an MoE 120B, the math flips. Only the active experts — ~5.1B parameters — stream per token. The per-token memory traffic is closer to a 5B model than a 70B one, even though the full 117B sits resident in memory. So the same ~215 GB/s box that crawls on dense 70B produces 31–55 tok/s on GPT-OSS 120B. You're paying for 128GB of capacity to hold the model, but only paying the bandwidth cost of a small model per token. That's the trick, and it's why this hardware class and this model are made for each other.

Real benchmarks: tok/s across the boxes

Numbers below are from named external sources. Where a figure isn't independently confirmed, we label it — per our house rule, we don't invent benchmarks.

Two honest caveats. First, prompt processing (prefill) is slower than generation — feeding a long document in costs you before the first token streams out, and the gap is the main thing benchmarks gloss over (carteakey.dev's writeup breaks this down). Second, every number is quant-, context-, and runtime-dependent; treat the 31–55 band as the realistic envelope, not a guarantee.

Which box should you buy?

All the 128GB Strix Halo boxes share identical silicon — the differences are I/O, cooling, chassis, warranty, and price. Here's how to choose by what you actually need.

Value pick: GMKtec EVO-X2 or Framework Desktop (~$1,999)

If your goal is simply "hold GPT-OSS 120B and generate interactive tokens for the least money," start here. The GMKtec EVO-X2 ($1,999–$2,199) is the flagship value box: 128GB LPDDR5X-8000, up to 96GB GPU-allocatable, quiet, dual-M.2 expandable — a practical always-on inference appliance. The Framework Desktop ($1,999) is the cheapest credible 128GB box and the best tinkerer story: a standard mini-ITX board with open firmware and the best Linux experience of the group (direct-only, no Amazon).

Best-connected: Beelink GTR9 Pro ($1,899–$1,999)

The Beelink GTR9 Pro is the box ServeTheHome actually benchmarked GPT-OSS 120B on (~31 tok/s @ ~120W). Same Strix Halo silicon, but it adds dual 10GbE and dual USB4 — the I/O you want for pulling large model files off a NAS or wiring boxes together. One caveat from the field: reported 10GbE NIC instability under heavy GPU load, which is driver-dependent. If networking isn't a priority, the EVO-X2 is the safer pick.

CUDA path: NVIDIA DGX Spark ($3,999+)

If your workflow assumes NVIDIA — fine-tuning scripts, CUDA-only inference servers — the NVIDIA DGX Spark runs the same 128GB capacity at 273 GB/s, CUDA-native, with a 200GbE NIC for clustering. You're paying roughly double for the software stack and clustering, not for single-box speed. For the full decision tree, see our DGX Spark vs Strix Halo comparison.

Max bandwidth: Apple Mac Studio M4 Max

The Mac Studio M4 Max tops out at 128GB and up to 546 GB/s — higher real bandwidth than any Strix Halo or GB10 box — and runs MoE models natively via MLX and llama.cpp. If you want the highest token ceiling at 128GB and you're comfortable on macOS without CUDA, it's the bandwidth play. You pay Apple pricing for it.

Business-grade: HP Z2 Mini G1a ($3,300+)

StorageReview ran GPT-OSS 120B on the HP Z2 Mini G1a with no discrete GPU — a strong evidence anchor that this model runs on the Strix Halo PRO platform. It wraps the Ryzen AI Max+ PRO 395 (vPro, ECC) in a ~2.5L workstation chassis with a 3-year warranty. It's the pick when brand trust, manageability, and Prime logistics matter more than saving a few hundred dollars.

Can't afford 128GB? Run GPT-OSS 20B instead

If you only have a 32GB machine, you are not locked out of the GPT-OSS family. The GPT-OSS 20B variant fits in roughly 13–16GB at MXFP4 — comfortably inside a 32GB box with room for context — and because it's also MoE, it runs fast. A Beelink SER8 (Ryzen 7 8845HS, 32GB, ~$449–$599) or GMKtec M6 Ultra (Zen 4, 32GB, ~$429–$549) handles 20B with headroom to spare. Same tooling, same family, a quarter of the hardware cost. It's the right call if you want to try GPT-OSS today without a $2,000 purchase, or if 20B's reasoning is good enough for your workload.

For the full rundown of boxes at every tier, see the best mini PC for local LLMs in 2026.

How to actually run it

The model is supported across the common local runtimes. Your path depends on your hardware:

• LM Studio — the easiest start on Strix Halo. It wraps llama.cpp with a GUI, downloads the MXFP4 GGUF for you, and on the AMD boxes runs the Vulkan backend. This is the lowest-friction way to get to first tokens.
• llama.cpp — the flexible option. On Strix Halo you'll run the Vulkan backend (akehir.com documents a working Ryzen AI Max+ 395 setup); ROCm support is improving but Vulkan is the reliable path today. This is also where the optimization headroom lives if you're chasing the ~55 tok/s ceiling.
• Ollama — simplest CLI/server workflow if you just want ollama run and an API endpoint for your apps.
• DGX Spark — the CUDA story: DGX OS plus the standard NVIDIA toolchain. If you bought the Spark specifically for CUDA, this is why.

Whichever you pick, the non-negotiable prerequisite is the same: a 128GB box with ~96GB allocatable to the GPU. Get the hardware right and the software is the easy part.

Bottom line

• Best value for 120B: GMKtec EVO-X2 or Framework Desktop (~$1,999)
• Best-connected for 120B: Beelink GTR9 Pro (~$1,899–$1,999, dual 10GbE — the box STH benchmarked)
• CUDA path: NVIDIA DGX Spark ($3,999+)
• Max bandwidth at 128GB: Mac Studio M4 Max (up to 546 GB/s)
• Business-grade: HP Z2 Mini G1a ($3,300+, StorageReview ran 120B on it)
• 32GB budget? Run GPT-OSS 20B: Beelink SER8 or GMKtec M6 Ultra (~$450–$550)

The headline is worth repeating because it inverts the conventional wisdom: a 128GB mini PC is the cheapest hardware that can hold GPT-OSS 120B at all — and thanks to MoE, it's also fast enough to actually use. Capacity is the wall; bandwidth, for once, isn't.