Podcast Summary: MCP Co-Creator on the Next Wave of LLM Innovation

Podcast: AI + a16z
Guests: Yoko Lee (a16z Infra Partner), David Soriapara (Anthropic, MCP Co-Creator)
Release Date: May 2, 2025

Main Theme

This episode explores the Model Context Protocol (MCP), an open standard designed to make large language model (LLM) applications extensible, composable, and interoperable with a wide variety of tools, datasets, and creative workflows. The conversation digs into MCP's origin story, how it unlocks “agentic” behaviors, key protocol features, developer use cases, underappreciated capabilities, and the future direction of MCP as open infrastructure.

Key Discussion Points & Insights

1. What Is an "Agent" in AI?

Timestamps: 00:00–00:39, 45:27–48:25

• Definition Debate:
  • Yoko Lee: Calls an agent “a multi-step LLM reasoning chain.”
  • David Soriapara: Sees agency as “autonomous orchestration or task solving,” with anything that reacts and takes multiple steps now having “some agency over what it’s doing.”
    • Quote: “Anything that’s a multi-step thing is for me already like an agent right the moment it does two steps and it reacts to the first step, it's basically an agent.” — David Soriapara (00:14, 45:41)

2. MCP: Purpose and Analogy to APIs

Timestamps: 01:51–04:04

• MCP is an open protocol enabling anyone to extend AI apps with custom workflows and integrations by standardizing the way LLM clients and external tools communicate.
  • Quote: “What it enables is something like the current API ecosystem, but for LLM interactions with some form of context providers or agents in any form or shape.” — David Soriapara (02:24)
• API Analogy: Like how APIs standardized SaaS integration, MCP provides a schema/interface to connect tools and LLM apps flexibly.

3. Origin Story and Rapid Prototyping

Timestamps: 04:04–07:29

• Frustration As Fuel: David's frustration with lack of workflow extensibility in apps like Claude Desktop and Z code editor sparked the idea of a universal integration protocol.
• Chicken-and-Egg of Protocols: MCP was shaped by fast prototyping, not theorizing. The first demonstration was a Puppeteer server that let Claude control a browser—designed to “wow” and prove possibility.
• Early clients integrated into Claude Desktop and Z; first “boring but useful” servers did things like Postgres or GitHub integration.

4. Creative & Unexpected Community Use Cases

Timestamps: 09:03–16:06

• Long-Tail Innovation:
  • Quote: “I just love it when a protocol kind of unlocks the long tails, when the long tails is really long. …Now everyone can build the software for one.” — Yoko Lee (11:50)
• Notable Community Examples:
  • Buying Christmas gifts via Claude on Amazon (10:00)
  • Morse code notifications using Philips Hue lights (13:09)
  • Cat-monitoring project with Raspberry Pi and narration agent (14:10)
  • JetBrains IDE control, creative tools (Blender/Unity/Synths), reverse engineering tools
• Personal Projects:
  • Yoko describes solving practical problems (like automating texts to her husband when late for dinner using MCP and Cursor agent), and inventive hacks (lights blinking Morse code when tasks finish).

5. Underutilized MCP Features

Timestamps: 16:06–26:22

• Sampling (16:54): Lets a server request a client’s current LLM to generate output (“sample”) instead of bringing its own, enabling richer integrations and agentic loops that are model-agnostic.
  • Quote: “Sampling is a way for the MCP server to go back to the client and ask the client, hey, can you give me, with the current selected model a completion... That way I can build these MCPs that are very rich, ...model independent.” — David Soriapara (16:54)
• Chaining: Chaining servers and clients to create multipart workflows and agent loops.
• Prompts & Resources (23:15):
  • Prompts: Insert dynamic or static context directly into LLM calls; can be user-driven and fetch data on demand.
  • Resources: Server-exposed blobs (files, screenshots, etc.) that clients can query—mindshift compared to traditional local resource access.
    • Quote: “You could expose your current screenshot as a resource…these things leave a lot more use cases open to explore.” — David Soriapara (26:04)
• Many features remain underused as most developers focus on the “tool calling” aspect only.

6. Transport, Authentication & Authorization

Timestamps: 26:47–34:29

• Transport Independence: MCP isn’t tied to HTTP—can use standard IO, JSON-RPC, or other transports.
• Authentication/Authorization:
  • Current usage: local servers with simple API keys.
  • OAuth in Development: Collaboration with auth experts (Microsoft, Okta, AWS) to shape secure, user-friendly mechanisms for professional/remote MCP servers.
    • Quote: “What authorization does…enables MCP servers that are remote, that are bound to a company account.…Now I’m authorized and it opens this company and corporate ecosystem.” — David Soriapara (29:37)
  • Focus: Authorization (“am I allowed access?”) before tackling identity/authentication in agentic chains.

7. Creativity, Artists & Non-Developer Use Cases

Timestamps: 34:29–39:10

• Early adopters: Developers (natural due to comfort with JSON, APIs, etc.)
• Creative use:
  • Blender/Unity for 3D and game environments
  • Music/synths programming via LLMs + MCP
  • Quote: “I think that's a very unique thing because… an environmental artist in Blender has probably never had the ability to really express itself in words…and have it translated to a 3D environment.” — David Soriapara (36:28)
• Inputs will expand from just words/code to images, curves, and more as clients evolve.

8. Abstraction Layer & Future Modalities

Timestamps: 39:10–43:40

• Debate over ultimate “interface” or abstraction—natural language, programming languages, pixels, video, etc.
  • “Only natural language…would not be good enough…a combination of them might be the right thing.” — David Soriapara (40:21)
• Experimentation is needed; MCP enables such experimentation with different modalities.
• Surprising example: LLMs can generate ASCII art/animations quite well due to their token sequence prediction (43:17).

9. MCP’s Roadmap and Scope

Timestamps: 43:40–47:33

• Will keep evolving on core features (auth, modalities, streaming).
• There’s open debate about what MCP should NOT try to address (e.g., being a full-fledged agent framework or handling all retrieval/database tasks).
• Staying focused on composability, useful abstraction.

10. Composability, Trust Boundaries & Multi-Agent Workflows

Timestamps: 47:33–50:26

• Multi-agent systems may naturally emerge where there are trust boundaries (e.g., separating access between a travel agent and a banking interface).
  • “Agents is less a function of the task, but more a matter of trust boundaries.” — David Soriapara (48:25)
• For most current workloads, single-agent “call graphs” are sufficient, but evolution is expected as needs grow.

11. How To Contribute & Community Growth

Timestamps: 50:26–52:57

• MCP operates as a traditional open-source project:
  • Review issues/PRs
  • Implement features in SDKs
  • Contribute to RFCs/spec proposals (higher bar for spec work)
  • Build trust with maintainers over time; governance models are evolving for more sustainability.
  • Quote: “Just go and help and work with us. That’s really what we need at the moment.” — David Soriapara (52:57)
• Key contributors include Microsoft, AWS, Okta, and active community members.

Notable Quotes & Memorable Moments

• “I just love it when a protocol unlocks the long tails...now everyone can build the software for one.” — Yoko Lee (11:50)
• “Sampling is a way for the MCP server to go back to the client and ask…with the current selected model a completion...so I can build these MCPs that are very rich, ...model independent.” — David Soriapara (16:54)
• “For me, agents is potentially more like agency. So something that does some form of autonomous orchestration, autonomous task solving…multi step thing is for me already like an agent.” — David Soriapara (00:14/45:41)
• “Developers know how to query an API; artists know how to sketch a line. What happens when both can instruct LLMs?” — Paraphrased from Yoko Lee (throughout)
• “I need that version for my dog.” — David Soriapara, on the cat-monitoring project (15:06)
• “There's so much going on…the spec lift is on the client side because we expect fewer clients than servers. We want to make it trivial to build a server.” — David Soriapara (19:09)
• “Inputs today are mostly words… later I wonder what kind of experience we'll have if every design tool becomes an MCP client.” — Yoko Lee (39:10)

Timestamps for Key Segments

• Agent Definitions: 00:00–00:39, 45:27–48:25
• Purpose and Origin of MCP: 01:51–07:29
• Creative & Real-World Uses: 09:03–16:06
• Underutilized Features (Sampling, Chaining, Prompts, Resources): 16:06–26:22
• Transport, Auth, and Authorization: 26:47–34:29
• Creative Tools & Modalities: 34:29–43:40
• Future, Roadmap, Agents vs. Trust Boundaries: 43:40–50:26
• Open Source & Community: 50:26–52:57

Engagement & Tone

The episode is playful, technical, and deeply collaborative. Both guests share a hackers’ delight in creative misuses and edge cases, while honestly addressing technical hurdles (e.g., client support bottlenecks, auth challenges). The spirit is one of open experimentation and empowerment—“unlocking the long tail” for everyone, from power users to professional dev teams, artists, and tinkerers.

For listeners wanting to dive deeper into building with or contributing to MCP, the episode encourages direct involvement, creative experimentation, and collaboration.