Apple Open Sources the Foundation Models Framework as iOS 27 Ships (Deep Dive)

Apple released iOS 27 on September 14, 2026, and the update carries the most consequential developer-facing change the company has made in AI infrastructure: the Foundation Models framework is now open source. The same Swift APIs that power on-device intelligence on the iPhone, Mac, and Apple Watch can now run on any server where Swift compiles. Combined with a new public protocol that lets developers swap between Apple's own models, Anthropic's Claude, Google's Gemini, and open-source alternatives through a single API surface, the framework transforms Apple's AI stack from a walled-garden SDK into an interoperable programming model. For developers, the immediate payoff is zero-cost access to on-device and server-scale models that were previously locked inside Apple Intelligence. The longer-term shift is architectural: a unified session, tools, and guided-generation interface that works identically whether the model runs locally, on Private Cloud Compute, or on a third-party endpoint.

What the Open-Source Release Includes

At WWDC 2026, Apple committed to open-sourcing the Foundation Models framework "later this summer," and the September 17 release of iOS 27 fulfills that timeline. The open-source repository contains the core framework plus two additional model execution implementations: CoreAILanguageModel for running custom models on the Apple Neural Engine, and MLXLanguageModel for running models on Mac GPUs via the MLX research framework. All three conform to the same LanguageModel protocol, so switching between them requires changing only the model argument passed to a LanguageModelSession.

Alongside the core framework, Apple released a companion Swift package called FoundationModelsUtilities under the Apache-2.0 license. This package is already available on GitHub and targets both Apple platforms and Linux distributions including Ubuntu. It ships three components that address the practical problems of building agentic AI apps: a Skills API for just-in-time instruction injection, profile modifiers for transcript history management, and a ChatCompletionsLanguageModel adapter that can point the Foundation Models programming model at any server speaking the chat completions REST API. The repository describes its contents as "emerging and experimental patterns," signaling that these are preview interfaces rather than frozen contracts.

The open-source release matters because it breaks a long-standing asymmetry. Until now, Apple's on-device models were accessible only through a proprietary SDK tied to Apple's operating systems. Developers who wanted to use the same session, tool-calling, and guided-generation patterns had to rewrite their logic for a different API when they moved to a server. The open-source framework eliminates that duplication: one Swift module handles client and server, and the same code that runs an on-device summarizer can run a cloud-scale document analyzer with a single line change.

The LanguageModel Protocol and Model Swapping

The technical foundation of the framework's flexibility is the LanguageModel protocol. Every model implementation, whether Apple's on-device system model, the Private Cloud Compute server model, a Core AI local model, an MLX-hosted open-source model, or a third-party provider package, conforms to the same protocol. This means developers code against a slot, not a specific model, and can swap providers without changing downstream logic.

The practical effect is visible in session initialization. Creating a session with Apple's on-device model looks like creating a session with the Private Cloud Compute server model, with the only difference being the model argument. Structured output through the Generable protocol and tool calling through the Tool protocol behave identically across both. Apple's developer documentation frames this as a one-line change from the on-device system model to the server-scale cloud model, with no modifications to prompts, tools, or instructions.

Third-party provider packages from Anthropic (Claude) and Google (Gemini) are expected to ship as separate Swift packages conforming to the same protocol. This means a developer can write an app that uses Apple's on-device model for fast, private, offline inference, routes to Private Cloud Compute for complex reasoning tasks, and falls back to Claude or Gemini for specialized workloads, all through the same session API. The developer does not rewrite code when switching providers; they change a configuration value.

Users also gain choice at the system level. iOS 27 introduces an Extensions setting that lets users designate their preferred AI provider for Writing Tools and Image Playground. ChatGPT, Claude, Gemini, and other compatible services can each serve as the default, and users can assign different voices to different models so they can tell which provider is handling a given request. Apple launched a dedicated App Store section listing compatible AI apps, reinforcing the message that the AI model market is becoming a marketplace rather than a monopoly.

Private Cloud Compute Moves to NVIDIA GPUs

The server-side model available through Private Cloud Compute offers a 32K token context window, compared to the on-device model's 4K shared budget, and supports three levels of reasoning depth: light, moderate, and deep. Apple frames the choice between on-device and cloud as a data-driven decision rather than a default: measure which model performs better on your specific workload using Xcode's new Evaluations framework, then configure the session accordingly.

The privacy architecture remains the headline. Private Cloud Compute was designed so user data is never stored and is used only for the request, with no API keys, no account setup, and no token cost to the developer. Each user receives a daily request limit counted against their iCloud account, with upgrade paths through iCloud+. Apps with fewer than two million first-time App Store downloads receive free access to the server model, removing infrastructure costs as a barrier to building AI-powered features.

In June 2026, Apple extended Private Cloud Compute to Google Cloud infrastructure running NVIDIA GPUs for certain Apple Intelligence workloads, marking the first time PCC guarantees applied to third-party data centers. The five core requirements, stateless computation, enforceable guarantees, no privileged runtime access, non-targetability, and verifiable transparency, remain unchanged. Apple hardens the deployment with NVIDIA Confidential Computing, Intel TDX, Google Titan chip attestation, and a cryptographically verifiable append-only ledger of all PCC hardware. Apple retains complete control over PCC software and will only trust code that is cryptographically approved by Apple. Researchers can inspect all binaries through the Apple Security Bounty Program.

The developer experience stays simple. PCC is integrated into the OS alongside iCloud, so there is no authentication to wire up, no API keys to rotate, and no account setup to ask users for. To use the server model, a developer changes one line of code that applies when creating a LanguageModelSession. The framework uses a unified API regardless of which model the session talks to, so the respond methods, tools, and instructions carry over without modification.

Dynamic Profiles and the Skills API

Dynamic Profiles are the foundational primitive that makes multi-agent and multi-model workflows possible within a single session. A DynamicProfile is a configuration state consisting of instructions, tools, and modifiers for things like the model, temperature, and sampling mode. A single LanguageModelSession can switch between profiles mid-conversation, so a brainstorming turn can use the cloud model with high temperature and a review turn can drop to the on-device model to save server calls.

The WWDC 2026 session on agentic experiences demonstrated this pattern with a craft assistant app that used different profiles for different phases of a task. A planning phase might use one model and set of tools, while an execution phase switches to a different profile with different instructions. The session manages the transition transparently, maintaining conversation context while swapping the underlying configuration.

The Skills API, released as part of the FoundationModelsUtilities package, builds on Dynamic Profiles to provide just-in-time instruction injection. A Skill is initialized with a prompt or instructions and can be activated or deactivated during a session. When a skill is active, it injects task-specific directions into the transcript only when needed, which prevents context pollution and optimizes time-to-first-token because the model processes a shorter, more relevant transcript. The SkillActivations type tracks which skills are currently active, and individual skills can be marked with allowsDeactivation: true when they should be removable mid-session.

Lori Hylan-Cho, Senior Engineering Manager for Swift Intelligence Frameworks, described the relationship precisely: Dynamic Profiles are "a foundational technology for sort of higher order things like skills," and the utilities package lets developers either use Apple's built-in skill abstractions or build their own on the same foundation. The design principle that governs the entire package is that any prompt baked into a utility, including the summarization prompt in history management, must be overwritable by the developer. The shipped default is a starting point to tune, not a fixed behavior to accept.

History management is the second component of the utilities package. Agentic loops produce transcripts that grow unbounded, and the package ships three strategies for managing that growth. Dropping completed tool calls removes the back-and-forth of finished invocations once their results are no longer needed. Rolling-window strategies keep a bounded slice of recent history rather than the entire transcript. Summarization collapses older turns into a shorter form the model can still reason over. Each strategy is a knob on the same dial: keep the transcript informative without letting it exceed what the model can process efficiently.

Core AI: Bringing PyTorch Models to Apple Silicon

Core AI is a separate framework announced alongside the Foundation Models framework at WWDC 2026. Where Foundation Models handles LLM-powered app features through a session-based API, Core AI provides the infrastructure for running custom machine learning models directly on Apple Silicon hardware, from the Neural Engine on iPhone to the GPU on Mac. Apple positions it as a complete AI development platform covering model authoring, optimization, conversion, debugging, and deployment.

The developer workflow starts with a PyTorch model. The coreai-torch Python package, installed via pip, converts PyTorch models into Core AI assets. The process uses torch.export to capture the computational graph, then TorchConverter produces an .aimodel file with weights, operations, and shapes in a format optimized for Apple Silicon. The coreai-build CLI compiles .aimodel into per-architecture .aimodelc assets ahead of time, and the resulting bundles can be loaded in an Xcode target like any resource.

For advanced use cases, developers can re-author models using Core AI APIs for target-aware patterns and layouts, add custom Metal 4 kernels for maximum performance, and optimize with the coreai-opt package. Apple's WWDC session demonstrated that a re-authored model ran 76 percent faster than the original PyTorch conversion after warmup, illustrating the performance gap between naive conversion and hardware-optimized re-authoring.

The debugging and profiling toolchain includes a Core AI Debugger app, an Xcode debug gauge, and an Instruments template. These tools cover model inspection, performance profiling, and validation of numerical accuracy between the original PyTorch model and the converted Core AI asset. Apple also released the coreai-models open-source repository with ready-to-use model architectures and reusable components.

The significance for the broader ecosystem is that Core AI replaces Core ML as the path for custom on-device models. It provides a Python-native workflow that integrates with existing machine learning toolchains, hardware-optimized operations for common patterns like attention and normalization, and a build system that produces assets targeting specific Apple Silicon generations. Siri runs on Core AI under the hood, and the framework's ahead-of-time compilation, dedicated instruments, and Python tooling give developers the same infrastructure Apple uses internally.

Developer Impact and the Zero-Cost Model

The zero-cost model for Foundation Models access is a concrete competitive advantage. On-device inference runs at approximately 30 tokens per second on iPhone 15 Pro at no cost per request. Server-scale inference through Private Cloud Compute carries no token cost to the developer; the user's daily limit is counted against their iCloud account, and small developers with fewer than two million downloads get free access. This eliminates the per-token pricing that makes cloud AI expensive at scale and removes the infrastructure management burden that makes self-hosting impractical for small teams.

For existing iOS apps, most Apple Intelligence features arrive as additions rather than rebuilds. Writing Tools work system-wide in any text field with no integration required from the developer. Siri actions integrate through App Intents, which Apple deprecated SiriKit in favor of, giving a two-to-three-year support window for migration. Image Playground, Visual Intelligence, and Call Context all work as additive layers that apps can opt into by exposing their content through App Intents.

The hardware requirements split into tiers. Base iOS 27 runs on iPhone 11 and newer, but Apple Intelligence features require iPhone 15 Pro or iPhone 16 and later. The advanced on-device model with new Siri voices requires iPhone 17 Pro with 12GB of RAM. Image Playground photorealistic generation routes to Private Cloud Compute with daily limits, and iCloud+ subscribers receive expanded access. Two regional limits apply at launch: Siri AI is unavailable in the EU pending regulatory approval, and all new Apple Intelligence features are unavailable in China pending separate approval.

The open-source Foundation Models framework, combined with the LanguageModel protocol, Dynamic Profiles, and Core AI, gives developers a unified platform for building AI features that span on-device privacy, cloud-scale processing, and third-party model flexibility. The framework ships as part of iOS 27, macOS Golden Gate, watchOS 27, and visionOS 27, all released on September 14, 2026. The developer tools are available through Xcode 27, which is 30 percent smaller, Apple silicon-only, and includes agentic coding features where agents can interact with the simulator, localize apps, run tests, and fix crashes pulled from Organizer.

Apple's bet is that an open, interoperable AI framework drives more developer adoption than a closed one, and that zero-cost access to on-device and server models creates a larger ecosystem than per-token pricing ever could. The September 14 release is the starting gun for developers to test that theory.

Key facts