Model Context Protocol (MCP) is a client-server protocol that standardizes how AI agents discover and invoke external tools across heterogeneous execution environments. An MCP server exposes tool metadata — names, input schemas, and descriptions — that an agent can query across multiple connected servers; when the agent selects a tool, it issues a structured request, and the server executes it and returns the result in serialized form.
Usage
From Determinism to Delegation: AI-Native Software Engineering and the Evolution of the Agentic Engineer describes the protocol’s origin and role structure. Connecting heterogeneous models to proprietary tools had historically required bespoke connectors, and that paper describes MCP as replacing N times M custom integrations with a single client-server contract. It names three roles: an MCP Host managing consent and policy, an MCP Client connecting to individual servers, and an MCP Server exposing read-only Resources, executable Tools validated by JSON Schema and gated by human approval, and reusable Prompts. That paper’s reading of why standardized tool protocols matter is structural: they are what allow agents to discover and act upon the deterministic APIs that classical software engineering provides — what it calls the technical seam of the symbiosis between the two disciplines.
A practitioner’s account on GitHub’s blog, Building your first MCP server: How to extend AI tools with custom capabilities,
describes the same structure from the side of someone configuring and building servers. The host
is the AI tool in use — its example is GitHub Copilot in VS Code — and it
creates one client per server it connects to; registering a server with the host (in VS Code, a
.vscode/mcp.json entry naming the command that starts it) is what makes the server’s capabilities
available to the agent. The post presents tools (actions the AI can take, each with a description
and input schema), resources (context the AI can read, often under a URI-based identifier) and
prompts (predefined guidance a server ships, surfaced in VS Code as slash commands) as the three
core server building blocks, and notes that the specification has since added further capabilities
including sampling and elicitation. Its practical advice is to look for an existing server before
building one, such as the GitHub MCP Server, and to vet third-party servers
as supply-chain dependencies — whether the publisher is recognizable and the code open to review.
Google’s Developer’s Guide to AI Agent Protocols frames the same contract from the side of maintenance cost. Without MCP, it says, a developer writes and maintains a custom tool for each endpoint of each service an agent uses; with it, servers advertise their tools and the agent discovers them automatically, through a single standard connection pattern. It adds that because MCP servers are maintained by the teams who built the underlying systems, the agent gets current tool definitions without the developer writing or updating integration code. In that guide’s worked example an Agent Development Kit (ADK) agent reads a PostgreSQL database, looks up recipes and emails suppliers through three MCP servers, and the guide’s closing advice is that most agents start with MCP for data access and add other protocols as requirements grow. That is Google’s recommendation, made in a tutorial for its own framework.
The MCP standardizes tool interfaces but does not specify how much metadata and output must be exposed to the model. A study of MCP execution models, From Tool Orchestration to Code Execution: A Study of MCP Design Choices, calls the traditional arrangement a context-coupled execution model: existing implementations serialize tool metadata, full schemas and tool outputs directly into the agent’s reasoning context, where they compete for space with user input and intermediate reasoning. That paper argues that as the number of connected servers and available tools grows, this material consumes an increasing share of the context window, leaving less capacity for reasoning and degrading performance on wide-context analytical tasks — so that context-coupled execution does not scale with the size of the tool ecosystem.
The same paper sets out Code Execution MCP as an alternative, context-decoupled execution model that addresses this limitation by decoupling tool orchestration from the agent’s context window.
A Chinese-language post by Phodal Huang,
2026 年，万物皆 Coding Agent 的平台工程（A2A / ACP / MCP / Skill）, states that MCP was released
by Anthropic in November 2024 and is hosted by the Linux Foundation. It presents MCP as unifying the
tool-calling interfaces of different AI clients — its examples are Claude’s tool_use and OpenAI’s
function_calling — around three things a server provides: tools (callable functions), resources
(readable data sources such as file systems, databases and API responses) and prompts (reusable prompt
templates), so that one MCP server can be used by every agent that supports the protocol. The post
places MCP in a three-layer protocol stack, likening it to a USB port through which an agent plugs in
new capabilities, alongside the Agent Client Protocol (ACP) for managing a coding agent’s
process lifecycle and Agent2Agent Protocol (A2A) for discovery and collaboration across
platforms. From an orchestration point of view, it adds, collaboration operations — creating a
sub-agent, delegating a task, messaging another agent, reporting to a parent — can themselves be
exposed as MCP tools that any MCP-capable agent can call.
A survey of agent communication protocols, A survey of agent interoperability protocols: Model Context Protocol (MCP), Agent Communication Protocol (ACP), Agent-to-Agent Protocol (A2A), and Agent Network Protocol (ANP), describes MCP as providing a JSON-RPC client-server interface for secure tool invocation and typed data exchange, and places it alongside three other emerging protocols: Agent Communication Protocol (ACP), Agent2Agent Protocol (A2A) and Agent Network Protocol (ANP). In the phased adoption roadmap that survey proposes, MCP comes first, for tool access, before the other three are adopted for messaging, collaborative task execution and decentralized agent marketplaces.
Related Terms
- Code Execution MCP — an alternative execution model for MCP that generates a single executable program instead of iteratively invoking tools through the context window
- From Tool Orchestration to Code Execution: A Study of MCP Design Choices — an empirical comparison of traditional MCP against Code Execution MCP on efficiency, task quality, and security
- From Determinism to Delegation: AI-Native Software Engineering and the Evolution of the Agentic Engineer — source of the Host/Client/Server role structure and the N-times-M framing above
- Building your first MCP server: How to extend AI tools with custom capabilities — an introductory walkthrough of building an MCP server and registering it with GitHub Copilot in VS Code
- Agent2Agent Protocol (A2A) — the agent-to-agent counterpart that Google’s protocol guide places alongside MCP
- Agent Client Protocol (ACP) — the protocol for managing coding agents’ process lifecycles that one practitioner places beside MCP and A2A in a three-layer stack
- A survey of agent interoperability protocols: Model Context Protocol (MCP), Agent Communication Protocol (ACP), Agent-to-Agent Protocol (A2A), and Agent Network Protocol (ANP) — a survey comparing MCP with ACP, A2A and ANP and proposing a phased adoption roadmap