GMKtec EVO-X2 Review (2026): The 128GB Ryzen AI Max+ 395 Mini PC That Runs 70B Models — Real Benchmarks & Who Should Buy

Quick answer: The GMKtec EVO-X2 is a 128GB AMD Ryzen AI Max+ 395 ("Strix Halo") mini PC that sells for roughly $1,999–$2,199 and holds a 4-bit 70B model (≈42–48GB) in its unified memory — something no 24–32GB consumer GPU can do. On its ~256 GB/s theoretical (~215 GB/s real) memory it runs a 7B model at ~50–80 tok/s, a dense 70B at ~5–10 tok/s, and — because Mixture-of-Experts models only stream a fraction of their weights per token — GPT-OSS 120B at around 31 tok/s and Qwen3 235B at ~8–11 tok/s. It's the flagship, quiet, always-on Strix Halo appliance and the value pick versus the $3,999 NVIDIA DGX Spark — provided you're fine living in the ROCm/Vulkan/llama.cpp world (no CUDA). Buy it for capacity, not raw speed.

GMKtec EVO-X2 at a glance (specs + price reality)

The EVO-X2 is GMKtec's flagship local-AI box, and the silicon inside it is identical to every other Ryzen AI Max+ 395 machine — what you're really buying is GMKtec's chassis, cooling, and I/O choices wrapped around AMD's Strix Halo APU. Here's the configuration, pulled straight from the spec sheet:

The headline number is that up to 96GB of the 128GB pool is assignable as VRAM. That's the entire reason this box exists: a 70B model quantized to 4-bit needs roughly 40–48GB plus context, which fits comfortably inside 96GB but is impossible on any 24GB or 32GB discrete card. Dual M.2 slots (2TB in the box, expandable to 16TB) make it a practical place to park a library of multi-gigabyte model files.

On price, be honest with yourself. The EVO-X2 launched near ~$1,500–$1,800, but mid-2026 street pricing has crept toward — and past — its ~$1,999–$2,199 MSRP during the ongoing DRAM shortage. Reviewers now benchmark it against a moving target. Verify the current price at the retailer before you buy; don't anchor on a stale launch figure. The memory is soldered, so whatever SKU you pay for is the SKU you keep — there is no upgrade path.

What it can actually run — benchmarks by model size

This is the table you came for. Speed on the EVO-X2 is governed by memory bandwidth, not compute or capacity, so the pattern is consistent: small dense models fly, big dense models crawl, and MoE models punch far above their parameter count. Every figure below is sourced or labeled; per our house rule, we don't invent tok/s numbers.

Sources & caveats. The GPT-OSS 120B figure (~31 tok/s at ~120W) is ServeTheHome's measurement on the sibling Beelink GTR9 Pro, which shares the EVO-X2's exact APU and memory; community datapoints on Strix Halo have reported ~46 tok/s and optimized llama.cpp/LM Studio runs into the low-50s. The 7B (~50–80 tok/s) and dense-70B (~5–10 tok/s) bands are the widely-reported envelope for ~215 GB/s Strix Halo hardware — treat them as realistic ranges, not guarantees. The Qwen3 235B figure is a community-reported ballpark we label needs verification. Every number is quant-, context-, and runtime-dependent; prompt processing (prefill) on long contexts is slower than generation, which is the caveat most benchmarks gloss over.

For a deep dive on the MoE case specifically, see how to run GPT-OSS 120B locally — the EVO-X2 is one of the recommended boxes there.

Why it's fast for some models and slow for others (bandwidth, not capacity)

The single rule that explains the whole table above: once a model fits in memory, token-generation speed is capped by how fast the box can stream the weights it needs for each token — memory bandwidth — not by compute or by how much memory you have spare. The EVO-X2's ~215 GB/s real bandwidth is about 2× a normal APU but roughly a quarter of a discrete GPU's 800–1,000 GB/s.

For a dense 70B, every single token requires streaming all ~70B parameters through that ~215 GB/s pipe. That's why you get single-digit tok/s — the box is bandwidth-starved, and this is the basis of the "local AI is slow" reputation. It's correct, for dense models.

For a Mixture-of-Experts model like GPT-OSS 120B, the math flips. The full ~117B parameters sit resident in the 128GB pool, but only the active experts — about ~5.1B parameters — stream per token. So the per-token memory traffic is closer to a 5B model than a 70B one, and the same box that crawls on dense 70B produces interactive ~31 tok/s. You pay for 128GB of capacity to hold the model, but only the bandwidth cost of a small model per token. That's why the EVO-X2 and modern MoE models are made for each other — and why the smart 2026 workload for this box is a big MoE, not a dense 70B. The full explanation lives in our Strix Halo explainer.

Thermals, noise, and always-on use

GMKtec pitches the EVO-X2 as a quiet, always-on inference appliance, and that framing holds up. Sustained LLM inference on Strix Halo pulls roughly 120–140W at the wall — modest for what it's doing — and the chassis cooling is sized to hold that load without the fan scream you'd get trying to push a discrete GPU that hard. Notebookcheck's Strix Halo thermal testing has documented these boxes running large models near 120W while staying acoustically reasonable; ServeTheHome measured the sibling GTR9 Pro sustaining ~120W inference at roughly 36–41 dBA.

What that means in practice: the EVO-X2 is genuinely suited to 24/7 duty as a home-lab inference server. It's quiet enough to sit on a desk, cool enough not to need a rack, and its dual-M.2 storage gives you room to keep several large models resident. If your plan is "leave a 70B or a 120B MoE loaded and hit it from other machines all day," this is exactly the profile you want — a low-wattage, low-noise box that doesn't fight you.

The software reality: ROCm, Vulkan, LM Studio, llama.cpp

Here's where you have to be clear-eyed. There is no CUDA on the EVO-X2. You live in AMD's ecosystem, and the honest state of it in mid-2026 is: inference "just works" through the mainstream tools, but anything beyond inference still has rough edges.

• LM Studio — the lowest-friction start. It wraps llama.cpp in a GUI, downloads the right GGUF for you, and runs the Vulkan backend on the Radeon 8060S. This is how most people should get to first tokens.
• llama.cpp (Vulkan) — the reliable path today and where the optimization headroom lives. The Vulkan backend is the dependable way to drive the iGPU; community writeups document working Ryzen AI Max+ 395 setups reaching the low-50s tok/s on GPT-OSS 120B.
• ROCm — improving fast, but still the fiddly option for GPU-compute beyond inference (fine-tuning, custom kernels). If your workflow assumes a mature ROCm stack, budget setup time.
• Ollama — simplest CLI/server workflow if you just want ollama run and an API endpoint for your apps.

Set expectations honestly: for running models locally, the EVO-X2 is a solved problem. For training or CUDA-dependent tooling, it isn't the box — that's the DGX Spark's job, and it's the main reason to pay double.

EVO-X2 vs the alternatives

The EVO-X2 doesn't exist in a vacuum. Here's the honest decision matrix against every box it competes with — three of them share its exact silicon, so the differences are I/O, cooling, price, and software stack, not raw capability.

vs Framework Desktop — the tinkerer's alternative

The Framework Desktop ($1,999) is the same silicon on a standard mini-ITX board with open firmware — the best pick if you want to drop it in your own case, run Linux, and tinker. It's direct-only (no Amazon). The EVO-X2 wins on being a finished, quiet appliance out of the box; Framework wins on openness and being the cheapest credible entry.

vs Beelink GTR9 Pro — the networking pick

The Beelink GTR9 Pro ($1,899–$1,999) is the box to buy if you need dual 10GbE — pulling multi-gigabyte models off a fast NAS or wiring boxes together. It's the machine ServeTheHome actually benchmarked GPT-OSS 120B on (~31 tok/s @ ~120W). The catch: reported 10GbE NIC instability under heavy GPU load, which is driver-dependent. If networking isn't a priority, the EVO-X2 is the safer, quieter default.

vs DGX Spark — the CUDA premium

The NVIDIA DGX Spark ($3,999+) is the reason to leave AMD behind: CUDA-native tooling and a 200GbE ConnectX-7 NIC that lets two boxes cluster into a 256GB pool for 405B-class models. But on single-box inference it's barely faster — 273 GB/s vs the EVO-X2's ~256 GB/s theoretical — so you're paying roughly double for the software stack and clustering, not throughput. We break the full decision down in DGX Spark vs Strix Halo.

vs Mac Studio M4 Max — the bandwidth king

If maximum token speed at 128GB is the priority, the Mac Studio M4 Max (up to 546 GB/s) has more than double the EVO-X2's real bandwidth and runs MoE models natively via MLX. You give up CUDA and pay Apple pricing, but for raw generation speed at 128GB it's the stronger box. For where every tier lands, see the best mini PC for local LLMs in 2026.

Who should buy the EVO-X2 (and who shouldn't)

Buy the EVO-X2 if:

• You want to run 70B-class or large MoE models locally for the lowest realistic price (~$2,000).
• You value capacity over raw speed — you'd rather hold a big model than race a small one.
• You want a quiet, always-on inference appliance that sits on a desk and runs 24/7.
• You're comfortable in the ROCm/Vulkan/llama.cpp/LM Studio world and don't need CUDA.

Don't buy the EVO-X2 if:

• You need CUDA for fine-tuning or NVIDIA-only inference servers → get the DGX Spark.
• You need to cluster to 405B-class models → DGX Spark's 200GbE.
• You want the highest token throughput at 128GB → Mac Studio M4 Max (546 GB/s).
• Your models are all 7–13B → a $429–$549 box like the GMKtec M6 Ultra does that for a quarter of the money.
• You need 10GbE networking → the Beelink GTR9 Pro.

Bottom line

The GMKtec EVO-X2 runs a 4-bit 70B model at roughly 5–10 tokens/sec and a 7B model at 50–80 tokens/sec on its 128GB of ~256 GB/s unified memory — making it the lowest-cost single box (~$2,000) that can hold a 70B-class model without a discrete GPU. It's quiet, always-on-friendly, dual-M.2 expandable, and the clear value pick against the $3,999 DGX Spark for anyone who doesn't need CUDA. Its best 2026 workload isn't a dense 70B at all — it's a large MoE model like GPT-OSS 120B at interactive ~31 tok/s, where the box's capacity is the asset and its bandwidth ceiling stops mattering. Just verify the current street price before you buy: the DRAM shortage has this box's price moving, and it's the one number we won't pin down for you.