Coding agent protocols · ACP vs MCP: what each AI protocol does
ACP vs MCP: which protocol does your AI coding workflow need?
ACP connects a coding agent to an editor interface. MCP connects an AI application to tools, data and workflows. Many coding setups use both.
ACP manages the interactive session between a coding agent and its editor. It carries prompts, progress updates, permission requests, file operations, terminal activity and review-friendly changes.[1][2] MCP connects an AI application to external tools and data. An MCP server can expose a database, calendar, search service or specialized workflow to an agent.[3] The protocols solve different integration problems. A coding agent can speak ACP to Zed or a JetBrains IDE while using MCP servers for the tools it needs.
- ACP connects
- Agent ↔ editor or IDE
- MCP connects
- AI application ↔ tools and data
- ACP transport
- JSON-RPC over stdio, with remote support developing
- Can they work together?
- Yes, an ACP session can provide MCP servers
The short answer
Use ACP when you want a coding agent such as Codex, Claude Agent or Gemini CLI to run inside a compatible editor interface. Use MCP when the agent needs a standard connection to external tools or data. Use both when an editor hosts the coding session and the agent also needs MCP servers.
ACP and MCP are complementary. ACP manages the conversation and coding experience, while MCP supplies capabilities behind the agent.[4]
What ACP controls
ACP's introduction [1] describes a standard between code editors or IDEs and coding agents. Local agents usually run as editor subprocesses and exchange JSON-RPC messages over standard input and output. Remote support over HTTP or WebSocket remains a work in progress.
A typical ACP turn begins when the client initializes the agent and creates or loads a session. The client sends a prompt and the agent streams session updates. The agent can ask the client to approve an action and, if the client advertised those capabilities, to read or write files or run terminal commands.[2]
ACP also represents coding-specific interface needs such as diffs and reviewable edits. That lets an agent keep its own runtime, authentication and model configuration while the editor supplies navigation, terminals and the visual review surface.[5]
What MCP controls
The MCP introduction [3] defines MCP as a standard for connecting AI applications to external systems. Servers expose data sources, tools and reusable workflows, while an MCP client inside the AI application connects to those servers.
MCP does not define the whole coding-agent interface. It can give an agent access to GitHub, a database or a browser tool, but it does not by itself define how an IDE displays the agent's session, requests approval or presents a multi-file diff.
MCP access can be powerful. A server may expose private records or actions that change production systems, so treat every server as a security boundary with explicit credentials and narrow permissions.
How ACP and MCP work together
An editor can launch an agent through ACP and pass configured MCP servers into that session. Zed documents that its MCP servers may be forwarded to external agents, and JetBrains exposes settings for passing custom or integrated MCP servers to installed ACP agents.[5][6]
The resulting path has three distinct parts: the editor is the ACP client, the coding agent is the ACP agent and MCP client, and each external integration is an MCP server. Keeping those roles separate makes authentication and troubleshooting easier.
ACP reuses some MCP data representations, but shared message shapes do not make the protocols interchangeable. Each protocol retains its own lifecycle and purpose.[1][4]
Choose the right protocol
- Choose ACP to put one coding agent behind several compatible editor interfaces without building an integration for every pair.
- Choose MCP to give one or more AI clients a standard route to tools, resources or prompts.
- Choose both when a coding agent runs inside an editor and needs external services.
- Choose neither for a small fixed integration where a direct library or API is simpler and does not need protocol-level portability.
- Check the current client and agent compatibility lists before committing because supported capabilities can differ by implementation.
Security boundaries to check
- Confirm which process stores the model or subscription credential. Zed says external agents usually own their authentication and billing.[5]
- Review which MCP servers the editor forwards and which servers the agent also loads from its own configuration. Duplicate or unexpected servers can broaden access.
- Require approval for consequential file, terminal and external-tool operations, then verify how the client represents a denied or cancelled request.
- Test a malicious repository instruction and a hostile MCP response before using the setup on private code.
- Inspect logs from both layers. ACP logs explain editor-agent messages, while MCP logs explain tool discovery and invocation.
A practical setup check
- List the editor, agent, model provider and every external system in the proposed workflow.
- Mark the ACP connection between editor and agent, then mark each MCP connection between the agent and a tool server.
- Record who owns authentication, permissions, logs and data retention at every boundary.
- Start with a read-only repository and one non-sensitive MCP server.
- Run one file edit, one terminal command, one denied permission and one cancelled task.
- Add broader tools only after the client shows clear approvals and the logs identify every action.
Limitations and trade-offs
ACP remote-agent support is still developing, and clients may implement different optional capabilities. Verify session loading, authentication, terminals, file operations and permission handling in the exact editor-agent pair you plan to use.[1][2]
Protocol portability does not make agents behave identically. Each agent keeps its model choices, instructions, tools and billing rules, while each editor decides how to present and constrain the session.[5]
MCP reduces custom integration work, but every added server increases the set of credentials, data and actions available to an agent. A direct API can remain the safer choice for a narrow fixed workflow.
Frequently asked questions
- Is ACP a replacement for MCP? No. ACP connects an agent to a client interface, while MCP connects an AI application to external systems.
- Can an ACP agent use MCP servers? Yes. ACP session setup can include MCP server configuration, and current editors document forwarding MCP servers to external agents.[4][5][6]
- Is ACP only for Zed? No. Zed created ACP, and JetBrains IDEs support installing ACP-compatible agents.[6]
- Does ACP choose the model? Usually no. External agents generally retain their own model, authentication and billing configuration.[5]
- Which should I learn first? Learn MCP first if your main task is tool or data integration. Learn ACP first if you are building a coding agent or editor integration.