A week ago I was writing about Microsoft welding a model to its harness — MAI-Code-1-Flash, trained directly against the GitHub Copilot harness it ships inside, with the forward worry that the model layer and the tooling layer were collapsing into one procurement decision. You could no longer swap the model without swapping the harness it was raised in.

At WWDC 2026 yesterday, Apple announced something that points the opposite direction, and it is genuinely worth getting excited about for a moment before we get sober about it. The new version of the Foundation Models framework introduces a public Swift protocol — LanguageModel — that does to the model what Codable did to serialisation: it makes the thing behind the interface interchangeable.

Here is the move, in the words of the reporting: a team prototypes against Apple's on-device model, then "route[s] complex queries to Google's Gemini or Anthropic's Claude — or swap[s] between them — by updating a Swift Package Manager dependency." Session logic untouched. App code untouched. You change a line in your package manifest and the model underneath your application changes.

What this actually is

Strip the keynote gloss off and you have an adapter pattern raised to the level of a platform primitive.

In ordinary software this is the most boring, most valuable idea we have. You define an interface — "anything that can take a prompt and a session and give me back tokens" — and then anyone can implement it. Apple calls the interface the LanguageModel protocol. Anthropic ships a Swift package that conforms to it. Google ships conformance through the Firebase Apple SDK. Apple's own on-device model conforms to it too. Your code talks to the protocol; it never talks to a vendor.

The analogy I keep reaching for is the power outlet. For years, plugging a model into an app has been like wiring an appliance directly into the mains — the model and the application were soldered together, and changing the model meant rewiring. What Apple shipped is the socket. The appliance and the wall are now separated by a standard plug. You can pull Claude out and push Gemini in, and the wall doesn't care.

And there's a sensible escalation ladder behind the socket. Three tiers: on-device for the cheap stuff (no network call leaves the phone), Private Cloud Compute for the middle, and full third-party cloud for the heaviest queries. Apple sweetened the floor of that ladder considerably — free access to Foundation Models on Private Cloud Compute for any developer under two million first-time App Store downloads. For a small shop building an AI feature, "the infrastructure is free until you're genuinely large" is not nothing. It removes the most common reason small teams reach for a single cloud vendor on day one and then can't leave.

If you've read this workshop for a while, you know I've been circling model commoditisation from a dozen angles — the premium tier no longer selling model quality, commodity-priced frontier-adjacent inference, on-device models escaping cloud pricing entirely. The LanguageModel protocol is what commoditisation looks like when it finally reaches the application layer. When the model behind your app is a swappable dependency, you are no longer buying a model. You are buying inference, and you can shop. That is the thing I have wanted for the better part of a year.

Now the sober part

Here is the catch, and it is the same catch that has shown up in nearly every tooling-capture story I've tracked this spring. The thing that makes the model interchangeable is itself not interchangeable.

The LanguageModel protocol is a swap-out for models. It is not a swap-out for Apple. Your session logic, your escalation ladder, your prompt plumbing — all of that now lives against an interface that exists on iOS 27, macOS 27, iPadOS 27, watchOS 27, and visionOS 27, and nowhere else. The abstraction is beautiful and it belongs to one company. You have gained the freedom to change models and, in the same motion, deepened your commitment to the platform that defines what a model is allowed to look like.

This is the exact shape of the Microsoft Execution Containers finding from Build: a genuinely good architectural primitive — containment, or in this case provider-abstraction — shipped as a first-party platform feature, where the load-bearing property of the independent version (it works across vendors) gets quietly collapsed into the platform. Third-party model-abstraction layers — LiteLLM, the OpenAI-compatible-endpoint convention, your own thin wrapper — were portable precisely because they belonged to no one. Apple's version is better engineered and only runs in Apple's house.

There's a second, subtler thing. The escalation ladder routes "complex queries" up to the cloud tiers automatically. That routing decision — what counts as complex enough to leave the device, and which provider catches it at the top — is a policy living inside the framework. Apple's privacy framing is strong (Federighi: user requests "are never stored, never accessible to anyone"), and I take it seriously. But routing is authorization-adjacent: the framework decides when your user's prompt leaves the phone and where it goes. That is a decision the application used to own and now shares with the platform. No security hole here. What happened is a control surface quietly changed hands, and control surfaces changing hands are exactly the thing this workshop exists to notice.

What to actually do with this

If you build for Apple platforms, this is a real upgrade and you should use it — with one discipline. Treat the LanguageModel protocol as a spec you could re-implement, not a place you live. Concretely:

  • Keep your provider-selection logic yours. The framework lets you swap the dependency; make sure the decision about which provider to use sits in your code, not buried in a profile you can't read. If Apple's open-sourcing of the framework "later this summer" lands, read the routing defaults before you trust them.
  • Don't let "free until two million downloads" become an architecture. Free Private Cloud Compute is a wonderful on-ramp and a quiet lock-in. Know what your inference costs and call path become at download 2,000,001, before you're there.
  • Keep one model relationship that doesn't run through the socket. If your entire model access is mediated by one vendor's protocol, you don't have a swap-out — you have a single point with good ergonomics. The whole value of an adapter is the option to leave through it.

The irony I can't stop turning over: the dream of model portability arrived, and it arrived as a property of a platform rather than a property of the ecosystem. We got the socket. We just don't own the wall.

So the question for anyone wiring this in: when the model finally became the easy thing to change, what became the hard thing — and did you choose it, or did the framework choose it for you?