What Actually Runs on an iPhone SE 2 (2020): LFM2.5 350M vs Qwen3.5-2B Benchmarked
I spent part of yesterday evening running local LLM benchmarks on my iPhone SE 2nd generation, the 2020 model with an A13 chip and 3GB of RAM. The question was simple: what is the biggest model this phone can actually use, and what happens when you push past that line. The two models I tested landed on opposite sides of it.
The setup
I used the PocketPal app, which runs llama.cpp under the hood, and benchmarked everything on the phone itself. Both models ran fully on device, offloading all 99 layers to the GPU with flash attention on and an f16 KV cache, context capped at 2048, batch and ubatch at 512, 4 CPU threads. Nothing tuned, nothing exotic, just the same fair settings for both.
The two contenders:
- LFM2.5 350M from Liquid AI, 226.93 MB as a GGUF, 354M parameters
- Qwen3.5-2B at Q4_K_M quantization, 1.26 GB, 1.88B parameters
The numbers
| Model | Size | Config | Prompt processing | Token generation | Total time |
|---|---|---|---|---|---|
| LFM2.5 350M | 227 MB | PP 512, TG 128 | 385.31 t/s | 63.49 t/s | 10s |
| LFM2.5 350M | 227 MB | PP 128, TG 32 | 197.86 t/s | 69.67 t/s | 4s |
| Qwen3.5-2B Q4_K_M | 1.26 GB | PP 128, TG 32 | 17.61 t/s | 0.32 t/s | 5m 22s |
| Qwen3.5-2B Q4_K_M | 1.26 GB | PP 512, TG 128 | 35.95 t/s | 0.30 t/s | 22m 11s |
Peak memory tells the other half of the story. LFM2.5 peaked at 11.6% of RAM (358 MB of 3GB) on the small config and 14.2% (441 MB) on the large one. Qwen3.5-2B peaked at 35.8% and 40.1% respectively, so around 1.2GB of 3GB once the KV cache and runtime overhead pile on.
The 0.3 t/s problem
0.3 tokens per second means one token roughly every 3.3 seconds. The full 128-token generation pass took 22 minutes. This is not a benchmark quirk or a bad run. I ran it twice with different configs and got 0.32 and 0.30 t/s. The phone is simply under-provisioned for a 1.88B model at Q4.
A 1.26 GB model file on a 3GB phone sounds fine on paper. It leaves room, the peak memory readout agrees, everything loads. But token generation is memory bandwidth bound, and the A13's bandwidth is shared with the OS, and the quantized matrix-vector kernels need far more bandwidth headroom than this 2020 chip has left over. So the model loads, the GPU crunches, and you watch text appear one character every few seconds.
Prompt processing scales the other way. Qwen3.5-2B managed 17.61 t/s on the short PP 128 config and 35.95 t/s on PP 512, so prefill speeds up with bigger batches, roughly doubling. It is only the decode side that collapses. If your app only needed to classify or embed text, a 2B model on this phone would still be tolerable. The moment you need generation, it is unusable.
Where the line actually is
LFM2.5 350M is the opposite story. 63 to 70 t/s of generation is genuinely interactive speed, faster than a human reads. Prompt processing at 385 t/s eats a 512-token prompt in about 1.3 seconds. Total benchmark pass: 10 seconds on the big config, 4 on the small one. The phone stays cool, memory barely moves, and you could run this thing as a real assistant background process all day.
Generation actually got slightly faster with the smaller config (69.67 t/s at TG 32 vs 63.49 t/s at TG 128), which makes sense for a model this small since the benchmark overhead weighs more per run at short lengths. Prompt processing did the opposite and roughly halved on the short config (197.86 vs 385.31 t/s), the mirror image of the Qwen behavior.
Why the 350M class matters right now
A year ago a 350M model was a toy that produced word salad. The current generation of small models, LFM2.5 being the standout but not alone, changed that. Liquid AI built these on their LFM architecture specifically for edge hardware, and the quality at 350M is now good enough for drafting, summarizing, function calls, and chat that does not embarrass itself. The model file is 227 MB. It fits anywhere.
Qwen3.5-2B is not a bad model. It runs great on better phones and on any laptop. The problem is specific to 3GB-class hardware, where parameter count stops being a quality choice and becomes a yes-or-no question. Somewhere between 350M and 1.88B on this phone there is a wall, and it arrives much earlier than the RAM math suggests.
What I would actually run
- 3GB phone (iPhone SE class, old Android budget devices): sub-500M models. LFM2.5 350M is the obvious pick. Keep the GGUF under 300 MB if you can.
- 4 to 6GB phones: this is where 1B to 2B models start making sense, but expect single-digit tokens per second on 2B and verify before committing.
- 8GB+ phones: 2B models are fine here, and 7B at low quant becomes possible on the better ones.
- Anything interactive on 3GB: stick to LFM2.5 350M at 70 t/s and accept the quality trade. A fast small model beats an unusable big one every single time.
The Qwen run took 22 minutes to finish. I let it finish mostly out of stubbornness. The LFM run was done before I put my coffee down. On hardware this constrained, that difference is the entire product.