The Best Local AI Models to Run Offline, November 2026
A local model is an AI model that runs on your own device. No account, no internet, nothing leaves the machine. Some of them now fit on a phone.
Since June I've had an agent scanning leaderboards and model releases about once a week and logging anything that runs offline. It's tracking 23 models as of 20 November 2026. This post is what's in it.
Note: Most of these numbers come from the labs that made the models. Independent phone tests are still rare. Where a number is from a community test or an estimate, I say so.
Three Words First
- Parameters: the numbers a model learned during training, counted in billions (B). More usually means smarter, and always means bigger.
- 4-bit: how precisely each parameter is stored. Models are trained at 16 bits per parameter. Squashing that to 4 bits (quantization) makes them four times smaller and only a little worse.
- Tokens: chunks of text, about three-quarters of a word each. Speed is measured in tokens per second.
Quantization is why any of this works on a phone. A 4B model is 8 GB at full size, which is all the memory most phones have. At 4-bit it's about 2 GB.
Prism ML's Ternary Bonsai 4B goes further. Every weight is one of three values, which works out to about 2 bits each, so the whole 4B model is a 1 GB file. It scores 70.7 on Prism's own mix of tests, against 77.1 for Qwen3 4B. It needs Prism's fork of llama.cpp for now.
Best for a Phone
The rough rule: a phone can give a model about 3 GB without the rest of the phone falling over. That means 1B to 4B models, at 4-bit.
- LFM2.5 1.2B Thinking (Liquid AI): the clearest phone pick. It takes about 900 MB and writes 70 tokens per second on a Snapdragon 8 Elite and 64 on an iPhone's A19 Pro. It scores 88 on MATH-500 and 88.4 on IFEval (following instructions).
- LFM3 1.7B (Liquid AI): the newer, bigger sibling, about 1 GB at 4-bit. Liquid says it was the fastest in its comparison on an iPhone 17 Pro and used the least memory. It's also surprisingly good at code (see below). Liquid says not to use it for complex reasoning.
- Gemma 4 E4B (Google): Google says it needs 2.5 GB on a phone, or 2.2 GB for text only, and ships official mobile builds. The "E" stands for effective: it acts like a 4B model.
- Qwen3.5 4B (Alibaba): a strong all-rounder. 79.1 on MMLU-Pro (general knowledge) and 89.8 on IFEval, plus vision and a 262K context. The weights are 2 GB at 4-bit, but the image side and long context push real use well past that.
- MiniCPM5 2B (OpenBMB): new this week. About 1.6 GB at 4-bit, and there's a build for Android and iOS. LLMCheck ranks it 28th of 130 local models, which is good for its size.
Anything over about 10 tokens per second already feels faster than you can read. All the small models clear that easily. The problem on phones is memory and battery, not speed.
Small Models Can Code Now
This surprised me most. LFM3 1.7B scores 73.5 on LiveCodeBench v6, a test of fresh programming problems. Google's Gemma 4 12B, about seven times bigger, scores 72.
Puzzles aren't real work, though. On SWE-bench Verified, where a model has to fix actual bugs in actual GitHub projects, LFM3 1.7B gets 43.4%. That's impressive for something that fits on a phone, but it's not going to replace a big cloud model for coding.
(I left Qwen3.5 2B out of the chart. A local-run guide lists it at 87.7, which would beat everything here, and I can't find that number in an official source yet.)
NVIDIA's Dory 4B does something different. It runs its layers more than once per token, in loops, so you can trade speed for quality.
At four loops it fixes 61.8% of SWE-bench issues, which is a lot for 4B. The download is 3.7 GB, and NVIDIA's own guides assume an NVIDIA GPU, so it's a laptop model for now.
Best for a Laptop or Desktop
With 16 to 32 GB of memory the options open up.
- Qwen3.6 35B-A3B (Alibaba): LLMCheck's number two out of 130 local models, with a score of 81. It needs about 24 GB of memory and runs at around 130 tokens per second in community tests. If you have a 32 GB machine, start here.
- Gemma 4 12B (Google): 77.2 on MMLU-Pro, 77.5 on AIME 2026 (maths) and 72 on LiveCodeBench, in about 8 GB. It fits a 16 GB laptop.
- SenseNova Loop 9B (SenseTime): out on 17 November. Another looped model. It needs about 10 GB of GPU memory at 128K context, and right now it needs custom runtime builds.
- Qwen3.8 27B (Alibaba): strong (75.3 on LiveBench) but 18 GB even at 4-bit. Desktop only.
Qwen3.6's trick is in the name. "35B-A3B" means 35 billion parameters in total, but only about 3 billion active for each token. It's a mixture of experts: a router picks a few specialist sections of the model for every token and skips the rest.
So it runs about as fast as a 3B model and answers more like a big one. The catch is that all 35B still has to sit in memory, which is why it isn't a phone model.
The Specialists
Some of the best small models only do one job.
- PLaMo 3 Translate 0.8B (Preferred Networks): translation in 53 languages, in a 548 MB file. Preferred Networks showed it running in real time on a phone in airplane mode, and it beats much bigger translation models on Japanese.
- LFM3-VL 2B (Liquid AI): looks at images, documents, charts and phone screens. 96.7 on DocVQA (reading documents). A community test got 34 tokens per second on a Galaxy S26.
- Liquid d1 3B: a decision model. It gives one answer in one pass instead of writing text. 30 ms per question on an Apple M5 Pro, 50 ms on a Jetson Orin Nano. Useful for sorting and classifying, not for chatting.
- MobileLLM-R1 950M (Meta) and OpenReasoning-Nemotron 1.5B (NVIDIA): small maths and code reasoners. Nemotron gets 55.5 on AIME24, which is wild for 1.5B.
It's Speeding Up
Fourteen of the 23 models arrived after 1 October. Three turned up this week.
Liquid, Qwen, Google and OpenBMB all shipped small models in the same few months.
Smarts vs Memory
The labs all test on different benchmarks, so their numbers don't line up. LLMCheck ranks 130 local models on one composite score and lists the minimum memory each needs. Nine of my 23 are on it.
The top of the chart costs memory. Qwen3.6 35B-A3B and GLM-4.7 Flash, both mixtures of experts, score 81 and 80 but need 18 to 24 GB. Below that it gets interesting: MiniCPM5 2B scores 69 in 3 GB, ahead of Gemma 4 12B (66 in 9 GB) and Llama 3.1 8B (57 in 5 GB).
LLMCheck marks five of these scores as its own estimates (the hollow rings), including MiniCPM5's. So treat the small-model end as promising, not proven.
The Picks
| Phone | Laptop (16 GB) | Desktop (32 GB+) | |
|---|---|---|---|
| General use | LFM2.5 1.2B Thinking | Gemma 4 12B | Qwen3.6 35B-A3B |
| Coding | LFM3 1.7B | Dory 4B | Qwen3.6 35B-A3B |
| Images | LFM3-VL 2B | Qwen3.5 4B | Qwen3.8 27B |
| Translation | PLaMo 3 Translate | PLaMo 3 Translate | PLaMo 3 Translate |
Trying One
On a laptop, Ollama and LM Studio are the easy way in. Install one, pick a model, wait for the download. In Ollama, ollama run qwen3.5:2b is a good first test. Both load GGUF files, the format most of these 4-bit builds come in.
On a phone it's still fiddly. Most phone builds of these models are for Google's LiteRT-LM or for llama.cpp, not apps from a store.
I'll update this as the tracker fills up.
Sources
- Liquid AI: LFM2.5 1.2B Thinking, LFM3 1.7B, LFM3-VL 2B, d1
- Qwen: Qwen3.5 4B on Onyx's self-hosted leaderboard, Qwen3.5 2B, Qwen3.8 27B, Qwen3.6 35B-A3B recipe
- Google: Gemma 4 overview, Gemma 4 12B
- NVIDIA: Dory 4B, OpenReasoning-Nemotron 1.5B
- OpenBMB: MiniCPM, MiniCPM5 2B docs
- Prism ML: Ternary Bonsai 4B
- Preferred Networks: PLaMo 3 Translate
- SenseTime: SenseNova Loop 9B
- Meta: MobileLLM-R1 950M, MLPerf Mobile v6
- Rankings: LLMCheck local leaderboard