The Future of MCP — David Soria Parra, Anthropic

April 19, 202618:46138,430 views

Summary

David Soria Parra, creator of the Model Context Protocol (MCP) at Anthropic, delivers a keynote at AI Engineer Europe 2026 outlining the evolution of MCP and its strategic role in powering the next generation of general-purpose AI agents. He opens with a live demonstration of an MCP application — an agent that ships its own UI interface via an MCP server, deployable identically to Claude.ai, ChatGPT, VS Code, and Cursor without platform-specific integration work — arguing this represents a fundamentally new paradigm because it requires both client and server to share semantic understanding of protocol primitives like UI rendering.

Parra traces MCP's rapid rise over the past 18 months: from a small spec document and a handful of SDKs to reaching 110 million monthly downloads, a milestone he notes React took roughly double the time to achieve. He credits the ecosystem's growth partly to adoption across competing AI stacks — OpenAI's Agent SDK, Google's ADK, LangChain, and thousands of other frameworks all pull MCP as a dependency — establishing it as the de facto cross-platform agent connectivity standard.

His central thesis is that 2024 was demos, 2025 was coding agents, and 2026 marks the transition to general knowledge-worker agents — financial analysts, marketing teams — where the primary bottleneck is not reasoning capability but connectivity to five-plus SaaS applications and shared drives. He proposes a three-layer 2026 connectivity stack: (1) Skills — reusable domain knowledge files; (2) MCP — for rich semantics, UI, authorization, resources, platform independence, enterprise governance; and (3) CLI/Computer Use — for local sandbox environments and tools with strong pre-training coverage like Git and GitHub.

Parra then details two underused client-side techniques he argues every agent harness should implement. The first is progressive discovery: instead of loading all MCP tools into the context window upfront, agents should use a tool-search mechanism to defer loading and fetch tools on demand. He shows before/after Claude Code token usage charts demonstrating a significant reduction in tool context after this pattern was adopted internally. The second technique is programmatic tool calling ("code mode"): rather than having the model orchestrate multi-step tool chains turn-by-turn — which is inference-heavy and latency-sensitive — agents should give the model a REPL (V8 isolate, Lua interpreter, etc.) and have it write short scripts that compose tool calls directly. MCP's structured output feature enables type-aware composition in these scripts.

On the server-author side, Parra calls out the anti-pattern of one-to-one REST-to-MCP conversion tools, advocating instead for agent-native API design — with Cloudflare's MCP server cited as a positive example of providing an execution environment rather than raw endpoint wrappers. He also pushes server authors to leverage MCP-specific primitives like elicitations, tasks, and MCP applications.

For the protocol roadmap, he announces several near-term milestones targeting June: a stateless transport protocol (contributed by Google) to make MCP servers deployable like standard stateless REST services on Cloud Run or Kubernetes; improved async task primitives for agent-to-agent communication; TypeScript SDK v2 and Python SDK v2 (explicitly acknowledging fast-MCP as a better developer experience than the current Anthropic Python SDK); cross-app access enabling single sign-on via enterprise identity providers like Okta and Google; server discovery via well-known URLs so browsers and agents can automatically detect MCP endpoints on any website; and skills-over-MCP, allowing server authors to bundle usage instructions alongside tools so models receive continuously updated guidance without relying on plugin registries.

Key Takeaways

•Implement progressive discovery in your agent harness: use a tool-search step to load MCP tools on demand rather than pre-loading all tools into context, which significantly reduces token usage.
•Replace multi-turn tool orchestration with programmatic tool calling: give the model a REPL environment (V8 isolate, Lua interpreter) so it writes scripts that batch and compose tool calls, reducing latency and inference cost.
•Do not build REST-to-MCP conversion wrappers one-to-one — design MCP servers for agent consumers, exposing execution environments and semantic primitives rather than raw endpoint mirrors.
•Use MCP structured output to provide type information that enables the model to compose tool results in programmatic mode without extra extraction calls.
•The right connectivity tool depends on context: use CLIs for local sandboxes and well-pre-trained tools (Git, GitHub); use MCP for rich semantics, authorization, UI, and platform independence; use Skills for reusable domain knowledge.
•Server authors should leverage MCP-specific primitives — elicitations, tasks, MCP applications, skills-over-MCP — that alternatives cannot provide, rather than treating MCP as a simple tool list.
•Plan for the June 2026 stateless transport protocol if you operate at hyperscaler scale — it will allow MCP servers to be deployed as standard stateless services on Kubernetes or Cloud Run.
•Skills-over-MCP (coming soon) will let server authors ship continuously updated usage instructions alongside their tools, removing dependency on plugin registries or client-side skill management.
•Cross-app access with enterprise identity providers (Okta, Google) is coming to MCP, which will smooth enterprise adoption by enabling SSO across MCP server connections.
The fast-MCP library is acknowledged by the Anthropic team as a better developer experience than the official Python SDK; Python SDK v2 is being rewritten to address this.

Transcript

[music] >> Well, welcome. Let's get started. This is an MCP application. That's an agent shipping its own interface not through like a plugin, not through an SDK, not rendered on the fly by the model on the client side, or hardcoded into the product. That is something that is served over an MCP server, and you can take the server, put it into cloud, you can put it into ChatGPT, you can put it into VS Code Cursor, and it will just work. And that I think it's kind of cool because for doing that, y...