methodology

Same models. Same versions.
Weeks on the bench, not minutes.

This page describes exactly how every machine in Benchmark 01 is tested. It is published before the first result, and any change is logged at the bottom of the page.

Version 1.0Published 20 October 2026Applies to Benchmark 01

01 / principles

Measured the way you would use it.

Every machine runs the same models, in the same formats, with the same software versions, in the same room. Results are measured, never taken from spec sheets. Each test is run three times and the median is reported; raw data for every run is published alongside the review.

  1. Reproducible. Model files, software versions and command lines are published, so anyone with the same hardware can check the numbers.
  2. Sustained, not peak. A machine that is fast for 30 seconds and throttles after 10 minutes is reported as such.
  3. Like for like. Machines are ranked only against machines of the same class.

02 / test classes

Three classes and one reference.

Memory capacity decides which models a machine can load; memory bandwidth decides how fast it answers. Classes follow the platform, so a 1,500 € machine is never ranked against a 7,000 € workstation.

ClassPlatformMemoryPeak bandwidth (vendor)
1 · EssentialRyzen AI 9 HX 470 / Core Ultra32–128 GB~90–128 GB/s
2 · PerformanceRyzen AI Max+ 395128 GB unified256 GB/s
3 · AI WorkstationRyzen AI Max+ PRO 495192 GB unified273 GB/s
ReferenceApple Mac mini M6 / M5 Pro32 / 64 GB unified170 GB/s / n.a.

03 / models

The model suite.

The suite covers what people actually run locally: small dense models, mid-size dense models, mixture-of-experts (MoE) models and the largest open models a desktop can hold. Each machine runs every model that fits in its memory; a model that does not fit is reported as “does not fit”, not as zero.

ModelTypeFormatApprox. sizeRuns on
Gemma 4 12BdenseQ4_K_M~8 GBall classes
gpt-oss-20bMoE · 21B / 3.6B activeMXFP4~14 GBall classes
Qwen 3.8 27BdenseQ4_K_M~18 GBall classes
Qwen3.6-35B-A3BMoE · 35B / 3B activeQ4_K_M~22 GBall classes
Llama 3.3 70Bdense · bandwidth referenceQ4_K_M~43 GB64 GB+
gpt-oss-120bMoE · 117B / 5.1B activeMXFP4~63 GBclass 2 & 3
Mistral Small 4MoE · 119B / 6B activeQ4_K_M~70 GBclass 2 & 3
DeepSeek V4-FlashMoE · 284B / 13B activeUD-IQ3_XXS~103 GBclass 3 class 2 on Linux
Qwen3-235B-A22BMoE · 235B / 22B activeQ4_K_M~135 GBclass 3
Frozen before testing. Exact model files (source repository and SHA-256 checksum) are frozen when testing starts and listed in the results. If a newer version of a model family is released during testing, it is added as a separate entry, never swapped in silently. Speech is tested with Whisper large-v3-turbo.

04 / software

Tools and backends.

The core numbers come from llama.cpp, the engine behind most local AI applications, so that every platform is measured with the same code. Everyday tools are then checked to confirm the experience matches.

core measurements

llama.cpp · llama-bench

  • AMD: Vulkan and ROCm backends, best result reported, both published
  • Apple: Metal backend
  • Intel: Vulkan / SYCL backend
  • Same release build on every machine

everyday tools

LM Studio · Ollama · MLX

  • Install-and-run check with default settings
  • Spot-check of speed against llama.cpp
  • MLX on Apple as an additional result

05 / speed

How fast it reads, how fast it answers.

Two numbers matter. Prompt processing is how fast the machine reads your input (documents, code, conversation history). Generation is how fast it writes the answer. Both are measured in tokens per second, at several context lengths, because speed drops as the conversation grows.

# same command on every machine, every model that fits
$ llama-bench -m <model> -p 512,4096 -n 128 -d 0,8192,32768 -r 3 -o csv

Context depths tested: empty, 8k and 32k tokens already in the conversation. Time to first token is reported for a 4k-token prompt.

06 / endurance

Hours of load, not a 30-second sprint.

endurance run

24 hours of continuous load

  • Non-stop generation mixing short questions and long-context requests (up to 32k tokens)
  • Throughput logged every minute over the full 24 hours
  • CPU/GPU temperature, clock speed and fan speed tracked throughout
  • Run with the default power profile, then repeated with the maximum profile
  • Throttling reported: when it starts and how much speed is lost
  • Stability: crashes, driver resets and errors counted

real-world scenarios

Several days of everyday work

  • Document assistant: questions across a set of contracts, invoices and manuals (hundreds of pages)
  • Coding assistant: completion and code review on a real project
  • Meetings: one-hour recording transcribed, then summarised with action items
  • Same scenarios and same documents on every machine; response times and stability recorded

team use

Several people at once

  • One machine serving a small office: 1, 3 and 5 simultaneous users
  • Response time per user and total throughput
  • How far each machine can go before answers become too slow to use

power & noise

Measured, not estimated

  • Power at the wall, logged once per second (idle, light use, full load)
  • Tokens per watt and estimated energy cost per day
  • Noise in dB(A) at 50 cm, idle and under load, ambient noted
Test conditions. Room temperature 21 ± 1 °C, machine on an open desk, latest BIOS and drivers available at test start (versions recorded). Each machine is also used hands-on for several days.

07 / npu

What the NPU really adds.

Most local AI tools run on the GPU, not the NPU. This section measures what the NPU brings where software can use it today, so that “TOPS” on a spec sheet can be read in practice.

language models

AMD Lemonade & FastFlowLM

  • NPU-only and hybrid NPU + GPU modes
  • Prompt processing, generation and tokens per watt vs. GPU-only

speech

Transcription

  • 30-minute meeting recording with Whisper
  • Real-time factor and energy used, NPU vs. GPU vs. CPU

08 / setup

From the box to the first answer.

  1. Windows 11, as shipped. Time and steps to a working local assistant with LM Studio.
  2. Linux. Clean install of the latest Ubuntu LTS: drivers, ROCm / Vulkan, llama.cpp build.
  3. Memory for the GPU. How much memory can be given to the GPU, how (BIOS, driver, kernel settings) and what it changes.
  4. Hardware notes. Ports, networking, storage, upgradability and build quality, briefly.

09 / scoring

Numbers first, opinions labelled.

Each machine gets a results sheet: speed per model, endurance curve, power, noise and setup notes. Rankings are given within each class only. Value is shown as generation speed per euro, using the manufacturer's public price on the day of publication. The written verdict is clearly separated from the measurements.

10 / independence

How this stays honest.

  1. No paid rankings. Placement cannot be bought, and no manufacturer reviews or edits the text.
  2. Supplied hardware is disclosed. Every review states who provided the machine.
  3. Method first. This protocol is public before testing starts; changes are logged below.
  4. Raw data published. CSV files for every run are released with the results.

11 / changelog

Changes to this protocol.

VersionDateChange
1.020 Oct 2026First published version.