Apple Is Turning Every App Into an AI Tool — MCP Support Means Siri Was Just the Warm-Up

Remember when every pizza place had its own phone number and you had to know it by heart? Then Uber Eats showed up, and suddenly every delivery driver on the planet could find your favorite pepperoni spot, take your order, and bring it to your door. The pizza place didn’t change. The kitchen didn’t change. The menu didn’t change. What changed was that everyone could reach them now — not just the people who memorized the number.

That’s what Apple is about to do to your iOS app.

The Discovery That’s Hiding in Plain Sight

Last September, when Apple seeded iOS 26.1 beta 1 to developers, most people focused on the usual stuff — new Apple Intelligence language support, performance tweaks, the kinds of things that make good release notes and boring dinner conversation.

But a few developers with too much free time and a habit of spelunking through beta binaries found something far more interesting: native MCP support baked into the operating system.

MCP — Model Context Protocol — is the standard that Anthropic open-sourced in November 2024 to let AI models talk to external tools and services. Think of it as a universal plug that lets any AI agent connect to any app’s functionality. OpenAI adopted it. Google adopted it. And now Apple is building it directly into iOS, macOS, and iPadOS.

The detail that makes this genuinely wild? Apple is building MCP on top of App Intents.

That’s the framework you (hopefully) already use to talk to Siri.

Wait, What Does This Actually Mean?

Let’s slow down because this is one of those things that sounds incremental but is actually massive.

Right now, if you build App Intents into your iOS app, here’s what happens: Siri can find you. Shortcuts can trigger you. Spotlight can surface you. The Action Button can invoke you. Focus filters can use you. It’s already a great deal — you write one framework, and Apple gives you five distribution channels.

MCP turns that five into infinity.

With native MCP support, any AI agent running on the device — Claude, ChatGPT, Gemini, whatever ships next — can discover and invoke your App Intents. Not through some hacky URL scheme or clipboard workaround. Through a standardized protocol that the operating system mediates.

Your app’s actions become tools in every AI agent’s toolbox. Automatically.

If you’ve been procrastinating on App Intents adoption because Siri felt like a niche feature that nobody really uses — well. That calculation just changed rather dramatically.

The Pizza Delivery Analogy (But Make It Technical)

Here’s how this plays out in practice.

Say you build a workout tracker. You’ve got an App Intent called LogWorkout that takes a workout type and duration. Today, a user can say “Hey Siri, log a 30-minute run” and your intent fires.

With MCP, the user could be chatting with Claude on their Mac and say: “I just did a 30-minute run, log it in my workout app.” Claude sees the LogWorkout intent exposed via MCP, understands the parameters, and invokes it. No Siri involved. No Shortcuts workaround. No switching apps.

Or imagine this: someone asks ChatGPT to “plan my week — check my calendar, find open slots, and schedule three workouts.” ChatGPT orchestrates across Calendar (via its intents), your workout app (via its intents), and Reminders (via its intents). One prompt, three apps, zero manual switching.

This is the multi-app agentic workflow that every AI company has been promising. Except Apple isn’t promising it — they’re building the plumbing for it in the OS itself.

The Code You Already Wrote Is the Code That Matters

Here’s the beautiful part: if you already have App Intents, you’re mostly done.

The MCP integration sits beneath App Intents at the system level. Apple handles the protocol translation. Your AppIntent struct doesn’t need to know whether it’s being called by Siri, Shortcuts, Spotlight, or Claude. It just conforms to the protocol and does its job.

struct LogWorkout: AppIntent {
    static var title: LocalizedStringResource = "Log Workout"
    static var description: IntentDescription = "Records a completed workout session"

    @Parameter(title: "Type")
    var workoutType: WorkoutType

    @Parameter(title: "Duration in Minutes")
    var duration: Int

    func perform() async throws -> some IntentResult {
        let tracker = WorkoutTracker.shared
        try await tracker.log(type: workoutType, duration: duration)
        return .result(dialog: "Logged \(duration)-minute \(workoutType.rawValue)")
    }
}

That’s it. That same struct that answers Siri today will answer Claude tomorrow. And ChatGPT. And Gemini. And whatever Google cooks up next quarter.

The developers who already went through the App Intents migration are now sitting on a goldmine they didn’t know they were digging. The ones who skipped it because “nobody uses Siri anyway” are about to have a very stressful WWDC.

Why Apple Chose MCP (and Not Their Own Thing)

This is, honestly, the part that surprised me most.

Apple loves proprietary standards. They invented Lightning when USB-C existed. They built iMessage when RCS was right there. They created AirDrop when Bluetooth file transfer had been working for a decade. If there’s a universal standard, Apple will usually build their own version, make it slightly better in one specific way, and lock it to their hardware.

So why adopt Anthropic’s open protocol?

Three reasons:

First, MCP already won. By the time Apple started building this, OpenAI had adopted MCP, Google had adopted MCP, Microsoft had integrated it into VS Code, and thousands of developers were already building MCP servers. Inventing a competing standard would have meant asking AI companies to support two protocols — and Apple doesn’t have enough leverage in the AI space (yet) to demand that.

Second, it’s a Trojan horse. By adopting MCP and building it into 2+ billion devices at the OS level, Apple instantly becomes the largest MCP platform on Earth. They don’t need to control the protocol if they control the distribution. Every AI agent that wants to work on iPhone has to go through Apple’s mediated MCP layer — which means Apple controls permissions, privacy, and which agents get access to what. Classic Apple: adopt the standard, own the implementation.

Third, it makes the open Siri platform actually work. Apple has been talking about letting users choose their AI assistant. But “choose your AI” is meaningless if each assistant needs custom integration with every app. MCP makes the integrations universal. Write one App Intent, reach every agent. The user picks their favorite AI, and everything just works.

What WWDC Will Probably Announce

We’re nine days out. The code has been sitting in betas since September. The genai.apple.com domain is registered and waiting. The Gemini partnership is in place. Everything is converging on June 8.

Here’s what I expect Apple to announce regarding MCP:

A public App Intents + MCP API. The beta code was described as “very incipient” last September. Nine months later, it’s likely matured into something Apple is ready to ship. Expect new protocols or property wrappers that let you mark which intents are MCP-compatible and define permission scopes.

An MCP permission model. This is the Apple part. You’ll probably see a permission prompt — similar to location or camera access — that asks users whether they want to let third-party AI agents access specific app functionality. Apple will gate this heavily. Privacy is the product.

Developer documentation at genai.apple.com. A dedicated hub for all the AI developer APIs — MCP, Foundation Models, Core AI (the likely successor to Core ML), and Siri Extensions. One URL to rule them all.

Multi-app intent chaining demos. Apple loves a good keynote demo. Expect Craig Federighi to show something like “Siri, book dinner for Saturday at 7 using my usual restaurant, add it to my calendar, and text my wife the details” — one command, four apps, zero friction. Then he’ll say “and it works with any AI assistant, not just Siri.” Standing ovation. Confetti optional.

What You Should Do Before June 8

Nine days. Here’s your checklist:

1. Audit your App Intents coverage. Open your project and list every user-facing action. How many have corresponding App Intents? If the answer is “none” or “just the easy ones,” you have work to do.

2. Add AppEntity and EntityQuery for your core data types. MCP agents will need to query your app’s data, not just trigger actions. If you have a fitness app, expose your workout types. If you have a note-taking app, expose your notebooks and tags. Entities are what make your intents actually useful in multi-app chains.

3. Think about permissions. Which intents should any AI agent be able to invoke? Which ones need user confirmation? A “show my dashboard” intent is fine. A “delete all my data” intent probably needs a gate. Start categorizing now.

4. Read the App Intents guide we published earlier this month. It covers the full migration from SiriKit to App Intents with real code examples. If you haven’t made the switch yet, that’s your starting point.

5. Update your AppShortcutsProvider. This is how Apple discovers your intents at install time. Make sure it’s comprehensive. The more intents you expose, the more useful your app becomes to every AI agent on the device.

The Bigger Picture

There’s a scene in The Social Network where Sean Parker tells Mark Zuckerberg: “You know what’s cool? A billion users.” That line could be rewritten for 2026: you know what’s cool? Two billion devices where any AI can use your app.

That’s what MCP on iOS means. It’s not just another framework. It’s a distribution mechanism disguised as a protocol.

Today, your app’s growth depends on the App Store chart, ASO keywords, and maybe a lucky feature from Apple. Tomorrow, it depends on whether an AI agent can find and use your app’s functionality. The apps that surface when someone says “help me do X” will win. The apps that stay silent will slowly become invisible.

We wrote about how App Intents are the new SEO. MCP makes that statement even more literal. Your App Intents aren’t just helping you rank in Spotlight — they’re listing your app in the AI equivalent of Google Search.

If you’re building with SwiftUI and want to understand how modern iOS architecture fits together — from modular SPM packages to App Intents to CloudKit — our SwiftUI at Scale course walks through production patterns that prepare you for exactly this kind of platform shift.

The Pizza Place Gets a New Sign

Nine months ago, Apple quietly wired MCP into their betas. Nine days from now, they’ll probably flip the switch on stage.

Your app’s App Intents started as a phone line to Siri. They’re about to become the sign on the door, the listing on every delivery app, and the QR code on every table. Every AI agent becomes a new front door to your functionality.

The pizza didn’t change. The kitchen didn’t change. But suddenly, the whole world can order.

Make sure your menu is ready.