What an ACP is not
ACP is a hook in your coding agent plus a gateway. Before each tool call runs, the hook checks it against your rules (allow, ask first, or never), logs it, and prices it. It does not replace the things below. It runs beside them.
Not your harness's auto mode or allowlist
Claude Code, Codex, Cursor and the rest each ship a permission mode: a prompt per call, an allowlist, an auto mode, sometimes managed settings an admin pushes out. They decide per call, inside that one harness.
What they do not give you: the same rules on the next harness you install, rules that change when nobody is watching, and one log across all of them. Each harness keeps its own settings and its own transcript. Run two harnesses and you keep two allowlists in sync by hand.
ACP installs one hook into each harness on the machine. Every call gets the same dotted key (Bash.git.push, Bash.rm, Bash.curl.api.github.com), and one rule on that key applies on every harness. In a connected workspace you can set rules by tier, so background and subagent runs get Never where an interactive session gets Ask first. Under your rules sits a safety floor: a force-push, destructive SQL sent to a database client, curl | sh, or a recursive delete outside the project is held for your approval, and rm -rf of home or root, mkfs, disk wipes and fork bombs are always blocked.
Two things to know before you install. A new workspace starts in audit mode: every call is recorded, nothing is held except by the floor, and /acp-enforce or the Policies page turns your rules on. And only Claude Code shows a safety-floor hold as a prompt in the session. Holds from your own rules, on every harness, block the call and wait on the console Approvals page and in your email; you approve, then ask the agent to retry. Enforcement depth also differs by harness. See the coverage matrix →
Use both: keep auto mode and your allowlists. ACP adds the rules that follow you across harnesses, the tiers, and the one log. Copy-paste rules for the scary things →
Not a sandbox
Docker, gVisor, micro-VMs, cloud execution environments, and the sandbox built into your harness all do one job. They put an OS boundary around where agent code runs: files, processes and network on one host.
A sandbox has no opinion about an action made with valid credentials. The agent that force-pushes over a shared branch, drops a table with your own connection string, or deletes cloud resources with your own key does all of it through channels the sandbox correctly allows. ACP checks the call itself, by rule, before it runs, and logs the decision and the cost.
Use both: the sandbox limits where the agent can write and what it can reach. ACP decides what it may do with the access it has. Run the agent inside whatever sandbox you like, with the hook in the harness. Why they compose →
Not an LLM routing gateway
Portkey, LiteLLM and OpenRouter pick the model: the cheapest, the fastest, or a fallback when one provider is down.
ACP does not pick a model. It decides whether the tool call the model asked for may run, and it records what each call cost. If you use a routing gateway, your model traffic goes through it and your tool calls go through ACP's hook. The two do not overlap.
Use both: route models through your LLM gateway. Check tool calls, and keep the log, with ACP.
Not an agent framework
LangGraph, CrewAI, AutoGen and the agent SDKs help you build an agent: tools, memory, reasoning loops, orchestration.
ACP does not build agents. When an agent built on any of them calls a tool, ACP checks the call against your rules, logs it, and prices it. The framework decides what to do. ACP decides whether it is allowed. For framework-built agents the check runs through the SDK integration rather than a harness hook. See the integrations →
Use both: build the agent with any framework. Put ACP on its tool calls.
Not a traditional API gateway
Kong, Apigee and AWS API Gateway manage HTTP traffic in front of your backend: routing, TLS, rate limits, token checks.
An API gateway sees an HTTP request with a token. It never sees the git push --force or the rm -rf on the developer's laptop, and it has no idea which agent, in which session, sent the request it does see. ACP sits in the harness, before the call leaves the machine, and records which agent ran which command and what was decided.
Use both: your API gateway handles TLS, global rate limits and routing for your services. ACP handles the agent's tool calls.
Not an identity provider
Okta, Auth0 and Entra now issue identities and credentials to AI agents: agent SSO, short-lived scoped tokens, discovery and revocation of agents across the company.
That layer decides whether an agent may hold a credential. It never sees the tool call the credential is used for. A routine update and a prompt-injected destructive write carry the same valid token in the same granted scope. ACP checks each call, on the tool and its arguments, and its log records actions rather than logins.
Use both: your IdP establishes who the agent is, and that identity is what ACP records on every call. One issues the badge, the other watches the hands. Where the identity plane ends →
One set of rules across harnesses and models
Some platforms bundle control into one vendor's ecosystem: identity, rules and audit that only work with that vendor's models or that vendor's agent.
ACP is the same hook and the same keys whichever model is behind the agent and whichever harness is running it: OpenAI, Anthropic, Google, open-weights, or your own fine-tune. Add a harness and the rules you already wrote apply to it.
Why it matters: your team already runs more than one agent. The rules should not reset when you add another.
Harness mode, sandbox, ACP: what each one does
You already have the first two. This is what the third adds, and where it stops.
| Question | Harness permission mode | Sandbox | Agentic Control Plane |
|---|---|---|---|
| Decides each tool call before it runs? | Yes, in that harness | No. It bounds files, processes and network | Yes, by your rules: allow, ask first, never |
| Where the rules live | That harness's settings | The container or VM config | One place for every harness on the machine: ~/.acp/policy.json locally, or the console |
| Same rules on a second harness | Re-create them | Yes, if the agent runs inside it | Yes, same keys, same rules |
| Different rules when nobody is watching | Varies by harness | No | Connected: rules by tier (interactive, subagent, background). Local: no tiers, one rule set |
| A hold with nobody at the keyboard | That harness's own timeout | Not applicable | Connected: waits on the console and in email; unanswered expires as denied. Local: the harness's timeout decides |
| A floor no rule can loosen | Depends on the harness | The OS boundary itself | Always blocked: rm -rf of home or root, mkfs, disk wipes, fork bombs. Held for approval: force-push, destructive SQL at a db client, curl | sh, deletes outside the project. An owner can switch the held tier off |
| One log across harnesses, with cost | Its own transcript | No | Connected: yes, per call, with what it cost. Local: ~/.acp/audit.jsonl, no cost |
| What leaves the machine | Depends on the harness | Nothing extra | Connected: tool name, input, up to 200KB of output; recognised credentials are redacted. Local: nothing |
How an ACP fits in your stack
Questions people ask before they install
Does it cover my other harness?
The keys and rules are the same on every harness the installer sets up. What differs is how a hold is shown and how deep the check goes. Only Claude Code shows a safety-floor hold inside the session; everywhere else the call is blocked and you approve it on the console or from the email, then the agent retries. The coverage matrix says what is intercepted on each harness, and the setup page walks through yours.
What leaves my machine?
In a connected workspace the hook sends each tool call to the gateway: the tool name, its input (the command or file path), and up to 200KB of its output. Credentials in a recognised format are redacted before a preview is stored. With --local, nothing is sent; decisions come from ~/.acp/policy.json and the record is ~/.acp/audit.jsonl on the same machine. What the installer writes →
What if ACP is down?
It depends on which hook is running. The Claude Code plugin lets an interactive session continue with a loud UNGOVERNED notice and keeps unattended tiers (subagent, background, api) blocked until the gateway answers. The shared hook that other harnesses use fails open in every tier unless you opt in with echo closed > ~/.acp/failmode or ACP_FAIL_MODE=closed on that machine. More on the trust page →
Can the agent turn it off?
ACP runs as a client-side hook, so a harness setting that disables hooks, or a harness mode that skips them, disables ACP too. It is a record and a check, not something the agent cannot reach. Pair it with a sandbox and keep production credentials out of the agent's environment; recipe 5 is the setup we recommend for unattended runs.
Feature comparison
| Capability | LLM gateway | Agent framework | API gateway | Enterprise agent platform | Agentic Control Plane |
|---|---|---|---|---|---|
| Model routing & fallback | Yes | No | No | No | No |
| Agent orchestration | No | Yes | No | Single vendor only | No |
| TLS & global rate limiting | Some | No | Yes | Platform-managed | No |
| Allow / ask / deny on each tool call | No | Some | No | Single vendor only | Yes |
| Rules by agent tier (interactive, subagent, background) | No | No | No | Single vendor only | Yes, connected workspaces |
| Safety floor on destructive shell commands | No | No | No | Varies | Yes |
| PII in tool output | No | No | No | Varies | Detected; redaction is a policy you turn on |
| Spend cap that can halt tool calls | Some | No | No | Platform-scoped | Yes, connected workspaces |
| One log across harnesses, per call, with cost | Model calls only | No | Generic HTTP logs | Single vendor only | Yes |
| MCP server controls | No | Partial | No | Proprietary SDK | Yes |
| Works with any model | Yes | Mostly | Not applicable | No | Yes |
| Self-serve setup | Yes | Yes | Yes | No | Yes, one install command, free up to 5 agents |
See the reference implementation
ACP is a hook in the agent harness plus a gateway that records every tool call and applies your rules before it runs. The harness plugins are open source, MIT licensed.