App Intents Are the MCP of the iPhone: How to Make Your App Usable by AI Agents
October 21, 2026 · 5 min read
If you build AI agents, you already know the pattern. An agent is only as useful as the tools it can call. That's why so much of the agent world has rallied around the Model Context Protocol: it gives models a standard way to discover tools, understand what they do, and use them.
Apple just did the same thing for the iPhone.
At WWDC 2026, Apple deprecated SiriKit and made App Intents the only way Siri can call into a third-party iOS app. With iOS 27, Siri became an orchestrator. It can take actions from many apps' App Intents across the system, while the apps themselves never drive each other directly.
In other words, Siri is now an agent. And every iPhone app is either one of its tools or invisible to it.
For anyone building in the agent space, this is worth understanding. Here's how Apple's agent layer maps to concepts you already know, and what it takes to make an app something Siri can actually use.
Apple's agent layer, translated for agent builders
Apple doesn't describe App Intents in MCP terms. But the parallels are close enough to be a useful mental model.
| Agent concept | MCP world | iPhone world |
|---|---|---|
| The agent | Claude, ChatGPT, or a custom agent | Siri AI |
| Tools the agent can call | MCP tools | App Intents (actions your app exposes) |
| Data the agent can reference | MCP resources | App Entities (your app's content, like messages, tasks, or orders) |
| Shared vocabulary | Tool schemas and descriptions | App Schemas, grouped into domains like messages |
| Context | What's in the conversation | What's on the user's screen, through view annotations |
| Orchestration | The agent chains tool calls | Siri chains intents across apps; apps can't call each other directly |
Apple's own WWDC session breaks Siri's new abilities into three: reaching your app's entities, acting through your intents, and understanding what's on screen.
The big difference from MCP is distribution. An MCP server reaches whoever installs it. An App Intent reaches every iPhone user who has your app, with Siri, Spotlight, Shortcuts, and widgets as the front door.
Why this matters: agents route around apps they can't use
The shift changes how users reach apps. Instead of opening an app and tapping through screens, a user tells Siri what they want, and Siri assembles the steps. Braze summed up the change in its WWDC recap: users can now act on third-party apps directly through Siri or Spotlight, without opening the app at all.
That creates a new kind of competition. When a user says "book my usual Saturday class" or "send the invoice to the client from yesterday," Siri can only complete the request with apps that expose those actions. An app without App Intents isn't broken. It's just not part of the conversation.
Agent builders have seen this movie before. On the web, services with clean APIs and MCP servers get picked up by agents first. Services without them get scraped, worked around, or ignored. The iPhone is now following the same path.
Two details make this more urgent than it sounds:
- It's not limited to the newest phones. On-device Apple Intelligence needs recent hardware, but App Intents also power Shortcuts, Spotlight, and widgets. Apps get value from them across a much wider range of iPhones.
- Agent-native products need a phone presence. Many agent startups live entirely in a browser or a chat window. If your agent manages calendars, tasks, files, or purchases, users will expect to trigger it from their phone. A native app with App Intents is how you get there.
What to expose first
The biggest mistake teams make is trying to turn every screen into an intent. Siri doesn't need your whole navigation tree. It needs the handful of things users actually want done.
Start with three questions:
- What would a user ask for without opening the app? "Log a workout." "Reorder my last purchase." "Add this to my project."
- What content would they want to find or reference? Orders, notes, contacts, bookings, messages. These become App Entities.
- What would they want to send to another app? A receipt to email, a photo to a poster app, a contact to a message.
Pick the top two or three actions and ship those first. A small set of reliable intents beats a long list of half-working ones.
Designing actions an agent can use reliably
Anyone who has written an MCP tool knows that a vague tool gets misused. The same lessons apply to App Intents.
| Principle | Why it matters | Example |
|---|---|---|
| One clear job per intent | The agent can match it to a request without guessing | "Create task" and "Complete task," not "Manage tasks" |
| Plain-language names and parameters | Siri matches natural speech to your descriptions | "Due date" instead of "dt_target" |
| Searchable entities | Users refer to things by name, not ID | Let Siri find "the Henderson project" from a text query |
| Adopt App Schemas where they exist | Shared vocabulary helps Siri understand your actions | Use the messages domain for a messaging app |
| Confirm before anything risky | Agents make mistakes, and users need control | Ask before sending money or deleting data |
| Fast, predictable results | Siri needs a clear answer to keep the flow going | Return the created item, not just "done" |
Apple's session also covers screen awareness. By tagging the content shown on screen, an app lets Siri understand requests like "send this to Sarah" while the user is looking at a specific item. For agent builders, think of it as giving the model context without making the user explain it.
Getting it built
App Intents are a native Apple framework, written in Swift and tied closely to how an app stores its data. That has a few practical consequences:
- The data model matters. Intents and entities sit on top of your app's real data, so a messy data layer makes for unreliable actions.
- Background work matters. Many apps were built to change data only while they're open. Siri-triggered actions often need to run without the full interface.
- Testing matters. Apple introduced dedicated tooling for testing App Intents this year. Agent-triggered actions need the same test discipline as any API.
For teams with an existing iOS app, this is usually an upgrade, not a rebuild. For agent startups that have never shipped on iPhone, it's a reason to start. Either way, it helps to work with an iOS development team that builds natively in Swift and SwiftUI, since App Intents, App Entities, and screen awareness all live closest to Apple's native frameworks.
The takeaway for agent builders
The agent era isn't only happening in browsers and chat windows. With iOS 27, Apple turned Siri into an orchestrator and gave every app on the iPhone a way to become one of its tools.
The rules will feel familiar to anyone who has built for agents: expose clear actions, describe them well, make your data findable, and keep risky steps under human control. The apps that do this early will be the ones agents reach for first.
Sources
- WWDC 2026: Build intelligent Siri experiences with App Schemas, Apple Developer
- WWDC 2026 App Intents and Apple Intelligence Q&A session, Apple Developer
- WWDC announcements bring App Intents, Safari Notify Me, and more to iOS 27, Braze
- iOS 27 App Intents Migration: The 95-Day Siri AI Developer Guide, eCorpIT