A score is only useful if it means the same thing every time. This page sets out exactly what ours mean.
The principle behind the rubric
Most hardware scoring implicitly ranks products against each other on general capability. That is the wrong shape for AI hardware, because capability here is not a single axis. A machine can be simultaneously the best and the worst choice in its price band depending on what you intend to run.
So our rubric starts from a hierarchy that reflects how local AI actually behaves:
1. Capacity determines what you can run at all
A model that does not fit in memory does not run — or it spills to system RAM and slows down by an order of magnitude. Memory capacity is therefore a threshold, not a gradient. A 16 GB card is not “80% as good” as a 32 GB card for a workload needing 20 GB; it simply cannot do it.
This is why a mini PC with 128 GB of comparatively slow unified memory can run a 70-billion-parameter model that a far faster and more expensive graphics card cannot load.
2. Bandwidth determines how fast it runs
Once a model fits, token generation is overwhelmingly memory-bandwidth-bound. During generation the machine reads essentially the entire set of active model weights from memory for every token produced.
That gives a useful ceiling:
theoretical tokens/second ≈ memory bandwidth ÷ model size in memory
A 40 GB model on a device with 800 GB/s of bandwidth cannot exceed roughly 20 tokens per second, no matter how much compute sits behind it. Real figures typically land at 60–80% of that ceiling. It is an approximation — it ignores mixture-of-experts models, batching and speculative decoding — but it explains more real-world results than any compute figure does.
3. Compute determines everything else
Prompt processing, image generation and training are compute-bound rather than bandwidth-bound. If your work is dominated by those, the hierarchy inverts, and we say so in the guides where it applies.
The nine criteria
Every hardware review is scored 0–5 against the same nine criteria. We do not score categories that are not meaningful for a product class, and unscored criteria are omitted rather than filled with a default — a graphics card, for example, is not scored on upgradeability.
| Criterion | Weight | What it measures |
|---|---|---|
| AI performance | ×4 | Local inference throughput relative to price class, weighted by memory capacity and bandwidth |
| General performance | ×1 | CPU and GPU performance outside AI workloads |
| Value | ×2 | Capability delivered per dollar within its price class — not absolute cheapness |
| Build quality | ×1 | Materials, assembly, component selection, serviceability |
| Thermals | ×1 | Sustained-load behaviour and headroom before throttling |
| Noise | ×0.5 | Acoustics under sustained inference load, not at idle |
| Power efficiency | ×1 | Work done per watt, weighted more heavily for always-on machines |
| Upgradeability | ×1 | Memory, storage and expansion headroom over the machine’s life |
| Connectivity | ×0.5 | Ports, networking and expansion interfaces |
Why the criteria are weighted, and why they did not used to be
The overall score is a weighted mean, and the weights are the table above. They are relative rather than percentages — the divisor is whatever the applicable weights add up to.
This was not always so, and the change is worth recording rather than quietly making. Until recently the overall score was a flat average, which sounded neutral and was not: thermals, noise and power efficiency between them counted three times, while AI performance counted once. On a site about AI hardware that measures the wrong thing, and it showed. Two of the weakest cards we had reviewed for local AI ended up out-totalling one of the strongest, purely because they were small and cool.
Weighting AI performance at four and value at two puts the emphasis where a reader of this site is actually looking. Noise and connectivity drop to half — both are real, and neither is why anyone chooses hardware for running models.
When the weights changed, every published review was rescored in the same change, because a scale that means one thing in an older review and another in a newer one is worse than an imperfect scale applied consistently.
The total is the least interesting number
Even weighted, an overall score compresses nine judgements into one and loses most of what matters. A card can be the right purchase and score modestly, or score well and be wrong for you.
The individual criteria are the part worth reading, which is why every review publishes all of them rather than a headline figure alone.
What the numbers mean
- 4.5–5.0 — Class-leading. Does something no competitor at the price does.
- 3.5–4.4 — Strong. Recommendable without reservation to the buyer it suits.
- 2.5–3.4 — Competent. Works, but there is a better answer for most people.
- 1.5–2.4 — Compromised. Only sensible under a specific constraint.
- Below 1.5 — Not recommended.
Scores are relative to price class. A 4.5 for value on a budget mini PC and a 4.5 on a flagship workstation are both real; they are not claims that the two machines are equivalent.
What we measure for AI hardware
For any machine assessed for AI work, we record:
- Memory capacity — VRAM on discrete cards; GPU-addressable memory on unified-memory systems, which is not always the same as total installed memory
- Memory bandwidth in GB/s, the primary predictor of generation speed
- Memory type and bus width, since these determine the bandwidth figure
- Compute capability — architecture, tensor core generation, supported numeric formats (FP16, FP8, FP4)
- Framework compatibility — CUDA, ROCm, Metal/MLX, Vulkan; and honestly, how much friction each involves
- Largest comfortable model, stated with the quantisation, because the number is meaningless without it
- Sustained power draw under inference load, not peak or idle
- Thermal and acoustic behaviour under sustained load
- Expandability — memory and storage headroom, and whether memory is soldered
Quantisation, and why we always state it
Model memory requirements depend entirely on numeric precision. Approximate figures for weights alone:
| Precision | Bytes per parameter | 7B | 14B | 32B | 70B |
|---|---|---|---|---|---|
| FP16 | 2 | ~14 GB | ~28 GB | ~64 GB | ~140 GB |
| Q8 | ~1 | ~7 GB | ~14 GB | ~32 GB | ~70 GB |
| Q5_K_M | ~0.7 | ~5 GB | ~10 GB | ~22 GB | ~48 GB |
| Q4_K_M | ~0.55 | ~4.4 GB | ~8.5 GB | ~19 GB | ~42 GB |
Add the KV cache on top, which grows with context length and can add several gigabytes at long contexts. As a working rule we budget the weight figure plus 15–25% for cache and runtime overhead.
Any claim on this site about what a machine “can run” is stated with its quantisation. “Runs 70B” without qualification is not a specification, it is a marketing sentence.
What our scores are not
- They are not independent laboratory measurements unless the page explicitly says the hardware was tested in-house. Where an assessment is specification-based, the page says so directly under the headline.
- They are not user ratings. These are editorial assessments by a named author, published as such. We do not aggregate reader opinion into a score, and we do not mark our scores up as user reviews in structured data.
- They are not permanent. A score reflects the product’s position at the time of writing. New competition changes the value calculation, and we revisit.
When we have not tested something
We are a young publication and we have not physically tested most of the hardware we write about.
We consider it more useful — and considerably more honest — to publish rigorous specification-led analysis clearly labelled as such than to imply testing we have not done. Memory capacity, bandwidth, bus width and power draw are published facts, and the conclusions that follow from them are sound.
What specification analysis cannot tell you is how loud a machine gets, how it behaves after an hour at full load, or whether the firmware is any good. Where those matter, we say that they are the open questions.
As we build out in-house testing, reviews will be upgraded to hands-on and the basis line at the top of the page will change to reflect it.