Specifications
The open specifications the map's terms rest on, each with its parts.
- Agent Skills specification
- Model Context Protocol (MCP)
- Agent Client Protocol (ACP)
- Agent Host Protocol (AHP)
- Agent2Agent protocol (A2A)
Agent Skills specification Agreed
The Agent Skills specification lets one skill work in any agent harness that adopts it, by fixing the form a skill takes (specification).
A skill is a directory holding at least a SKILL.md file. Its front matter carries a name, of up to 64 characters, and a description, of up to 1,024, and may carry license, compatibility, metadata and allowed-tools; the body holds the instructions. The directory may also hold scripts/, references/ and assets/, and any other files or directories. Skills are loaded by progressive disclosure.
The specification advises keeping file references one level deep from SKILL.md. That concerns chains of references, one file sending the reader to another, not the depth of folders, which the specification leaves open.
Anthropic, OpenAI, Google and Microsoft each build their skills on it.
Products whose cards say they conform: Antigravity, ChatGPT, Claude Code, Codex, Copilot Studio, Cursor, Gemini CLI, GitHub Copilot CLI, GitHub Copilot cloud agent, goose, Kiro, Microsoft 365 Copilot, Pi.
Progressive disclosure, in the Agent Skills specification its card
Progressive disclosure keeps a skill cheap until it is needed, so an agent can hold many skills at once. It is part of the Agent Skills specification (specification).
A skill is loaded in three levels:
- Metadata: the
nameanddescription, about 100 tokens, loaded at startup for every skill. - Instructions: the body of
SKILL.md, advised to stay under 5,000 tokens, loaded when the skill is activated. - Resources: the files the skill bundles, loaded only as they are needed.
Model Context Protocol (MCP) Agreed
The Model Context Protocol gives any LLM application one standard way to reach the context, data and tools it needs, so one integration works in every application that adopts it (MCP1).
MCP is a protocol of JSON-RPC 2.0 messages between three roles: an MCP host, the application, which creates one MCP client for each MCP server it connects to. A server offers resources, prompts and tools; a client may offer elicitation, asking the user for more information. Messages travel over its transports. Optional extensions, among them tasks and Skills over MCP, are negotiated on top (MCP1).
The current revision is 2026-07-28 (MCP7). It made MCP stateless: the initialize handshake and the protocol-level session of revisions up to 2025-11-25 are gone, and every request carries its own protocol version and capabilities (MCP8). MCP has no session in this graph's sense. The same revision deprecates four features, which still work but which new implementations should not adopt: roots, sampling, logging, and dynamic client registration, replaced by Client ID Metadata Documents (MCP8).
An agent harness uses MCP to reach its tools; the tool card rests on it. The Agent Client Protocol works beside it.
MCP sits in the Linux Foundation's Agentic AI Foundation (AAIF), to which Anthropic gave it on 9 December 2025; its maintainers keep its governance (MCP11).
Products whose cards say they conform: Antigravity, ChatGPT, Claude Code, Claude Desktop, Codex, Copilot Studio, Cursor, Delta, Devin Desktop, Gemini CLI, GitHub Copilot CLI, GitHub Copilot cloud agent, goose, Grok, Grok Build, Hermes Agent, Kimi Code, Kiro, LM Studio, Microsoft 365 Copilot, MiniMax Code, OpenAI Agents SDK, OpenClaw, OpenCode, Paperclip, Pi, Qwen Code, ZCode, Zed.
MCP host, in the Model Context Protocol its card
An MCP host keeps the conversation and the user's consent in one place, so that each server it uses sees only what it needs. It is part of the Model Context Protocol (MCP2).
MCP defines its hosts as "LLM applications that initiate connections" (MCP1). The MCP host creates and manages one MCP client for each server, controls their permissions and lifecycle, enforces security policies and consent, coordinates the model, and aggregates context across clients. The full conversation stays with it (MCP2).
This is a third sense of "host", and it is never written bare. Its role is closest to an agent harness, which holds the tools and the context and talks to the model. It is not an agent host, which runs harnesses and owns their sessions for clients to display, although one program can be both. MCP's hosts also include LLM applications that are not agentic, such as chat interfaces.
MCP client, in the Model Context Protocol its card
An MCP client keeps each server apart from the others, so that one server can never see into another. It is part of the Model Context Protocol (MCP2).
MCP calls its clients "connectors within the host application" (MCP1). The MCP host creates one MCP client for each MCP server, and each talks to exactly that one server. It attaches the protocol version and its capabilities to every request, routes messages both ways, manages subscriptions and notifications, and keeps the security boundary between servers (MCP2). It may offer the server elicitation, asking the user for more information (MCP1).
An MCP client is not a client in this graph's sense: it is plumbing inside an application, not a window onto a session. Most agents that speak the Agent Client Protocol are MCP clients as well (ACP5).
MCP server, in the Model Context Protocol its card
An MCP server packages one focused capability, such as a database or an external service, so that any application speaking MCP can use it. It is part of the Model Context Protocol (MCP2).
MCP defines servers as "services that provide context and capabilities" (MCP1), local processes or remote services. Each offers any of three features to an MCP client:
- Resources: context and data, such as files or database schemas, each named by a URI, for the application to include as it chooses (MCP9).
- Prompts: templated messages the user selects, often as slash commands (MCP10).
- Tools: functions the model can call.
A server should be easy to build and to combine with others. It never reads the whole conversation or sees into another server; where it needs input from the user, it asks for it in its reply, by elicitation (MCP2, MCP8). Sampling, by which a server asked for the model's help, is deprecated in the 2026-07-28 revision (MCP8).
Tools, in the Model Context Protocol its card
MCP's tools let a model act on systems outside itself, such as querying a database or calling an API, through any MCP server that offers them. They are part of the Model Context Protocol (MCP3).
A tool is named by a unique name and described by a description, an inputSchema in JSON Schema, and optionally a title, an outputSchema and annotations. A client discovers tools with tools/list and calls one with tools/call; the result carries text, images, audio, resource links, embedded resources or structured content (MCP3).
Tools are model-controlled: the model chooses them from its context and the user's prompts. In this graph's terms, the agent harness makes the call, through its MCP client, and the MCP server runs the tool and returns the result (MCP3). The specification says there should always be a human able to deny a call, and treats a tool's annotations as untrusted unless its server is trusted (MCP3).
The tool card rests on this part.
Transports, in the Model Context Protocol its card
MCP's transports let the same messages reach a server on the same machine or across the internet, with the same meaning on every one. They are part of the Model Context Protocol (MCP4).
A transport says only how messages are framed and delivered, how request metadata travels, and how a request is cancelled. MCP defines two:
- stdio: the MCP client launches the MCP server as a subprocess and they exchange newline-delimited JSON-RPC over its standard input and output (MCP5).
- Streamable HTTP: the server runs as an independent process with a single endpoint; each message is an HTTP POST, answered with one JSON object or a stream of Server-Sent Events for that request (MCP6).
Clients and servers may add custom transports that keep the same messages. Streamable HTTP replaced the HTTP+SSE transport of 2024-11-05 in revision 2025-03-26, which deprecated it; revision 2026-07-28 marks it Deprecated under MCP's feature lifecycle, and removes Streamable HTTP's session id (MCP6, MCP8).
Agent Client Protocol (ACP) Agreed
The Agent Client Protocol lets any code editor drive any coding agent, so that an agent works in every editor that adopts it and each side can develop on its own (ACP1).
ACP is a protocol of JSON-RPC 2.0 messages between an ACP client, usually an editor, and an ACP agent. The client initialises the connection, opens an ACP session and sends prompts; the agent streams back updates, reports tool calls and asks permission before acting (ACP2). It reuses the Model Context Protocol's JSON representations where it can, and the client hands the agent the user's MCP servers (ACP5).
Its one transport is stdio: the client launches the agent as a subprocess and they exchange newline-delimited JSON-RPC. A remote transport over Streamable HTTP is still being specified (ACP4).
The stable protocol is version 1. Its release of 18 November 2026 carried schema v1.33.0, the draft version 2's schema v2.0.0-alpha.17 and the Rust crate v1.19.0 (ACP8); ACP releases several times a week, so a card cites a release by its date. Version 2 has been in draft since 20 July 2026 (ACP7). Zed Industries and JetBrains govern it jointly, under an interim model, while working towards an independent foundation (ACP6), and Zed is one of its clients (agents).
It is not the Agent Communication Protocol, IBM's BeeAI project, also called ACP, which merged into Agent2Agent in 2025 (ACP5).
Products whose cards say they conform: Antigravity, Cursor, Devin Desktop, Gas City, Gemini CLI, goose, Grok Build, Hermes Agent, Kimi Code, Kiro, MiniMax Code, OpenClaw, OpenCode, Paperclip, Qwen Code, Zed.
ACP client, in the Agent Client Protocol its card
An ACP client lets you drive a coding agent from the tool you already work in, usually your editor. It is part of the Agent Client Protocol (ACP2).
ACP says clients "provide the interface between users and agents": typically code editors, though other interfaces qualify. A client launches the ACP agent, sends prompts, shows the updates and tool calls it streams back, and answers its requests for permission. It may also lend the agent its files and terminals, and passes it the user's MCP servers (ACP2, ACP10). An agent can itself be an ACP client, running other coding agents as subagents (ACP5).
It is narrower than a client in this graph's sense: it reaches an agent only through ACP. It also does more than a window does, since it starts the agent and serves its files and terminals. Zed is one (agents).
ACP agent, in the Agent Client Protocol its card
An ACP agent lets one coding agent work in every editor that speaks ACP, without an integration for each. It is part of the Agent Client Protocol (ACP1).
ACP defines agents as "programs that use generative AI to autonomously modify code", which usually run as subprocesses of the ACP client. An agent negotiates the protocol version, creates and keeps ACP sessions, runs each prompt and streams its progress back, and asks the client's permission before a tool call (ACP2). Most ACP agents are also MCP clients (ACP5).
An ACP agent is an agent narrowed to coding. It is usually not an agent host: the client launches it as a subprocess and ends it (ACP4), so its sessions do not live independently of their client. Examples include Claude Agent, through Zed's adapter, Codex CLI, through ACP's adapter, and Gemini CLI (ACP9).
Session, in the Agent Client Protocol its card
An ACP session keeps one conversation with an agent together, so that one agent can run several at once and a client can come back to any of them. It is part of the Agent Client Protocol (ACP3).
ACP calls a session "a specific conversation or thread" between client and agent, with its own context, conversation history and state. The client opens one with session/new, giving an absolute working directory and the MCP servers to connect to, and the ACP agent answers with a unique session id. Where the agent supports them, the client can load a session, replaying its history; resume it without replay; list, close or delete sessions (listing, deleting). Loading lets a session persist across restarts and be shared between client instances (ACP3).
It closely matches a session in this graph's sense, but where ACP says "thread", this graph means a part of a session, never another word for one.
Agent Host Protocol (AHP) Agreed
The Agent Host Protocol lets several clients share the same agent sessions, each seeing the same live state, whatever agent runs behind them (what is AHP).
It defines how an agent host, which it calls a portable, standalone sessions server, talks to its clients. The agent host holds the authoritative state of each session and its chats; clients subscribe to it through channels and change it only by actions the agent host puts in order. Messages are JSON-RPC 2.0 over any reliable, ordered, two-way transport, most often WebSocket, and versions are negotiated when a client connects (overview, transport).
AHP fixes how state is shared, not how an agent works. Below the agent host an agent is reached through its own interface, such as the Agent Client Protocol: AHP calls itself the coordination layer and ACP the communication layer (AHP and ACP). Agents talking to each other are outside it.
Microsoft publishes it. Specification 1.1.0, released on 13 November 2026, is the latest, and 1.2.0 is in draft (release, versioning); its Root, Session, Chat, Terminal, Telemetry and Resource watch channels are Stable, the others not yet (versioning). VS Code's agent host is the reference server (implementations).
Agent host, in the Agent Host Protocol its card
The agent host lets sessions live apart from the windows that show them: it owns them, so clients can come and go. It is the server's role in the Agent Host Protocol, and the source of the agent host term.
AHP describes it as a portable, standalone sessions server (what is AHP); its pages call it the server, the host and the agent host alike. It owns the authoritative state of every channel that has one, puts every change in order and echoes it to each subscribed client, and where clients conflict it sequences the outcome (doctrine). It manages sessions, which clients subscribe to by URI, and delegates the agent work to the agents behind it (AHP and ACP); its root channel lists the agents it offers (channels and subscriptions).
It wraps an agent harness: its job is "to normalize whatever the harness exposes into AHP state" (MCP servers). Towards its agents it may speak another protocol, such as the Agent Client Protocol, translating between the two (AHP and ACP).
Client, in the Agent Host Protocol its card
An AHP client lets a person see and drive sessions an agent host owns, from several places at once. It is a role in the Agent Host Protocol, in the client term's sense.
A client connects to an agent host, agrees a protocol version, and subscribes to the channels it wants to follow, receiving a snapshot of each and then every change in order. It sends commands and dispatches actions, applying its own at once and reconciling when the agent host echoes them back among other clients' (what is AHP). After a dropped connection it reconnects and replays what it missed.
Any number of clients may share one session. Any of them may cancel a running turn, and any may approve a pending tool call, where the first approval wins and later ones are rejected (AHP and ACP).
AHP names IDEs, web apps and CLIs as clients (what is AHP); VS Code, AHPX and ahpc are among them, with official client libraries in Rust, TypeScript, Kotlin, Swift and Go (implementations).
Session and chat, in the Agent Host Protocol its card
AHP's sessions and chats let clients follow and share a piece of agent work, or just one conversation within it. They are part of the Agent Host Protocol.
A session is the coordination scope for one or more chats. Its state holds its lifecycle, title and status, the agent that backs it, its working directory, customizations, changesets, active clients and the catalogue of its chats (session channel). A client chooses the session's id when it asks the agent host to create it, and the agent host then starts the agent.
A chat carries one conversation: its turns, streamed responses, tool calls, pending messages and requests for input. Every chat belongs to a session and records how it began: made by the user; forked from another chat at a completed turn; opened as a side chat, a conversation of its own using another chat's context; or spawned by a tool call in another chat, as when work is delegated to a subagent (chat channel). Only one turn runs at a time in each chat (AHP and ACP).
AHP's session is close to the session term, but its chats are not all that card's threads. Only a chat spawned by a tool call is one: a subagent's thread. A chat the user makes, a fork or a side chat is a conversation of its own, nearer an ACP session than a thread.
Channels and subscriptions, in the Agent Host Protocol its card
Channels keep every client of an agent host in step, so each sees the same state and can recover it after a break. They are the core of the Agent Host Protocol (what is AHP).
AHP defines a channel as "a sequence of messages that is identified by a URI", and every channel has a state, empty for some, as the telemetry channel's, ahp-otlp:, always is. Among them are the root, ahp-root://, and each session, chat, terminal and changeset (channels and subscriptions). A client subscribes to a channel and receives a snapshot of its state, which the agent host may omit where the state is empty, then the actions that change it, numbered in order by the agent host, and notifications for events the state does not keep. Every request and notification names its channel, so it can be routed by method and channel alone. The root channel's state holds the agent host's agents, terminals and configuration; sessions are listed by a request, listSessions (channels and subscriptions).
An AHP channel carries the state of one resource to its subscribers. It is not a channel in this graph's sense, something outside a session pushing events into it while it runs; that card names AHP's as a sense of its own.
Agent2Agent protocol (A2A) Agreed
The Agent2Agent protocol lets independent agents, built by different vendors on different frameworks, find each other and work together without access to each other's internal state, memory or tools (specification).
An A2A client sends requests to an A2A server, the remote agent, which it finds through its Agent Card. The specification has three layers. Its data model holds tasks; messages, each one turn from the user or the agent; artifacts, the outputs of a task; and parts, the text, file or structured data inside messages and artifacts. Its operations send messages and get, list and cancel tasks. Its bindings, JSON-RPC 2.0, gRPC and HTTP+JSON/REST, carry them with the same behaviour, and custom bindings are allowed. Updates arrive by polling, by streaming or by push notifications to a webhook. The Protocol Buffers file a2a.proto is normative.
A2A covers agents working with agents; MCP covers an agent using tools and data, and the two are complementary. Version 1.0 was released on 12 March 2026 and patch 1.0.1 on 28 May 2026, still the latest on 19 November 2026 (release); patches do not affect compatibility (specification).
A2A's joining the Linux Foundation's Agentic AI Foundation (AAIF), as a Growth Stage project beside MCP, was announced on 27 August 2026 (A2A blog).
Products whose cards say they conform: Copilot Studio, Gemini CLI, Hermes Agent.
Client, in the Agent2Agent protocol its card
An A2A client lets an agent, or an application, hand work to another agent on a user's behalf. It is a role in the Agent2Agent protocol.
The specification defines it as "an application or agent that initiates requests to an A2A Server on behalf of a user or another system" (specification); its key concepts call it the client agent (key concepts). It reads a remote agent's Agent Card, uses the first interface on it that it supports, sends messages, and follows the tasks that come back.
It is not the client term's sense. An A2A client starts work with another agent, and is often an agent itself; our client is a window onto a session an agent host owns. The two are related, not the same.
Remote agent, in the Agent2Agent protocol its card
The remote agent lets work be handed to an agent elsewhere that keeps its own workings to itself. It is the server's role in the Agent2Agent protocol.
The specification defines the A2A server (remote agent) as "an agent or agentic system that exposes an A2A-compliant endpoint, processing tasks and providing responses" (specification). It must publish an Agent Card, and it runs the tasks its clients ask for. To a client it is opaque, a black box whose memory and tools stay hidden (key concepts); it may itself use MCP to reach its tools.
A remote agent is an agent in its own right, or an agentic system of several, and not a subagent: it is independent of its client and opaque to it, where a subagent acts within its controlling agent's boundaries. The remote agent term rests on this card and means exactly what it means.
Agent Card, in the Agent2Agent protocol its card
The Agent Card lets a client find an agent and know, before calling it, what it can do and how to reach it. It is part of the Agent2Agent protocol.
It is a JSON document that every remote agent must publish, describing its identity, capabilities, skills, service endpoint and authentication requirements (specification). A client finds it at the well-known address https://{server_domain}/.well-known/agent-card.json, in a registry or catalogue, or by direct configuration. It lists the agent's interfaces, each a binding and URL, in order of preference, and the client uses the first it supports. A card may be signed, and an agent may offer a fuller extended card to clients once they have authenticated.
The card's skills are capabilities the agent declares, each with an id, name, description and tags. They are not skills in the Agent Skills sense, which extend an agent harness with knowledge and procedures; the two are related only by name.
Task, in the Agent2Agent protocol its card
A2A's task lets a client follow work it has handed to a remote agent, however long it takes, through to its result. It is part of the Agent2Agent protocol.
A task is "the fundamental unit of work managed by A2A, identified by a unique ID" (specification). A remote agent answers a message with a message when it can reply at once, or with a task for longer work. A task moves through states: submitted and working; interrupted while it needs input or authentication; and finally completed, failed, cancelled or rejected. A finished task never restarts: a follow-up starts a new task in the same context (life of a task). Its outputs are artifacts. A context, contextId, groups related tasks and messages, which the specification says should be treated as one conversational session.
This graph uses "task" only as a vendor's or a specification's own word, never as a term, because vendors use it for a session, for delegated work and for scheduled work. A2A's task is delegated work, as the remote agent holds it. Its context comes nearest to a session, though what the remote agent keeps across a context is up to it.