Back in 2016, Apple introduced Siri Intents—a framework that allowed developers to expose their app’s functionality to Siri. If you’ve ever asked your iPhone to “send a message,” “order coffee,” or “start a workout,” you’ve probably used them. Siri wasn’t just listening; it was matching your voice command to a structured interface developers had defined.

Fast forward to today, and we’re seeing a similar—but broader—concept emerge in the world of language models: the Model Context Protocol (MCP) from Anthropic. It's a new open protocol aimed at helping AI agents (like Claude or ChatGPT) interface with external tools and APIs in a secure, declarative, and dynamic way.

On the surface, these systems feel worlds apart—one is Apple's voice assistant; the other is an interface layer for LLMs. But conceptually? They're siblings.

Both Were Built to Answer the Same Question

“How can we give a smart system safe, predictable access to tools it doesn’t own?”

For Siri Intents, the goal was to make Siri useful beyond built-in apps. Apple needed a way to say: Here’s how to let Siri send a Venmo payment or start your Peloton workout—without guessing how those apps work under the hood.

For MCP, the goal is nearly identical—but for LLMs. Large models are great at generating language, but they’re not inherently wired into your calendar, CRM, or shipping database. MCP lets models discover and invoke those external tools in a structured way—no guessing, no scraping, no brittle plugins.

How Siri Intents Work

Siri Intents require developers to define their app’s capabilities using .intentdefinition files. These described:

• The intent name (“SendPayment”)
• The parameters it accepted (“amount”, “recipient”)
• And the expected response (“paymentSuccess”, “errorMessage”)

This structure allowed Siri to match user queries to real-world actions. It also let Apple maintain a tight control loop: developers declared what they supported, users got autocomplete-style suggestions, and the assistant never went off-script. That predictability is what made the system safe, even if it sometimes felt limiting.

MCP Takes That Idea and Cranks It to Eleven

MCP plays a similar role—but for general-purpose models, not voice assistants. Instead of .intentdefinition files, you expose tools described with JSON schemas or OpenAPI specs. Each tool defines:

• A name and description
• The parameters it accepts
• And the expected output

The model—Claude, for instance—can “see” this information in its context window and decide if/when to call a tool. This opens the door to AI that not only understands natural language but executes actions based on it—fetching data, triggering workflows, or chaining multiple tools together.

MCP is still in its early stages. While the core spec is available and Anthropic is already experimenting with it inside Claude, it's a living standard. There’s no official governance body yet, and many key design decisions—especially around authentication, rate-limiting, and permissions—are still being debated in public.

Siri’s Walled Garden vs. MCP’s Open Frontier

One major difference between the two systems is security. Siri Intents live in a tightly controlled Apple ecosystem. Apps are vetted, permissions are managed through the OS, and there’s a clear trust model. The assistant only does what it’s explicitly allowed to do—and only with approved apps.

MCP, on the other hand, operates in a much looser, open-world context. Any developer can expose a tool. Any model that supports MCP can potentially invoke it.

That’s powerful—but also dangerous.

As Elena Cross put it in her excellent write-up, “🛡️ The ‘S’ in MCP Stands for Security,” the core challenge ahead for MCP is ensuring trust, authentication, and context-aware permissions in a world where models might call anything.

There’s no OS-level sandbox like iOS. Which means things like OAuth, scope-limited access, and human-in-the-loop verification need to be first-class citizens of any serious MCP implementation.

Where They're Alike

Both aim to solve the same core problem: How can we create a safe, structured, and extensible interface between an assistant and the outside world?

Why It Matters

MCP could become the glue that binds future AI systems to the real world.

Anything Siri Intents could do—like ordering a pizza, sending a message, or starting a workout—MCP can do too. But it doesn’t stop there. Want a model to book a meeting? MCP gives it structured access to your calendar API.

Want it to browse a knowledge base, summarize insights, and kick off a ticket in your support system? MCP enables that entire chain—because the tools are composable, and the agent is smart enough to use them.

Where Siri Intents gave voice assistants a limited but useful playbook, MCP hands AI models a full toolkit—and the ability to reason about when and how to use each tool, in context.

Final Thought

When Siri Intents launched, it was ahead of its time. It brought predictability and composability to the messy world of natural language. But it was locked in a walled garden.

MCP builds on that idea—and takes it cross-platform, cross-service, and model-native. You don’t need to be on iOS. You just need to have a tool worth calling.

But with great power comes real risk. If MCP is going to succeed, it’ll need more than a spec. It’ll need a trust framework that lets developers and users decide what models can do, when, and on whose behalf.