MacBook Pro M5 Max 128GB: The Real Local AI Benchmark Numbers

Why This Benchmark Exists

The M5 Max 128GB configuration sits at the top of our hardware configurator, and until now it was the one machine on that chart we hadn't tested ourselves. Getting real numbers meant finding someone who already owns one and is willing to follow a strict protocol. A reader of ours, Joël Ramat — a cybersecurity and GRC consultant, ISO 27001 auditor, and co-founder and president of the consultancy Sywédgia — offered to do exactly that. We wrote the test protocol, he ran it on his own machine on September 16, 2026, and everything below reports his measurements, credited as the source.

Every number here comes straight from Ollama's own verbose output, copied after each run with no editing. Nothing is estimated or extrapolated except where we say so explicitly.

The Test Machine and the Protocol

The unit is a 16-inch MacBook Pro with the full M5 Max chip: 18 CPU cores, 40 GPU cores, and 128GB of unified memory rated by Apple at 614 GB/s. It ran macOS 27.0 with Ollama 0.34.1, with no system tuning applied — the GPU memory ceiling is whatever ships by default, which matters if you're comparing against your own machine.

Four rules kept the results honest: the laptop stayed plugged into power the entire time, since macOS throttles Apple Silicon on battery; no other heavy applications were running; only one model was loaded at a time; and every model answered the exact same prompt, which is what makes the numbers comparable to each other and, eventually, to other machines running the same protocol.

• Series A, the baseline: Gemma 4 12B and Qwen 3.8 27B in GGUF — two models that also run on far more modest Macs, used to place this machine on a known scale.
• Series B, MLX vs. GGUF: the same Qwen 3.8 27B, same weights, served through Ollama's MLX engine instead of llama.cpp. Only the engine changes.
• Series C, the actual point of 128GB: gpt-oss 120B, a 65GB model that simply does not fit on a PC laptop.
• Series D, prefill under real load: a 16,689-token document sent in one block to gpt-oss 120B with a summarization instruction — the only prefill measurement in this campaign that's actually meaningful.
• Two bonus runs: Qwen 3.6 35B-A3B in MLX and gpt-oss 20B, both already installed on the test machine, measured under the same conditions.

Each model was run twice, with only the second pass kept, so model loading and Metal shader compilation are excluded from the numbers. On short prompts (43-98 tokens), prefill finishes in under a second — that's a fixed startup cost, not a reading speed, which is exactly why Series D exists.

Generation Speed: Six Models, One Verdict

Ollama reports two separate rates, and mixing them up is the most common mistake in Apple Silicon benchmarks. Prefill (prompt eval rate) is how fast the model reads your prompt before it starts responding — it's what determines the wait before the first word. Generation (eval rate) is how fast it writes the answer, token by token — it's what determines whether output feels fluid. A model can be fast at one and slow at the other.

Read naively, this ranking looks broken: a 120-billion-parameter model beating a 27B model two-to-one. The explanation is three letters — MoE. gpt-oss 120B, gpt-oss 20B, and Qwen 3.6 35B-A3B are all mixture-of-experts models. At each token, only a fraction of the parameters actually gets used: roughly 5 billion for gpt-oss 120B, 3.6 billion for gpt-oss 20B, and 3 billion for the Qwen model. Generation speed tracks what moves through memory at each step, not what's sitting dormant in it.

Why a 120B Model Outruns a 27B Model

The dense models — Gemma 4 12B and Qwen 3.8 27B — activate every parameter on every token. Their speed is a straightforward function of memory bandwidth divided by model size, a rule that's held on Macs since the M1, and the M5 Max doesn't escape it. Qwen 3.8 27B has to move roughly 17GB of weights per generated token; at 614 GB/s, that caps it mechanically at around 36 tokens/sec — which is exactly what was measured.

gpt-oss 120B, by contrast, only has to move about 3GB per token — the weights of whichever experts got activated — even though the full 65GB has to sit in memory to be available. That leaves it with headroom the dense model simply doesn't have, which is how a model five times larger ends up running more than twice as fast.

MLX vs. GGUF: The Free Speed Upgrade

Everyone claims MLX, Apple's library tuned for Apple Silicon, beats llama.cpp. Very few people actually measure it under identical conditions — same model, same day, same machine. That's what Series B does: Qwen 3.8 27B in GGUF Q4 ran at 36.6 tokens/sec; the same weights through MLX ran at 68.0 tokens/sec. That's a 86% improvement from switching the engine alone, nothing else.

Our own MacBook spec guides had pegged the typical MLX gain at 30-40% for generation. On this chip and this model, the real-world gap is more than double that. Some of it likely comes from M5-specific MLX optimizations and the neural accelerators built into the GPU, though we can't yet isolate exactly how much. What we can say plainly: on a recent Mac, running a dense model in GGUF when an MLX build exists means leaving roughly half the machine's performance on the table. Before pulling a model, check the Ollama library for a -mlx tag — for anything above 20GB, the difference is not subtle.

What 128GB Actually Buys You

The real story of the 128GB tier isn't speed — it's what fits in memory at all. gpt-oss 120B weighs 65GB in MXFP4. No PC laptop runs it on-GPU; mobile discrete GPUs top out around 16-24GB of VRAM. On this machine, the model loads, answers at 75-79 tokens/sec, and there's still room left over.

A memory check taken before the test session found 35GB already committed to macOS and open applications, leaving 93GB free for AI workloads. The 120B model settles in with roughly 30GB of headroom — enough for a long context window plus a second, lighter model running alongside it, an 8B for code autocomplete, for example. On a 64GB M5 Max, this same model doesn't load at all; on 96GB it loads with essentially no margin left.

One gap in this campaign: a dense 70B model in Q4 wasn't installed on the test machine, so it wasn't measured. Our separate spec estimate for that configuration, based on the best Macs for 128GB local AI ranking, lands between 15 and 25 tokens/sec in MLX — treat that as an estimate pending the next test round, not a verified number.

Prefill: The Number Nobody Publishes

A twenty-word prompt tells you nothing about prefill speed. To actually measure it, Joël sent gpt-oss 120B an 11,280-word document in a single block — 16,689 tokens, roughly 45 pages — with instructions to summarize it. Result: 1,388 tokens/sec on ingestion, meaning about twelve seconds passed before the first word of the response appeared, followed by a 2,584-token summary generated at 67.6 tokens/sec.

This is the number that actually matters for serious use cases. Reviewing a contract, summarizing an audit report, querying a document set for RAG — in all of these, the model spends most of its time reading, not writing. Twelve seconds to ingest 45 pages, on a laptop, with nothing leaving the device, is what makes local AI genuinely usable for anyone bound by confidentiality: a consultant under privilege, or a company that can't ship documents to a third-party API. At 1,388 tokens/sec, a 30-page contract reads in about 8 seconds and a 100-page report in about 27 — budget roughly a minute total once the response itself is generated.

Thermals, Limitations, and the Verdict

Thermal pressure, checked after every test series, read "Nominal" throughout, with no audible fan noise at any point — including during the 50-second sustained GPU load of the prefill test. That matches what we've seen on M4 Max machines, with one caveat: every run here was a burst under a minute long. The planned throttling test — ten minutes of continuous load followed by a fresh Series A measurement — wasn't completed in this round, and it's the first thing we'll ask for next time. Other open items: no dense 70B was measured, no battery-power runs were taken (expect materially lower numbers off the charger), and this was a single machine and a single operator, so run-to-run variance is unknown.

The verdict is narrow but clear. The M5 Max 128GB earns its price with one specific job: running local models that don't fit anywhere else in a portable form factor, with room to spare for long context and a second model. gpt-oss 120B at up to 79 tokens/sec and a 45-page document read in twelve seconds, with the fans silent the whole time, is a legitimate AI workstation that fits in a backpack. If your workloads top out around 30B parameters, half the memory is enough and the price difference buys a much better display; check current pricing with our cost calculator. If your workloads start at 100B-plus, there's no portable alternative, and these are the numbers to bring to whoever signs off on the purchase. One caveat before you extrapolate: every speed on this page was measured on the 40-core GPU chip with 614 GB/s of memory bandwidth. A lower M5 Max configuration or an M5 Pro has slower memory, so the same models may fit but will generate more slowly. The full protocol, including a shared 11,292-word reference text for the long-document test, is published with the original French write-up on our sister site QuelLLM.fr, so you can rerun it on your own Mac and compare.