Protocol
Model Context Protocol
Model Context Protocol (MCP) is an open standard for connecting AI agents to external data and tools. Anthropic shipped MCP in November 2024 and donated it to the Linux Foundation's Agentic AI Foundation in December 2025. The wire is JSON-RPC 2.0; the structural model is the Language Server Protocol (LSP) applied to AI clients and capability servers.
What MCP is
MCP standardizes how agent clients (Claude Code, Claude Desktop, Cursor, Windsurf, ChatGPT, Continue, Cline, Zed) discover and invoke functionality from external servers. A client speaks MCP. A server exposes capabilities. The two negotiate features during an initialize handshake, then exchange JSON-RPC requests, responses, and notifications over a chosen transport.
The structural analog is LSP. LSP standardized how code editors (the clients) talked to language analyzers (the servers). MCP applies the same shape to AI agents and the data, tools, and prompt templates they need.
One protocol instead of every pairwise integration
Before MCP, every model vendor needed custom integration code for every external tool. OpenAI's 2023 function-calling API and ChatGPT plugins were vendor-specific takes on the same problem, each requiring tool builders to target one schema. With every model and every tool implementing each other's interfaces directly, the work scales as the product of the two ecosystems.
MCP defines a universal middle contract. Every client speaks one protocol; every tool exposes one server. The wiring becomes M + N. The protocol provides the standard; the ecosystem still has to ship and maintain the servers.
The three server primitives
Servers advertise three primitives during the initialize handshake. Clients read these lists and decide what to surface to the model.
Resources
Read-only data the model can reference. Exposed via URIs with content types: file contents, database schemas, API responses streamed into context.
Tools
Invocable verbs with side effects. Servers publish JSON Schema definitions; clients format requests against the schema; servers execute and return structured results.
Prompts
Parameterized message templates. Servers ship predefined prompt structures the client offers to the user, shaping how the model approaches a task or dataset.
The three client capabilities
Clients can also advertise capabilities that invert the usual flow. Servers query the client. The flow runs in both directions.
Roots
Clients expose filesystem boundaries. By declaring roots, the client tells the server which URIs it may operate against (e.g. file:///home/user/project).
Sampling
Servers can request the client's underlying LLM to perform a completion. The host model processes data on the server's behalf and returns the result.
Elicitation
Servers can request the client to prompt the user for additional required information mid-task, rather than failing on missing inputs.
Transport
JSON-RPC 2.0 is transport-independent. MCP picks the transport per deployment. For local execution, the client spawns the server as a child process and exchanges JSON over standard input/output (stdio). For remote or stateless execution, MCP uses Server-Sent Events (SSE) for server-to-client streaming and HTTP POST for client-to-server requests.
The protocol itself provides no authentication or sandboxing. Local stdio servers run with the host user's permissions; remote servers rely on HTTP-layer auth (typically OAuth 2.1) and any gateway policy the deployment enforces.
Governance and adoption
Anthropic launched MCP in November 2024 as a single-vendor open standard. In December 2025 Anthropic donated the protocol to the Linux Foundation, forming the Agentic AI Foundation (LF AAIF). The transition mirrors the pattern Kubernetes and OpenTelemetry followed: move the specification to a neutral steward so no single vendor dictates direction.
The AAIF launched with 8 platinum members backing the foundation, including Anthropic, OpenAI, Google DeepMind, Block, AWS, Bloomberg, Cloudflare, and Microsoft. OpenAI integrated MCP into ChatGPT apps by late 2025. The AAIF's scope extends beyond MCP itself: Block donated the Goose agent framework and OpenAI donated AGENTS.md (a repository-level agent instructions standard) at the same launch.
Where MCPowered fits
The LF AAIF runs the canonical registry at registry.modelcontextprotocol.io.
Smithery, Glama, and mcp.so each operate independent catalogs. MCPowered federates
these sources and layers per-server trust scoring (static source review, sandboxed
runtime behavior, supply-chain provenance, incident history) plus a verified
publisher tier and universal install-config generation across agent clients.