The 5 Best AI Models You Can Actually Run on a MacBook Pro (2026)

One of these five shouldn't work at all — a 27-billion-parameter model crushed down to 2 bits, small enough to run on a base MacBook Pro. It came second. Here's the whole cast, ranked, and which one belongs on your Mac.

There's a model in this lineup that has no business working.

It's 27 billion parameters — the size of a model you'd expect to need a serious desktop for — but someone crushed every weight down to two bits, essentially three possible values each. On paper that should lobotomize it. It fits in 8 GB. It runs on the cheapest MacBook Pro Apple sells. And when I put it through the same gauntlet as four "normal" models, it landed second place overall.

I'll get to which one it is. First, the setup: your MacBook Pro is a genuinely capable private AI workstation. No account, no monthly bill, no network round-trip, nothing you type ever leaving the machine. The only real question is which model to run — and most of the advice out there is either pure vibes or benchmarked on a $6,000 Mac Studio that looks nothing like your laptop.

So I took five local models that actually fit a MacBook Pro and ran every one through identical coding, reasoning, general-knowledge, and tool-calling tests, tracking exactly how much memory each one really eats. Here's the leaderboard, then the story of each model — counted down from the one the internet oversold me to the one that changed what I think a laptop can do.

The leaderboard

Sorted by memory footprint — the one that fits the most Macs is at the top:

One honest warning before you read too much into this, because this community checks: each capability score is a 10-question probe (30 for tools), not the full 500-question academic gauntlet. That's plenty to sort these five into tiers and catch a model that face-plants — it is not enough to litigate a three-point gap. Treat ±10% as noise, treat the tiers as real. Every model ran with enable_thinking: false and temperature: 0; the whole harness and all five raw result files are in the repo if you want to check my work or run it on your own Mac.

Now the cast, worst to first.

5. Nemotron-Nano-30B — the one the internet oversold

I went in expecting NVIDIA's Nemotron to win. On the public leaderboards it beats Qwen3 and GPT-OSS on LiveCodeBench; it's the shiny new Mamba-Transformer hybrid everyone's posting about. On my bench it came dead last at 61%, with a brutal 40% on general knowledge.

Before you @ me: yes, I know it's a reasoning model, and yes, I ran it with thinking disabled like everyone else — which hurts a think-first model more than the others. It could also be an answer-extraction quirk on my end. Both are on the retest list with thinking turned on. But here's the honest takeaway for today, on a laptop, out of the box: the model the benchmarks told me to love got quietly outclassed by models half its hype. It's fast (124 t/s) and architecturally the most interesting thing here — it's just not the one I'd actually run yet.

4. GPT-OSS-20B — the reliable commuter car

OpenAI's little open model is the Toyota Corolla of this list, and I mean that as a compliment. It's the fastest genuinely-useful model here (125 t/s), sips just 12 GB, and never embarrasses itself — 80% on tool calling, 80% on reasoning. It's not going to win a drag race on any single skill (50% on coding and general knowledge), but it starts every morning and gets you there. This is why it became the default "just give me something that works" model on 16 GB Macs, and nothing here dethrones it from that job.

3. Qwen3.6-27B — the savant

Every list has one genius with a blind spot. Qwen3.6 posted a perfect 100% on coding and 93% on tool calling — the sharpest pure-code model in the room, tailor-made for driving Aider or Claude Code. Then it turned around and scored 50% on math reasoning, the kind of split that makes you double-check the logs. It's also the slowest thing here by a mile (37 t/s), because it's the only old-school dense model in the group and pays full price for all 27 billion parameters on every single token. A specialist worth hiring — for exactly one job, on a 32 GB Mac.

2. Gemma-4-26B — the quiet valedictorian

While everyone else has a spiky profile, Google's Gemma just quietly does everything well. Highest average on the board at 84%. A perfect 100% on reasoning, 90% on coding, 87% tool calling — the only model here without a real weakness (general knowledge at 60% is its softest, and it's still fine). At 14.7 GB and 110 t/s it's fast and fits a 24 GB Mac. If you want the top raw score and one model that never lets you down, technically this is your winner.

Technically. Because there's one model I'd hand a lot of people instead — even though it scored three points lower.

1. Bonsai-27B — the one that shouldn't exist

This is the 2-bit model from the intro. A 27B brain, ternary-quantized into 8.0 GB — less memory than models with a third of its parameters — and it posted an 81% average, second only to Gemma, while tying for the best tool-calling score in the entire lineup (93%).

I didn't believe it either. A 2-bit 27B keeping pace with 4-bit models nearly twice its size sounds like a broken test, and if you're skeptical, good — go run it yourself, the harness is right there. But the number held up across all four suites, and it reframes the whole question. Every other model on this list makes you choose between "smart" and "fits a normal MacBook." Bonsai is the first one that just... doesn't. It's the only model here a base 16 GB MacBook Pro can run with room to spare — and it's nearly the smartest one too.

It's not perfect: at 48 t/s it's middling on speed (ternary weights don't get the acceleration that MoE models do). But "a genuinely smart 27B that runs on the cheapest MacBook Pro made" is a category that basically didn't exist a year ago. For most people, on the most common Macs, this is the one to run.

So which one fits your MacBook Pro?

The scores are hardware-independent, but the memory is the part that decides whether a model runs on your machine at all. Match the peak-RAM column to your Mac and leave ~20% headroom for macOS and your context window:

Reality check from the machine I wrote this on — a MacBook Pro with an M3 Pro and 18 GB, one of the most common configs Apple ships: it comfortably holds only the two smallest models here, Bonsai and GPT-OSS. Everything from Gemma up is too tight once macOS and a working context are in memory. Which is exactly why that weird little ternary model matters more than its spec sheet suggests.

About that speed column

Two caveats, because they're the honest ones. First, the decode speeds (\*) were measured on a Mac Studio that was busy serving other models at the time — GPT-OSS clocked 125 t/s here versus 124 on a clean run, so they're trustworthy as a floor, but a lab-clean laptop pass is still coming. Second, a Mac Studio (M3 Ultra, ~819 GB/s of memory bandwidth) decodes a lot faster than any laptop. Bandwidth is the lever, so to estimate your MacBook Pro, derate roughly:

The capability, memory, and tool-calling numbers don't move — only speed does.

Run any of these in two minutes

Everything above ran on rapid-mlx, an OpenAI-compatible local server, which means your existing tools (Claude Code, Cursor, Aider, anything that speaks the OpenAI API) point at it with a one-line change — same API as the cloud, just localhost:

pip install rapid-mlx
rapid-mlx serve bonsai-27b-2bit
# → OpenAI-compatible server on http://localhost:8000/v1

If a model won't fit your Mac, it tells you before loading instead of thrashing your machine — drop to a smaller alias and go again. For the full memory-to-model map across every model size, not just these five, see Which Local LLM Fits Your Mac's RAM? or the live picker at models.rapidmlx.com.

The fine print

• Suites: 30 tool-calling scenarios (9 categories) plus 10-question probes

each of HumanEval+ (coding), MATH-500 (reasoning), and MMLU-Pro (general) — the same harness as our 17-model M3 Ultra benchmark, so the two posts are directly comparable. Small suites: good for tiers, not for splitting hairs.

• Settings: enable_thinking: false and temperature: 0 for every model, so

each gets its full token budget for the answer and the run reproduces. This under-reads think-first models like Nemotron — noted above.

• Hardware: Mac Studio, M3 Ultra, 256 GB. Capability and memory are

hardware-independent; decode speed is Studio-measured and derated for laptops as noted.

• Reproduce it: the eval harness and all five raw result files ship in the

repo. Run rapid-mlx serve <model>, point the harness at localhost, and you'll get your own numbers — on your own Mac. Corrections welcome; that's how the last one got better.