Apple's on-device AI is now an API

Every recent iPhone now ships a capable language model that your app can call directly - no API key, no network round-trip, no per-token bill. Apple's Foundation Models framework exposes the same ~3-billion-parameter on-device model that powers Apple Intelligence as a plain Swift API, and at WWDC 2026 Apple both added image input and opened the framework so a cloud model can be swapped in behind the same interface. For a large class of in-app AI features, the barrier to entry in 2026 is roughly three lines of Swift and zero dollars. That changes the right way to architect the feature.

Why this matters now

On-device AI used to mean "ship and quantize your own model, and good luck." Now the model is part of the OS. Apple's own technical report puts real numbers on it: the on-device model is about 3 billion parameters, compressed to roughly 2 bits per weight using quantization-aware training, with a footprint near 1 GB, and it supports tool calling and 15+ languages. Quantization costs some accuracy - Apple reports MMLU dropping from 67.8 to 64.4 on-device - but the trade is enormous gains in memory and speed for a model that runs entirely on the phone.

The 2026 additions matter for product design, not just benchmarks. Image input means the on-device model can caption a photo, read a receipt into structured fields, or classify what's on screen without a single byte leaving the device. And WWDC 2026 session 339 introduced a provider protocol: the same call site can target the built-in model or a conforming cloud model, so "on-device vs cloud" becomes a configuration decision rather than a rewrite.

The architecture that follows: hybrid

Free, private, and offline is a fantastic default - but a 3B model is not a frontier model. The design question for every AI feature becomes: does this task actually need the big model?

The honest rule of thumb: route the common, structured work on-device and reserve the cloud for genuine reasoning. The on-device model is strong at exactly the tasks most apps actually need:

• Structured extraction - pull totals and dates off a receipt, turn a note into fields
• Classification and routing - tag, sort, or decide which action a request maps to
• Summarization of on-screen or in-app content
• Tool calling - deciding which of your app's functions to invoke, with arguments

It's the wrong tool for long-form reasoning, deep world knowledge, or anything needing the latest facts. That's where a cloud model - Apple's server model, or your own via the new provider protocol - earns its per-token cost.

The best on-device task is one the user never knew ran a model. No spinner, no network error, no "this feature needs a connection" - it just works, instantly, on the plane.

Our opinion

We've argued for a while that on-device AI is quietly winning, and this is the moment the argument stops being philosophical. When the model is free, offline, and private by construction, the economics flip: the question is no longer "can we afford to add AI here?" but "is there any reason to send this to a server?"

Our take is that most teams should treat on-device as the default and the cloud as the exception - not the other way around. It's better for privacy (data that never leaves the phone can't leak), better for cost (no per-token meter on your most common actions), better for reliability (no network dependency for core features), and often better for latency. Reach for the cloud deliberately, for the specific tasks that need it, behind a clear fallback. The mistake we'd caution against is the reverse: piping every keystroke to a cloud model out of habit, paying for capability the task never needed and handing user data to a server for no reason.

There's a real constraint to plan around: the framework needs Apple-silicon devices with Apple Intelligence, so you design a sensible fallback for older hardware. That's ordinary progressive enhancement - the same discipline good mobile teams already apply to any capability that isn't universal.

How Ashvara helps

On-device is not a bolt-on for us - it's how we've built apps like Cull and SafeBite, where the whole point is that your photos and your health data never leave your phone. We know where the on-device model shines, where it quietly falls down, and how to design the hybrid fallback so users never hit a wall.

If you're planning an AI feature for an iOS app, the framing matters more than the model: get the on-device/cloud split right and you ship something faster, cheaper, and more private than the default. That's the conversation we have on every iOS build. Tell us what you're building and we'll map which parts belong on the device.

Sources: Apple Machine Learning Research - Foundation Models tech report 2025; Foundation Models framework docs; WWDC 2026 session 339.