Your iPhone can now run a 3-billion-parameter language model entirely on-device. No API calls. No cloud. No data leaving your phone. Apple's Foundation Models framework just made local AI a first-class citizen in Swift.
This changes the economics of building AI into mobile apps. Until now, you had two options: ship a tiny model that runs locally but can't do much, or call a cloud API that's powerful but costs money and raises privacy questions. Foundation Models gives you a third option: a genuinely capable model, running locally, with Swift-native APIs that feel like any other iOS framework.
What You Can Build
The framework handles text generation, summarisation, translation, and structured data extraction. The interesting bit is the @Generable macro. You define a Swift struct - say, a parsed invoice with fields for vendor name, amount, date, and line items - and the macro generates type-safe code that extracts that structure from unstructured text.
This matters because structured output is where most production AI applications live. You're not building chatbots. You're parsing receipts, extracting meeting action items, categorising support tickets. The difference between "here's some JSON that might be valid" and "here's a Swift struct with compile-time guarantees" is the difference between a prototype and something you can ship.
The model runs inference fast enough for real-time interaction. The article demonstrates a travel assistant app that processes natural language queries - "Find me a flight to Tokyo under £500" - and returns structured results. All on-device. No network lag. No API quota. No usage costs beyond the initial download.
The Privacy Story
For apps handling sensitive data - medical records, financial information, personal communications - on-device inference isn't just faster. It's the only option that doesn't create a liability. Cloud APIs require sending user data to a third party. That triggers compliance requirements, data processing agreements, audit trails. On-device models avoid all of it.
Foundation Models doesn't send telemetry. Doesn't phone home. Doesn't require an internet connection after the initial model download. A user's data stays on their device. For developers building in regulated industries, that's not a nice-to-have. That's the feature that makes the project viable.
The Developer Experience
Apple integrated Foundation Models into Xcode with the same design patterns as SwiftUI and Combine. You import the framework, define your prompt as a string or a struct, and call generate(). Inference happens asynchronously. Results come back as Swift types. If you've built an iOS app, this feels familiar.
The model download happens through Apple's standard asset delivery system. Users get the model as part of app installation or as an on-demand resource. For small models, that's a non-issue. For the 3-billion-parameter version, it's a 2GB download - significant but manageable on modern devices.
Performance scales with hardware. On an iPhone 15 Pro, inference is fast enough for interactive use. On older devices, it's slower but still usable. Apple provides profiling tools in Xcode that show exactly where inference time is being spent, so you can optimise prompts and model selection based on your target devices.
What This Opens Up
The immediate applications are obvious: smarter keyboards, better voice assistants, local document processing. The less obvious applications are more interesting. A field service app that works offline and can still generate reports from photos and voice notes. A health app that interprets lab results without sending data to a server. A language learning app that doesn't need a subscription model because there's no per-use API cost.
Foundation Models turns AI from an operational expense into a development cost. You build the feature once. It ships with the app. The marginal cost of each inference is zero. For small teams and indie developers, that's the difference between "we can't afford to build this" and "we can ship this next week".
On-device models aren't new. What's new is Apple making them easy to use, performant enough to matter, and integrated into the platform. That's what shifts a capability from technically possible to actually built.