Apple's newest on-device model carries about 20 billion parameters, and on any given request it fires maybe one to four billion of them. That gap — 20B stored, roughly 3B running — is the whole story of 2026. The model that now ships inside the latest iPhone is no longer a shrunken, lobotomized cousin of the cloud model. It's a different kind of object: large in flash, small in motion, and it never phones home.

For three years the on-device pitch was mostly aspirational. Demos ran, latency was rough, quality trailed the API by a generation, and every serious AI feature still resolved to a per-token bill in someone's datacenter. In mid-2026 that stopped being true. Two releases — Apple's third-generation Foundation Models at WWDC on June 8, and Google's Gemma 4 family on April 2 — quietly moved the floor. Genuinely useful agents now run on hardware you already own, offline, for free.

The economics nobody priced in

Forget benchmarks for a second; the load-bearing fact here is accounting. When the model lives in the cloud, every inference is a metered event — input tokens, output tokens, a line item that scales linearly with usage and explodes the moment you wrap the model in an agent loop. Agentic workloads are the worst case for the token meter: a single "go do this task" can fan out into dozens of model calls as the agent plans, calls tools, retries, and re-reads its own output. The bill grows with your ambition.

Move the model onto the device and the marginal cost of an inference is approximately $0. No API key, no rate limit, no usage dashboard. You paid for the silicon once; every token after that is free in the only sense a product manager cares about — it doesn't show up on a monthly invoice that grows with your success. That single change rewrites which features are worth building. A background task that re-summarizes your inbox every five minutes is insane on a per-token plan and trivial on-device. So is an agent that quietly loops a hundred times to get one answer right.

And it isn't only cost. On-device means offline — the model works on a plane, in a tunnel, in a country where your cloud provider has no presence. And it means private in the literal architectural sense: the data never leaves the NAND. For a calendar, a photo library, a health log, or a half-written message, "these bytes physically did not transit a network" is a far stronger guarantee than any privacy policy.

Sparse beats big: the architecture that did it

The reason this works now isn't that someone discovered how to cram a frontier model into 3GB of RAM. It's that the model designs changed shape. The winning idea across both Apple and Google is the same: decouple how big the model is from how much of it actually runs on any given token.

Apple's AFM 3 on-device model uses what the company calls Instruction-Following Pruning (IFP). The full ~20B-parameter model lives in flash. For a given request, the system activates only the relevant ~1-4B parameters, swapping the needed "experts" into DRAM on demand. The phone never holds the whole model in working memory — it streams the slice it needs. That's how a 20B model fits inside a memory budget that physically cannot hold 20B of active weights.

Google's Gemma 4 attacks the same problem from two angles. The edge models — E2B and E4B — use "Per-Layer Embeddings" to keep the active footprint small: E4B carries roughly 8B total parameters but runs with about 4.5B effective. Its bigger sibling, a 26B mixture-of-experts, only lights up a fraction of its experts per token. MoE and per-layer tricks are Apple's IFP insight wearing different clothes — most of a large model is dead weight on any single token, so don't pay to run it.

The hardware finally met the software halfway. The neural accelerators (NPUs) now standard in phones and laptops run 4-8B-class models at genuinely usable speeds. The practical question shifted from "can it run at all" to "which model fits this RAM tier" — and that's a routine product decision, not a research problem. Google says the Gemma 4 edge models run "completely offline with near-zero latency" not just on phones but on a Raspberry Pi and an NVIDIA Jetson Orin Nano; the prior generation's E4B reportedly fit in about 3GB of RAM.

These are not toy models anymore

The capability jump is real, and it's broadest where it matters for everyday use: multimodality. AFM 3's on-device model is now multimodal — it takes images in, and Apple reports human raters preferred its image understanding about 61% of the time over the previous generation. Its on-device text-to-speech scored 4.24 on a 5-point mean-opinion scale versus 3.82 for the baseline — roughly the difference between "obviously a robot" and "fine, I'll actually listen to this." Gemma 4 ships native vision and audio, 128K context on the edge models, and 140+ languages.

The open-model leaderboard backs the claim up. Google's 31B dense Gemma 4 lands around #3 among open models and its 26B MoE around #6 on LMArena's text board — and Google's own framing, that these "outcompete models 20x their size," is the whole thesis in one line. The point of a small model in 2026 isn't to match GPT-class frontier reasoning. It's to be good enough at the 90% of tasks that don't need it, while running for free in your pocket.

What it still can't do

The honest caveat: the device model is not the frontier model, and pretending otherwise is how you ship a disappointing feature. Hard multi-step reasoning, long-horizon coding, deep research across large corpora — those still belong in the cloud, where a much larger model with a big context budget earns its token bill. Treat the small-model benchmark numbers that float around — figures in the mid-80s on MMLU for 14B-class models, high-60s for sub-4B ones — with suspicion; MMLU is saturated and gameable, and a leaderboard score tells you almost nothing about whether the thing can hold a five-step plan together. The right mental model is a hybrid: the device handles the fast, private, high-frequency work and hands off to the cloud only when a task genuinely outgrows it. The interesting engineering of the next year is the routing layer that decides which is which.

Apple opened the gates

The most underrated WWDC announcement wasn't the model — it was the door. Apple opened its Foundation Models framework to third-party and open models, with Swift packages for Anthropic's and Google's models on the way, and added agentic primitives plus on-device semantic search to the SDK. Translation: a developer can write an app against one local-first AI framework and let the device decide which model answers. That's the platform move. The model becomes a commodity inside it; the framework — the agent primitives, the semantic index over your own files, the routing — is the moat. Once the OS ships a free, private, capable model and a clean API to it, "add AI" stops meaning "add a cloud dependency and a billing relationship" and starts meaning "call a system function."

The take

The cloud-AI era trained everyone to assume intelligence is a utility you rent by the token. 2026 is the year that assumption cracked at the edge — not because device models got as smart as the frontier (they didn't), but because sparse architectures finally made "large but cheap to run" a real category, and the economics of $0 marginal inference are too good to ignore for the enormous class of features that never needed a genius in the first place. The cloud keeps the hardest problems. The device quietly takes everything else — offline, private, and off the meter. That's not a demo anymore. It's the new default, and most software hasn't been rewritten to assume it yet. The teams that rewrite first will look, briefly, like magicians.