Agent Client Protocol: swapping agents like editors

Before a standard protocol, putting a new agent into an editor meant writing an extension for that editor, and putting that agent into a second editor meant doing it again. The Agent Client Protocol inverts it: the agent speaks one interface, the editor speaks the same one, and everything connects.

What ACP actually standardises

It is a session protocol, not a model API. The client sends messages, the agent replies with structured updates: text, tool call requests, permission requests, diffs and checkpoints. The client owns the interface and the approval prompts. The agent owns its own loop, its tools and its reasoning.

That division is the useful part. Because permission prompts come back over the protocol, the editor can show them in its own voice with its own buttons, rather than the agent inventing a terminal prompt that may or may not be readable. Diffs can be rendered as editor review UI. Session state can be displayed the way the editor displays state for anything else.

• Session lifecycle. New session, prompt, cancel, resume, all defined rather than inferred.
• Permission requests. The agent asks, the editor decides and answers, so approval is always a client-side UI decision.
• Streaming updates. Text, tool calls and diff hunks arrive as typed events the client can render properly.
• File references and checkpoints. Image and file references use local paths, and checkpoints let the client offer undo at the protocol level.
• MCP as a first-class transport. An agent can announce MCP support over ACP rather than every client reimplementing it.

Editorial technical sequence diagram, 16:9, flat vector. Two vertical lifelines (editor on left, agent on right) with five horizontal message arrows passing between them in descending order, each arrow a different thickness to imply message type, with a small shield glyph on one arrow (permission request) and a small split-rectangle glyph on another (diff). Charcoal (#121212) background, grey (#8c8c8c) outlines, the permission and diff arrows in indigo (#5560d4), ordered-dither dot texture in the background, generous negative space. Mood: conversational, structured. No readable text, no logos, no watermark.

What shipped in 2026

The registry went live at the end of January 2026, which was the missing piece. Previously an agent had to be exposed as an extension per client or installed manually by the user, so distribution was fragmented even where the protocol was already implemented. Now an agent that speaks ACP is submitted once and appears in every client that also speaks it.

Agents already registered include the major CLIs, so you can run one inside an editor that is not its native home. The original design ran over local process streams, and a WebSocket interface was added later so browser-based clients could join without a native bridge.

Why this matters beyond editors

The reason to care is that it makes the agent replaceable. An editor that speaks ACP is one where you can change your mind about the agent without changing everything else, which is the same argument as bring your own model one layer down the stack.

There is a second, less obvious benefit: a protocol boundary is a place to audit. Tool calls and permission requests cross a well-defined interface where a client can log them, block them, or show them to a user, instead of living inside a monolith that decides on its own.

“Implement once, work everywhere. The registry is the missing distribution mechanism for that promise.”

the announcement that made ACP a ecosystem rather than a specification

How Quaka fits into this

Quaka works in both directions. It ships a dedicated quaka-acp binary, so any ACP-capable editor can drive a Quaka session and get permission prompts, diffs and streaming updates rendered in its own interface. Quaka can also act as the client, driving Claude Code or Codex through their CLIs as providers so their sessions, tool calls and diffs appear inside Quaka's thread.

Both directions use the same underlying idea as provider-neutral threads: the conversation belongs to you, and the thing producing the next message is a choice you can change.

Get an invite

Quaka is in private beta.

One email when your invite is ready. macOS, Windows and Linux, bring your own key.

Email addressJoin waitlist↵

No spam. One email when your invite is ready.

Read the source on GitHub