Apple’s Foundation Models, in plain terms

Apple’s Foundation Models are Apple’s family of AI models for Apple platforms.

They power Apple Intelligence features such as rewriting text, summarizing information, understanding images, and helping the system work with personal context. The important part is that Apple designed these models around Apple devices and Apple’s privacy architecture, not as a generic cloud chatbot.

In simple terms:

• Apple’s Foundation Models are the AI engine.
• Apple Intelligence is the product experience built on top.
• The Foundation Models framework is the developer API.

Apple introduced Apple Intelligence at WWDC 2024, on June 10, 2024. Apple’s machine learning team later described the model family in Introducing Apple’s On-Device and Server Foundation Models. One year later, at WWDC 2025 on June 9, 2025, Apple introduced the Foundation Models framework. Apple’s 2025 model update describes it as developer access to the approximately 3-billion-parameter on-device language foundation model at the core of Apple Intelligence.

Why they matter

Most AI products start in the cloud. Apple starts on the device.

That changes the shape of an app feature. A local model can answer without sending every prompt to a server. It can work without a custom backend. It can also avoid per-request token costs for many small tasks.

That makes Foundation Models especially useful for private, personal, app-specific features:

• summarize a note
• rewrite selected text
• extract action items
• classify local content
• generate a small Swift data structure
• power a focused in-app assistant

This is not a replacement for every large model API. It is best when the task is close to the user, close to the app, and small enough for an on-device model.

What Apple actually built

For app developers, the practical split is between two deployment paths.

The first is a compact on-device language model. In its 2024 model report, Apple described an approximately 3-billion-parameter model optimized for Apple silicon. This is the kind of local model the Foundation Models framework exposes to apps.

The second path is server-based models that run with Private Cloud Compute. Those models are meant for heavier Apple Intelligence tasks that need more capacity while still fitting Apple’s privacy architecture.

For app developers, the practical focus is the on-device model.

The on-device model is built for common language tasks:

• summarization
• rewriting
• classification
• entity extraction
• short dialog
• structured generation
• tool use

It is not meant to be a general-purpose chatbot with always-current world knowledge. If your feature needs live web data, a very large context, or deep external knowledge, you still need another source of truth.

The developer API

The Foundation Models framework is a Swift framework.

The basic flow is:

1. Check whether the model is available with SystemLanguageModel.
2. Create a LanguageModelSession.
3. Send a prompt.
4. Read or stream the response.

At the highest level, it looks like this:

import FoundationModels
 
let session = LanguageModelSession(
    instructions: "You are a concise writing assistant."
)
 
let response = try await session.respond(
    to: "Rewrite this sentence so it sounds clearer: \(text)"
)
 
print(response.content)

The framework handles the local model access. Your app handles the product experience: when to show the feature, what to ask, how to handle errors, and how to present the result.

If you want to see a small implementation, my project Localight shows the same idea in a real iOS app. It includes separate implementations for iOS 26 and iOS 27, so you can compare the Foundation Models API surface across both system versions.

Availability matters

You should never assume the model is ready.

The user needs a supported device, Apple Intelligence must be enabled, and the model may still be downloading or preparing. Apple exposes those cases through SystemLanguageModel. A real app should treat them as normal UI states, not as unexpected failures.

let model = SystemLanguageModel.default
 
switch model.availability {
case .available:
    // Start a LanguageModelSession.
    break
 
case .unavailable:
    // Show a clear fallback.
    break
}

This is one of the biggest differences between a demo and a real feature. Local AI is powerful, but it is still a system capability with availability rules.

Typed output

Prompting for plain text is useful for chat and rewriting. App logic usually needs structure.

That is where guided generation comes in. With @Generable, you define the Swift type you want, and the framework guides the model toward output that can become that type.

@Generable
struct TaskSummary {
    var title: String
    var actionItems: [String]
    var priority: Int
}
 
let summary = try await session.respond(
    to: note,
    generating: TaskSummary.self
).content

Instead of parsing a paragraph, your app receives a TaskSummary. That makes Foundation Models more useful for real interfaces, because the model output can become state, rows, labels, filters, or actions.

Tools

The model does not automatically know what is inside your app.

Tool lets you expose a controlled piece of app behavior to the model. A tool might look up a local project, search a database, create a reminder, or fetch a record from SwiftData.

The useful rule is simple: keep tools narrow. A good tool has one job, a clear name, and predictable input.

Tool calling is where the framework becomes more than text generation. The model can reason about when it needs app data, call the tool, and use the result in its response.

The technical picture

Under the hood, Apple has optimized the on-device model for memory, latency, and power use.

The 2024 model report described an approximately 3-billion-parameter on-device language model and a larger server model for Private Cloud Compute. Apple also described adapters for specialized tasks, compression, quantization, and inference optimizations designed for Apple silicon.

Apple’s third-generation Foundation Models article, published on June 8, 2026, goes further. Apple describes the third generation as a family of five models, built in collaboration with Google, spanning on-device use and server-side use through Private Cloud Compute.

The five models are:

• AFM 3 Core: the next generation of Apple’s 3-billion-parameter dense on-device language model.
• AFM 3 Core Advanced: Apple’s strongest on-device model, a multimodal 20-billion-parameter sparse model that activates only part of itself for a given request.
• AFM 3 Cloud: the main server-side model for speed, efficiency, and performance on Private Cloud Compute.
• ADM 3 Cloud (Image): the image model for generation and editing, including Apple Intelligence image features.
• AFM 3 Cloud Pro: Apple’s most capable server-side model for demanding tasks such as agentic tool use and more complex reasoning.

The split is important. AFM 3 Core and AFM 3 Core Advanced are for on-device experiences. AFM 3 Cloud, ADM 3 Cloud (Image), and AFM 3 Cloud Pro run through Private Cloud Compute. Apple says AFM 3 Core, AFM 3 Core Advanced, AFM 3 Cloud, and ADM 3 Cloud (Image) are purpose-built for Apple silicon, while AFM 3 Cloud Pro runs on NVIDIA GPUs in Google Cloud with Private Cloud Compute protections extended to that environment.

For developers, the practical takeaway is this:

• the framework model runs locally
• prompts and outputs stay inside the app flow
• structured output is a first-class feature
• tool calling connects the model to app-specific data
• availability, safety, context size, and errors still need product design

When to use it

Use Foundation Models when the feature is small, private, and close to the app:

• “Summarize this note.”
• “Rewrite this draft.”
• “Extract the tasks from this message.”
• “Classify these local documents.”
• “Turn this text into a Swift data structure.”

Reach for a server model when you need current web knowledge, large-scale retrieval, long context, centralized control, or a model that is stronger than the on-device one.

Apple’s Foundation Models are not just “ChatGPT, but local.” They are a native AI layer for Apple platforms. Used well, they let apps add useful intelligence without turning every feature into a cloud service.