Skip to content
Agentic Control Plane

Why you need an Agentic Control Plane

Your coding agent runs shell commands, edits files, and pushes code. In auto mode, or overnight, nobody reads each call before it runs. An agentic control plane is one checker every tool call passes through first: allow it, ask you, or stop it, with one log of who ran what and what it cost. ACP does this with a hook in your harness. A new workspace starts in audit mode: everything is recorded, only the safety floor holds anything.

What it looks like when this bites

This one is ours. From Caught in the Wild, the running log of real interceptions on our own agents:

CAUGHT BY METERING 2026-07-21

The surprise bill came from the one agent outside the plane

“A ~$15/day model bill traced to a container running on a fresh API key — spend invisible because it never crossed the proxy. … The bill you get surprised by is always from the agent you didn't control.”

Nothing crashed and no alert fired. The agent did its job, on a key nobody was metering, at a rate nobody chose. Every check we had written held. The bill came from the one call path those checks never saw. That is the shape of the problem: agents rarely fail loudly. Whatever is not on the call path is invisible until the invoice, the deleted row, or the leaked record arrives.

Read the full log →

Why not auto mode plus a sandbox?

Keep both. They answer different questions than ACP does.

  • A sandbox decides where the agent's code can reach. It cannot tell a wanted action from an unwanted one made with valid credentials: the force-push to main, the DELETE FROM with no WHERE on a database the agent may reach, the curl that sends a file to a host the sandbox allows. ACP reads the command before it runs and holds those for your approval.
  • Auto mode and allowlists are per harness. Your Claude Code rules do nothing for Codex or Cursor on the same machine, and none of them write one record you can read the next morning. ACP keeps one set of rules and one log across the harnesses you run.
  • Neither has an idea of who is watching. ACP rules can differ by agent tier: Ask first in an interactive session, Never for a background run or a spawned subagent.

What ACP adds, concretely:

  • A safety floor, with no rule written. A force-push, destructive SQL through a database CLI, curl | sh, and rm -r of a path outside the project are held for your approval. rm -rf of your home or root, mkfs, writing to a raw disk, and fork bombs are always blocked. The floor reads shell commands only; MCP and non-shell tools do not reach it. A workspace owner or admin can switch the floor off on the Policies page.
  • Rules by tool key. Bash.git.push: ask, Bash.rm: deny, Bash.curl.api.github.com: allow. Set per person and per agent tier, from a slash command, the console, or a rule the agent proposes when it hits a hold.
  • One log. Every call, with who ran it, which rule decided, and what it cost.

A connected workspace starts in audit mode. Everything is recorded, the floor applies, and your own rules do not block until you run /acp-enforce. Read a day of traffic first if you want to; the rows show what the starter rules would have asked about.

Does it cover my other harness?

The installer finds the coding agents on your machine and wires the hook into each one: Claude Code, Codex, Cursor, OpenCode and the others on the coverage matrix. Coverage is not identical. Only Claude Code shows a hold inline in the session. On every other harness the held call is blocked, you approve it on the console Approvals page or from the email, then ask the agent to retry. The matrix lists what the hook can intercept on each harness, so check your harness there before you count on it.

What leaves my machine?

In a connected workspace, before each call the hook sends the gateway the tool name and its input (for a shell call, the command text), the working directory, the session id and the agent tier, and waits up to four seconds for a decision. After the call it sends the output, cut at 200 KB. A credential in a command's arguments is redacted before the log stores it. In Claude Code the hook also reads the model name and token counts of each turn from the session transcript, so model spend is priced; not the prompt text. Model prompts and responses pass through ACP only when you start the agent through the launcher the installer adds (claude-acp, codex-acp, ...), which is also how other harnesses get their model calls priced.

With --local, nothing leaves. The hook decides against ~/.acp/policy.json plus the safety floor and appends to ~/.acp/audit.jsonl. No account. You give up identity, approvals, the console and cost, and some harnesses (Hermes, DeepSeek Harness, Pi, Prime Agent, Muse Code, Grok Build, Antigravity) are skipped in local mode today.

What if ACP is down?

In the Claude Code plugin, an interactive session keeps going: each call is allowed with a loud UNGOVERNED notice and is not logged. Subagent, background and API tiers stay blocked until the gateway answers. The other harnesses use the shared hook, which fails open in every tier unless you set ACP_FAIL_MODE=closed or write closed to ~/.acp/failmode on that machine. In local mode there is no gateway to lose.

Before and after

Concern Without an ACP With an ACP
Identity Shared API keys; the log cannot say whose agent ran a call Every call tied to the person who installed the hook and the agent tier it ran in
Rules Allowlists kept by hand, one per harness Per-user, per-tool rules decided at the gateway; enforced there on the proxy, MCP and SDK paths, and by the hook in your harness for coding agents
Data protection Tool output flows back into the model unchecked PII in tool results detected and redacted before it reaches the model on the model-proxy path; on hook-only installs, a policy you turn on
Cost control No per-user limits; surprise bills, runaway loops Rate limits per user; a spending budget that can halt tool calls, and a context guard, that you switch on (Claude Code model turns are priced from the transcript; other harnesses need the launcher)
Audit Harness logs with no user attribution, one per tool Every call logged with identity, the rule that decided it, and cost
Compliance Manual controls and audit gaps An identity-attributed call log you can export as evidence for your own SOC 2 or HIPAA reviews (ACP itself is not certified; see pricing)

The setup for agents that run with nobody watching

This is the configuration we recommend. Each step has a copy-paste rule in Rules that stop the scary things.

  1. Interactive sessions on Ask first for Bash.rm, Bash.git.push, Bash.curl and your database clients. The starter rules do this once enforce is on.
  2. The background and subagent tiers on Never for the same keys, set on Policies → Agents. Claude Code started with --dangerously-skip-permissions reports as background; auto mode counts as interactive.
  3. Production credentials out of the agent's environment. Rules key on the tool, not the connection string, so ACP cannot tell prod-db.internal from localhost.
  4. A spending budget with halt on. Claude Code model spend is priced from the transcript; on other harnesses, launch through the launcher so the budget can see model calls.

Afterwards the Sessions view on Activity shows the run call by call, with what each call cost.

One command to the first audit row

Run it on your machine with no account (local rules plus the safety floor, for the harnesses wired for local mode), or connect a workspace for identity, approvals and cost. The enforcement modules are MIT-licensed.

curl -sf https://agenticcontrolplane.com/install.sh | bash