Introduction
This analysis draws from two November 2025 sources documenting Model Context Protocol’s evolution at its one-year mark: the 8th AI Agent Meetup in San Francisco featuring technical presentations from Prefect, reboot.dev, and PayPal on emerging production MCP implementation, plus an extended technical discussion with MCP protocol architect David Soria Parra examining the specification releasing this week. The SF meetup brought together engineers confronting real-world agent infrastructure challenges. The Soria Parra conversation provided rare protocol-level insight into design decisions shaping asynchronous operations, OAuth evolution, and extension mechanism discussions. Together, these perspectives reveal MCP transitioning from experimental standard to a production infrastructure layer.
Executive Summary
The Core Shift: MCP’s new specification introduces asynchronous operations through a primitive called “tasks” reshaping how agents orchestrate long-running workflows. This moves agent architecture from synchronous request-response patterns toward event-driven coordination across distributed execution patterns.
The Production Tension: Perumal Palani Architect reveals PayPal MCP now exposes 32 commerce operations requiring transaction integrity and compliance. Apache Mesos creator Benjamin Hindman asks whether MCP servers survive mid-transaction reboots. Prefect’s Adam Azzam critiques servers as “glorified REST wrappers” designed for SDKs rather than agents. The gap between protocol elegance and enterprise requirements shape the infrastructure emerging.
The Design Paradox: MCP succeeded through minimalism but now faces structural demands for capabilities intentionally omitted. Tasks resolve this through composition rather than proliferation, a meta-primitive enabling async operations within any future protocol capability without specification expansion. Sophistication achieved through constraint instead of expansion.
The Stabilization Imperative: Protocol architect David Soria Parra signals velocity reduction after this release. “I really want the protocol to slow down from there on.” Client adoption consistently lags feature expansion. The ecosystem needs implementation time more than additional capabilities. Extensions framework provides escape valve for vertical requirements without core protocol bloat.
Strategic Implications: Agent infrastructure splits into layers: minimal protocol primitives, framework abstractions handling complexity, platform services ensuring durability and compliance. Production deployment demands thinking beyond protocol compliance toward reboot resilience, graceful error recovery, and transaction integrity. The transition from experimental agent demos to autonomous commerce systems requires infrastructure assumptions MCP now provides but doesn’t enforce.
The Infrastructure Moment: After one year, MCP moves from protocol experimentation to foundational layer beneath production agents. Async operations represent not a feature addition but architectural threshold, the point where agent orchestration either standardizes on shared primitives or risks fracturing into incompatible implementations. The specification releasing this week positions MCP as infrastructure underpinning autonomous systems emerging over the next year, not just the agents demonstrated today.
The Async Threshold: MCP’s Infrastructure Moment Arrives
One year into Model Context Protocol’s presence, the standard confronting every major AI platform stands at an inflection point. The new specification releasing this week introduces asynchronous operations, what protocol architect David Soria Parra calls “tasks,” and the change reveals something larger than feature expansion. It exposes the tension between elegant protocol design and production-grade agent infrastructure.
The paradox sharpens when examined closely: MCP succeeded precisely because it remained minimal, yet agents operating at scale demand capabilities the original design intentionally omitted. “We really want to keep it as lean as needed without adding too much,” Soria Parra explained during a technical deep-dive, “but at the same time there are certain domains where you want additional information.”
That restraint now faces collision with reality. PayPal now exposes 32 commerce operations through MCP. Prefect built FastMCP, the most adopted framework for server construction. Apache Mesos creator Ben Hindman asks the question enterprises actually care about: “What happens if your MCP server reboots in the middle of executing a tool call?”
The answer reshapes how agent infrastructure gets built.
When Synchronous Architecture Becomes the Constraint
Adam Azzam frames the problem with characteristic directness: “Too many MCP servers are simply glorified REST wrappers, regurgitating APIs that were designed for SDKs, not agents.” His critique cuts deeper than implementation quality, it identifies a category error in how developers approach agent tooling.
REST APIs assume human tempo. Request, response, next action. The model works when latency measures in milliseconds and operations complete before users refresh browsers. It collapses when agents orchestrate workflows spanning minutes or hours, when checkout processes involve shipping quotes and payment authorization and inventory verification, when research tasks fan out across dozens of data sources before synthesis.
“Tools allow for this very natural synchronous operation where a model invokes a tool, you call it, and it returns a result,” Soria Parra observed. “But for long-running operations, particularly agents themselves, it is not really suitable.”
The architecture gap manifests as brittle polling loops, bloated context windows, and agents unnecessarily waiting on operations that should execute in background. Developers responded by building custom task orchestration, each implementing their own UUID schemes, status endpoints, result retrieval mechanisms. “We all solved them in different ways,” Azzam noted, “so we couldn’t have it as a standardized thing across everybody’s MCP servers.”
Pattern fragmentation exactly where standards should provide coherence.
Composability Through Constraint
The task implementation reveals sophisticated protocol thinking. Rather than adding task-specific methods proliferating across the spec, MCP introduces a meta-primitive: clients create tasks receiving server-assigned IDs, then interact with those tasks using existing protocol operations (tool calls, resource access, prompts).
“It’s not just one long-running tool call,” Soria Parra explained. “You create a task and then you can have multiple interactions, standard MCP interactions with that task, and at the end you get a final result back.”
The design choice matters. By keeping tasks generic rather than binding them exclusively to tools, the protocol remains forward-compatible. Future MCP capabilities, whatever emerges beyond current imagination, can operate asynchronously without spec revision. “You could technically retrieve a resource asynchronously if you really wanted to,” Soria Parra suggested, acknowledging the compositional elegance even as he questioned practical utility.
But elegance introduces complexity. During the technical session, senior implementers wrestled with edge cases: correlation semantics, task ID reuse, state management across async boundaries. “This is really confusing,” one contributor noted while parsing the specification. The protocol achieves generality through indirection, trading immediate clarity for long-term flexibility.
Soria Parra acknowledged the tension: “I think you need to see how it will pan out in the actual SDKs. What you get out of the SDK is I want to make a long-running tool call, that’s what you actually care about.” The abstraction layer matters. Developers interact with frameworks; frameworks negotiate protocol mechanics.
Production Reality: Commerce Agents as Proof
PayPal’s implementation shows why async operations became non-negotiable. Perumal Palani architected an MCP server exposing invoice creation, subscription management, dispute resolution, catalog operations, each requiring multi-step workflows with external dependencies and regulatory compliance checkpoints.
“This isn’t a REST API wrapper,” the meetup description emphasized. “It’s an agent-native interface designed to solve the unique challenges of financial MCP servers: absolute security compliance, transaction integrity ⚡ graceful error recovery, and production scale.”
Transaction integrity particularly demands durability. Hindman’s framing question (can your MCP server survive reboot mid-transaction?) exposes infrastructure assumptions most developers haven’t confronted. “We’re not talking about tools that add two numbers together,” he stated. “We’re talking about tools that can book vacations, and we don’t want to find out we have a flight booked but no hotel.”
The reboot.dev founder brings Apache Mesos experience to agent infrastructure, recognizing patterns from distributed systems evolution. Long-running stateful operations require separation of concerns: orchestration logic isolated from execution, state persistence across failures, idempotent retry semantics. “If any of these tasks fail for some reason, it crashes the process the agent’s working in,” Azzam noted, describing the anti-pattern MCP tasks aim to eliminate.
PayPal’s scale validates the architectural shift. Commerce operations can’t exist as synchronous calls waiting for payment authorization that might require manual review. They can’t survive connection timeouts during shipping calculations calling external carriers. Agent workflows spanning hours demand infrastructure thinking beyond HTTP request-response cycles.
The OAuth Subplot: Trust Architecture Evolves
Buried in the specification discussion: client ID metadata replacing dynamic client registration (DCR). “I got the original implementation kind of wrong,” Soria Parra admitted, “because I didn’t understand certain requirements in the enterprise space really well.”
The OAuth evolution story parallels the async operations arc: elegant protocol design meeting production friction. Dynamic client registration promised plug-and-play MCP (any client connecting to any server without pre-coordination). Reality delivered whitelist lockdown, restricted domains, partnerships prerequisites. “Every client you need to, they’re restricting effectively the clients that can register to certain domains that they know,” Soria Parra explained.
Client ID metadata, freshly ratified by IETF, replaces registration with URL-based trust. Clients provide metadata via domain, servers verify domain ownership, DNS becomes the trust foundation. “Why has it never worked like this in the first place?” Soria Parra wondered. “Why did I always have to get this weird client ID registered in advance?”
The pattern repeats: sophisticated mechanisms revealing simpler primitives. Trust reduces to domain verification. Async operations reduce to task IDs and polling intervals. Complexity handled through composition rather than proliferation.
“We all collectively decided that the only trust system that exists on the internet is DNS,” one contributor observed. “Everything relies on trusting a domain name. Everything.”
The Stabilization Imperative
Protocol velocity creates adoption friction. Claude desktop supports tools. ChatGPT supports tools. Full MCP feature adoption remains sparse across clients because the specification kept expanding. “Most people use it primarily for tool calling at the moment,” Soria Parra acknowledged. Resources, prompts, sampling, capabilities existing in spec but underutilized in practice.
Tasks and client ID metadata land this week. Extensions framework targets spring. Transport improvements (bidirectional persistence, long-lived connections) follow after. “I really want the protocol to slow down from there on,” Soria Parra stated. “Everything else will hopefully be refinements over time.”
The stabilization imperative balances innovation against ecosystem fragmentation. Kubernetes veterans on the call recognized the pattern: protocol maturity requires freezing core semantics so implementations can catch up. “Don’t want to keep changing,” one noted. “Definitely want to have it more stable now.”
Yet agent capabilities accelerate faster than protocols standardize. The “from what if to how to” transition which I documented (AI Agent Revolution: LangChain’s Perspective on Future of Enterprise AI) demands infrastructure that exists today, not specifications arriving in six-month cycles.
Implications: Infrastructure Beneath Agents
Three observations crystallize:
Async operations shift agent architecture from orchestration toward choreography. Clients manage task lifecycles rather than blocking on synchronous calls. Agents coordinate workflows across distributed execution rather than controlling linear sequences. The mental model changes from procedure invocation to event-driven coordination.
Production-grade MCP requires thinking beyond protocol compliance. Hindman’s durability challenge, Azzam’s design quality critique, PayPal’s compliance requirements, all point toward infrastructure concerns the specification enables but doesn’t enforce. Reboot resilience, FastMCP abstractions, PayPal’s transaction integrity: these emerge as framework and platform responsibilities layered atop protocol primitives.
Extensions signal protocol boundary definition, not feature completeness. UI rendering, financial services compliance, healthcare HIPAA requirements 🎯 vertical-specific needs already exceeding general protocol scope. MCP’s extension mechanism acknowledges that standardization limits exist, that composable primitives matter more than comprehensive coverage.
The one-year mark arrives with MCP transitioning from experimental protocol to production infrastructure. Tasks represent not a feature addition but architectural threshold: the moment agent orchestration demands async primitives or fractures into incompatible implementations.
“At the moment it’s built around the idea to compose the idea of creating a task with inputs and outputs being standard MCP primitives,” Soria Parra explained. “That’s the basic goal.”
Composition through constraint. Sophistication through minimalism. Infrastructure designed not for the agents we demonstrate today but the autonomous systems emerging next year.
The specification releases this week 🌊 and the real test begins when commerce agents book hotels alongside flights, research tasks compile evidence across weeks, enterprise workflows orchestrate compliance across departments. When async operations stop being protocol features and become infrastructure assumptions.
When minimal design reveals maximal possibility, or when production reality demands more than elegant composition provides.
Sources & Further Reading
SF AI Agent Meetup #8: MCP Ecosystem Thursday, November 13, 2025 Digital Jungle SF, San Francisco Sponsored by AI Alliance, PayPal, Neo4j Hosted by Dave Nielsen, Alexy Khrabrov, Max, Yolande Poirier, Alison Granger, Cyril Attia Event Details
The Context: MCP Specification Update Live stream with David Soria Parra, Co-Creator of MCP, Anthropic Wednesday, November 12, 2025 Watch Full Interview
Featured Presentations:
“Can your MCP server survive a reboot?” by Ben Hindman, reboot.dev
“Your MCP Server is Bad and You Should Feel Bad” by Adam Azzam, Prefect
“Making Commerce Agent-Native: PayPal’s MCP Implementation” by Perumal Palani, Architect, PayPal
Additional sources:
PayPal MCP Server Github: github.com/paypal/paypal-mcp-server
Model Context Protocol (MCP) github.com/modelcontextprotocol
SEP 1686: github.com/modelcontextprotocol/modelcontextprotocol/issues/1686 introduces both the task primitive and the associated task ID, which can be used to query the state and results of a task, up to a server-defined duration after the task has completed. This primitive is designed to augment other requests (such as tool calls) to enable call-now, fetch-later execution patterns across all requests for servers that support this primitive.
MCP Documentation: modelcontextprotocol.io
Big thanks to organizers & production team including Dave Nielsen Alexy Khrabrov Cyril Attia Yolande Poirier Alison Granger Ganansia
#MCP #AIInfrastructure #AgenticAI #EnterpriseAI #ProtocolEngineering
siege took place between 18 June and 9 September 1686, ending nearly 150 years of Ottoman control over the former Hungarian capital. Azzam highlights the coincidence: SEP 1686, the spec freeing agents from synchronous limitation, carries the same number as the 1686 Siege of Buda that ended Ottoman rule. Historical patterns in protocol numbering
Twitter summary: x.com/schwentker/status/1990237129029616005
Bluesky: bsky.app/profile/schwentker.bsky.social/post/3m5s4b2qfgs2i
