# Model Context Protocol

> The Model Context Protocol (MCP) is the open standard connecting AI agents to tools and data. Covers the stateless 2026-07-28 spec and AAIF governance.

Source: https://metavert.io/model-context-protocol  
Published: 2026-07-04  
Updated: 2026-10-07

Agentic Economy

[View Market Map](https://metavert.io/agentic-market-map)

Layer 2: Creation & Orchestration as MCP

The Model Context Protocol (MCP) is an open standard that defines how [AI agents](https://metavert.io/agentic-ai) connect to external tools, data sources, and services. Think of it as the USB-C of the AI world—a universal interface that lets any agent work with any tool, without custom integration for each combination.

[![MCP Adoption: Explosive Growth — from The State of AI Agents 2026](https://flipbook.metavert.io/data/flipbooks/871ee5e1-1d5c-4c35-a11f-2ed507688ff7/pages/page-091.png)](https://flipbook.metavert.io/v/state-of-ai-agents-and-agentic-engineering-2026-metavert?page=91)

Before MCP, connecting an AI agent to a database, API, or application required bespoke code for each integration. MCP standardizes this into a client-server architecture where tools expose their capabilities through a consistent protocol, and agents discover and use those capabilities dynamically. An MCP server might provide 25+ tools for interacting with a chess platform, or expose a content management system's full API, or give an agent access to browser automation.

Originally contributed by Anthropic, MCP has gained adoption across the AI ecosystem, and since December 2025 it has been governed by the Linux Foundation's [Agentic AI Foundation (AAIF)](https://metavert.io/agentic-ai-foundation) rather than by any single vendor. It supports multiple transport mechanisms, handles authentication, and provides a structured way for agents to understand what tools are available and how to use them. The protocol is particularly important for [multi-agent systems](https://metavert.io/multi-agent-systems), where different agents need to discover and coordinate around shared tools.

MCP matters because it addresses a foundational challenge of the [agentic web](https://metavert.io/agentic-web): interoperability. Without a common protocol, every agent-tool combination requires custom work. With MCP, building an agent that can interact with any MCP-compatible system becomes dramatically simpler—lowering the barrier for [agentic engineering](https://metavert.io/agentic-engineering) and accelerating the transition to AI-native workflows.

MCP is also becoming a foundational layer in a broader protocol stack. MIT's [NANDA Protocol](https://metavert.io/nanda-protocol) builds on MCP (alongside Google's [A2A](https://metavert.io/a2a) and Microsoft's NLWeb) to create the meta-layer for the [Internet of Agents](https://metavert.io/internet-of-agents) — providing cross-protocol [agent discovery](https://metavert.io/agent-discovery), [identity verification](https://metavert.io/agent-identity-trust), and decentralized routing. In this architecture, MCP handles the tool-connection layer while NANDA handles discovery and trust *across* protocols. The [agent harness](https://metavert.io/agent-harness) layer sits above both, managing the full lifecycle of agent execution including MCP tool orchestration.

The Chessmata project demonstrated MCP's practical power: a single MCP server exposed 25+ tools that allowed any AI agent to play chess, manage tournaments, and interact with leaderboards through a standardized interface. This pattern—exposing complex systems through MCP—is becoming the default architecture for [agent-native](https://metavert.io/agentic-ai) software.

## 2026 Developments: The Stateless Specification

On July 28, 2026, MCP shipped its largest revision since launch, the 2026-07-28 specification, after a release candidate published on May 21. The MCP project summarizes it as "a stateless core that scales on ordinary HTTP infrastructure," new extensions, authorization "that aligns more closely with OAuth and OpenID Connect deployments," and "a formal deprecation policy so the protocol can evolve without breaking what you've built."

### Stateless core

Earlier versions began every connection with an `initialize`/`initialized` handshake that created a session tracked by an `Mcp-Session-Id` header. That forced "sticky" routing, so every request from a client had to reach the same server instance. In the new spec each JSON-RPC request is self-contained, carrying client information in a `_meta` object, and clients discover a server's capabilities on demand through a new `server/discover` method. MCP servers can now sit behind ordinary round-robin load balancers like any other web API, which matters as remote, cloud-hosted MCP servers replace local ones.

### Multi Round-Trip Requests, routing headers and caching

Removing sessions also removed the open stream a server used to ask the client for something in the middle of a call. The replacement is Multi Round-Trip Requests (MRTR): when a tool needs input, the server returns `resultType: "input_required"` along with the requests it needs answered, and the client retries the original call with the answers attached in `inputResponses`. According to the specification post, MRTR replaces the server-initiated `elicitation/create`, `sampling/createMessage` and `roots/list` requests, so a confirmation prompt becomes an ordinary request and response. A server that still needs state across calls is told to "mint an explicit handle from a tool and have the model pass it back as an argument."

Two smaller changes serve the same goal. Streamable HTTP requests must now carry `Mcp-Method` and `Mcp-Name` headers, so a gateway, rate limiter or web application firewall can route and meter traffic without parsing JSON bodies. Responses from `tools/list`, `prompts/list`, `resources/list` and `resources/read` carry `ttlMs` and `cacheScope` values that tell clients how long, and how widely, a result may be cached.

### MCP Apps and Tasks

Two official extensions widen what servers can do. **MCP Apps** lets a server ship an interactive HTML interface, declared as a `ui://` resource, that renders inside the conversation in a sandboxed iframe and talks back to the host over JSON-RPC. A tool can return a working form, chart or dashboard instead of only text. **Tasks** standardizes long-running work: a server returns a task ID, the client polls with `tasks/get` and can send more input with `tasks/update`, and tasks are designed to survive dropped connections. That fits the hours-long jobs that [work agents](https://metavert.io/work-agents) now run.

### Authorization

Authorization is now aligned with OAuth 2.1 and OpenID Connect, so MCP servers can sit behind the identity providers enterprises already use. According to AAIF's migration guide, the release adds an Enterprise-Managed Authorization extension for centrally provisioned access and incremental scope consent, and proposes deprecating Dynamic Client Registration.

The final specification post goes further on that last point: Dynamic Client Registration "is now formally deprecated in favor of" Client ID Metadata Documents (CIMD), though it continues to work for backward compatibility. The post also requires clients to validate the authorization server's issuer under RFC 9207 before redeeming a code, and binds client credentials to the issuer that granted them.

### Deprecations

For the first time, MCP has a formal deprecation policy, with a minimum 12-month window before anything is removed. Four features are deprecated: **Roots** (a poor fit for remote servers; pass paths as tool parameters instead), **Sampling** (servers calling back into the client's model, which complicated trust boundaries), **Logging** (superseded by stderr or OpenTelemetry), and the original **HTTP+SSE transport** (superseded by Streamable HTTP). The earliest removal date is July 28, 2027.

### SDK tiers

MCP's official SDKs are ranked by a tiering system that the project published on February 23, 2026, a month after its automated conformance tests became available. **Tier 1** SDKs must pass 100% of applicable conformance tests, support new protocol features before a new specification version is released, triage issues within two business days and resolve critical bugs within seven days. **Tier 2** SDKs must pass 80% and add new features within six months. **Tier 3** covers experimental or partial implementations with no commitments. An SDK is relegated if conformance tests fail continuously for four weeks.

The specification post states that "all four Tier 1 SDKs speak `2026-07-28` as of today: TypeScript, Python, Go, and C#," with the Rust SDK supporting the new spec in beta. The C# SDK's place in that group puts .NET on the same footing as the two original SDKs. As of October 2026, the project's SDK page lists six SDKs at Tier 1 (TypeScript, Python, C#, Go, Rust and Ruby), Java at Tier 2, and Swift, PHP and Kotlin at Tier 3. Extensions such as Tasks and MCP Apps are not required for any tier, so a Tier 1 badge does not by itself mean an SDK implements them.

## Scale, Governance and Marketplaces

MCP's adoption is now measured in SDK traffic: the project reports that its Tier 1 SDKs see "close to half-a-billion downloads a month," led by the TypeScript and Python SDKs. Governance has also changed. The [Agentic AI Foundation](https://metavert.io/agentic-ai-foundation) now hosts MCP alongside AGENTS.md, goose, agentgateway and — since August 17, 2026 — Google's [A2A protocol](https://metavert.io/a2a-protocol), and the migration guidance for the 2026-07-28 spec was published on AAIF's blog. MCP connects agents to tools; A2A connects agents to each other; both now sit under the same neutral foundation.

MCP has also become a commercial distribution layer. [Anthropic](https://metavert.io/anthropic)'s Claude Marketplace, launched September 23, 2026, offers more than 2,000 connectors and plugins plus partner agents from companies including CrowdStrike, [Cursor](https://metavert.io/cursor), Harvey, [Lovable](https://metavert.io/lovable) and Snowflake, and is built on MCP and Agent Skills; customers can pay with committed Anthropic spend. Microsoft's Foundry "Toolboxes" likewise expose MCP alongside other tools and enterprise data through a single endpoint for agents. The broader reach brings a broader attack surface: tool descriptions and tool outputs are untrusted input, which makes [prompt injection](https://metavert.io/prompt-injection) the main security concern for MCP deployments.

## Related Topics

- [AI Agents](https://metavert.io/agentic-ai)
- [Agentic Engineering](https://metavert.io/agentic-engineering)
- [Multi-Agent Systems](https://metavert.io/multi-agent-systems)
- [The Agentic Web](https://metavert.io/agentic-web)
- [Decentralization](https://metavert.io/decentralization)
- [A2A (Agent-to-Agent Protocol)](https://metavert.io/a2a) — Google's complementary agent communication protocol
- [NANDA Protocol](https://metavert.io/nanda-protocol) — The cross-protocol discovery and trust layer built on MCP
- [Internet of Agents](https://metavert.io/internet-of-agents) — The decentralized vision MCP enables
- [Agent Harness](https://metavert.io/agent-harness) — Infrastructure managing MCP tool orchestration in production
- [Agent Discovery](https://metavert.io/agent-discovery) — Finding agents and tools across networks
- [SKILL.md](https://metavert.io/SKILL.md) — Teaching agents to use MCP capabilities well
- [markupmarkdown](https://metavert.io/markupmarkdown) — An MCP server where agents review documents alongside humans
- [Agentic AI Foundation](https://metavert.io/agentic-ai-foundation) — The Linux Foundation body that governs MCP
- [Work Agents](https://metavert.io/work-agents) — Long-running agents that MCP Apps and Tasks are built for
- [Prompt Injection](https://metavert.io/prompt-injection) — The main security risk for MCP tool use
- [Tool Use](https://metavert.io/tool-use) — The model capability MCP standardizes

## Further Reading

- [Chessmata: An Agentic Chess Platform, Built by Agents](https://meditations.metavert.io/p/chessmata-an-agentic-chess-platform)
- [I Built a CMS for the Age of Agents](https://meditations.metavert.io/p/i-built-a-cms-for-the-age-of-agents)
- [I Built an Agent That Discovers Other Agents](https://meditations.metavert.io/p/i-built-an-agent-that-discovers-other-agents)
- [Model Context Protocol specification](https://modelcontextprotocol.io)
- [The 2026-07-28 Specification — Model Context Protocol Blog](https://blog.modelcontextprotocol.io/tags/protocol/) — Release candidate and final spec announcements
- [MCP 2026-07-28: What's Changing and How to Migrate — AAIF](https://aaif.io/blog/mcp-2026-07-28-whats-changing-and-how-to-migrate) — Migration guide covering statelessness, extensions, auth and deprecations
- [A2A Joins AAIF — AAIF](https://aaif.io/blog/a2a-joins-aaif) — How MCP and A2A divide the agent stack
- [Claude Marketplace — Anthropic](https://claude.com/blog/claude-marketplace) — A marketplace of connectors and agents built on MCP
- [The 2026-07-28 Specification](https://blog.modelcontextprotocol.io/posts/2026-07-28/) — Model Context Protocol Blog, July 2026
- [SDK Tiering System](https://modelcontextprotocol.io/community/sdk-tiers) — Model Context Protocol, accessed October 2026
- [SDKs](https://modelcontextprotocol.io/docs/sdk) — Model Context Protocol, accessed October 2026