Protocols

Agents do not exist in isolation. They need to talk to models, tools, and other agents. The protocols that mediate these conversations are the connective tissue of the ecosystem.

Model Context Protocol

MCP standardizes how agents discover and invoke tools. A tool is a function with a schema: name, description, parameters, return type. The MCP server advertises its tools; the MCP client queries the advertisement and invokes what it needs.

The power of MCP is decoupling. The agent author does not need to know about every tool the agent might use. The tool author does not need to know about every agent that might call it. Both agree on the protocol.

Tool Schema

Every MCP tool exposes a JSON Schema describing its interface. This schema serves two purposes: it tells the LLM how to call the tool, and it validates the arguments at runtime.

{
  "name": "read_file",
  "description": "Read the contents of a file",
  "parameters": {
    "type": "object",
    "properties": {
      "path": { "type": "string" }
    },
    "required": ["path"]
  }
}

Agent Client Protocol

ACP standardizes how clients interact with agents. Where MCP is about tools, ACP is about agents as services. An ACP agent exposes a session-based interface: start a session, send messages, receive responses, end the session.

The ACP session model maps cleanly to the reasoning loop. Each message from the client triggers an iteration of the loop. The response contains the agent’s current state: what it is thinking, what it is doing, and what it needs from the user.

Session Lifecycle

1. Init: Client creates a session, optionally providing initial context
2. Turn: Client sends a message; agent processes and responds
3. Stream: For long-running operations, the agent streams intermediate states
4. End: Client or agent terminates the session, optionally with a summary

Choosing Between Protocols

Use MCP when:

• You are building a tool ecosystem (servers that expose capabilities)
• You want decoupled tool/authorship from agent authorship
• Your tools need to be discoverable and composable

Use ACP when:

• You are building an agent service that clients interact with
• You need session management and stateful conversation
• You want a standardized wire format for agent-to-agent communication

In practice, most production systems use both: MCP for the tool layer, ACP for the agent layer.