I Think Apple Just Won AI: Here’s Why

So I watched Apple’s WWDC26 developer video, and I came away with a strong sense that Apple might be about to win this whole AI game. Put simply, this may be the most important AI video of the year for anyone trying to build actual agentic software.

The reason is simple. Apple showed a full stack for AI apps. Siri can find and operate your app. Your app can generate and reason. Custom models can run on device. Xcode agents can help build the whole thing.

And most importantly: 

• Developers with fewer than 2M first-time App Store downloads can use Apple Foundation Models running in Private Cloud Compute with no cloud API cost.
• As an added bonus, the Foundation Models framework will be open source later this summer, so the same Swift APIs can run in apps and on servers.

I think the Platforms State of the Union is the video to watch because it shows the build path. You can even hand this article to your coding agent and start turning a normal app into an Apple Intelligence app today.

First up, the TL;DR

Before we get into our take, let's talk about the key takeaways.

On June 8, Apple delivered the WWDC26 Platforms State of the Union, a major annual developer announcement covering Apple Intelligence advancements, platform refinements, and significant productivity tools.

The Most Impactful Highlights:

• Apple open-sourced the Foundation Models framework and introduced Dynamic Profiles for flexible, adaptive on-device + server AI features with free frontier access for smaller developers.
• New Core AI framework delivers best-in-class on-device runtime for custom models (PyTorch to optimized) scaling from iPhone vision models to Mac LLMs with zero cloud costs.
• Xcode 27 deeply integrates agentic coding with ACP support, project-aware agents, simulator interaction, crash fixing, localization, and plugin ecosystem for end-to-end development.
• iOS apps now resize dynamically on iPad/Mac mirroring; Liquid Glass, SwiftUI, and Swift received major polish plus powerful new capabilities for adaptive, expressive, high-performance interfaces.

Now let's dive into the details a bit deeper.

Apple Intelligence & Foundation Models Framework

• Apple collaborated with Google to create the latest Apple Foundation models leveraging technologies behind the Gemini family to power Apple Intelligence experiences and give developers better on-device and Private Cloud Compute support. [2:27]
• The Foundation Models framework expanded this year to include image input for multimodal prompts (text + images) and support for server models, allowing a single API to handle any model from on-device to frontier cloud models. [3:03]
• Developers with fewer than 2 million first-time App Store downloads can now use Apple Foundation Models running on Private Cloud Compute with no cloud API cost, delivering frontier-level intelligence with strong privacy protections (data not stored or accessible to Apple). [3:20]
• The Vision framework is now integrated into the Foundation Models framework, giving the model on-device purpose-built tools such as OCR for precise text extraction and barcode readers. [7:00]
• The framework was extended so developers can easily call server models (Claude, Gemini, and more) that support tool calling and guided generation; any model provider can create a Swift package conforming to the Language Model protocol. [7:25]
• A new open-source Swift package was introduced with pre-built tools for skills, utilities, and context management, plus new declarative Dynamic Profiles APIs that enable truly adaptive AI experiences, orchestration of skills/sub-agents, swapping tools/instructions/models on the fly, and continuous transcript sharing across profiles. [8:29]
• Dynamic Profiles let developers define multiple profiles (e.g., brainstorming helper with high-temperature creativity, deep-reasoning tutorial generator, on-device jargon explainer) inside one LanguageModelSession; the body recomputes on every turn so the session stays current with app state. [9:31]
• New developer tools include the Evaluations framework for testing prompts and validating intelligence features, an upgraded Foundation Models instrument for visualizing/debugging model behavior, a new FM command-line tool, Python SDK, tool calling with images, and a private RAG tool powered by Core Spotlight. [12:00]
• The Foundation Models framework will be open sourced later this summer so the same Swift APIs used in apps can also run on servers for complete end-to-end AI workflows. [12:41]
• Core AI, a brand-new framework built into the platform, is the best way to bring and run custom models on-device with a modern memory-safe Swift API, fine-grained interest management, model specialization, custom GPU kernels, and Python-based tools to convert/optimize PyTorch models. [13:15]
• Core AI includes ahead-of-time compilation, dedicated instruments, a powerful visual debugger that traces tensor values back to original Python source, and scales from compact real-time vision models on iPhone to multi-billion-parameter LLMs on Mac with zero server dependencies and zero token costs. [13:48]

App Intents, Siri & System-Wide Intelligence

• The App Intents framework now lets developers integrate apps with Apple Intelligence through entity schemas (for content/concepts and Spotlight semantic indexing with attribution back to the app) and intent schemas (for actions), making features available via Siri, Shortcuts, widgets, and Action button. [14:53]
• Schemas are system-defined and will automatically benefit from future Siri language understanding improvements, new languages, and regional dialects without code changes. [16:17]
• The new View Annotations API lets developers associate views with entities so users can reference and take action on on-screen content conversationally (e.g., “this photo” or “the second message”) without memorized commands. [16:35]

Design System & Liquid Glass Refinements

• Liquid Glass was refined with better diffusion of complex content behind it, a darkened edge for more depth and separation, brighter specular highlights, and a new settings slider letting users personalize from ultra clear to fully tinted; existing apps get these improvements automatically without recompiling. [22:33]
• macOS 27 now supports the “show borders” environment value (matching iOS); sidebars expand to edges with clearer structure and accent-colored icons; every window has a tighter corner radius for consistency. [23:25]
• When content scrolls under floating bars, a uniform toolbar appears across the top (automatic for standard toolbars, customizable via existing scroll edge effect APIs). [24:18]
• Icons and menus gained an API to intentionally show icons for key actions; icon rendering was updated to be sharper with optional refraction; Icon Composer now supports designing icons from multiple Liquid Glass layers with new annotation features and an interactive preview of how the icon will look on earlier releases. [24:36]
• iOS apps rebuilt with the latest SDK are automatically opted into resizability; they can now be resized when running as iPhone apps on iPad or via iPhone Mirroring on Mac, with new resizable simulator and Previews support plus a coding-agent skill to find/fix common issues. [25:45]

SwiftUI Updates

• SwiftUI added reorderable containers: add .reorderable() to ForEach and .reorderContainer() to the parent for drag-to-reorder in grids, stacks, or any container with automatic lift and drop animations. [29:12]
• Swipe actions now work inside any container (not just lists) by adding .swipeActions() to the row and .swipeActionsContainer() to the scrollable container. [30:03]
• Text selection on iOS gained the same full-fidelity selection as TextField/TextEditor; on macOS it now supports custom text renderers, text vibrancy, and vertical text. [30:22]
• Performance improved via unified architectures across SwiftUI/AppKit/UIKit (shared on-the-line improvements), short-circuiting unnecessary measurements in nested stack layouts (up to 2× faster resizing), lazy initialization of state objects (converted to macro), and automatic HTTP caching in AsyncImage. [30:50]
• Toolbars gained finer control: visibilityPriority modifier to keep important items visible longer as space shrinks, a new overflow menu container for less prominent actions, and topBarPinnedTrailing placement that anchors items to the trailing edge regardless of reflow; prominent tab role pins tabs to the trailing edge. [32:19]
• A new document infrastructure for document-based apps provides first-class URL access for fully customizable partial read/write, observable configuration for attributes, and deep integration with modern Swift (observation, concurrency, etc.). [33:32]
• The Spatial Preview framework gives Mac apps new ways to extend in space around Vision Pro users; adopting it lets a 3D model become spatial when streamed, enabling real-time preview, edit, and share. [34:26]

Swift Language

• Swift 6.4 lets developers suppress warnings in specific parts of code and promote warnings to errors where strict enforcement is wanted; availability attributes can use the simple anyAppleOS shorthand; the limitation on async calls inside defer blocks is removed. [38:48]
• Compiler diagnostics were improved for complex operator expressions, closures, and deeply nested SwiftUI view bodies; many cases that previously hit the “unable to type check this expression in reasonable time” fallback now compile successfully or give more actionable errors. [39:38]
• macOS Tahoe was the final release supporting Intel Macs; the transition to Apple silicon is complete, enabling developers to ship Apple silicon-only binaries on the Mac App Store (smaller downloads, focused testing). [40:32]
• Support for opting out of the new Liquid Glass design is removed; once an app is recompiled with Xcode 27 it automatically uses the new design. [41:09]

Xcode 27 & Developer Productivity / Agentic Coding

• Xcode 27 is 30% smaller and Apple silicon-only, with agents, documentation, and other components downloading in the background; settings are now automatically saved to iCloud with easy import (including Git config) on a new Mac. [44:04]
• New project creation is instant (select app → boom, in the editor) with no file name, bundle ID, or setup required upfront. [44:40]
• The UI is highly customizable: toolbar items can be rearranged, activity view is tucked into the document title, themes now flow color throughout the entire app (not just editor) with gorgeous new options (Emerald, Neon Noir, Coral Reef) that support both light/dark and per-project themes. [45:10]
• Xcode Cloud setup is one-click (grant repo access); builds are up to twice as fast and now support Apple Vision Pro and Metal apps on Apple silicon. [46:32]
• Previews now let you pass any enum/property and instantly see a grid of all state variations. [47:02]
• The new Device Hub replaces the old Simulator with a rebuilt high-fidelity experience: supports physical devices from the same window, dynamic resizing of iOS apps, system setting changes (dark mode, text size), pinch-to-zoom, two-finger scrolling, and direct interaction with connected hardware. [47:44]
• Xcode added support for the Agent Client Protocol (ACP) so any compatible agent can be brought in; built-in integrations exist for Anthropic, OpenAI, and Google agents (ACP + Gemini shipping in an Xcode 26 update). [42:31]
• Agents are woven into every layer with tools for understanding the project, searching documentation, building, testing, rendering previews with variants, interacting with the simulator (tap/swipe/type), localizing apps, pulling top crashes from Organizer, reproducing issues, and applying fixes. [49:08]
• The /plan command lets agents first explore the codebase, ask clarifying questions, generate a reviewable plan with diagrams in markdown, then implement while showing every change; agents can validate with tests, playgrounds, and Previews across light/dark, orientations, sizes, and localizations. [51:22]
• Xcode ships with a rich corpus of built-in specialist skills (SwiftUI structure & data flow, accessibility, universal sizing, testing, performance) plus documentation and MCP tools; plugins (widely adopted by the community) can now contain skills (markdown), MCP tools, and full agents via ACP, installed via CLI, git URL paste, or one-click from partners like Figma and GitHub. [56:05]

Additional Tools & Ecosystem

• The MLX array framework was updated with Metal 4 and GPU Neural Accelerator support and can now scale training across multiple Macs using RDMA over Thunderbolt; it remains open source and faster than ever. [20:19]
• Reality Composer Pro 3 was completely rebuilt for crafting production-ready 3D experiences with RealityKit, adding character animation support, more realistic lighting, and live previews via Mac Virtual Display. [57:57]
• Game Porting Toolkit received a major update that dramatically cuts porting time by adding AI skills for coding agents plus new Metal command-line tools that give agents direct control during development and debugging. [58:19]
• More than 100 sessions are available on the Apple Developer app, website, YouTube, and (new this year) Bilibili, plus Group Labs, online panels, Q&A with engineers/designers, and in-person opportunities at Developer Centers (new fifth center opening in Berlin this fall). [59:25]

Now here's our take, and how to apply this to your ongoing agentic coding work, whether you're just getting started building code with agents or just dipping your toe into working with agents as a legit iOS engineer.

Apple’s real AI play is the operating system

At WWDC26, Apple said the latest Apple Foundation Models were created by working with Google and leveraging technology behind the Gemini model family. Apple then adapted those models to run on device and on Private Cloud Compute, Apple’s privacy-focused cloud system for more powerful AI requests (docs).

That alone would have been a big developer announcement. Apple went much further.

The company laid out a world where apps can plug into Apple Intelligence in three directions:

• Your app can expose its content and actions to Siri through App Intents (docs).
• Your app can generate, reason, classify, summarize, and use images through Foundation Models (docs).
• Your app can bring its own specialized model on device through Core AI (docs).

Then Apple showed Xcode agents planning features, writing code, testing the simulator, localizing strings, and fixing crashes (Xcode docs).

That is the big shift. Apple Intelligence is becoming an interface for apps, and Xcode is becoming the place where developers teach agents how to build those interfaces.

For nontechnical readers, here is the plain version. Apple is giving developers a way to make their apps legible to the iPhone, Mac, iPad, Siri, and Spotlight. The app can say what it knows, what it can do, and which kind of AI should handle each job.

The four pieces you need to understand

Before the build recipe, the vocabulary matters.

• App Intents are the actions your app makes available to the system. Think of them like labeled buttons Siri can press for the user. “Send this message,” “create this task,” “find this photo,” and “summarize this note” can all become intents.
• App Entities are the things inside your app. A note, message, contact, project, recipe, invoice, workout, or 3D model can be an entity. Siri needs entities because actions need nouns. “Send this photo” only works when the system understands what “this photo” refers to.
• Spotlight semantic index is Apple’s private search map for your app’s content. “Semantic” means it understands meaning, not only exact keywords. When your app contributes content to Spotlight, Apple Intelligence can find relevant items and point users back to your app.
• Foundation Models is Apple’s Swift framework for using language models in your app. Swift is Apple’s programming language. A framework is a ready-made developer toolkit. In normal human words: it is the interface your app uses to ask a model for help.

Those four ideas create the backbone:

• App Intents tell the system what your app can do.
• App Entities tell the system what your app contains.
• Spotlight helps the system find private app content.
• Foundation Models let your app use AI inside the product.

Once those pieces are in place, Apple Intelligence can surface your app across the system. It can understand a user’s request, find the right private context, call an action in the right app, and return the result.

Step 1: Decide the job your app should expose

Start with the user’s job, not the model.

In Apple’s Origami demo, the app has a real product task: combine a person’s paper materials, interests, and a dog photo into a custom origami project. The model analyzes images, translates Japanese text, brainstorms options, and then generates a tutorial.

That works because the AI feature is attached to a concrete app workflow.

Your first planning question should be:

What should the user be able to ask Apple Intelligence to do with my app?

Good answers look like this:

• “Find the meeting where Sarah mentioned the renewal date.”
• “Turn this note into three follow-up tasks.”
• “Send this photo to Kevin with a short message.”
• “Summarize this invoice and flag anything unusual.”
• “Create a training plan from my last month of workouts.”

Weak answers sound like “add AI.” That gives your agent nothing to build.

Give your coding agent this first:

You are helping me add Apple Intelligence support to my app.

First, inspect the app and identify 5 user jobs that would make sense for Siri, Spotlight, Shortcuts, or in-app AI.

For each job, define:
1. The user request in natural language.
2. The app content needed to answer it.
3. The app action needed to complete it.
4. Whether it belongs in App Intents, Foundation Models, Core AI, or a combination.
5. The smallest shippable version.

Do not write code yet. Give me the plan first.

That last line matters. Apple’s Xcode demo used /plan before implementation. The agent explored the project, asked clarifying questions, created a rendered markdown plan, and only then started writing code.

Step 2: Make your app understandable to Siri with App Intents

App Intents are how your app raises its hand and says, “Here are the things I can do.”

The important detail is schemas. A schema is a standard structure Apple already understands. If your app handles messages, tasks, photos, media, or other common categories, you map your app’s objects and actions to Apple’s schemas.

That matters because Siri can understand natural language without you manually writing every possible phrase.

In the Origami demo, Apple showed message, contact, and conversation entities. Siri could answer “Who’s coming to origami night?” because the app had made its messages legible to the system.

Then the developer added a send-message intent. Siri could follow up and send Richard a text about making one pizza vegetarian. The system found the context, understood the action, and asked for confirmation.

For a notes app, the equivalent might look like this:

• Entities: Note, Folder, Person, Meeting, Task.
• Intents: SearchNotes, SummarizeNote, CreateTask, SendFollowUp.
• Schemas: Use Apple’s system-defined structures where they fit.
• Safety: Ask for confirmation before sending, deleting, purchasing, or sharing.

Give your agent this:

Add App Intents support for the highest-value workflow in this app.

Use Apple’s App Intents documentation and prefer system schemas where available.

Define the relevant App Entities first. Then define the App Intent actions.

For every intent, include:
1. The natural language requests it should support.
2. The entity types it needs.
3. The user confirmation points.
4. The failure states.
5. Tests using the App Intents Testing framework.

Keep the first implementation narrow and easy to validate.

The key phrase is “entity types first.” Agents often jump straight to actions. Apple’s system needs nouns before verbs.

Step 3: Add your app’s content to Spotlight

Spotlight used to feel like a search box. In Apple’s AI stack, it becomes a private context layer.

When your app uses Core Spotlight to index content, it gives the system a way to find items inside your app. Apple’s developer updates point developers to two docs for this reason: Adding app content and making entities available.

For a normal user, this means Siri can answer a request using app content without the user digging through menus.

For a developer, this means every meaningful object needs metadata. Metadata is descriptive information about a thing. A meeting note might have a title, date, participants, transcript, project, related tasks, and permissions.

A strong agent brief looks like this:

Implement Spotlight indexing for the app’s most important entities.

For each entity, define metadata that helps Apple Intelligence and Spotlight retrieve it accurately.

Include:
1. A stable identifier.
2. A display title.
3. A short description.
4. Relevant dates.
5. Related people or projects.
6. Permission rules.
7. A deep link back to the correct screen in the app.

After implementation, add tests that confirm newly created, edited, and deleted items stay in sync with Spotlight.

That last point keeps the app from becoming stale. AI retrieval fails fast when the index drifts from reality.

Step 4: Let users refer to what is on screen

The View Annotations API may be one of the most underrated pieces in the whole presentation.

It lets your app connect visible interface elements to App Entities. That is how Siri can understand phrases like “this photo” or “the second message”.

With this layer, the user can point through language instead of naming the exact thing.

In Apple’s demo, the developer mapped message rows to message entities. Then Siri could send “this photo” to Kevin with a message. The user did not need to copy, paste, attach, or navigate.

For an app builder, this means your UI needs labels the system can understand.

Agent prompt:

Add View Annotations for the screens where users are most likely to ask Siri to act on visible content.

Map visible rows, cards, images, messages, tasks, and documents to their matching App Entity.

Support references like:
- this item
- this photo
- the second message
- the selected task
- that document

Add a short manual QA checklist for each screen.

This is where Apple’s strategy starts to feel different. The AI layer is tied to what the user is seeing, what the app contains, and what the app can do.

Step 5: Use Foundation Models for intelligence inside the app

Now we get to the model work.

The Foundation Models framework gives developers a standard Swift interface for model-powered features (docs). Apple’s updates page points developers to generating content, which is the place to start.

Three terms matter here:

Prompt: the instruction you send to the model.

LanguageModelSession: the ongoing conversation between your app and the model. A session can preserve context across turns.

Attachment: a way to send extra input, such as an image, alongside a prompt.

In the Origami demo, Apple used image input so the app could analyze paper materials and a dog photo. Apple’s docs now point developers to Analyzing images with multimodal prompting. “Multimodal” means the model can work with more than one type of input, such as text plus images. Apple also showed the model using OCR and barcode readers from the Vision framework.

A practical in-app AI feature usually follows this pattern:

• Gather the user’s current context.
• Retrieve relevant app content.
• Build a prompt with clear instructions.
• Add attachments when images matter.
• Ask the model for structured output.
• Show the user the result inside the app.
• Let the user edit, confirm, or reject it.

Agent prompt:

Build the first Foundation Models feature for this app.

Use a LanguageModelSession for the workflow.

The feature should:
1. Gather the minimum app context needed.
2. Build a clear Prompt.
3. Use structured output when possible.
4. Keep private or lightweight tasks on device when possible.
5. Ask for confirmation before taking external actions.
6. Include error handling for unavailable models, weak network, and low-confidence output.
7. Add an evaluation plan for response quality.

For nontechnical teams, the big lesson is simple: the app should decide what context the model sees. Good AI features are usually context design problems before they are prompt problems.

Step 6: Pick the right model for each task

Apple’s approach matters because developers can choose different model paths without rewriting the whole product.

• Use the on-device Apple model for fast, private, lightweight work. That might include rewriting text, explaining a term, classifying a small note, or generating a quick summary.
• Use Private Cloud Compute for harder requests that need more reasoning or a larger context window. A context window is the amount of information a model can consider at once. Apple says Private Cloud Compute gives developers larger context and stronger reasoning for more complex tasks.
• Use third-party server models when your workflow needs a frontier model from a provider like Claude or Gemini. Apple said model providers can conform to the LanguageModel protocol, which means they can bridge their models into the Foundation Models API (docs).
• Use Core AI when you have your own specialized model and want it to run on device. A medical app, music app, design app, or industrial tool might use a custom model because its task is too specialized for a general assistant.

This is the model-routing mindset:

• Small and private: on-device Foundation Models.
• Bigger and still privacy-focused: Private Cloud Compute.
• Highest capability or provider-specific tools: third-party server model.
• Specialized and local: Core AI.

Agent prompt:

Design a model-routing plan for this AI feature.

Compare four options:
1. Apple on-device model.
2. Apple Private Cloud Compute model.
3. Third-party server model through the LanguageModel protocol.
4. Custom on-device model through Core AI.

For each option, explain:
- expected quality
- latency
- privacy implications
- cost
- implementation complexity
- fallback behavior

Recommend the simplest route for version one.

This is the part where Apple may have made the strongest move. Developers can think in terms of tasks, then route each task to the right model.

Step 7: Use Dynamic Profiles for multi-step AI workflows

Dynamic Profiles were the sleeper announcement.

A Dynamic Profile is a declarative recipe for how a model session should behave at a given moment. “Declarative” means the developer describes the desired setup, and the framework resolves it.

In the Origami demo, Apple used different profiles for different jobs:

• A brainstorming profile with a creative cloud model.
• A tutorial-generation profile with deeper reasoning.
• A jargon-explainer profile using the smaller on-device model.

All three profiles shared the same continuous transcript. That means the app can switch models, tools, and instructions without losing context.

For regular readers, think of this as a way for the app to say: “For this part, be creative. For this part, reason carefully. For this small part, stay local and fast.”

For agent builders, this is the path to more reliable app-native agents. You can separate responsibilities without spawning a chaotic pile of prompts.

Agent prompt:

Refactor this AI workflow into Dynamic Profiles.

Create one profile per distinct job.

For each profile, define:
1. The model choice.
2. The instructions.
3. The available tools.
4. The input it expects.
5. The output it should return.
6. The app state that activates it.

Preserve a shared session transcript where that improves continuity.

This is the architecture I would pay attention to. Dynamic Profiles are Apple’s bridge from “AI feature” to “app agent.”

Step 8: Add retrieval when the app needs memory

Retrieval-augmented generation, usually called RAG, means the app retrieves relevant information first and then asks the model to answer using that information.

Apple’s updates mention a new RAG tool powered by Core Spotlight that is private to the app. That is important because many useful app questions require private context.

A project-management app might retrieve related tasks, comments, and due dates. A legal app might retrieve relevant clauses. A fitness app might retrieve recent workouts and injuries.

The workflow looks like this:

• User asks a question.
• App searches its private Spotlight index.
• App selects relevant records.
• Model receives the user request plus the retrieved context.
• Model answers with citations or references back to app items.

Agent prompt:

Add retrieval-augmented generation to this Foundation Models feature.

Use the app’s private indexed content as the retrieval source.

The response should:
1. Use only retrieved app context for factual claims.
2. Reference the source item for each important claim.
3. Ask a follow-up question when context is missing.
4. Avoid guessing when the retrieved context is weak.
5. Let the user open the source item from the answer.

This is how app AI becomes trustworthy. The model should be grounded in the user’s actual data rather than loose guesses.

Step 9: Use Core AI when your app needs its own model

Core AI is Apple’s new framework for bringing your own models into apps (docs).

The easiest way to understand it: Foundation Models is for talking to language models through Apple’s standard API. Core AI is for running your own model on Apple devices.

Apple says Core AI can run compact vision models on iPhone for real-time camera tasks. It can also run multi-billion-parameter language models on a Mac for complex local workflows, with zero server dependencies and zero token costs.

The developer path is roughly:

• Start with your own model, often from PyTorch.
• Convert and optimize it for Core AI.
• Specialize it for your app’s task.
• Compile it ahead of time or cache it on first use.
• Expose it through the same broader Apple model stack.

Apple’s docs break that into three pieces. Start with integrating models. Then read about specialization and caching, plus ahead-of-time compilation.

Agent prompt:

Assess whether this app needs Core AI.

Compare a general Foundation Models implementation against a custom Core AI model.

Recommend Core AI only if:
1. The task requires a specialized model.
2. On-device performance or privacy is essential.
3. A suitable model exists or can be trained.
4. The added maintenance burden is justified.

If Core AI is justified, outline the conversion, optimization, caching, and evaluation plan.

This is the counterweight to cloud-model sprawl. Some AI belongs inside the device.

Step 10: Test the AI like a product, not a demo

AI features fail differently from normal software.

A normal button either opens the settings screen or it does not. A model-generated tutorial can be mostly correct, subtly confusing, unsafe, too verbose, or perfect in 99 cases and wrong in the one case users remember.

That is why Apple introduced the Evaluations framework. Think of evaluations as tests for AI behavior. They help developers measure whether prompts, model choices, and generated outputs meet specific criteria (docs).

Apple’s docs cover the whole testing loop. Start with evaluating responses and designing evaluations. Then build datasets, define criteria, and expand coverage with synthetic data. Apple also showed agents using tests, playgrounds, and previews as part of the validation loop.

A good evaluation suite asks questions like:

• Did the model use the provided context?
• Did it follow the output format?
• Did it avoid making unsupported claims?
• Did it ask for confirmation before taking action?
• Did it handle missing context gracefully?
• Did it respond in the tone the product requires?

Agent prompt:

Create an evaluation suite for this Apple Intelligence feature.

Include:
1. A small hand-written dataset of realistic user requests.
2. A larger synthetic dataset for edge cases.
3. Specific pass and fail criteria.
4. Tests for missing context, ambiguous requests, and unsafe actions.
5. Regression tests so prompt changes do not quietly break the feature.
6. A reporting format the team can review after each run.

This is where teams will separate real products from impressive demos. The demo gets applause. The evaluation suite keeps support tickets from eating your week.

Step 11: Let Xcode agents do the boring parts

The Xcode section may be the most immediately useful part for builders.

Apple showed agents working inside Xcode to plan features, inspect a project, render previews, run tests, and interact with the simulator. The same agent flow can localize an app, inspect top crashes, reproduce a bug, make a fix, and validate the result.

A few terms matter here:

• MCP, or Model Context Protocol, lets agents connect to tools and sources. In Apple’s example, Xcode can connect to tools like Figma and GitHub.
• ACP, or Agent Client Protocol, lets developers bring a compatible coding agent into Xcode.
• Plugins package agent capabilities. Apple says plugins can include skills, MCP tools, and agents.
• Skills are markdown files that teach an agent how to perform a specific task. In other words, they are reusable instructions.

That stack means an agent can do more than edit code. It can use Xcode’s built-in skills, documentation, and MCP tools, plus previews, simulator controls, and external tools.

The workflow Apple demoed is worth copying:

In this Xcode project, I want to add Apple Intelligence support for [specific workflow].

Use /plan first.

Before writing code:
1. Inspect the project structure.
2. Identify the relevant screens, models, and data stores.
3. Propose the App Entities and App Intents.
4. Propose the Foundation Models feature.
5. Propose the evaluation suite.
6. Ask clarifying questions.
7. Show the implementation plan in markdown.

After I approve the plan, implement in small steps.

After implementation:
1. Build the app.
2. Run relevant tests.
3. Check previews in light mode, dark mode, large text, and resized layouts.
4. Use Device Hub or simulator interaction to test the workflow.
5. Summarize what changed and what still needs review.

That is probably the most practical takeaway from the whole video. Developers should ask agents for a plan, a set of system integrations, a test path, and a validation report before they ask for a pile of code.

A concrete build recipe: turn a notes app into an Apple Intelligence app

Imagine you have a meeting-notes app.

The old version stores notes, tags speakers, and lets users search manually. The Apple Intelligence version should let users ask:

“What did Maya ask me to follow up on from last week’s sales meeting?”

Here is the build sequence.

1. Define entities. Create App Entities for Note, Meeting, Person, ActionItem, and Project. Each entity needs a stable identifier, display name, relevant dates, and a deep link back into the app.
2. Define intents. Create App Intents for SearchMeetings, SummarizeMeeting, ExtractActionItems, CreateReminder, and SendFollowUp.
3. Index content. Add notes, transcripts, action items, and project metadata to Spotlight. Keep the index updated when the user edits or deletes content.
4. Annotate views. Map visible notes, tasks, and people in the UI to their entities with View Annotations. Let the user say “this note,” “that person,” or “the second task.”
5. Add Foundation Models. Use a LanguageModelSession to summarize meetings, extract action items, and draft follow-up messages.
6. Route models. Use the on-device model for short summaries. Use Private Cloud Compute for long meetings. Use a third-party server model if the team needs provider-specific quality or tools.
7. Add retrieval. Add RAG so the app retrieves relevant meeting notes and action items before asking the model to answer.
8. Add confirmations. Ask before creating reminders, sending messages, or sharing notes.
9. Add evaluations. Use the Evaluations framework to test the system with real meeting examples, ambiguous requests, missing context, and edge cases.
10. Use Xcode agents. Have the agent build the intents, previews and tests, localization, and crash fixes in small, reviewable steps.

That is Apple’s WWDC26 story in miniature. The app becomes searchable, understandable, actionable, generative, and testable.

The strongest counter-case

The strongest counter-case is simple: Apple still has to prove the experience works in the wild.

Developers have to adopt the APIs. Users have to trust Siri again. Third-party model providers have to ship strong integrations. Private Cloud Compute access has to be generous enough for real products. The on-device models have to be good enough for everyday tasks.

OpenAI, Anthropic, Google, and others can still move faster in pure model capability. Web-first agents can still become the default place people ask for help. Enterprise developers may still prefer cross-platform stacks over Apple-specific frameworks.

So the claim “Apple won AI” needs the right frame. Apple may have won the developer distribution layer for its own ecosystem. That is narrower than “best model.” It may also be more valuable for app builders.

The reason is that most people do not experience AI as a benchmark. They experience it when a tool helps them finish a task.

Apple’s WWDC26 stack is built around that moment.

Important dates and migration notes to track

A few timing details are worth pulling out before the adoption watchlist:

• Available now: ACP support and Gemini integration are shipping in an Xcode 26 update. If your team already uses Xcode, this is the first thing to test.
• Later this summer: the Foundation Models framework goes open source, which means the same Swift APIs can run in your app and on your server.
• Later this month: Apple says its Swift rewrite of the QUIC transport layer will be open sourced through SwiftNIO integration. This is more infrastructure than app AI, but it shows how far Swift is moving down the stack.
• With Xcode 27: Apple silicon-only Xcode becomes the default, developers can ship Apple silicon-only Mac App Store binaries, and apps recompiled with Xcode 27 automatically use Liquid Glass.
• Starting in iOS 27: UIKit apps built with the latest SDK must use the scene-based life cycle or they fail to launch. That one came from Apple’s documentation page, not the video, but it is worth flagging for builders.
• Fall 2026: Apple plans to open its fifth Developer Center in Berlin.

What to watch next

The next year comes down to adoption.

Watch how quickly major apps add App Intents schemas. Watch whether model providers ship clean LanguageModel packages. Watch whether Xcode agents become the default way Apple developers migrate to new APIs. Watch whether Siri can handle real app workflows. And watch whether we see a burst of activity amongst small apps.

Apple said developers with fewer than 2M first-time App Store downloads will be able to use Apple Foundation Models running in Private Cloud Compute with no cloud API cost. If that works well, indie developers get access to frontier-level intelligence without building cloud infrastructure first.

That could matter more than another chatbot leaderboard.

Apple’s bet is that intelligence belongs inside the operating system, inside the app, inside the UI, and inside the developer tool. The open question is whether Apple can turn that architecture into user trust before web-first AI assistants become the default operating system for work.

WWDC26: Platforms State of the Union | All Key Moments, With Timecodes Hyperlinked

Check out the key moments from the 60-minute Apple Developer walkthrough of Apple Intelligence, Foundation Models, Core AI, Liquid Glass, Swift / SwiftUI, and Xcode 27 agentic coding below.

• (00:00:19) Apple frames the Platforms State of the Union as the developer-focused deep dive into the technologies, frameworks, and tools used to build apps and games.
• (00:00:53) Apple says developer feedback shaped two major 2026 themes: the new Liquid Glass design and Apple Intelligence.
• (00:01:43) The talk is organized around three areas: Apple Intelligence, platform improvements, and developer productivity.
• (00:02:27) Apple says it worked with Google and used technologies behind the Gemini family to create the latest Apple Foundation models.
• (00:02:44) Apple adapted those models to run both on-device and on Private Cloud Compute.
• (00:02:56) The Foundation Models framework is expanding to include image input and support for server models.
• (00:03:03) For complex tasks, Apple says the API can integrate with the cloud model provider of a developer’s choice.
• (00:03:20) Developers with fewer than 2M first-time App Store downloads will be able to use Apple Foundation Models running in Private Cloud Compute with no cloud API cost.
• (00:03:43) Apple positions the Foundation Models framework as a single API that can support “any model you need.”
• (00:04:02) App Intents lets Apple Intelligence surface apps across the system, helping users discover and return to them.
• (00:04:11) Apple describes three system pieces behind this: the Spotlight semantic index, the app toolbox, and the system orchestrator.
• (00:04:51) The Foundation Models framework is described as a native Swift API that gives developers access to the same on-device model powering Apple Intelligence.
• (00:04:59) Apple says developers have already used Foundation Models for shopping, education, and sports apps, all running on-device with no infrastructure costs or privacy trade-offs.
• (00:05:37) Apple demos an Origami sample app that tailors projects to a person’s interests and materials with step-by-step feedback.
• (00:06:15) The Origami app uses Foundation Models to analyze inspiration pictures, understand available materials, identify a dog theme, translate Japanese text, and brainstorm project options.
• (00:06:40) Foundation Models now supports multimodal prompts with text and images.
• (00:07:00) The Vision framework is integrated so models can use on-device tools like OCR for text extraction and barcode readers for scanning.
• (00:07:20) Apple acknowledges on-device models are useful for many tasks, but larger server models may be needed for complex workflows.
• (00:07:25) The framework can call server models like Claude, Gemini, and others for capabilities such as tool calling and guided generation.
• (00:07:35) Any model provider can create a Swift package conforming to Apple’s Language Model protocol, letting developers choose the model they want.
• (00:07:44) Apple says it is opening access for developers getting started with AI to use Apple Foundation Models on Private Cloud Compute with no cloud API cost.
• (00:08:04) Users will get daily access to cloud-model-powered features, with expanded access for iCloud+ subscribers.
• (00:08:16) Apple calls Foundation Models “the best way to run any large language model in your app.”
• (00:08:29) Apple is introducing an open source Swift package with pre-built tools for concepts like skills and context-management utilities.
• (00:09:00) Dynamic Profiles are introduced as declarative APIs for building adaptive AI experiences with less code.
• (00:09:17) Dynamic Profiles let developers orchestrate skills and sub-agents, swap tools in and out, and update instructions on the fly.
• (00:09:31) Apple shows a LanguageModelSession using Dynamic Profiles instead of a fixed model, fixed tools, and fixed instructions.
• (00:10:00) The demo uses Private Cloud Compute with temperature turned up for creative brainstorming.
• (00:10:28) A second profile uses Private Cloud Compute with reasoning level set to deep for tutorial generation, which Apple calls the hardest task in the app.
• (00:10:44) A smaller jargon-explanation task runs on the on-device SystemLanguageModel to save server calls.
• (00:10:57) Dynamic Profiles can swap models while sharing the same continuous transcript, giving developers more context with less prompting.
• (00:11:12) Instructions and tools can also be swapped in and out based on app state.
• (00:11:23) The Dynamic Profile body recomputes on every model turn so the session stays up to date.
• (00:11:34) Apple explicitly says the three Origami Profiles look like three AI agents because Dynamic Profiles are built as adaptable blocks for agents, skills, or other abstractions.
• (00:12:00) The new Evaluations framework lets developers test prompts and validate that intelligence-powered features work reliably.
• (00:12:10) The upgraded Foundation Models instrument helps developers visualize and debug model behavior inside apps.
• (00:12:17) Apple adds an FM command-line tool so developers can prompt the model from the terminal.
• (00:12:23) Additional Foundation Models updates include a Python SDK, tool calling with images, and a new private RAG tool powered by Core Spotlight.
• (00:12:41) Apple says the Foundation Models framework will be open source later this summer, allowing the same Swift APIs to run on servers.
• (00:13:15) Core AI is introduced as a new framework for bringing and running models on-device in apps.
• (00:13:28) Core AI offers a memory-safe Swift API, fine-grained tuning, model specialization, and custom GPU kernels.
• (00:13:41) Apple includes Python-based tools to convert and optimize PyTorch models for the Core AI runtime.
• (00:13:48) Core AI is backed by ahead-of-time compilation, dedicated instruments, and a visual debugger that traces tensor values back to the original Python source.
• (00:14:07) Apple says Core AI can run compact vision models in iPhone apps for real-time camera queries.
• (00:14:12) Apple says Core AI can also deploy a multi-billion-parameter LLM in a Mac app for an agentic assistant handling complex workflows.
• (00:14:22) Apple emphasizes that Core AI runs on-device with zero server dependencies and zero token costs.
• (00:14:38) Apple Intelligence can be integrated through the App Intents framework, which tells Apple platforms what apps can do.
• (00:15:00) App Intents can expose app content and capabilities through the Action button, Shortcuts, widgets, and Siri AI.
• (00:15:10) App Intents schemas are recognizable structures Siri understands, built on years of language-model training.
• (00:15:30) Entity schemas let apps contribute content to the Spotlight semantic index so users can find information from the app with attribution back to it.
• (00:15:49) Siri’s understanding of intent schemas means users can make requests naturally, without memorizing specific phrases.
• (00:16:17) Because schemas are system-defined, Apple says they can improve as Siri’s language understanding, language support, and dialect support evolve.
• (00:16:27) The new View Annotations API lets users reference and act on content currently visible in an app.
• (00:17:16) In the Origami demo, Siri answers “who’s coming to origami night?” by drawing on messages from inside the Origami app.
• (00:17:49) The demo makes content actionable by conforming an intent to the sendMessage schema.
• (00:18:18) View Annotations let users say things like “the second message” or “this photo,” and Siri can pass those entities into app intents.
• (00:19:06) Apple describes the end goal as apps becoming part of the “intelligent fabric of the system” through natural language, semantic search, and daily workflows.
• (00:19:39) Apple summarizes three developer paths: Siri integration through App Intents, AI features through Foundation Models, and custom on-device models through Core AI.
• (00:20:10) MLX is positioned for enthusiasts experimenting with, training, researching, fine-tuning, or serving generative models locally.
• (00:20:26) MLX now supports Metal 4, GPU Neural Accelerators, and training across multiple Macs with RDMA over Thunderbolt.
• (00:21:16) Apple says apps rebuilt with the new SDK will launch faster and feel more responsive.
• (00:22:26) Liquid Glass gets foundation updates, design refinements for consistency, and new ways for iOS apps to adapt across devices and screen sizes.
• (00:22:43) Apple tuned Liquid Glass to diffuse complex content more effectively for readability.
• (00:23:09) Apps already using Liquid Glass get many improvements automatically on this year’s releases without recompiling.
• (00:23:37) Sidebars expand to the edges on Mac and iPad, with icons regaining color through the app’s accent color.
• (00:24:36) Apple adds an API to show icons for key app actions in menus and updates icon rendering for Liquid Glass.
• (00:24:59) Icon Composer can now design icons with multiple layers of Liquid Glass, plus annotation features and previews for earlier releases.
• (00:25:45) Apple is adding support to resize iOS apps in iPhone Mirroring and on iPad.
• (00:25:55) Rebuilding with the latest SDK automatically opts an app into resizability.
• (00:26:08) Apps already using SwiftUI, Auto Layout, or size-class changes are described as well-positioned for full resizability.
• (00:26:23) The new resizable iOS simulator and Previews let developers test multiple screen sizes directly in Xcode.
• (00:26:34) Apple is providing a skill for coding agents to help find and fix common resizability issues.
• (00:27:41) Apple cites The Goat, a game-development environment built on the open source Godot engine, as an example of an app built with SwiftUI to feel native across Apple platforms.
• (00:28:01) Apple says apps that used cross-platform or web technologies, including Notion, are migrating UI to SwiftUI for performance and UI consistency.
• (00:28:17) Apple claims agentic coding tools make porting code to Swift easier than before.
• (00:29:12) SwiftUI adds reorderable containers, making drag-to-reorder as simple as adding .reorderable() and .reorderContainer().
• (00:30:03) SwiftUI swipe actions now work inside any container, not only standard list-style views.
• (00:30:22) Text selection improves on iOS and gains support on macOS for custom text renderers, text vibrancy, and vertical text.
• (00:31:02) SwiftUI, AppKit, and UIKit now share a common foundation across many controls.
• (00:31:22) Nested stack layouts in SwiftUI now resize up to twice as fast by short-circuiting unneeded computations.
• (00:31:41) SwiftUI state objects are now initialized lazily only when first loaded.
• (00:32:04) AsyncImage now automatically caches content using standard HTTP caching so images download once and refresh only when needed.
• (00:32:30) SwiftUI adds finer toolbar control for dynamic screen sizes, including visibility priority, overflow menus, and pinned trailing placement.
• (00:33:32) SwiftUI adds new document infrastructure with direct file URL access and customizable reading and writing to disk.
• (00:33:53) Developers can now read only the parts of a file they need and write only the pieces that changed.
• (00:34:22) The Spatial Preview framework lets Mac apps extend 3D models into space around Apple Vision Pro users.
• (00:35:50) Apple argues Swift’s key advantage is breadth: low-level systems, server programming, apps, frameworks, Linux, Windows, Android, and the web.
• (00:36:17) Apple gives three cross-platform Swift examples: Flighty using Swift in services, GoodNotes reusing 100K+ lines through WebAssembly, and Frameo sharing Swift libraries with Java.
• (00:36:46) Swift interoperability lets developers bring Swift into existing C, C++, and Java systems without a rewrite.
• (00:37:14) Apple says WebKit is incrementally replacing core C++ components with Swift versions using safe C++ interoperability.
• (00:37:29) Apple rewrote the QUIC transport layer in Swift and plans to open source it through SwiftNIO integration.
• (00:37:52) The TrueType font rendering engine replaced decades of hand-optimized C with Swift code that Apple says is both memory safe and faster.
• (00:38:10) Apple says parts of the core operating system kernel are now being written in Swift.
• (00:38:48) Swift 6.4 lets developers suppress warnings in specific code areas and promote warnings to errors where stricter enforcement is needed.
• (00:39:14) Swift 6.4 adds anyAppleOS to simplify availability attributes across Apple platforms.
• (00:39:21) Swift removes the limitation on async calls inside defer blocks, so awaiting inside defer now works.
• (00:39:38) Apple says the frustrating “unable to type check this expression in reasonable time” fallback error is improved, with many cases now compiling or producing more actionable errors.
• (00:40:32) Apple reiterates that macOS Tahoe was the final release to support Intel Macs, completing the transition to Apple silicon.
• (00:40:53) Developers can now ship Apple silicon-only binaries on the Mac App Store, reducing download size and focusing testing on one architecture.
• (00:41:09) Apple says support for opting into the old design will be removed; once apps recompile with Xcode 27, they automatically use Liquid Glass.
• (00:42:03) Earlier this year, Apple brought coding agents to Xcode with tools for previews, documentation search, and more through Model Context Protocol.
• (00:42:15) Xcode can connect through MCP to tools developers already use, including Figma and GitHub.
• (00:42:24) Xcode includes built-in integrations for agents from Anthropic, OpenAI, and now Google.
• (00:42:31) Xcode adds Agent Client Protocol support so developers can bring any compatible agent into Xcode.
• (00:42:38) ACP support and Gemini integration are shipping in an Xcode 26 update available today, with more coming in Xcode 27.
• (00:43:49) Xcode improves project loading, top crashes and spins, debugging reliability, expression evaluation, and logging performance.
• (00:44:04) Xcode 27 is 30% smaller, Apple silicon-only, and downloads agents, documentation, and other components in the background.
• (00:44:16) Xcode settings are now saved automatically to iCloud, including Git config when setting up a new Mac.
• (00:44:40) Xcode 27 lets developers create a new app project directly in the editor without upfront file name, bundle ID, or setup steps.
• (00:45:10) Xcode 27 adds customizable toolbars, with navigation, canvas, editor split, and assistant controls available at the top.
• (00:45:42) Xcode themes now apply color across the whole app, not only the editor, and can differ by project.
• (00:46:32) Xcode Cloud setup can start inside Xcode without App Store Connect setup, and Xcode Cloud builds are up to twice as fast.
• (00:47:02) Previews can now show variations for any property, demonstrated with an enum that renders all UI states in a grid.
• (00:47:54) Device Hub replaces Simulator and combines simulator-style convenience with management of real hardware.
• (00:48:11) Device Hub lets developers test system settings like dark mode and larger font size.
• (00:48:27) Device Hub allows dynamic simulator resizing so developers can test how iOS apps handle different sizes.
• (00:48:37) Device Hub can manage and interact with physical devices from the same window.
• (00:49:23) Xcode 27 takes “the next big step” in agentic coding by integrating models and agents directly into Xcode.
• (00:49:40) Xcode agents get tools to understand projects, search documentation, build, and test.
• (00:49:46) Xcode 27 adds agent tools for rendering previews with variants, interacting with the simulator, localizing apps, debugging, and more.
• (00:49:59) Apple says agent answers in Xcode are grounded in Swift, SwiftUI, and Apple frameworks.
• (00:51:14) Apple says the best agentic-coding results come from collaborating on implementation and design before code is written.
• (00:51:22) The demo uses /plan and asks the agent for a diagram before starting implementation.
• (00:51:31) The agent explores the project, understands architecture and patterns, and asks clarifying questions before creating the plan.
• (00:51:56) The agent’s plan appears beside the conversation in rendered markdown, and the developer can refine it before execution.
• (00:52:21) Xcode shows code and preview changes while the agent implements the plan.
• (00:53:10) Xcode agents can validate logic by running tests, try ideas in playgrounds, and check visual changes in Previews.
• (00:53:42) Agents can interact with an app in the simulator by tapping, swiping, and typing.
• (00:53:56) After simulator testing, the agent returns a test summary and screenshots.
• (00:54:24) Xcode agents can localize an app by adding a language to the strings catalog and translating strings across the project.
• (00:54:37) Apple says Xcode localization looks at each string in context, including surrounding code, UI, and action, rather than doing word-for-word translation.
• (00:55:03) Xcode Organizer gives agents access to anonymized, aggregated real-world insights like crashes, hangs, and performance metrics.
• (00:55:23) In the demo, Xcode pulls up top crashes from the latest release and ranks them by frequency.
• (00:55:33) The agent reads a symbolicated crash log, locates the issue in the project, reproduces the crash, makes the fix, and validates it.
• (00:56:05) Xcode 27 ships with a corpus of Apple-built skills, documentation, and MCP tools.
• (00:56:14) Apple compares those built-in resources to specialists, such as SwiftUI, accessibility, universal sizing, testing, and performance specialists.
• (00:56:37) Xcode integrates these capabilities through plugins, a format Apple says is widely used by agents and the community.
• (00:56:45) Plugins can contain skills, which Apple defines as markdown files that teach agents new tasks.
• (00:56:56) Plugins can also contain MCP tools, and now can bring an agent through Agent Client Protocol.
• (00:57:09) Plugins can be installed from the command line or by pasting a git URL into Xcode, with partners like Figma and GitHub offering one-click setup.
• (00:57:22) Apple’s example end-to-end workflow: implement a Figma design in SwiftUI, refine variants, make it resizable using a skill, and post a PR to GitHub.
• (00:57:57) Reality Composer Pro 3 has been rebuilt for production-ready 3D experiences using RealityKit.
• (00:58:08) Reality Composer Pro 3 adds character animations, more realistic lighting, and live previews through Mac Virtual Display.
• (00:58:19) Game Porting Toolkit gets a major update that uses AI skills for coding agents to cut the time required to bring games to Apple platforms.
• (00:58:33) New Metal command-line tools give agents direct control during game development and debugging.
• (00:59:25) Apple says there are more than 100 WWDC sessions covering Apple Intelligence, Xcode 27, design, and other topics.
• (00:59:37) WWDC sessions are available on the Apple Developer app, website, YouTube, and, new this year, Bilibili.
• (01:00:20) Apple points to Developer Centers in Cupertino, Shanghai, Singapore, Bengaluru, and a fifth opening this fall in Berlin.

That's all folks! For more, check the Updates on Apple's documentation website.