Your coding agent, controlled and priced — in one command
You run Claude Code, Codex, or both, for hours a day, and some of those runs happen with nobody watching. ACP adds a hook that checks each tool call before it runs, one log across every harness, and a price on each session. Your harness, your keys, your workflow stay as they are.
curl -sf https://agenticcontrolplane.com/install.sh | bash
What changes on your machine
The installer finds the agents you have (Claude Code, Codex, Cursor, GitHub Copilot, OpenCode, OpenClaw, Hermes, DeepSeek Harness, Qwen Code, Antigravity, Grok Build, pi, Prime Agent, Muse Code) and asks which to cover. For each one it adds a hook that runs before and after every tool call. It also creates ~/.acp/ and adds one marked line to your shell rc for ~/.acp/bin. acp-uninstall removes all of it.
From then on, plain claude (or codex, or cursor) asks ACP before each tool call. The hook sends the tool name, a truncated preview of the arguments, and later the result and the decision, to your workspace. ACP answers allow, ask, or deny, and the hook enforces the answer on your machine. A secret that appears in a command’s arguments is redacted before it is stored.
A new workspace starts in audit mode. Every call is recorded and the safety floor applies, but your own rules do not block anything until you run /acp-enforce in your agent or turn it on in the console. You can watch a day of real traffic before you hold anything.
If ACP cannot be reached, what happens depends on who is at the keyboard. In Claude Code, an interactive session keeps running and each call carries a loud UNGOVERNED notice; subagent, background and API sessions wait until ACP answers. On the other harnesses the shared hook lets calls through unless you set ACP_FAIL_MODE=closed or write closed to ~/.acp/failmode on that machine. A policy deny always blocks; the fail mode only covers outages.
The floor: what is stopped with no rule at all
The safety floor is on from the first call, in audit mode too. Its holds read shell command text only; MCP tools and most file edits do not reach it (edits to ACP’s config, hook settings and shell rc files are refused).
- Always blocked, no approval possible:
rm -rfof your home directory, the root filesystem or a system directory;mkfs;ddonto a raw disk; fork bombs. - Held for your approval: a force-push (
--force,-f,+refspec);DROP,TRUNCATEorDELETEwithout aWHEREhanded topsql,mysql,mariadborsqlite3; piping a download into a shell (curl | sh); a recursive delete outside the working directory. - Not on the floor, recorded only: deletes inside the project,
rm -rf $DIR,git push --deleteor--mirror, ORM resets likeprisma db push --force-reset, SQL passed as a file. A rule on the tool key (Bash.rm,Bash.prisma) is how you hold those.
Where you approve a held call: only Claude Code shows the hold inline in the session. On every other harness the call is blocked, you approve it on the Approvals page or from the email, then ask the agent to retry. A workspace owner can switch the floor off on the Policies page; you are asked at install. The full recipe list, with the local, slash and console form of each rule, is in Rules that stop the scary things.
Why not auto mode plus a sandbox
Both are good and you should keep them. They answer a different question than ACP does.
A sandbox is a boundary around where the agent’s code runs. It cannot tell whether an action made with your valid credentials was one you wanted: the branch force-pushed with your git token, the table dropped with your database password, the $50 model loop. ACP sits at the tool call and decides those by policy, then logs the decision. Why they compose has the longer version.
Your harness’s built-in auto mode and allowlist live in that harness, on that machine. Codex has its own, Cursor its own, and none of them share a log. ACP keys every call the same way everywhere (Bash.git.push, Bash.psql, Bash.curl.api.github.com) and applies one set of rules across all of them, by agent tier. Claude Code sessions started with --dangerously-skip-permissions report as background; a Task-spawned subagent as subagent; a normal or auto-mode session as interactive.
The setup we recommend for unattended runs, from docs/rules section 5: in the console, Policies → Agents → background and subagent, set Bash.rm, Bash.git.push, Bash.curl and your database clients to Never; leave interactive sessions on Ask first; keep production credentials out of the agent’s environment. An unanswered hold expires and counts as denied. The Sessions view shows the overnight run afterwards, call by call, with what each call cost.
Does it cover my other harness
The same hook, the same rule keys and the same log cover the fourteen clients above. Coverage is not identical everywhere: some harnesses have no inline ask, and a few report a decision they cannot enforce. The per-harness pages under /controls say what ACP can and cannot hold on each one. Read the one for your second harness before you rely on it unattended.
What a session costs
Your model spend never changes. Your subscription or API key is forwarded untouched and Anthropic bills you exactly as before. ACP only makes the number visible, two ways:
- From the hook, with no launcher. In Claude Code the hook reads token counts from the session transcript and sends them with the tool-output call it already makes. The gateway prices them at list rates. This is an estimate at API-rate equivalents.
- Through the launcher.
claude-acp(andcodex-acp) is the same session with its model calls routed through the ACP proxy. Those calls are metered at the gateway, and the proxy can also act on the agent’s declared tool list (next section). A spending cap in Settings → Limits counts metered calls and can halt tool calls when it is reached.
When a claude-acp session exits, it tells you what just happened:
ACP · session: 276 model calls · 1,697 tool calls · $148.16 @ API rates
→ https://cloud.agenticcontrolplane.com/sessions/…
That is a real session: a full working day of Claude Code on a Max subscription, priced at API rates. If your org is deciding between seats and API billing, this is the number that decides it.
The X-ray shows where the money went
One click from the summary line: the session’s cost curve, turn by turn. The session pictured is a real working stretch, $472.03 at API rates across 1,052 turns and 31h 42m, with a 100% loop tax: the orchestration loop re-read 298.9M tokens of context, at a 100% cache hit rate, which is the only reason it was not several times more. The last 119 turns bought 10% of the output. All 3,744 tool calls underneath were free. That fact changes how you use the tool, and which model you point the loop at.
Every tool it could call, before it does
This part needs the launcher. In a claude-acp session the proxy sees the tool list the agent declares on its first request and turns it into a control table.
A real Claude Code session declares 76 tools in every request: the coding loop, plus tools that send messages, publish public web pages, schedule their own future runs, and drive your logged-in browser. Sixty-four of them were never invoked. Every tool is a row, every row a click: allow, flag, or deny. A denied tool is removed at the proxy before the model can call it; the agent gets the reason and adapts.
Which ones should you deny? We argued a default posture from blast radius and keep live captures per client.
The morning after, in your inbox
ACP · yesterday: $0.28 billed · $148.16 @ API rates · 2 things worth a look
WHAT CHANGED (last 24h)
codex_exec — NEW AGENT, 17 tools declared:
+ apply_patch, exec_command, image_generation …of 17 [Review →]
A daily digest: spend against your typical day, the runs to look at, and each change to your agents’ tool lists as a diff. Each line links to the control that fixes it.
What leaves your machine
With the default install: the tool name, a truncated preview of the arguments and the result (capped per call), the decision, and in Claude Code the token counts from the transcript. Not your repository, not your files. Secrets in command arguments are redacted before storage.
If you want nothing to leave at all, install with --local. There is no account; rules live in ~/.acp/policy.json, the record in ~/.acp/audit.jsonl, and the hook decides on-device. Local mode has no agent tiers, no cost meter, and skips the harnesses whose ACP plugin needs a workspace (Hermes, DeepSeek Harness, pi, Prime Agent, Muse Code, Grok Build, Antigravity).
What this costs you
Nothing to start: free up to 5 agents, with unlimited calls, free subagents, the floor, rules, the log, and the cost X-ray. Your model spend stays on your own keys and subscriptions. ACP never marks up your tokens.
curl -sf https://agenticcontrolplane.com/install.sh | bash
Teams: per-agent policy, roles, org-wide cost, and approval workflows live on the team plan.