WWDC 2026 just dropped the biggest AI developer story Apple has ever told. This isn’t the Apple that bolted “AI” onto existing features and called it a day. This is Apple shipping a full on-device inference framework, opening Xcode to third-party agents, deprecating SiriKit, and quietly confirming a billion-dollar deal with Google to train its own models.
If you build for Apple platforms — or if you’re watching the on-device AI space — here’s everything that matters.
Core AI: Apple’s On-Device LLM Framework
The headliner. Core AI is a brand new framework for running custom AI models directly on Apple silicon. Not Core ML with a new coat of paint — a purpose-built system for generative AI workloads.
What it gives you:
- Swift API for model inference on iPhone, iPad, Mac, and Vision Pro
- coreai-torch for converting PyTorch models to Core AI format
- coreai-optimization for quantization and model compression
- Core AI Debugger integrated into Xcode
- Zero-copy data paths between CPU and GPU
- Ahead-of-time compilation for predictable latency
- Metal 4 kernels optimized for transformer architectures
This is Apple’s answer to the question developers have been asking: how do I run LLMs on-device without paying API costs? If you’ve been running models on Apple silicon via Ollama or llama.cpp, Core AI gives you a first-party path with tighter hardware integration.
We wrote a deep dive: What is Apple Core AI.
Foundation Models Framework Updates
The Foundation Models framework (introduced last year) got a major upgrade. The pitch is simple: one Swift API to rule on-device models, Apple’s server models, and third-party providers.
What’s new
- Image input — multimodal support for on-device models
- Server models — route requests to Apple’s Private Cloud Compute when the task exceeds on-device capability
- Custom skills — define domain-specific capabilities your app provides to the model
- Dynamic Profiles — adjust model behavior at runtime without reloading
- Streaming responses — token-by-token output for chat-style interfaces
Language Model Protocol
This is the big architectural play. The Language Model Protocol is a Swift protocol that any AI provider can conform to. Claude, Gemini, or any third-party model can plug into the same API surface your app already uses for Apple’s on-device models.
Think of it as Apple’s version of MCP but at the model routing level — a single interface regardless of where inference happens.
Free Private Cloud Compute
Apple announced free Private Cloud Compute access for apps in the App Store Small Business Program (under 2 million downloads). That means indie developers and small teams can offload to Apple’s cloud models at zero cost.
This is a direct shot at API pricing from OpenAI, Anthropic, and Google. For apps that stay within Apple’s ecosystem, the cost drops to zero.
Xcode 27: AI Agents Built In
Xcode 27 is the most aggressive IDE update Apple has shipped in years. The highlights:
Built-in AI agents
Agents from Anthropic, Google, and OpenAI are integrated directly into Xcode. You don’t install extensions — they’re available out of the box. This puts Apple in the same space as Cursor, VS Code with Copilot, and every other AI-enhanced IDE, but with one key difference: Apple controls the integration layer.
MCP and Agent Client Protocol support
Xcode 27 supports the Model Context Protocol natively. You can connect MCP servers to your development workflow, giving agents access to your databases, documentation, APIs, and custom tools.
The new Agent Client Protocol (ACP) is Apple’s extension for coordinating multiple agents within a single session. Think of it as the orchestration layer that lets your Anthropic agent delegate file operations to a local agent while keeping context synchronized.
Device Hub
A centralized interface for deploying, testing, and debugging AI models across your connected devices. Push a model to your iPhone from Xcode, profile its performance, and iterate without leaving the IDE.
Additional changes
- GitHub and Figma plugins for design-to-code workflows
- On-device code completion — no network required
- Apple silicon only — Intel Macs are officially unsupported
- 30% smaller installation size
- Xcode Cloud 2x faster build times
For developers already choosing between AI coding agents, Xcode 27 means you might not need a separate tool at all — especially for Swift/SwiftUI projects.
Siri AI: The 1.2 Trillion Parameter Rewrite
Siri got rebuilt from the ground up. The new Siri runs on a 1.2 trillion parameter Mixture-of-Experts model (based on Gemini architecture from the Apple x Google partnership).
Key capabilities
- Personal context — Siri accesses your messages, emails, calendar, photos, and files to answer questions with personal knowledge
- On-screen awareness — understands what’s currently displayed and can act on it
- App actions — performs multi-step tasks across apps without pre-built shortcuts
- Conversational memory — maintains context across sessions
SiriKit deprecated, App Intents mandatory
This is the breaking change. SiriKit is officially deprecated. All Siri integration must use App Intents going forward. If your app uses SiriKit, you have until iOS 21 (fall 2027) before it stops working entirely.
App Intents is the only path to getting your app’s actions into the new Siri. The model decides when to invoke your intents based on user requests — you no longer define rigid voice command patterns.
Apple x Google: The $1 Billion Training Partnership
The most significant business announcement. Apple confirmed a roughly $1 billion per year partnership with Google. But this isn’t Apple deploying Gemini to users — it’s far more strategic than that.
What the deal actually is
- Google provides Gemini technology and architecture for Apple to train its own models
- Apple uses Nvidia Blackwell B200 GPUs on Google Cloud infrastructure
- Confidential computing — Google cannot see Apple’s training data or model weights
- Apple retains complete software control over Private Cloud Compute
Apple is essentially renting Google’s AI expertise and hardware while keeping full ownership of the resulting models. The AFM (Apple Foundation Model) family is trained on Google’s infrastructure but belongs entirely to Apple.
This explains why Siri’s new model uses a Mixture-of-Experts architecture similar to Gemini — Apple licensed the architectural approach, then trained on their own data.
AFM Model Family
Apple revealed the full AFM lineup:
| Model | Parameters | Deployment | Use Case |
|---|---|---|---|
| AFM Core | ~3B | On-device | Basic inference, autocomplete, summarization |
| AFM Core Advanced | 20B sparse (1-4B active) | On-device | Complex reasoning with MoE efficiency |
| AFM Cloud | Undisclosed | Private Cloud Compute | Extended capabilities |
| AFM Cloud Pro | Undisclosed | Private Cloud Compute | Professional workloads |
| AFM Cloud Image | Undisclosed | Private Cloud Compute | Image generation |
The AFM Core Advanced model is particularly clever. It’s a 20B sparse model that only activates 1-4B parameters per inference, meaning it runs efficiently on devices with limited memory while maintaining the quality of a much larger model. This is the same MoE approach used by models like DeepSeek.
Pricing Impact for Developers
Here’s how WWDC 2026 changes the cost equation:
Free tier (App Store Small Business Program, <2M downloads):
- On-device inference: free (always was)
- Private Cloud Compute: free (new)
- Foundation Models API: free for both on-device and server
Paid tier (larger apps):
- On-device: free
- Private Cloud Compute: pricing TBA (expected fall 2026)
Compare this to running equivalent workloads through external APIs:
- OpenAI GPT-5.5: $2.50/$10 per million tokens
- Anthropic Claude Opus: $15/$75 per million tokens
- Google Gemini 3.5 Flash: $0.15/$0.60 per million tokens
For Apple-ecosystem apps, the math is clear. On-device inference costs nothing. Cloud fallback costs nothing for small developers. Even paid tiers will likely undercut third-party APIs since Apple is subsidizing the infrastructure.
What This Means for Non-Apple Developers
Even if you don’t build for Apple platforms, WWDC 2026 signals important trends:
- On-device inference is mainstream — Apple shipping a full framework validates what local AI enthusiasts have been building toward
- MCP is winning — Xcode adopting MCP means the protocol has critical mass across Apple, Anthropic, and the open-source ecosystem
- The agent IDE is here — every major IDE now ships with integrated AI agents
- MoE is the architecture — Apple, Google, and DeepSeek all converging on sparse models that activate subsets of parameters
FAQ
When can developers access Core AI?
Core AI ships with Xcode 27 beta (available now for Apple Developer Program members). The SDK targets iOS 20, macOS 17, iPadOS 20, and visionOS 4. Production release is expected fall 2026.
Does Core AI replace Core ML?
No. Core ML remains for traditional ML tasks (classification, object detection, smaller models). Core AI is specifically for generative AI — LLMs, diffusion models, and large transformer architectures. We wrote a full comparison: Core AI vs Core ML.
Can I run my own fine-tuned models with Core AI?
Yes. The coreai-torch tool converts PyTorch models to Core AI format, and coreai-optimization handles quantization. You can bring any compatible model architecture and deploy it on-device.
Is Private Cloud Compute really free for small developers?
Free for apps in the App Store Small Business Program (under 2 million downloads per year). Apple hasn’t disclosed rate limits, but the goal is enabling indie developers to ship AI features without API costs.
Do I need to rewrite my SiriKit integration immediately?
Not immediately. SiriKit is deprecated but functional through iOS 20. Apple has set iOS 21 (fall 2027) as the hard cutoff. Start migrating to App Intents now — the API surface is cleaner and gives you access to Siri’s new capabilities.
Does Xcode 27 work on Intel Macs?
No. Xcode 27 requires Apple silicon. This applies to both the IDE itself and the on-device code completion features. If you’re still on Intel, Xcode 16 remains available but won’t receive new AI features.