Agent Client Protocol

Agent Client Protocol (ACP)

ACP started with one job: a standard way for an editor to talk to a coding agent — editor as client, agent as server, a shared boundary instead of N×M custom IDE integrations. The LSP move applied to agents: implement the protocol once, interoperate everywhere. Created by Zed with Google around Gemini CLI; adopted by JetBrains; Apple shipped ACP support in Xcode 26.6. Agent side: Codex, Claude Agent, Gemini CLI, Copilot, Kiro, OpenCode, Factory Droid, Goose, Grok Build. Adapters like codex-acp/claude-agent-acp make existing runtimes speak it; the ACP Registry adds register-once distribution.

The expansion: ACP beyond the IDE (@JoshARosen survey, 100+ projects)

The interesting finding — the common denominator is increasingly not the IDE:

1. Application interface — the client generalizes past editors: Obsidian Agent Client (vault as ACP client — agents work against notes), Unity, JupyterLab, hash (a POSIX-style shell with AI in the grammar driving agents over ACP)
2. Persistent agent sessions — session lifetime decoupled from any client: acp-ui / Agents Anywhere (desktop/web/mobile via WebSockets over stdio agents), hydra-acp (the session is independently addressable; terminal, editor, browser, or Slack can attach to the same running agent)
3. Worker API — orchestrators and “software factories” need exactly what IDEs need: start, assign, observe, steer, cancel, collect. Helix (fleet in isolated environments, spec-driven Kanban, workers = anything that speaks ACP), Open Multi Agent (task DAG with ACP workers), Zenith (orchestrator + workers + testers, replans mid-flight)
4. Workflow/event primitive — agents as callable units inside deterministic flows: n8n-nodes-acp (agent as workflow node), acpx (headless client: persistent sessions, one-shot exec, machine-readable output, a flow layer mixing ACP turns with checkpoints), OpenTag (Slack/GitHub/GitLab/Linear/Lark events → local ACP agent → result back to the thread)
5. Agent-to-agent delegation — MCACP exposes ACP workers through an MCP server (a host asks for a Codex/Gemini/Claude session; pipelines where one writes, one reviews, one tests); OpenClaw speaks ACP both directions

Positioning in the protocol stack

• LSP analogy, literalized: replaceable unit = the whole agent (planning behavior, tools, model routing, auth, runtime) — not just the model
• vs MCP: MCP connects agents to tools; ACP connects clients to agents. MCACP stitching them together (ACP workers behind an MCP server) is the emblematic bridge — one agent delegates to another vendor’s agent through the same interface it uses for tools
• The “where it’s going” bet: security, observability, identity, policy, audit will need to understand ACP — a common worker interface means agent governance infrastructure gets built once instead of per-harness. ACP as the natural observe-and-govern point for agent work

Why it matters here

• Hermes-adjacent: this agent is an ACP-shaped system in one respect — a harness with tools, sessions, and delegating work (delegate_task subagents ≈ the MCACP pattern internally). The field’s convergence on “harness as addressable worker” validates the architecture
• The Obsidian Agent Client is a direct garden hook: vault-as-ACP-client would let any ACP agent tend notes — alternative to the current qmd-MCP integration path
• Kanban-codex-lane skill: Helix’s spec-driven Kanban dispatching ACP workers is the same shape as the existing lane — a reference implementation of the pattern at fleet scale

Open

• (open: acpx hands-on — headless ACP one-shots as a scripting primitive for agent work)
• (open: does the governance bet land? watch for ACP-aware audit/policy tools)

Agensh: the manager-free scaling datapoint (Microsoft Research, arXiv:2609.26781)

The counterweight to meta-harnesses: drop the orchestrator entirely (project page captured; via @nykdotdev and @rohanpaul_ai). Self-organized concurrent workers run an asynchronous cooperation loop — gather context → CLAIM a sub-task (announced scope) → act → share findings → verify → merge — over a lightweight “agentic organization infrastructure”: shared workspace (Git platform, private branches → main), message interface, shared context (append-only typed entries: OBSERVED / FACT / FAIL / CLAIM / PATCH_SUMMARY). The loop lives in each worker’s prompt, identical except for worker ID — no hard-coded runtime orchestration. Results on ProgramBench’s 5 hardest tasks (FFmpeg, gromacs, pandoc, PHP-src, ctags; 6h, no Internet, GPT-5.6-sol high): 1→128 agents lifts mean pass rate 19.31%→28.78% (+49% relative; pandoc 1→1,024: 33.89%→55.06%, +62%); larger orgs hit given scores earlier (128 agents pass 30% at 30 min vs 90 min for 8). Emergence: peer coordination → multi-worker integration → standardized workflows → specialized roles. nykdotdev’s caveat is the production note: “no manager still needs a ledger — claiming a task has to be atomic, or two agents do the same work and you pay for it twice.” (Paper doesn’t report cost.) Kin: CRDT-style convergence without consensus, pi-durable’s shared-state commits, the self-organization end of the harness spectrum.
Related: MCP reconsidered · Agent sandbox · Hermes Agent · Software factory (orchestrator layer made declarative)

Meta-harnesses: orchestration above the harness layer

The layer above is consolidating too: omnigent (OSS) (10.5k★, Apache-2.0, by Databricks — via @bibryam, “Harness orchestration is getting hot”) is a meta-harness: a common orchestration layer over Claude Code, Codex, Cursor, OpenCode, Hermes, Pi, and custom agents — native tmux terminal wrappers per harness, bwrap/seatbelt OS-sandboxing around each, swap or combine harnesses without rewriting, policies (approval gates, spend caps, tool allowlists) at server/agent/chat scope, real-time shared sessions (co-drive, fork), and disposable cloud sandboxes (Modal/E2B/K8s/Databricks…). Same structural bet as ACP but from the opposite side: ACP standardizes the client↔agent boundary; Omnigent standardizes the operator↔many-harnesses boundary. The stack emerging: protocol (ACP) below, meta-harness (Omnigent) above, harnesses (pstack-style skills) in between.

• Google Antigravity ships an official ACP server (2026; via pi-antigravity-acp-provider, captured) — first frontier lab to expose its models over ACP as a supported route for third-party harnesses (vs the reverse-engineered Cloud Code Assist OAuth that got accounts flagged). See Google models outside Antigravity.