agent-readings / Tool Use and Interoperability
A driver model for agent tools and context
The one sentence
Agent infrastructure needs an interface contract. MCP gives hosts, clients, and servers a shared JSON-RPC vocabulary for discovery, invocation, context access, user prompts, and permission-sensitive client features.
Before this paper
LLM applications often used bespoke tool schemas, plugin manifests, local subprocess wrappers, or host-specific integration APIs.
A tool or data connector written for one host did not reliably compose with another host.
Tool calling, context injection, user prompts, and local filesystem scoping were mixed into application-specific conventions.
The protocol asks how AI applications can discover and use external context and capabilities through a common client-server contract without prescribing the application shell or agent algorithm.
Core idea
Split an AI integration into a host, one client connection per server, and server/client capabilities negotiated at initialization; use JSON-RPC methods for listing, retrieving, invoking, and notifying changes.
A host application starts or connects to an MCP server through stdio, Streamable HTTP, or another compliant transport.
The host instantiates an MCP client for that server and negotiates capabilities during initialization.
The client discovers server-provided resources, prompts, and tools with list methods and pagination where supported.
The host chooses how to display or insert resources and prompts into the model context.
Action grammar
Initialize: client and server negotiate protocol version and supported capabilities.
List resources/prompts/tools: the client asks a server what context, prompt templates, or functions it exposes.
Read resource: the client requests URI-addressed context from a server.
Get prompt: the client retrieves a parameterized prompt template for explicit user use.
Executable shape
Evidence
The spec says MCP uses JSON-RPC 2.0, stateful connections, and server/client capability negotiation between hosts, clients, and servers. The architecture docs describe an MCP...
Resources expose URI-addressed context and optional templates; prompts expose parameterized messages for explicit user invocation; tools expose named functions with input schemas...
Roots expose filesystem scopes; sampling lets servers request completions through clients; elicitation lets servers request structured user input with JSON schemas. The top-level...
The transport spec defines UTF-8 JSON-RPC over stdio and Streamable HTTP, requires the Streamable HTTP endpoint to support POST and GET, adds session and protocol-version header...
Claim map
MCP defines a host/client/server architecture using JSON-RPC 2.0, stateful connections, and capability negotiation for AI application integrations.
The server-side interface is organized around resources, prompts, and tools, with different intended controllers: application, user, and model.
The client-side interface adds roots, sampling, and elicitation so servers can request filesystem scope, model generations, and structured user input through...
MCP currently standardizes stdio and Streamable HTTP transports for JSON-RPC messages, while allowing custom transports that preserve lifecycle requirements.
Agent infrastructure
MCP is the agent-tool driver model: the goal is to make connectors reusable across hosts instead of embedding each tool into one application.
Server primitives should be stored separately in review data: resources are context, prompts are reusable workflows, and tools are side-effecting...
Client primitives matter because they move sensitive actions back through the host: roots, sampling, and elicitation all require host/user policy...
The protocol boundary is not the security boundary. Serious agent runtimes still need sandboxing, capability grants, audit logs, and consent UX.
Caveats
This is a specification and documentation corpus, not an empirical paper with benchmark results.
MCP changes over time; this review is anchored to the 2025-06-18 protocol revision while the README entry is dated by the 2024 launch.
The spec standardizes protocol shape, not context-ranking algorithms, model routing, tool planning, or workflow execution semantics.
Security outcomes depend on host and client implementation. The spec explicitly notes that MCP itself cannot enforce the security principles.
Run it
No PoC yet - contributions welcome. A useful local PoC would run a tiny stdio MCP server with one resource and one tool, then show the JSON-RPC initialize, tools/list, resources/list, and tools/call exchange.