Which local AI model can your iPhone run?

The question people ask before downloading a local model is usually “which one is best.” That is the wrong question to start with. The right one is which models your particular iPhone can hold without crashing, because the best model in the world is useless if iOS kills the app halfway through a sentence.

Your phone’s memory sets a hard ceiling. Everything else is preference. So here is the ceiling, why it is lower than the spec sheet suggests, and what to run underneath it.

Start with how much RAM your iPhone has

Apple does not print RAM on its spec sheets, which is part of why this is confusing. Teardowns and developer documentation fill in the gap. Here is where every recent iPhone lands:

iPhone	RAM
iPhone 13, 13 mini, 13 Pro, 13 Pro Max	6GB
iPhone 14, 14 Plus, 14 Pro, 14 Pro Max	6GB
iPhone 15, 15 Plus	6GB
iPhone 15 Pro, 15 Pro Max	8GB
iPhone 16, 16 Plus, 16 Pro, 16 Pro Max	8GB
iPhone 17	8GB
iPhone Air, iPhone 17 Pro, 17 Pro Max	12GB

Two things stand out: the jump to 8GB happened at the iPhone 15 Pro, not the iPhone 15, so a standard iPhone 15 has the same memory as an iPhone 13. And the iPhone 16 line standardized 8GB across every model, which is why the 16 is often the cheapest sensible phone for running mid-sized models.

The part nobody mentions: you do not get all of it

Here is where most model recommendations quietly mislead people: your iPhone’s RAM is not your app’s RAM.

iOS reserves memory for the system, background apps, and the camera pipeline, and it enforces a per-app ceiling through a watchdog called Jetsam. If an app crosses that ceiling, iOS does not slow it down or swap it to disk. It terminates the app immediately. No warning, no error, the app just disappears.

The ceiling varies by device, but the working rule is that an app gets roughly half the phone’s physical RAM. An iPhone 16 Pro with 8GB gives an app somewhere around 4GB. A 6GB phone gives around 3GB.

That single fact explains almost every “why did my local AI app crash” complaint. Somebody with an 8GB iPhone reads that 8B models are about 4.5GB at Q4, does the arithmetic against 8GB, and concludes it fits. It does not. It has to fit in 4GB, alongside the app itself and the memory the conversation consumes as it grows.

So the number that matters is not your phone’s RAM, it is roughly half your phone’s RAM, minus room to think.

What quantization does to the file size

Model sizes get quoted in parameters, like 3B or 8B, but what you download is a file, and the file size depends on quantization.

An unquantized model stores each weight at 16 bits. Quantization stores them at lower precision, which shrinks the file at a small cost in quality. Q4 stores roughly 4 bits per weight, cutting the file to about a quarter of full precision. Q8 is half. The naming you will see most often on phones is Q4_K_M, a variant that keeps the more sensitive parts of the model at higher precision and squeezes the rest, which is why it has become the default balance for on-device use.

In practice, at Q4, a rough rule is that a model’s file size in gigabytes is a bit over half its parameter count in billions. A 3B model lands near 2GB. A 4B model lands near 2.5GB. An 8B model lands near 4.5GB. That estimate is close enough to plan around.

The context window costs extra on top of the file. A long conversation holds more tokens in memory, and that memory grows as you chat. This is why a model can load fine, answer three questions, and then die on the fourth. It did not run out of room at launch. It ran out of room later.

Matching a model to your phone

With the usable-memory rule and the file-size rule together, the tiers fall out cleanly.

6GB iPhones (iPhone 13, 14, and the standard 15 and 15 Plus). You have roughly 3GB to work with. Stay in the 1B to 2B range. Gemma 3 1B and Qwen 3 1.7B both run well here and leave real headroom for a conversation. A 3B model will often load, but you are close enough to the ceiling that a long chat becomes a gamble. If your phone is on this tier, a smaller model that never crashes is worth more than a larger one that sometimes does.

8GB iPhones (iPhone 15 Pro, the entire iPhone 16 line, iPhone 17). Roughly 4GB usable, which is the sweet spot for the 3B to 4B class. Llama 3.2 3B is the safe default and is consistently rated among the strongest models for its size on instruction following. Phi-4 Mini at 3.8B is the better pick if you lean on reasoning or code, where it punches well above its parameter count. Qwen 3 4B is the strongest all-rounder in the tier if you want the most capable thing that still fits. All three land between 2 and 3GB at Q4, which leaves genuine room for context.

12GB iPhones (iPhone Air, iPhone 17 Pro, 17 Pro Max). Roughly 6GB usable, which finally opens the 7B to 8B class. This is where local models stop feeling like a compromise. The tradeoff moves from “will it fit” to “am I willing to wait,” because a larger model generates text more slowly on the same chip.

Speed is the tradeoff you will notice

Fitting the model is the hard constraint. Speed is the one you live with.

A 3B to 4B model on a recent iPhone generates somewhere in the range of 10 to 30 tokens per second, depending on the chip, the model, and the quantization. Published figures vary a lot and often come from whoever is selling the app, so treat any specific number as a rough guide rather than a promise. What that means in practice is that a short reply arrives in a few seconds and a paragraph takes maybe half a minute.

For writing, summarizing, and thinking through a problem, that is fine. You are reading as it generates. For a quick factual lookup where you wanted the answer instantly, it feels slow, and no local model on a phone is going to fix that.

The practical advice that follows from this is unintuitive: start one tier smaller than your phone can handle. A fast model you open every day beats a larger one you stop using because every reply takes 40 seconds. You can always move up later. It is only another download, and deleting a model you did not like is clean.

If your model keeps crashing

Work down this list: shorten the conversation or start a new chat, since context memory grows as you talk and is the usual culprit for a crash that happens mid-session rather than at launch. Close background apps, which frees memory the system would otherwise be holding. Drop to a smaller quantization, since moving from Q8 to Q4 roughly halves the file. And if the file still will not fit, move down a parameter tier. A 1.7B model that runs is strictly better than a 3B model that dies.

The short version

Find your phone in the table, halve the RAM, and pick a model whose file is comfortably under that number with room left over for the conversation. Six gigabytes means 1B to 2B. Eight means 3B to 4B. Twelve means 7B to 8B.

Once the model fits, everything else is preference, and the rest of the experience is the part worth having: chat that works in airplane mode, prompts that never leave your phone, and no account or subscription attached to any of it. If you are new to the category, what a local LLM is covers the why, running AI offline on iPhone covers the setup, and prompting small models covers getting good answers once a smaller model is doing the work.