WWDC 2026 for Devs: The AI Stuff That Actually Matters (TLDR)

This was Tim Cook's last keynote as he passes the torch onto John Ternus. Under all the Siri and Liquid Glass theater at WWDC 2026, Apple shipped its most developer-friendly AI release ever: a multi-model agentic Xcode, a multimodal on-device LLM you can call for free, and a Core ML replacement that finally lets you bring your own model weights.

Public beta in July, final release in the fall. So if you write Swift and ship to the App Store, here's the TLDR, ranked by how much it'll change your week, not Apple's stock price.

1. Xcode 27 is now a multi-model agentic IDE (Claude, GPT, and Gemini built in)

The main event. Xcode 27 is finally more than autocomplete. It runs full coding agents from Anthropic, Google, and OpenAI, built into the IDE, and you pick the model. The agent can plan across multiple turns, write and run your tests, use Playgrounds, inspect SwiftUI previews for visual changes, and drive the Simulator through a new Device Hub.

It's also extensible. Plug-ins let you add custom skills, connect external tools over Model Context Protocol (MCP), and link to any agent that speaks the Agent Client Protocol (ACP). GitHub and Figma are the first two integrations with one-click install links.

Under the hood it runs a dual engine. A small, fast model on the Neural Engine handles local predictive autocomplete tuned to your Swift project and the Apple SDKs, while the heavier agent work routes to your chosen cloud model.

The takeaway: You now have a lot less reason to live in Cursor or Claude Code and tolerate Xcode for the Apple-only bits. Same agents are now native to the toolchain, know your project structure, your previews, and your simulator.

2. Foundation Models framework: multimodal, custom skills, free on-device inference

Last year's Foundation Models framework gave Swift devs a 3-line API to the on-device model behind Apple Intelligence: structured outputs, streaming, tool calling, session management. The catch was that it was text-only.

That catch is gone. The framework now takes image input alongside text, supports custom skills, and can run larger models server-side when you need more horsepower. The Swift API itself barely changed, so existing apps mostly inherit the upgrade for free.

And the inference is free. No API key, no billing, no rate limits, no telemetry. Data stays on device by default. For a huge class of features (summarize this, classify that, extract fields, draft a reply) you no longer pay per token or ship user data anywhere.

The takeaway: "add an LLM feature" used to mean "add an OpenAI line item and a privacy review." On Apple platforms, for on-device-sized tasks, it now means "import FoundationModels."

3. Core AI replaces Core ML and lets you ship your own weights

Core ML is roughly nine years old, and was renamed with Core AI. This is more than marketing. The big unlock is a standardized API to plug third-party model weights in alongside Apple's own models, running locally on Apple Silicon and taking advantage of the Neural Engine.

The design philosophy also shifts from loading frozen, pre-trained models toward generative inference: native streaming token generation, multi-turn conversation, persistent session memory. Core ML still works, but Apple points new projects to Core AI.

The takeaway: if you've been wrestling a custom fine-tune onto a phone, this is the framework you wanted. Bring your weights, get on-device performance and privacy without rolling your own runtime.

4. App Intents is now the only road to Siri (and SiriKit is on the clock)

This one's a chore, not a treat, but you can't skip it. App Intents is now the mandatory way Siri talks to your app, and SiriKit is formally deprecated with a roughly 2 to 3 year migration window before SiriKit voice features stop working.

The good news is that App Intents is the better system. It's pure Swift (no more XML intent-definition files and a separate extension process), the compiler bakes a compact metadata representation into your app bundle at build time, and this year it adds streaming responses and multi-turn conversational follow-ups so Siri can hold a real dialogue inside your app's context. You conform your intents and entities to assistant schemas to tap personal context, and the same definitions surface across Siri, Spotlight, Shortcuts, and controls. You can even declare, per intent, whether an interaction may go to the cloud or must stay on-device, important in healthcare and enterprise. Launch partners include Uber, Amazon, YouTube, WhatsApp, and AllTrails.

The takeaway: the new Siri is genuinely capable, but it only reaches your app through App Intents. Start the migration now; the window sounds long until you're staring down a deprecation deadline.

---

---

5. System-wide MCP

MCP moves from an Xcode feature to an OS-level one. Siri and Core AI's routing layer can invoke registered MCP servers (users or MDM register them explicitly), which means your agent tooling can reach system context and actions, not just your editor. Xcode already shipped around 20 built-in MCP tools for file ops, build, test, and diagnostics, and Claude Code and Codex already connect through the Xcode MCP server today.

The takeaway: the same protocol you're already using for agents now plugs into the OS. The plumbing is consistent from your IDE to Siri.

6. Gemini-powered Siri 2.0, in dev preview today (with a waitlist)

The consumer headline, but devs should care because it's the surface your App Intents feed into. The rebuilt Siri does multi-step actions, reads on-screen context, analyzes files (PDFs, photos, docs), and does multi-turn conversation with web search. It's built on a licensed Google Gemini model (multiple outlets peg it at a ~1.2-trillion-parameter mixture-of-experts running on Google Cloud, with simpler requests still handled on-device and cloud queries routed through Private Cloud Compute).

There's also a standalone Siri chatbot app, and the OS lets users pick the underlying model (Gemini default, Claude, or ChatGPT). It's in the developer preview starting today, but gated: open Settings, go to Siri, and join the waitlist. It won't ship in the EU or China at launch.

The takeaway: the assistant your users will actually talk to is finally good, and your app gets into those conversations through the App Intents work in #4.

7. Swift 6.3 and a few things worth knowing

Swift 6.3 itself ships no AI language features (the AI tie is that Foundation Models is Swift-first), but a couple of items are genuinely useful: the first production Swift SDK for Android with Kotlin/Java interop, a new @c attribute to expose Swift to C, module selectors (ModuleA::getValue()) to disambiguate names, and performance attributes like @specialize and @inline(always). Swift Testing adds try Test.cancel() and image attachments. Concurrency keeps softening Swift 6's sharp edges.

8. Foundation Models ships a CLI (and a local API server)

Run fm on the macOS beta and you get a command-line tool that talks to the same on-device model from your terminal. It's the quickest way to feel out the model's responses and dial in your prompts, token budgets, and JSON schemas before you write a line of Swift:

fm respond 'What is Swift?'              # one-shot prompt
fm chat                                  # interactive session
fm serve                                 # start a Chat Completions API server
fm token-count 'Hello world'             # count tokens
fm schema object --name Person --int age # generate a JSON schema
fm available                             # check model availability

Two models are exposed: system (the on-device default) and pcc (the larger model on Private Cloud Compute), so you can flag up to the cloud with --model pcc when you need the horsepower. The standout is fm serve: it stands up an OpenAI-compatible Chat Completions endpoint on your own machine, backed by the local model. Point any existing OpenAI client at localhost and you have a private LLM server with no key and no bill.

The sleeper feature is fm schema, and structured output more broadly. The on-device model returns typed JSON with no network call, which means reliable structured extraction that runs fully offline. That's a big deal for any app that can't assume connectivity: field tools, travel apps, privacy-sensitive flows. You get the "turn this messy text into clean fields" trick without a server in the loop.

The takeaway: the framework is the headline, but the CLI is what you'll open first. fm serve gives you a local, keyless OpenAI-compatible endpoint to prototype against, and fm schema turns offline structured extraction into a one-liner.

Bonus: the app-level AI you get mostly for free

These ride the same dev hooks (App Intents, Visual Intelligence, Foundation Models) and ship across iOS 27, iPadOS 27, macOS 27, and visionOS 27:

• Shortcuts: describe an automation in plain language and it builds the shortcut.
• Safari: describe an extension and it generates one; plus "Notify Me" page monitoring and automatic tab grouping.
• Photos: Spatial Reframing repositions your subject after capture and generatively fills the edges; Extend changes aspect ratio without losing content.
• Calendar: create events from natural language or from an image (snap a flyer, get the events).

Recap

The keynote was bloated and the "why 15 minutes" crowd has a point about the consumer half. But the developer half is the strongest AI story Apple has told yet: free multimodal on-device inference, your own weights running locally, agentic Xcode with the three frontier models built in, and one consistent protocol (MCP) from your editor to the OS. The Gemini deal is the spicy headline, but the frameworks are the substance.

If you ship to Apple platforms, your move this week is: grab the developer beta, run your existing app against the bigger Foundation Models model, and spend an afternoon in agentic Xcode. Then put the App Intents migration on the roadmap before the SiriKit clock runs out.

View tool: Codex

Promoted

Sponsored

Codex

A lightweight, open-source coding agent from OpenAI that runs locally in your terminal, enabling AI-powered software engineering tasks from the command line.

View tool