Foundation Models: Apple's On-Device AI for Developers

With iOS 26, Apple finally opens the doors to its embedded language model for third-party developers. The Foundation Models Framework allows you to integrate artificial intelligence capabilities directly into your applications, without remote servers, without inference costs, and with complete user data privacy.

This guide explores this new API in depth: from simple text generation to complex architectures with Tool Calling, through the type-safe guided generation that makes this framework shine.

This article covers the entire Foundation Models Framework:

The Foundation Models Framework relies on Apple Intelligence, available only on devices equipped with a sufficiently powerful Neural Engine:

Three conditions must be met to use the framework:

The model (~3 billion parameters) weighs approximately 3 GB and downloads automatically after Apple Intelligence activation. This download happens in the background and may take several minutes depending on connection speed.

The LanguageModelSession class is the main entry point for the framework. It manages communication with the model and maintains conversation history:

This approach waits for the model to generate its entire response before returning. For long responses, the user may feel the application is unresponsive.

For a smooth user experience, use streamResponse which returns an AsyncThrowingStream:

Streaming allows displaying text character by character, exactly like modern chat interfaces. The user sees the response being built in real time.

Instructions define the model's behavior and personality for the entire session duration:

Instructions are more powerful than a simple prompt prefix. The model considers them as priority directives and applies them consistently throughout the conversation.

Guided generation is the flagship feature of the Foundation Models Framework. It allows obtaining structured responses as native Swift types, without fragile JSON parsing.

Annotate your structures with @Generable so the model can instantiate them directly:

The model uses "constrained decoding" to guarantee that the output respects the defined structure exactly. No malformed JSON, no missing fields.

The @Guide macro allows refining generation behavior for each property:

Available constraints include:

The order of property declaration is crucial. The model generates values sequentially, from top to bottom:

If you place summary before mainTopics, the model cannot rely on identified topics to build the summary.

Combine guided generation and streaming for optimal UX:

The PartiallyGenerated type exposes each property as optional, allowing you to display values as they are generated.

The embedded model has limited knowledge (training data until 2023) and no access to external data. Tool Calling fills these gaps by giving it access to your APIs.

A Tool implements the Tool protocol with the following elements:

The name is auto-generated from the struct/class name and can be omitted.

Tools are passed to the session at creation:

Here's a realistic example integrating HealthKit for health data:

The model can call multiple tools in sequence to answer a complex request:

The framework automatically handles inserting tool results into the conversation transcript.

The Foundation Models Framework defines specific errors via GenerationError:

Apple applies strict and non-disableable safety filters. Certain content systematically triggers a violation:

These guardrails are sometimes too restrictive (a news article about a death may be blocked). Apple is working to improve these false positives — report them via Feedback Assistant.

Apple recommends avoiding these use cases:

The model excels however for:

Initial model loading takes a few seconds. Use prewarm() to anticipate. This method is synchronous and doesn't throw — it returns immediately and loading happens in the background:

Call prewarm() as soon as you anticipate model usage (e.g., when user opens the chat screen).

With ~3 GB of RAM used by the model, monitor memory footprint:

Each property of a @Generable type is generated sequentially. More properties mean slower generation:

Design your Generable types with only the properties you will actually display.

Here's a complete implementation of a conversational assistant with SwiftUI and iOS 26:

This implementation handles:

The Foundation Models Framework opens considerable possibilities for iOS applications. It doesn't replace cloud models for complex tasks, but excels for quality of life features that work offline and respect privacy.