Briefing
At WWDC 2026, Apple did not merely announce new features. It laid out a comprehensive, vertically integrated vision for artificial intelligence that spans from the silicon itself all the way to the developer tools that build the experiences. Delivered from the iconic Steve Jobs Theater, the "Apple Intelligence & Xcode Uncovered" special presentation was a nearly 90-minute masterclass in what Apple calls its "AI platform" - a tightly woven stack of hardware, software, frameworks, and tools designed to make intelligence a native part of the Apple ecosystem rather than an bolted-on afterthought.
The message was unmistakable: while the rest of the industry forces developers to stitch together disparate components from different vendors, Apple wants you to simply *build*. Whether you are a curious newcomer exploring what AI can do for your app, a model developer pushing Apple silicon to its limits, or somewhere in between, Apple claims there is now a place for you - and a tool for every job.
Let us unpack everything that was revealed.
Xcode 27: Agentic Coding Arrives
The headline-grabber was undoubtedly Xcode 27 and its new "agentic coding" workflow. Apple positioned this not as a chatbot bolted onto an IDE, but as a collaborative partner that understands the totality of your project - a co-creator that thinks in Swift and speaks Apple's frameworks fluently.
Ken and Jerome demonstrated the workflow: developers describe what they want in conversational panels, the agent formulates a plan, asks clarifying questions, and only proceeds once aligned with the developer's intent. In the demo, Jerome handed Xcode a sketch of a WWDC badge collector app alongside a folder of badge images, and watched the agent plan and build a complete SwiftUI application from a single prompt.
What makes this more than a party trick is the depth of integration. Xcode 27 operates across the entire codebase - invoking the compiler, running tests, rendering live previews, interacting with simulators, and handling localisation. The agent can spin off sub-agents to work in parallel, as shown when Jerome started two simultaneous conversations, one adding a holographic 3D drag effect and another building a corkboard display wall.
Under the hood, Xcode leverages multiple underlying models through partnerships with Anthropic, OpenAI, and Google. Through the Agent Client Protocol (ACP), developers can bring their own agents - including ones running entirely locally. When a prompt is entered, Xcode enriches it with embedded context about project configuration, file structure, build settings, editor state, and recent files, making deictic commands like "fix this" actually work.
Security leverages new macOS 27 capabilities: kernel-level file access management ensures agent sub-processes can only touch explicitly authorised files, with prompts for sensitive operations. A new documentation system optimised for LLMs, built on vector embeddings, gives agents deep contextual awareness of Apple's APIs.
Xcode 27 also introduces an extensible plugin architecture using the MCP (Model Context Protocol) tool specification. Plugins can bundle Markdown skills, connect to external resources, and bring in third-party agents. Installing one is as simple as pasting a GitHub URL. Official partners including Figma and GitHub have already shipped plugins.
App Intents: Your App Becomes Part of the System
Michael Gorbach, who leads the App Intents team at Apple, demonstrated how the framework now serves as the bridge between third-party applications and Siri's dramatically upgraded capabilities. This year's Siri is more powerful, contextually aware, and personalised than ever before - and it achieves this by understanding your app's content and operations through App Intents.
The framework provides a structured way to model what your app does and what data it contains. Through three core concepts - Entities, Intents, and App Schemas - developers can expose their app's capabilities to the system. Entities represent your app's data types (alarms, timers, photos, events), while Intents represent the actions users can perform. App Schemas provide standardised definitions for common concepts across domains like timers, alarms, and photos, so Siri understands what your data *means* regardless of which app it comes from.
A particularly powerful addition is the semantic index - a system-level data store that enables Siri to search based on meaning rather than mere keyword matching. When you mark your entities as IndexedEntity and call indexAppEntities, they become discoverable through this semantic layer. This means a timer created in your app can appear alongside timers from Apple's Clock app in Siri's search results - your app's content becomes a first-class citizen of the system.
Entity annotation APIs let you mark your UI views with the data entities they display. This enables Siri to understand what is currently on screen - so when a user says "cancel the fourth one" while looking at a list, Siri knows exactly which item they mean. The API extends beyond visible UI to system features like notifications, media sessions, and AlarmKit, meaning Siri can act on your app's data even when the app is not foregrounded.
The Interaction Donation API allows your app to teach Siri how users actually interact with it. By donating intents that mirror in-app actions, you help Siri learn user preferences and improve its ability to route requests to the right app. If someone always uses your app for timers, Siri will gradually learn to prefer it over alternatives.
Schema conformance also brings automatic benefits: Spotlight search keys are configured automatically, and privacy and security features like confirmation prompts and locked-device handling are managed by Siri on your behalf. As Siri's language understanding evolves, your app benefits without any additional work.
Foundation Models Framework: AI at the API Level
Luis unveiled the Foundation Models framework, giving developers direct access to Apple's system LLMs through a unified, native Swift API. The framework's philosophy is straightforward: your app sends a prompt, the model reasons, and generates a response. But the capabilities extend far beyond basic text generation.
Five major upgrades were announced. First, image input support enables multimodal prompts with both text and images. Combined with the @Generable macro, apps can extract structured data directly from images - tasks that previously required custom ML models.
Second, Private Cloud Compute (PCC) expands reasoning capabilities for eligible developers (App Store Small Business Program, under 2 million annual downloads). Switching from on-device to server models requires just one additional line of code - no API keys, no token costs. Users needing more can upgrade to iCloud+. PCC promises data is never stored, only used for the immediate request.
Third, a Language Model Protocol lets any provider ship a Swift package that plugs into the framework. Matt demonstrated swapping Apple's system model for a local Qwen model via Core AI in a single line. Google and Anthropic are shipping official packages for Gemini and Claude.
Fourth, agentic experience APIs including DynamicProfile provide Swift builder syntax for orchestrating multiple models with shared context. Fifth, the Evaluations framework (detailed below) enables systematic testing.
Most significantly, Apple announced the Foundation Models framework will be open-sourced this summer, making it a cross-platform Swift API for any LLM on Linux and server-side Swift. A new fm command-line tool in macOS 27 provides easy access to on-device and PCC models.
Core AI: Deploying Custom Models On-Device
For developers who need to run their own custom models entirely on-device - with zero external dependencies and no compromises on performance - Apple introduced Core AI. This is a ground-up framework for on-device model execution that Apple calls "the next evolution of on-device AI."
Core AI leverages the full Apple silicon stack - CPU, GPU, and Neural Engine - through a modern Swift API designed for memory safety without sacrificing speed. The framework covers the entire model deployment lifecycle: creation, optimisation, inference fine-tuning, app integration, and debugging.
A comprehensive Python toolkit integrates with PyTorch workflows: export your model, use Core AI's TorchConverter to generate a Core AI representation, and save it as a resource file. The toolkit offers extensive customisation from chip-specific optimisation to custom kernels.
The Swift API is approachable yet powerful - instantiate a model, select a function, and run it in three lines. Advanced use cases support cache management, shared cached models across app groups, device-specific tensor layouts, and pipelined async execution. A new Core AI Debugger app lets you visualise computation graphs, inspect tensors, and trace values back to Python source. Model pre-compilation generates optimised resources that load rapidly on device.
Core AI already powers Apple Intelligence and the new Siri, meaning developers now have access to the same inference framework driving Apple's most advanced AI features.
MLX: Open-Source Power for Research and Scale
For researchers and scale-seekers, Ronan presented MLX - Apple's open-source ML and numerical computing framework built for Apple silicon. MLX rests on four pillars: numerical computing, automatic differentiation, distributed computing, and machine learning.
The framework exploits Apple's unified memory architecture, uses Metal for GPU acceleration, and supports the latest silicon including the M5 chip's GPU neural network accelerator. It is available in Python, Swift, C, and C++. Running state-of-the-art LLMs locally requires just two lines of Python, and over 10,000 models on Hugging Face work out of the box with MLX LM. Popular tools including Ollama, LM Studio, and vLLM all run on MLX.
The distributed computing capabilities were demonstrated impressively. Using Thunderbolt 5 RDMA, multiple Macs form low-latency clusters. Angelos showed a MacBook Pro with an M5 Max processing *The Great Gatsby* at nearly 2,000 tokens per second - roughly 100,000 tokens in just over 30 seconds. With two Macs, throughput exceeded 3,000 tokens per second.
Then Yannic from LM Studio demonstrated a cluster of four Mac Studios via Thunderbolt 5 running Kimi K2.6 - a 1 trillion parameter frontier model - entirely locally. The model ingested *The Great Gatsby* and generated a customised HTML quiz, all without a byte leaving the local network. No token costs. No cloud dependency.
The entire MLX stack - from low-level kernels to high-level APIs - is fully open source on GitHub.
Evaluations: Making AI Development Reliable
Rob introduced the Evaluations framework, addressing perhaps the most painful aspect of LLM-powered development: unpredictability. Traditional code does exactly what you tell it; language models, as Rob amusingly demonstrated, might tag *Dracula* as "cute" and "family-friendly."
The framework provides a flexible system for quantifying and measuring model output quality. You define custom evaluation metrics and can use LLM-as-judge evaluators to automate scoring across large datasets. A new Swift Testing trait called @evaluates automatically configures evaluation suites that run within your unit tests, with a dedicated test report view in Xcode 27.
Metrics can range from simple pass/fail checks to scored float values, with aggregation across datasets enabling statistical assertions. The framework also supports synthetic test data generation - using LLMs to create test cases when you need more variety. Rob described an iterative "hill climbing" process of prompt engineering driven by evaluation feedback, which Apple calls Evaluation-Driven Development.
The Bigger Picture: A Platform, Not a Collection of Features
What distinguishes Apple's approach is the intentional vertical integration. The chip architecture that drives Core AI and MLX is the same foundation that enables on-device Foundation Models. The privacy architecture protecting on-device models and Private Cloud Compute is identical to the one safeguarding App Intents. The Swift APIs you use to add intelligence to your apps are the same ones Xcode's agent uses to help you build those apps.
As Rachel summarised in closing, this is not a collection of features thrown together - it is a coherent system designed from the ground up to make AI faster, safer, and more powerful at every layer. Whether you are a builder, an integrator, a product engineer, or an explorer, Apple wants you to have a seat at this table.
With over 100 technical sessions available through the Apple Developer app, website, YouTube, and Bilibili, plus live online labs staffed by Apple's engineers and designers, WWDC 2026 offers ample opportunity to dive deeper into every topic covered. A new AI-powered search on the developer site unifies documentation, sample code, sessions, and labs in one place.
The gauntlet has been thrown. The tools are here. The only question remaining is: where will you begin?
Helpful Resources
Official Links
- Video: Apple Intelligence & Xcode Uncovered: Special Presentation - The full WWDC 2026 session at the Steve Jobs Theater
- Apple Developer Channel: YouTube @AppleDeveloper (opens in a new tab)
- MLX Framework: mlxframework.org (opens in a new tab) - Official website for Apple's open-source ML framework
- MLX on GitHub: github.com/ml-explore/mlx (opens in a new tab) - Open-source machine learning framework for Apple silicon
- Apple Developer Website: developer.apple.com (opens in a new tab) - Documentation, sample code, sessions, and labs
Frameworks and Tools Mentioned
- Xcode 27 - Available through the Mac App Store and Apple Developer portal, featuring agentic coding workflows
- Foundation Models Framework - Native Swift API for on-device and Private Cloud Compute LLM access (open sourcing summer 2026)
- Core AI - New framework for deploying custom on-device models with optimised inference
- MLX (Machine Learning eXplore) - Open-source numerical computing and ML framework for Apple silicon
- MLX LM - Language model toolkit within MLX for running LLMs locally
- App Intents Framework - Connect your app's content and actions to Siri and Apple Intelligence
- App Intents Testing - New framework for testing App Intents integrations
- Evaluations Framework - Swift framework for systematic testing and evaluation of AI features
- Private Cloud Compute (PCC) - Apple's privacy-preserving cloud inference service
- `fm` Command-Line Tool - New macOS 27 CLI for accessing on-device and PCC models
Third-Party Integrations and Partners
- Anthropic - Claude models available through Foundation Models framework
- OpenAI - Agents integrated into Xcode 27 via ACP
- Google - Gemini models via official Swift package for Foundation Models framework
- Figma - Official plugin for Xcode 27
- GitHub - Official plugin for Xcode 27
- LM Studio - Local LLM GUI powered by MLX, with MLX Distributed support coming later this year
- Ollama - Local LLM tool running on MLX
- vLLM - High-throughput LLM inference engine with MLX support
- Hugging Face - Over 10,000 models compatible with MLX LM
Technical Concepts and Protocols
- Agent Client Protocol (ACP) - Protocol enabling any agent to integrate with Xcode 27
- Model Context Protocol (MCP) - Tool specification for Xcode plugins, originated by Anthropic
- Language Model Protocol - Swift protocol allowing any model to plug into Foundation Models framework
- Semantic Index - System-level data store powering Siri's meaning-based search
- Interaction Donation - API for teaching Siri about in-app user behaviour
- Evaluation-Driven Development - Apple's methodology for iterative AI feature improvement using the Evaluations framework
- Thunderbolt 5 RDMA - Technology enabling MLX distributed computing across Mac clusters
Community and Learning
- Apple Developer Forums - Staffed by Apple experts throughout WWDC week
- Apple Developer App - Browse 100+ technical sessions and labs
- Apple Developer Center - In-person labs and interactive experiences in Cupertino
- Swift Team Labs - Hands-on sessions with Swift engineers
- Bilibili - WWDC content available on Apple's new channel
