Apple Is Open-Sourcing the Foundation Models Framework

Apple committed to open-sourcing the Foundation Models framework this summer, so the same Swift APIs you call from an app can run on your server too.¹ At the Platforms State of the Union, Apple framed the move plainly: “Plus, we’re doing something big. Later this summer, the framework will be open source. So the same Swift APIs you use in your app can now run on your server too, giving you a complete end-to-end AI workflow anywhere you deploy Swift.”¹ Alongside that announcement, a companion Swift package landed on GitHub the same week, carrying a Skills API, history-management tools, and a model adapter that points the Foundation Models programming model at any chat-completions endpoint.² The framework itself stays a summer promise; the utilities package is live now.

The open-source announcement at 12:44.

TL;DR

• Apple will open-source the Foundation Models framework “later this summer,” so the same Swift APIs run on a server and give you “a complete end-to-end AI workflow anywhere you deploy Swift.”¹ The framework is not open source today.
• A separate open-source Swift package, FoundationModelsUtilities, is already on GitHub under Apache-2.0, supporting Apple platforms and select Linux distributions like Ubuntu.²
• The package ships a Skills API: a Skills type conforming to DynamicInstructions, built with a result builder, that injects task-specific directions into a session transcript just-in-time to prevent context pollution and optimize time-to-first-token.²
• It also ships history-management profile modifiers (dropping completed tool calls, rolling windows, summarization) and a ChatCompletionsLanguageModel that talks to any server speaking the chat completions REST API.²
• The package is the third skills delivery of this WWDC, after Xcode toolchain skills and Game Porting Toolkit skills, and the repo describes its own patterns as “emerging and experimental.”²

The framework goes open source this summer

The headline is a date, not a download. At roughly 12:44 into the State of the Union, Apple set the timeline and the consequence in two sentences: “Later this summer, the framework will be open source. So the same Swift APIs you use in your app can now run on your server too, giving you a complete end-to-end AI workflow anywhere you deploy Swift.”¹ The framework you already call from a LanguageModelSession on device becomes a thing you can also run wherever Swift runs, including a server you control.

What that buys you is symmetry. Apple spent this year widening where Foundation Models points: the on-device model, Private Cloud Compute, and third-party models like Gemini and Claude, covered in Foundation Models and Private Cloud Compute. Open-sourcing the framework extends that reach in the other direction, off the device entirely. As the session put it, “You’ve seen how the Foundation Models framework connects to third-party models, Private Cloud Compute, and the on-device model. You have the flexibility you need to get the right model for the job.”¹ The open-source step means one programming model spans client and server instead of two.

A caution worth holding precisely: the framework is not open source yet. Apple said “later this summer,” and the honest reading is a commitment with a season attached, nothing shipped today. The package described below is a separate artifact, and conflating the two overstates what exists right now.

The utilities package that is already live

The part you can clone today is FoundationModelsUtilities, an open-source Swift package on GitHub under Apache-2.0.² It supports Apple platforms and select Linux distributions like Ubuntu, which matters because it foreshadows the cross-platform direction the framework itself takes this summer.² The repository describes its contents as “emerging and experimental patterns,” so treat the APIs as a preview of where Apple is steering rather than a frozen contract.²

The State of the Union introduced the package directly: “we’re introducing a new open source Swift package, loaded with pre-built tools to help you get started with concepts like skills and utilities for context management.”¹ Apple grounded the concrete example in a real app: “a task management app like Tiimo can use the package to pull in a skill that adapts its tone and recommendations to the user’s data, delivering a personalized brief to help them stay on top of their day.”¹ The same passage named the foundation underneath: “these utilities from the open source package are created with new fundamental building blocks called Dynamic Profiles.”¹

Three components carry that promise, and each maps to a real problem in agentic Swift apps.

A Skills API built on Dynamic Profiles

The first component is the Skills API. The package defines a Skills type that conforms to DynamicInstructions and gets built with a result builder, with a SkillActivations type that tracks which skills are currently active.² You initialize an individual Skill with a prompt or instructions, and you can mark a skill allowsDeactivation: true when it should be removable mid-session.²

The purpose is the interesting part. A skill adds task-specific directions into a LanguageModelSession transcript just-in-time, which keeps the transcript from filling with instructions a given turn does not need.² Two concrete payoffs follow: the session avoids context pollution, and it optimizes time-to-first-token, because a shorter, more relevant transcript is faster for the model to process before it starts responding.² The Skills API is the just-in-time injection mechanism for instructions, scoped to the moment they matter.

Dynamic Profiles are what make that possible. In the day-three recap, Lori Hylan-Cho, Senior Engineering Manager for Swift Intelligence Frameworks, placed skills directly on top of that primitive: “So we also have Dynamic Profiles, which is kind of a foundational technology for sort of higher order things like skills, which we’re also releasing as a package, so that people can use those or build their own abstractions like skills.”³ The phrasing is precise. Apple ships skills as one package, and it expects developers to either use that package or build their own abstractions on the same Dynamic Profiles foundation.

History management as profile modifiers

The second component manages the other half of the context problem: a transcript that grows unbounded as an agentic loop runs. The package ships profile modifiers for history management, and the README names three strategies.² Dropping completed tool calls removes the back-and-forth of finished tool invocations once their results are no longer needed. Rolling-window strategies keep a bounded slice of recent history rather than the whole transcript. Summarization compresses older turns into a shorter form the model can still reason over.² Each is a knob on the same dial: keep the transcript informative without letting it balloon past what the model can process efficiently.

A chat-completions adapter, the sleeper

The third component is the one that quietly does the most. ChatCompletionsLanguageModel communicates with any server that speaks the chat completions REST API, with optional guided generation.² The implication is large: the Foundation Models programming model, the session, the tools, the instructions, can point at any chat-completions endpoint, not only Apple’s models.

The natural pairing is a local one. The MLX-LM Server runs on the Mac as a chat-completions-compatible HTTP server, covered in Running Agentic AI on the Mac with MLX. Wire ChatCompletionsLanguageModel at a local MLX server and you get the Foundation Models API surface driving a model running entirely on your own hardware. Point it at a cloud endpoint instead and the same code calls a hosted model. The adapter is what turns “Foundation Models” from a name for Apple’s models into a programming model you aim wherever you like.

The third skills delivery of one WWDC

Apple shipped skills three distinct ways at this WWDC, and the utilities package is the third. The Xcode 27 toolchain bundles SwiftUI agent skills you pull out with xcrun agent skills export, covered in Xcode 27 Ships Agent Skills You Can Export Anywhere. Game Porting Toolkit 4 distributes Metal and MetalFX porting skills as a Claude Code plugin from a GitHub marketplace, covered in Game Porting Toolkit 4: Agentic Game Ports on Mac. The Foundation Models utilities package adds a third shape: a Skill API as runtime code, a Swift type you compose in your app rather than a markdown file you export or a plugin you install.

The three deliveries answer different questions. The Xcode skills and the GPTK plugin distribute Apple’s expertise to whatever agent you run. The utilities package gives you the building blocks to author and activate skills inside your own session, against your own data, with your own activation logic. Apple is shipping both the curated knowledge and the machinery to build your own, on the same Dynamic Profiles foundation Lori described.³

Key Takeaways

For Swift developers building AI features: - Plan for one programming model across client and server. The Foundation Models framework goes open source “later this summer,” so the Swift APIs you write today are the ones that will run server-side then.¹ Treat it as a roadmap commitment, not a current capability. - Clone FoundationModelsUtilities now to preview the Skills API and history-management modifiers, but read the repo’s “emerging and experimental” framing as a signal that the surface can change.²

For teams managing context and cost: - Reach for the Skills API to inject task-specific instructions just-in-time, which reduces context pollution and improves time-to-first-token instead of front-loading every instruction into the transcript.² - Apply the history-management modifiers (drop completed tool calls, roll a window, or summarize) to keep long agentic loops from outgrowing the model’s effective context.²

For developers running local or third-party models: - Use ChatCompletionsLanguageModel to point the Foundation Models programming model at any chat-completions endpoint, including a local MLX-LM Server on the Mac, so one API surface drives on-device, local-server, or cloud models.²

FAQ

Is the Foundation Models framework open source today?

No. At WWDC 2026, Apple said the framework will be open source “later this summer,” so the same Swift APIs run on a server and give “a complete end-to-end AI workflow anywhere you deploy Swift.”¹ As of the announcement, that is a commitment with a timeline, not a shipped release. The separate utilities package on GitHub is what you can use right now.²

What is the FoundationModelsUtilities package?

FoundationModelsUtilities is an open-source Swift package on GitHub, licensed Apache-2.0, that supports Apple platforms and select Linux distributions like Ubuntu.² It ships a Skills API, history-management profile modifiers, and a ChatCompletionsLanguageModel adapter. The repository describes its contents as “emerging and experimental patterns.”² The package is distinct from the framework; it is not the framework being open-sourced.

How does the Skills API work?

The package defines a Skills type conforming to DynamicInstructions, built with a result builder, plus a SkillActivations type that tracks active skills.² You initialize a Skill with a prompt or instructions and can set allowsDeactivation: true. A skill injects task-specific directions into a LanguageModelSession transcript just-in-time, which prevents context pollution and optimizes time-to-first-token.² Skills build on Dynamic Profiles, which Apple describes as “a foundational technology” for higher-order things like skills.³

Can I use Foundation Models with a non-Apple model?

Yes, through the package’s ChatCompletionsLanguageModel, which communicates with any server speaking the chat completions REST API, with optional guided generation.² You can point it at a local MLX-LM Server on the Mac or a cloud endpoint, so the Foundation Models programming model drives models beyond Apple’s own.

How does this package relate to Apple’s other WWDC 2026 skills?

The package is the third skills delivery of the WWDC. Xcode 27 bundles SwiftUI skills you export with xcrun agent skills export (covered in the agent skills export post), and Game Porting Toolkit 4 ships porting skills as a Claude Code plugin (the GPTK 4 post). The utilities package differs by providing a Skill API as runtime Swift code you compose in your own app, built on Dynamic Profiles, so you can author and activate your own skills.²

The open-source step extends the same reach Apple built toward the device this year: Foundation Models and Private Cloud Compute covers the on-device, Private Cloud Compute, and third-party model paths the framework already spans. The skills strategy runs through the whole WWDC, from the Xcode toolchain in Xcode 27 Ships Agent Skills You Can Export Anywhere to the local-model pairing in Running Agentic AI on the Mac with MLX, where the MLX-LM Server gives ChatCompletionsLanguageModel a chat-completions endpoint to call. The full series hub is the Apple Ecosystem Series.

References