How is ACP different from MCP?

MCP (Model Context Protocol) standardizes how an LLM/agent calls tools and data sources. ACP (Agent Client Protocol) standardizes how a host application coordinates multiple agents. MCP is agent-to-tool; ACP is client-to-agent. They're complementary — an ACP-hosted agent can use MCP servers internally.

Which tools support ACP as of July 2026?

Devin Desktop is the launch client (June 2, 2026). Other IDEs, terminals, and orchestration platforms are expected to add support through the second half of 2026. Cognition has open-sourced the spec, though it's not yet under a neutral foundation the way MCP is under the Linux Foundation.

Should I build agents with ACP or MCP first?

Build with MCP first if you're exposing tools or data to LLM agents — MCP is more mature (2025), more widely supported (Anthropic, OpenAI, Google, Microsoft), and the enterprise standard. Add ACP if you're building an agent that needs to be hostable inside Devin Desktop or similar orchestration UIs.

Quick Answer

What is Agent Client Protocol (ACP)? July 2026 Guide

Q: What is Agent Client Protocol (ACP)?

Agent Client Protocol (ACP) is Cognition's open protocol shipped with the Devin Desktop rebrand on June 2, 2026. It lets a client application (like Devin Desktop's Agent Command Center) host and coordinate third-party coding agents — Claude Code, Codex, or custom agents — from one UI. Think of it as USB-C for agents, layered on top of MCP's USB-C for tools.

Published: July 1, 2026

What is Agent Client Protocol (ACP)? July 2026 Guide

Agent Client Protocol (ACP) is Cognition’s June 2, 2026 open protocol for hosting agents inside a client application. It shipped with the Devin Desktop rebrand and lets one UI — like Devin Desktop’s Agent Command Center — coordinate multiple third-party agents (Claude Code, Codex, custom) alongside Cognition’s own Devin agents. Here’s the July 2026 primer.

Last verified: July 1, 2026

The one-sentence definition

MCP is how agents talk to tools. ACP is how host applications talk to agents.

The two protocols solve related but different problems:

Protocol	What it standardizes	Analogy
MCP (Model Context Protocol)	LLM/agent → tools + data sources	USB-C for tools
ACP (Agent Client Protocol)	Host application → multiple agents	USB-C for agents

An ACP-hosted agent can (and usually will) use MCP servers internally. They’re complementary layers of the same stack.

Why ACP exists

Through 2025 and early 2026, the AI coding world converged on two facts:

Users want to run multiple agents simultaneously — one for the current file, one for the background refactor, one for tests, one for docs
Nobody wants to run multiple UIs to manage them

The problem: every agent (Claude Code, Codex, Cursor Agent, Devin, Aider, Cline) has its own protocol for lifecycle, status updates, input/output, and cancellation. Building one UI that hosts all of them meant custom integration per agent.

ACP standardizes the client-agent interface. A UI implementing ACP once can host any ACP-compliant agent without agent-specific glue code.

What ACP actually specifies

The protocol covers:

Agent lifecycle — spawn, pause, resume, terminate an agent session
Task specification — how the host describes work to the agent (goal, constraints, files/context)
Progress streaming — how the agent reports intermediate state (thinking, tool calls, file edits) back to the host
Input protocol — how the host sends user replies, interventions, or approvals
Output protocol — how the agent surfaces final artifacts (diffs, summaries, logs)
Cancellation and error semantics — graceful stop, retry, and failure reporting

This looks similar to MCP’s client-server model, but the roles are inverted: in MCP, the agent is a client calling tool servers. In ACP, the host is a client managing agent workers.

The Devin Desktop use case

Cognition’s Agent Command Center is the reference ACP implementation. Inside Devin Desktop you can:

Spawn multiple Devin Local agents on different tasks
Spawn Claude Code as an ACP agent on another task
Spawn Codex or a custom agent on yet another
Watch all their progress from one dashboard
Intervene or accept work without switching UIs

This is the workflow ACP was designed to enable: the IDE becomes the agent orchestrator, and any agent that speaks ACP plugs in.

Where ACP stands vs MCP in July 2026

Dimension	MCP	ACP
Age	Since Nov 2024	Since June 2, 2026
Governance	Linux Foundation (Agentic AI Foundation)	Cognition-led (not yet in a neutral foundation)
Adopters	Anthropic, OpenAI, Google, Microsoft, Salesforce, Snowflake, Apple, AWS, Databricks	Devin Desktop (launch), other IDEs expected in H2 2026
Public servers	9,400+ MCP servers	Small ecosystem so far
Enterprise auth	Standardized layer (2026)	Nascent
Maturity for production	High	Early

ACP is where MCP was in early 2025 — an open protocol with a strong reference implementation, needing broader industry adoption before it’s the safe default.

Who should care about ACP right now

Agent authors

If you build a coding agent (like Aider, Cline, or a custom in-house agent), consider adding ACP support so users can run it inside Devin Desktop or future ACP-compliant hosts. The developer surface is small compared to shipping your own UI.

IDE and orchestration platform authors

If you’re building an IDE, terminal multiplexer, or agent-orchestration platform, implementing ACP as a host protocol future-proofs you against having to write per-agent adapters. Expect ACP support to become a table-stakes feature during H2 2026.

Enterprise buyers

Not urgent yet. ACP-hosted agents are still a small fraction of production AI coding work. Watch adoption through Q3 2026; if major vendors (JetBrains, VS Code, Cursor) add support, it moves to a required capability for your standard AI-coding stack.

Individual developers

Not a today problem. Use whatever coding agent you like directly. If Devin Desktop’s multi-agent orchestration workflow appeals to you, ACP is what makes it possible under the hood — but you don’t need to think about the protocol itself.

What might block ACP adoption

Governance — ACP hasn’t been donated to a neutral foundation yet. Vendors have learned from MCP that neutral governance drives adoption; expect this to be a 2026 question for Cognition.
Competing standards — Anthropic, OpenAI, or Microsoft could ship a competing “agent host protocol” in H2 2026. If so, expect a standards fight similar to MCP vs proprietary alternatives in 2024.
Bootstrapping — a host protocol is only useful if agents implement it. Cognition is subsidizing early implementations (SDKs, docs, sample agents) but broad adoption requires competitor tools to buy in.

The bigger pattern in 2026 AI protocols

The AI coding stack is now composed of at least four open protocols:

MCP — agents ↔ tools (Anthropic, 2024)
ACP — hosts ↔ agents (Cognition, June 2026)
AGP (Agent Gateway Protocol) — enterprise routing and policy (various, mid-2025+)
A2A (Agent-to-Agent) — direct agent coordination (Google, still emerging)

The stack is maturing along the same axes that the API/web stack matured through in the 2000s (HTTP, DNS, TLS, OAuth, etc.). If you build in this space, expect the “which protocols do we support” question to be a permanent part of platform strategy.

The bottom line

ACP is early, vendor-led, and pragmatically useful today only if you’re inside the Devin Desktop workflow. MCP is your default for now. Watch ACP through Q3 2026 — if it lands under neutral governance and picks up Anthropic, OpenAI, or Microsoft adoption, it becomes the second required protocol for anyone building in the AI coding ecosystem.

Last verified: July 1, 2026. Sources: Cognition Devin Desktop June 2, 2026 launch announcement, apidog.com Devin 2026 review, chatforest.com ACP builder guide, Linux Foundation MCP governance updates, industry protocol landscape reporting.