In March 2026, MCP lead maintainer David Soria Parra published the protocol's 2026 roadmap. It is the first formal roadmap since MCP moved to the Agentic AI Foundation under the Linux Foundation — and it reveals where the protocol's maintainers see the gaps between MCP's current state and what production deployments actually need.
The roadmap identifies four priority areas: transport scalability, agent communication, governance maturation, and enterprise readiness. Each addresses a specific class of problems that emerged as MCP adoption moved from experimental integrations to production infrastructure.
Understanding these priorities matters for any team building agent systems on MCP — including Neumar, whose agent orchestration is built on MCP as the primary tool integration mechanism.
Transport Scalability: Beyond Single-Server Patterns
Streamable HTTP — the transport layer that replaced MCP's original stdio-based communication — gave the protocol a production-ready network transport. But running Streamable HTTP at scale exposed gaps that single-server deployments never encountered.
The specific problems:
Horizontal scaling. An MCP server that works on a single instance needs additional design to work across multiple instances behind a load balancer. Session state, connection affinity, and request routing become concerns that the current transport specification does not address explicitly.
Stateless operation. The current Streamable HTTP transport assumes stateful connections. For serverless and edge deployment patterns — where the MCP server may be a Lambda function or a Cloudflare Worker — the transport needs to support stateless request-response patterns without requiring persistent connections.
Middleware compatibility. API gateways, reverse proxies, and service meshes need to understand MCP traffic to route, authenticate, and monitor it correctly. The current transport works through these layers but does not provide the metadata they need to handle MCP traffic intelligently.
The roadmap's goal: evolve Streamable HTTP to run statelessly across multiple server instances and behave correctly behind load balancers and proxies. This is infrastructure work that is invisible to most developers but essential for organizations deploying MCP servers as managed services.
For Neumar, transport scalability matters because MCP servers that Neumar connects to may be running in any of these deployment patterns. A user connecting Neumar to a company's internal MCP server running behind a load balancer needs the transport to handle that topology correctly.
Agent Communication: MCP Between Agents
The most architecturally significant item on the roadmap is agent-to-agent communication through MCP. Today, MCP defines communication between a client (an AI application) and a server (a tool or data source). The roadmap extends this to communication between agents — where one agent's capability is exposed to another agent as an MCP server.
This enables hierarchical and collaborative agent architectures where agents can discover and use each other's capabilities through the same protocol they use to access tools and data sources. A planning agent can delegate subtasks to specialized execution agents. A research agent can request analysis from a domain-specific agent. The protocol provides the discovery, invocation, and result-passing mechanisms.
The implications for multi-agent architectures are substantial:
| Current State | With Agent Communication |
|---|---|
| Agents share state through shared memory or databases | Agents communicate through typed MCP interfaces |
| Agent composition requires custom orchestration code | Agent composition uses standard MCP client-server patterns |
| Agent discovery is manual (hardcoded endpoints) | Agent discovery through MCP service registries |
| Multi-agent workflows are framework-specific | Multi-agent workflows are protocol-level, framework-agnostic |
For Neumar's architecture — which supports both Claude Agent SDK structured agents and LangGraph workflow agents — MCP-based agent communication would enable interoperability between agent types. A Claude SDK agent could delegate to a LangGraph workflow agent (or vice versa) through MCP, without either agent needing to understand the other's orchestration framework.
Governance Maturation: Community Leadership
The governance priority addresses the organizational structure of MCP development itself. SEP-1302 formalized Working Groups and Interest Groups. SEP-1835 established succession and amendment procedures. The 2026 roadmap extends this with a focus on giving the community a clear path to leadership positions.
This is not technically interesting but is organizationally critical. MCP's credibility as a neutral standard depends on governance that is not controlled by a small group of individuals — regardless of how well-intentioned those individuals are. The Linux Foundation umbrella provides the legal structure; the community leadership pipeline provides the operational structure.
For teams evaluating MCP as a long-term infrastructure dependency, governance maturation reduces the risk that the protocol's direction will shift in ways that disadvantage specific adopters. It is the organizational counterpart to the technical stability that the protocol specification provides.
Enterprise Readiness: The Real Gaps
The enterprise readiness section of the roadmap is the most pragmatically important. It identifies four specific gaps:
Authentication and authorization. MCP's current auth story is underspecified for enterprise environments. OAuth 2.0 support exists but is not consistently implemented across SDKs. Enterprise patterns like SAML, OIDC integration, fine-grained permission models, and token rotation are not addressed at the protocol level.
Observability. Production MCP deployments need metrics, logging, and tracing that integrate with existing observability infrastructure — OpenTelemetry, Datadog, Grafana. The protocol does not currently define standard telemetry outputs or health check interfaces.
Gateway patterns. Enterprises want to route MCP traffic through API gateways for centralized authentication, rate limiting, audit logging, and policy enforcement. The current protocol does not define gateway-specific metadata or routing conventions.
Configuration portability. MCP server configurations — connection parameters, authentication credentials, tool selection — need to be shareable across environments and teams. The current configuration model is file-based and machine-specific.
These gaps explain why, despite MCP's broad community adoption, enterprise deployment remains slower than community adoption. Enterprises cannot deploy infrastructure that lacks the auth, observability, and governance layers their security and compliance requirements demand.
SDK Ecosystem Status
The current MCP SDK versions as of March 2026:
- TypeScript SDK: v1.27.1
- Python SDK: v1.26
- OpenAI Agents SDK: v0.12.x with MCP integration
- Google ADK: v2.0 with Task API updates
The SDK ecosystem's breadth — with official support from Anthropic, OpenAI, and Google — validates MCP's position as the industry-standard protocol for agent-tool integration. The version numbers indicate active development with regular releases addressing the gaps the roadmap identifies.
What This Means for Teams Building on MCP Today
The 2026 roadmap is reassuring for teams that have already adopted MCP: the protocol's maintainers are addressing the specific problems that production deployments encounter. None of the roadmap items require breaking changes to existing MCP servers — the work is additive, extending the protocol's capabilities rather than changing its fundamentals.
The practical guidance for teams building on MCP today:
Build MCP servers as usual. The protocol's core — JSON-RPC over Streamable HTTP, typed tool definitions, server-client communication — is stable and will not change.
Plan for auth. The current auth story will evolve. If you are implementing custom auth for your MCP servers, design it to be replaceable when the protocol-level auth specification stabilizes.
Instrument for observability. Add logging and metrics to your MCP servers now, even if the protocol-level telemetry standard is not yet defined. The observability you add will be useful regardless of how the standard evolves.
Watch agent communication. The agent-to-agent communication spec will change how multi-agent architectures are designed. If you are building multi-agent systems, design your agent interfaces to be exposable as MCP servers.
Neumar's agent architecture uses MCP as the primary tool integration layer. The 2026 roadmap's focus on transport scalability, agent communication, and enterprise readiness directly benefits Neumar users — expanding the set of MCP servers that work reliably and enabling new multi-agent composition patterns.