Apple just gave away the quiet part of its AI plan

The locked-down company is teaching everyone how to run AI locally.

Apple, the company famous for closing the box, just opened a very strange door.

Here is something strange.

The company that controls the chip, the operating system, the store, the APIs, the privacy story, the developer rules, and the user experience has now published an open source toolkit for turning its devices into local AI machines.

Not a white paper.

Not a keynote promise.

A GitHub repo.

And the quietest detail is not the code. It is not even the model recipes. The quietest detail is that Apple shipped agent skills for Claude Code, Codex, and Gemini CLI.

Their competitors’ tools.

Think about that for a second.

Apple has spent decades building walls. Beautiful walls. Expensive walls. Walls with rounded corners and very good typography. Then, in the middle of the AI race, it releases a toolkit that says, in effect, bring your agent, bring your workflow, bring your terminal, bring your model experiments, and run them toward Apple hardware.

That is not how people expect Apple to behave.

Which is why it matters.

The repo is called coreai-models. It arrived around Apple’s wider WWDC 2026 announcement, where the company laid out its next wave of Apple Intelligence, Siri, and AI features. Apple also published its research write-up on the third-generation Apple Foundation Models, the model family sitting behind the company’s push into local intelligence.

The obvious headline is simple. Apple is doing more AI.

Fine. Everyone is doing more AI.

The better headline is weirder. Apple is building the paths, tools, formats, and habits that could make local AI feel normal.

That is the bigger story.

For the last two years, most AI talk has pointed upward. To clouds. To giant clusters. To data centers that drink power by the megawatt. To subscription interfaces sitting on someone else’s servers.

Apple is pointing downward.

Into the phone.

Into the laptop.

Into the chip already sitting in your bag.

And Apple has a number that makes this whole thing feel different: 2 billion active devices.

Two billion is an absurd number. It is hard to make it feel real. So try this.

If one percent of that base becomes useful for local AI work, that is 20 million machines. If ten percent becomes active over time, that is 200 million. If developers start treating Apple silicon as the default local inference target, the center of gravity shifts from “which cloud model do I call?” to “what can I run right here?”

Right here is Apple’s favorite phrase, even when it does not say it out loud.

The toolkit has four main pieces, and each one tells you something about the plan.

First, a model catalog with export recipes.

That sounds dry. It is not. Export recipes are how model work becomes repeatable. They give developers a path from an existing model to something Apple devices can load and run. The key artifact is the .aimodel format, which is Apple’s export target for these workflows.

Second, Python primitives.

This matters because model people live in Python. If Apple wants researchers, tinkerers, and AI engineers to touch its stack without groaning, it has to meet them where they already are. Python is that place.

Third, a Swift runtime.

This is Apple speaking to its own developer base. Swift is how app developers bring the exported models into Apple apps. Python gets you into the workshop. Swift gets you into the product.

Fourth, agent skills.

That is the odd one.

The repo includes skills named working-with-coreai, model-authoring, and model-compression-exploration. They are designed for agentic coding tools, including Claude Code, Codex, and Gemini CLI. A source tweet called attention to this detail because it is so easy to miss and so revealing once you see it.

Apple did not just publish instructions for humans.

It published instructions for coding agents.

That is a different kind of developer experience. In the old version, a developer reads docs, copies code, fixes errors, and builds a mental map. In the new version, the agent reads the docs, writes the first pass, converts the model, probes the runtime, and explains why the device build failed.

This is a small shift with a long tail.

Because Apple is not only courting developers. It is courting the tools developers will use.

That includes tools made by Anthropic, OpenAI, and Google.

This is the part I keep coming back to. Apple could have made the agent support private. It could have waited. It could have only supported Xcode. It could have acted like the terminal did not exist.

Instead, it put competitor-adjacent workflow files in the repo at launch.

That is Apple being practical in public.

The old Apple developer story was centered on a cathedral. Download Xcode. Learn the frameworks. Follow the blessed path. Submit to the store. Obey the rules. The new AI developer story is messier. People are in VS Code. They are in Cursor. They are in terminal agents. They are asking Claude to debug Swift package issues and asking Codex to rewrite conversion scripts.

Apple sees that.

More than that, Apple is feeding it.

There are catches, of course. There are always catches.

The toolkit targets iOS and macOS 27.0 or later, and requires Xcode 27.0 or later. That puts it firmly in the next generation of Apple platforms. If you are hoping to run all of this across old devices tomorrow morning, slow down. The door is open, but the room is still under construction.

The repo also launched under a BSD 3-Clause license. That is permissive, friendly to commercial use, and very Apple in a quiet way. You can build with it. You can study it. You can adapt parts of it within the terms.

But Apple is not accepting pull requests at launch.

That detail matters too.

Open source, yes. Community-governed, no. Apple is sharing the map while keeping hold of the steering wheel. The code is public, but the direction still comes from Cupertino.

That tension is classic Apple.

The technical breakdown from AIBit frames the release around export recipes, Python tooling, Swift runtime support, and on-device AI deployment. That is the practical layer. It is what developers need to know if they want to try the thing.

But beneath the practical layer is a market argument.

Apple is saying local AI should be a first-class target.

That phrase gets tossed around too easily, so make it concrete. A first-class target has docs. It has formats. It has working examples. It has conversion flows. It has runtime support. It has agent guidance. It has a reason for developers to test on the device instead of assuming the cloud is the only serious place to run intelligence.

Apple is trying to make that path less weird.

And it has a strong reason to do so.

Cloud AI is powerful, but it is also expensive, slow in the wrong moments, and awkward around private data. Every remote call has a cost. Every server round trip has a delay. Every piece of user context sent away from the device creates a trust question.

Apple has been waiting for that trust question.

Privacy is the one AI angle where Apple does not have to pretend. The company has spent years training users to believe that their phone is a private machine, not just a screen attached to a server. Local AI fits that story perfectly.

The third-generation Foundation Models are built for exactly this. They run on device. They respect the secure enclave. They do not phone home.

coreai-models is the key that lets anyone build for that world.

Two billion devices.

Over the next few years, most of them will be capable of running local models.

And Apple just gave away the toolkit.