GMKtec EVO-T2S Review: First 18A Silicon in a Mini PC, Benchmarked for Local AI
Disclosure: GMKtec provided this unit through their reviewer program. They had no input into the contents of this review and did not see it before publication.
TL;DR
The EVO-T2S is the first mini PC built on Intel’s 18A process, and as a general-purpose machine it’s excellent: 16 modern cores, 10GbE + 2.5GbE, OCuLink, dual USB4 in a 54W box. As a local AI machine it’s good-but-bounded, and the boundary is exactly one number: ~136 GB/s of memory bandwidth. Modern sparse MoE models are built for precisely this constraint, and on those it delivers a consistent, genuinely usable 31–36 tokens/sec. Dense model performance leaves a lot to be desired at 5-12 tokens/sec, depending on model size. It arrives ready to generate tokens, fully loaded with software to get you started.
Introduction
I have recently been looking for some hardware to support my local AI needs, mainly summarization and sentiment analysis. I’m still using proprietary models for coding, but I’ve had great luck at using OpenRouter with open source models for these tasks, but of course worrying about overspending and topping up your balance is annoying.
I have a few macs around the house that could serve up a decent model, but I didn’t want to dedicate one to that task. I saw a couple stories about GMKTec making hardware targeted for this use case, and they caught my interest. I currently run my home’s k8s cluster (everyone should have one!) on a GMKTec Nucbox I bought before prices went stratospheric, it’s been a great piece of hardware so was interested in trying their latest offerings. I reached out to an old contact at GMKTec and asked them what they recommended for the task and they offered me to try this new EVO-T2S on them.
While I didn’t really know about the Intel stack for LLM inference in 2026, I decided I’d give it a try, and it turns out it’s pretty painless to work with for simple stuff. Intel’s GPU speaks Vulkan, and that’s all llama.cpp needs to operate, making it work with the larger ecosystem.
The hardware
- CPU: Intel Core Ultra X7 358H (Panther Lake) — 4 P-cores + 8 E-cores + 4 LP E-cores, 16 threads, Intel 18A. Power modes: 35/45/54W, 60W peak.
- GPU: Intel Arc B390 iGPU — 12 Xe3 cores, 96 XMX engines, 12 RT units. Intel rates it at 122 INT8 TOPS.
- NPU: NPU 5, 50 TOPS.
- Memory: 64GB LPDDR5X-8533, soldered, on Panther Lake’s 128-bit bus.
- Storage: Phison “AI SSD,” 853GB (advertised as 768GB storage + 85GB “dedicated AI cache”) in the PCIe 5.0 x4 slot.
- Networking: 10GbE (Realtek RTL8127) + 2.5GbE (RTL8125), Wi-Fi 7, BT 5.4.
- I/O: 2× USB4 (40Gbps, 100W PD), OCuLink (PCIe 4.0 x4), HDMI 2.1, DP 1.4, assorted USB-A.
The one number that matters for AI: memory bandwidth
LLM token generation is memory-bandwidth-bound: every generated token requires reading the model’s active weights out of RAM. The Intel chip in the EVO-T2S has a 128-bit bus at 8533 MT/s, which tops out at 136.5 GB/s theoretical. In comparison to Apple and AMD’s latest AI targeted APUs, this is a big limitation, but for many usecases it’s still perfectly usable for Local LLM.
Everything in my benchmark results reduces to this. Across every model I tested, the machine sustained an effective ~85–90 GB/s feeding the inference workload, and tokens/sec is simply that number divided by how many bytes of weights each token has to touch. Dense models read all their weights per token. Mixture-of-Experts (MoE) models read only a small active subset. That single architectural difference is worth a 6x speedup on this box.
Out-of-box software: Herdsman
The machine ships with Windows 11 Pro and a preinstalled AI app called Herdsman (it first boots in Chinese; switching to English is straightforward). Credit where due: it works out of the box. It downloaded Gemma 4 26B A4B, ran it on the GPU with no configuration and I was able to start chatting immediately.
Under the hood, though, Herdsman is a catalog wrapper around llama.cpp — the same open-source engine LM Studio uses. It ships standard community GGUF quants (Unsloth Dynamic Q4_K_M, in my unit’s case) in a plain folder structure. While it’s great for getting started, I found LMStudio was better:
- It’s slower. The same class of workload that Herdsman ran at ~23 tok/s, LM Studio’s current Vulkan build ran at ~31 tok/s. That’s roughly a third of your decode speed left on the table by a stale or untuned llama.cpp build.
- The Think toggle doesn’t work. Gemma 4 has a reasoning mode; Herdsman exposes a toggle for it, but never rendered thinking output, and response characteristics matched thinking-disabled runs in LM Studio.
Practical guidance: use Herdsman to verify the machine works, then install another tool like LM Studio (or run llama.cpp directly). It’s fine for the basics but if you want the most out of the machine, a frontend wrapping a current llama.cpp build is worth the trouble.
The machine also included GMKTec-branded “Claw” and a hybrid local/cloud AI app that I didn’t fully evaluate, for my needs, I only care about serving tokens via an API on my network.
Benchmarks
All results: LM Studio 0.4.19, Vulkan llama.cpp backend, full GPU offload, thinking disabled, Windows 11 Pro, Performance power mode. Prefill measured on a ~2,200-token prompt. The prompt was fairly simple, I pasted in a current event from Wikipedia and asked the models to summarize and provide the latest updates. Quality assessments are totally biased towards whatever I thought looked best, so it’s not scientific whatsoever.
| Model | Type | Quant | Weights | Prefill | Decode |
|---|---|---|---|---|---|
| Gemma 4 26B A4B | MoE (3.8B active) | Q4_K_M | 18.0 GB | ~660 t/s | 31 t/s |
| Gemma 4 26B A4B QAT | MoE (3.8B active) | Q4_0 QAT | ~16 GB | — | ~31–33 t/s |
| Qwen3.6-35B-A3B | MoE (3B active) | Q4 | ~20 GB | — | 36 t/s |
| gpt-oss-20b | MoE (3.6B active) | MXFP4 | ~12 GB | — | 36 t/s (low reasoning) |
| Gemma 4 12B QAT | Dense | Q4_0 QAT | ~7 GB | — | 12 t/s |
| Gemma 4 31B QAT | Dense | Q4_0 QAT | ~17.5 GB | — | 5.2 t/s |
| Gemma 4 26B A4B (Herdsman) | MoE (3.8B active) | UD-Q4_K_M | 15.8 GB | 600+ t/s | 23 t/s |
The pattern is unmissable once you multiply it out: 17.5 GB × 5.2 t/s ≈ 91 GB/s. 7 GB × 12 t/s ≈ 84 GB/s. The MoE runs land in the same range against their active footprint. The hardware delivers one constant, and every model’s speed is that constant divided by bytes-per-token.
Three takeaways from the table:
1. For almost all cases, you’ll want to use an MoE model. The 26B MoE is six times faster than the 31B dense model at nearly the same total parameter count and most of the quality. It’s also faster than a dense model half its size — the 12B dense is both slower and less capable than the 26B MoE. The old heuristic that smaller means faster is dead on unified-memory machines; architecture matters more than parameter count.
2. Prefill is genuinely strong. ~660 t/s of prompt processing means long documents, big system prompts, and agentic tool loops feel responsive. That’s the 96 XMX engines earning their keep — prefill is compute-bound, and compute is the thing this box has in reasonable supply.
3. Quality notes. Google’s QAT (quantization-aware training) releases are perfect for a box like this: the 26B QAT matched the standard Q4_K_M in my testing while being smaller and slightly faster. Qwen3.6-35B-A3B is at least on par with Gemma quality-wise (and benchmarks ahead on coding) at a faster 36 t/s. gpt-oss-20b is fast and reasons well, but it’s a mid-2025 model in a mid-2026 field and it shows; its mandatory reasoning mode also means time-to-first-answer is worse than the raw decode number suggests.
One Windows-specific ceiling worth knowing: the graphics stack caps the iGPU’s memory allocation at ~36GB of the 64GB pool. The RAM is physically unified, but a model bigger than ~36GB can’t fully offload to GPU under Windows. This matters for the extreme-sparsity models arriving now (80B-total/3B-active class) that would otherwise be perfect for this machine — and it’s a Windows limitation, not a hardware one, which is one of several reasons a Linux follow-up is coming. However, for these smaller models I tested, you really don’t need all that extra RAM. It’s good to consider though if you are buying a box like this and plan to run Linux, you may not need as much RAM as you think, especially as expensive as it is these days.
The “AI SSD”: marketing, as shipped
The headline storage feature is a Phison “AI SSD” — 853GB advertised as 768GB of storage plus an 85GB “dedicated AI cache” that supposedly “works in tandem with the NPU and GPU to optimize data flow.” Phison’s aiDAPTIV technology is real. It’s middleware that tiers model data between DRAM and purpose-built flash, demoed with Intel at Computex. The underlying drive appears to be legitimately differentiated hardware, and I do see the 85GB cache in Disk Management.
Unfortunately it seems there’s nothing in Windows that utilizes it, the only thing occupying the dedicated AI cache as shipped is the Windows recovery partition. There is no Phison or aiDAPTIV software installed. No service, no driver package, no toggle in Herdsman. The models run from RAM, as they would with any SSD, and inference performance would be identical with any competent Gen5 drive. The aiDAPTIV middleware that would give the “AI cache” meaning seems to be a separate, Linux-first product. Once I get Linux going, I plan to look into this and report back, though I think due to the memory bandwidth limitations any benefits of a larger model might be wasted unless it’s sparse.
What to actually run on it
- Daily driver: Gemma 4 26B A4B QAT. Best all-around quality at conversational speed (~31 t/s), vision works, ~16GB leaves lots of headroom for context.
- Coding: Qwen3.6-35B-A3B. Equal-or-better quality for code, 36 t/s, Apache 2.0.
- Quality-over-speed: Gemma 4 31B QAT. Noticeably smarter, 5.2 t/s. Fine for drafting, batch summarization, and anything you can walk away from; not for chat.
- Skip unless nostalgic: gpt-oss-20b. Fast, but outclassed a year after release.
The general rule this machine teaches: on 136 GB/s of bandwidth, pick sparse MoE models and spend your abundant RAM on total parameters and context, not on dense weights you’ll pay for on every token.
As a general-purpose machine
Outside of AI, this is an easy machine to like. Sixteen Panther Lake cores make it a legitimately fast small computer. It has gobs of IO: dual USB4, OCuLink for eGPU or fast external storage, 10GbE + 2.5GbE, and a Gen5 M.2 slot. The B390 trades blows with a mobile RTX 4050 in games, which is remarkable for integrated graphics, even if a PS5 buyer would rightly be unimpressed. Official Linux support is on the spec sheet, which most vendors in this segment won’t commit to. Fan noise in Quiet mode is unobtrusive; the RGB is optional.
The two structural caveats: 64GB soldered memory with no upgrade path, and a second M.2 slot limited to PCIe 4.0 x1.
What’s next
This review covered the machine as shipped, on Windows. I think this machine will work best with Linux. I’ll be able to test the extreme-sparsity models (Qwen3-Coder-Next 80B-A3B, gpt-oss-120b) without hitting Windows limitations, truly evaluate the Phison AI SSD situation, and experiment with DiffusionGemma. I’m looking forward to these experiments and will report back on anything interesting I discover.
Verdict
Buy it if: you want the best-connected mini PC in its class, you understand that local AI on it means sparse MoE models at a genuinely usable 30–36 t/s, and you value 18A-generation efficiency and I/O over raw GPU bandwidth.
Skip it if: local LLM speed is your primary purchase driver. A Strix Halo machine like GMKtec’s EVO-X2 has nearly double the memory bandwidth and up to double the RAM for similar money, though it does heat up your room more.
Rating: 4.5/5