GMKtec EVO-X2 (Ryzen AI Max+ 395 96GB)

The GMKtec EVO-X2 (Ryzen AI Max+ 395 96GB) is a compact mini PC that bridges the gap between consumer desktop hardware and workstation-class unified memory for local AI inference. At $1,799 MSRP, it’s a cost-conscious entry point into running large language models (LLMs) that require more than the 24GB VRAM ceiling of most consumer GPUs. This is the 96GB variant of GMKtec’s flagship Strix Halo system, sitting just below the 128GB SKU — a deliberate tradeoff for practitioners who value unified memory capacity over raw GPU throughput.

The hardware is built around AMD’s Ryzen AI Max+ 395 APU (codenamed Strix Halo), a monolithic chiplet design that combines 16 Zen 5 CPU cores, a Radeon 8060S iGPU with 40 RDNA 3.5 compute units, and a 50 TOPS XDNA 2 NPU. All memory is unified LPDDR5X-8000, meaning the CPU and GPU share the same 96GB pool. In AI workloads, up to 64GB can be allocated to the iGPU as VRAM — a configuration that enables loading models like Llama 3.1 70B at low quantizations or running multi-model agent workflows without cold starts.

This unit is not a discrete GPU replacement. It’s a purpose-built, near-silent, 140W chassis designed for developers and engineers who need to serve local inference at modest token rates, run multiple models concurrently, or deploy AI agents at the edge. It fills a specific niche: high VRAM capacity in a small, energy-efficient footprint, with the caveat that memory bandwidth (256 GB/s) is the primary bottleneck for large models.

The critical metric for LLM inference is memory bandwidth. At 256 GB/s, the EVO-X2 is roughly on par with a mobile RTX 4090 (360 GB/s) but significantly behind a desktop RTX 4090 (1,008 GB/s) or an Apple M2 Ultra (800 GB/s). This means token generation speeds will be lower than discrete GPU solutions, but the unified architecture offers unique advantages.

What the 64GB VRAM allocation enables:

• 32B parameter models (e.g., Command R, Qwen 2.5-32B) at Q5_K_M quantization with room for context.
• 70B parameter models (e.g., Llama 3.1 70B, DeepSeek-R1) at Q3 with tight context windows (4K–8K tokens).
• Running multiple smaller models (e.g., 8B + 7B) simultaneously without reloading.
• Multimodal models (e.g., LLaVA-NeXT, Qwen-VL) with image or audio inputs.

Real-world token rates for this hardware (based on testing with llama.cpp and Ollama):

These numbers make the EVO-X2 a comfortable experience for 8B–14B models (interactive chatbot speeds above 20 tok/s) and usable for 32B models. 70B models are functional but require patience — suitable for batch processing, offline agents, or research where throughput matters less than model access.

With a 140W peak TDP and a well-tuned thermal solution, the EVO-X2 operates near-silently even under sustained load. This is a major advantage over GPU-based solutions that often require loud fans or liquid cooling. For edge deployments or office environments where noise matters, this is a practical choice.

The hardware’s best performance-to-quality ratio comes from models that fit entirely within the iGPU’s 64GB allocation with headroom for context. For practical use:

• Llama 3.1 8B at Q4_K_M (approx. 5.6GB VRAM) — runs at 45+ tok/s. Ideal for real-time chatbots.
• Mistral Nemo 12B at Q5_K_M (approx. 9.5GB VRAM) — runs at 30 tok/s. Good for instruction-following tasks.
• Command R 32B at Q5_K_M (approx. 22GB VRAM) — runs at 12 tok/s. Viable for RAG and document analysis.
• Mixtral 8x7B (MQE) — fits entirely at Q4_K_M (approx. 28GB) with context up to 32K tokens.

The 64GB allocation is enough to load a 70B model at Q3 (roughly 24–28GB), but memory bandwidth becomes the bottleneck. Expect 2–5 tok/s — slow enough that you won’t want interactive chat, but fine for offline summarization, code generation, or agent pipelines that don’t need real-time output.

Models like Llama 3.1 70B, DeepSeek-V2, and Qwen 2.5 72B are all loadable. Use --ctx-size 4096 to keep overhead low. Concurrent multi-model setups — e.g., running a 32B Q5 model alongside a 7B embedding model — are also feasible without reloading.

With 64GB unified memory, multimodal models that process images, audio, or video frames can allocate both the LLM weights and large encoder features simultaneously. For example, LLaVA-NeXT 13B (Q4) leaves ~40GB free for high-resolution image processing and streaming. This is an edge over consumer GPUs that often run out of VRAM when handling large visual inputs.

For long-context tasks (128K+ tokens), memory bandwidth again limits speed. A 70B model with 128K context will generate tokens at sub-1 tok/s. More practical: use a 32B model with 32K context at Q5 for retrieval-augmented generation (RAG) pipelines.

• Developers building AI agents — need to run multiple small models (e.g., orchestrator + task-specific models) simultaneously without reloading. Unified memory eliminates VRAM fragmentation and cold-start delays common with GPU setups.
• Edge AI deployers — require a silent, compact, low-power box (140W) that can run local inference on-site without a dedicated GPU server rack. Great for in-store kiosks, industrial QA, or demo environments.
• Hobbyists / prosumers running local LLMs — want to experiment with 70B models on a budget. If you accept slower token rates (<10 tok/s) for the ability to test larger architectures, this is the most affordable way to do it.
• Teams needing private, offline inference — for sensitive data, the EVO-X2 provides a self-contained AI workstation that fits on a desk. No cloud dependency, no data leaving the premises.
• Researchers evaluating model quantizations — having 64GB of unified memory allows quick iteration across different model sizes and quant levels without managing separate GPU memory pools.

• If your primary use case is high-throughput inference (50+ tok/s on 70B models), a used RTX 4090 or two RTX 3090s in parallel will outperform this unit at similar price points — but with higher power, noise, and space requirements.
• If you need to train or fine-tune models larger than 7B parameters, the EVO-X2’s memory bandwidth is inadequate. Stick with dedicated GPUs or cloud instances.
• For pure 8B–32B inference at sub-10ms latency for production serving, a desktop GPU with higher memory bandwidth (e.g., RTX 4080) is a better fit.

Choose the EVO-X2 when: you need more than 48GB of VRAM for under $2,000, you value silence and small footprint, and you prioritize model flexibility over raw speed.

Choose a Mac Studio when: you have a larger budget, need 128GB+ unified memory, and require higher bandwidth for faster inference on large models.

Choose an RTX 4090 when: your primary models fit within 24GB, you need maximum tokens per second (especially for batch generation or real-time applications), and power/noise aren’t constraints.

The EVO-X2 is not the fastest inference box you can buy. It’s the most accessible way to load a 70B model on consumer hardware without building a custom multi-GPU rig. For practitioners who trade speed for capacity, silence, and simplicity, it’s a compelling entry into the Strix Halo ecosystem.