Skip to content
Agentic Control Plane

Getting started with ACP

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

Setting up a team? Invite teammates from the console’s Team page before they install. Each one then runs the same command and joins your workspace: team setup.

ACP is a hook that runs before each tool call your coding agent makes. It records the call, holds the risky ones (force-push, destructive SQL, curl | sh, deletes outside your project) for your approval, and always refuses a short list of catastrophic shell commands: rm -rf on your home or root, mkfs, dd onto a disk, fork bombs. What is and is not on that list: Rules that stop the scary things.

Three steps from install to protected. Pick the path for what you run:

  • AI coding client (Claude Code, Cursor, Codex CLI, opencode, Hermes, DeepSeek Harness and others): Path A below, one command.
  • Agent framework (CrewAI, LangGraph, OpenAI Agents SDK, …): Path B below, one decorator.
  • You are an AI agent spawning subagents: agents-building-agents quickstart

Protected in 3 steps

Out of the box, ACP records every tool call your agents make. A short safety floor applies in every mode: catastrophic commands (rm -rf on your home or system folders, disk wipes) are always blocked, and force-push, destructive SQL, piping a download into a shell, and deleting outside your project are held for your approval. Your own rules (ask first / never) start applying when you turn on enforce. No rule can loosen the floor; a workspace owner or admin can switch it off on the Policies page (you were asked at install). With --local the always-blocked list is narrower: rm -rf on your home or root, disk wipes, fork bombs.

  1. 1
    Install. One command, then approve this machine in the browser. curl -fsSL https://agenticcontrolplane.com/install.sh | bash
  2. 2
    Turn on your rules. Run /acp-enforce in your agent. The starter rules start applying: rm and keychain reads are held for your approval (you approve on the console Approvals page or from the approval email); everything else keeps running and is recorded. Add your own with /acp-ask Bash.curl, /acp-deny Bash.git.push, /acp-allow Bash.npm, or on the Policies page. With --local there is no mode switch: the rules in ~/.acp/policy.json apply from the first call, and the starter file asks before rm, curl, git push, chmod and chown.
  3. 3
    See it work. Ask your agent to do something risky, for example git push --force on a scratch repo. ACP holds the call for your approval; the call and your answer land in the audit log (/acp-why for the last hold, the console Activity page, or ~/.acp/audit.jsonl with --local).

Copy-paste rules for the things people are most afraid of (force-push, prod database, rm -rf, a secret in a curl, overnight runs, a cost cap): Rules that stop the scary things.

Before you install: four questions people ask

I already run auto mode in a sandbox. Why add this? Keep the sandbox. It limits where the agent can write and which hosts it can reach. It cannot tell a plain push from a force-push, or a SELECT from a DROP TABLE, because both go to a host you allowed with credentials you gave the agent. ACP reads the command before it runs and holds those. It also gives you one set of rules and one log across every harness the installer wires, rules by tier (interactive, subagent, background), and an approval that reaches you by email when nobody is at the keyboard. ACP is a hook inside the harness, not a sandbox. A harness can be told to skip its hooks, so the two cover different failures.

Does it cover my other harness? The installer detects the AI clients on your machine and registers a hook in each one. The rules and the log are shared. Enforcement is not identical everywhere: only Claude Code shows a hold inline, as a prompt in the session. On the other harnesses the held call is blocked, you approve it on the console Approvals page or from the approval email, then ask the agent to retry. One exception today: DeepSeek Harness reports the block to the agent but does not enforce it yet. Each integration page says what its hook sees and what it cannot stop.

What leaves my machine? With a connected workspace, each tool call’s name and arguments go to the ACP gateway before the call, and its output (capped at 200 KB) after. That is what the decision and the log are made from. A credential that appears in a command’s arguments is redacted from the audit trail. If you start the agent through the launcher the installer adds (claude-acp, codex-acp), its model calls go through ACP’s proxy so they can be priced; a plain launch records tool calls only. With --local, nothing leaves your machine and there is no account.

What if ACP is down? On Claude Code with the plugin, an interactive session fails open: the call runs, and the session shows a loud UNGOVERNED banner. Subagent, background and API sessions fail closed: they wait until ACP answers. On the other harnesses the shared hook fails open in every tier unless you set ACP_FAIL_MODE=closed or echo closed > ~/.acp/failmode on that machine. With --local there is no network call to fail.

Step 1 in detail: install for your stack

Free up to 5 agents. There is also a fully on-device option that needs no account.

Path A: AI coding clients

Start connected. The installer opens your browser to set up a free workspace: your rules across every agent, the cost X-ray, and a shared console.

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

Prefer fully on-device? Add --local. No account. Decisions come from ~/.acp/policy.json, every call is logged to ~/.acp/audit.jsonl, and nothing leaves your machine.

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

The installer detects the clients you have, registers PreToolUse and PostToolUse hooks, and verifies them. The connected install covers Claude Code, Cursor, Codex (shell, apply_patch edits and MCP calls by hook on 0.145+; hosted tools such as web search through the MCP connector; no native ask, so a hold is approved on the console), opencode, Hermes (native pip plugin) and the other clients on the integrations page. --local covers Claude Code, Cursor and Codex’s local tool calls on-device; Codex’s MCP connector is cloud-only.

Piping a script to bash deserves a read first. Here is every file it writes to your machine, in plain language, and how --local differs from the connected install.

Windows

curl … | bash cannot run in PowerShell. Use the native installer instead (PowerShell 5.1 and 7, no modules, Node.js required):

irm https://agenticcontrolplane.com/install.ps1 | iex

The Windows installer detects and wires 13 clients: Claude Code, Cursor, Codex, Copilot, Qwen Code, opencode, OpenClaw, Grok Build, Antigravity, pi, Prime Agent, Hermes and DeepSeek Harness. It also installs the ACP MCP connector and the claude-acp / codex-acp cost X-ray launchers in %USERPROFILE%\.acp\bin.

Muse Code and the on-device --local mode need WSL. Run the shell installer there, exactly as on Linux:

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

Path B: agent frameworks (CrewAI, LangGraph, OpenAI Agents SDK, Anthropic SDK, etc.)

One package per framework, then wrap your tool handlers:

pip install acp-crewai
from crewai import tool
from acp_crewai import governed

@tool("send_email")
@governed("send_email")
def send_email(to: str, subject: str, body: str):
    ...  # your code, your creds

ACP checks every wrapped tool call against your rules, writes the audit row, and returns control to your agent. The same @governed decorator works across CrewAI, LangGraph, Google ADK, Vercel AI SDK, Mastra, Pydantic AI, and AutoGen. The OpenAI Agents SDK goes through the proxy below instead, and the Anthropic SDK has its own package. Which path each framework uses.

Then price the model calls. Wrapping tools controls what your agent does; the proxy meters what it spends. init() wires both. Call it before you construct a model client:

import acp_governance as acp

acp.init()            # interception + proxy
client = Anthropic()  # now priced and metered by ACP

That matches what Path A gets from one command: tool calls checked, model calls priced. Node is the same: import { init } from "@agenticcontrolplane/governance" (@agenticcontrolplane/governance on npm).

See all integration guides

The whole thing end to end: install, a normal command allowed, a force-push stopped before it runs, and the audit line that records both. Recorded 2026-08-21, when the local floor denied a force-push outright; today it is held for your approval instead.

Step 3 in detail: what the audit log shows

Run any tool call from your AI client or agent. For a held call, the row also carries your answer.

  • Connected workspace (default): open the activity log at cloud.agenticcontrolplane.com/activity and sign in if you haven’t. A workspace was set up when you ran the installer.
  • Local install (--local): tail -f ~/.acp/audit.jsonl shows every decision on-device, as it happens.

Every call through ACP is logged with:

  • Identity: the user behind the call (connected workspace)
  • Decision: allow / hold / deny / redact / rate-limit, with the reason
  • Tool: name and parameters
  • Chain: depth, root identity, scope at each hop (connected workspace)
  • Cost: latency, dollar attribution, tokens (connected workspace)

The on-device audit.jsonl logs tool, decision, reason, and timestamp for every call. Identity, delegation chain, and cost attribution come with a connected workspace.

ACP Activity log: one row per tool call with tool name, decision, verified identity, and latency, streaming in real time
What step 3 looks like: every call one row. Tool, decision, identity, latency. This is a real workspace's live traffic.

Until you run /acp-enforce, a connected workspace is in audit mode: everything is recorded, the safety floor applies, and your own rules do not block yet. Stay there for a day if you want to read your traffic first; the rows show what the starter rules would have asked about. Then turn enforce on. Copy-paste rules for the common fears

What you get

Three things, on every call, from the first row:

  1. Record. Every tool and model call, in order, with its cost, latency, the decision, and the identity behind it. Audit mode by default: everything is recorded, the safety floor still blocks its short hardline list and holds force-push, destructive SQL, curl | sh and deletes outside your project for your approval, and your own rules apply once you turn on enforce.
  2. Learn. Any row becomes a standing rule in one click. Agents propose rules from the denials they hit, and you confirm them on Policies. In audit mode the rows show what the starter rules would have asked about, so you see enforce before you switch it on.
  3. Control. Allow, ask first, or never, per tool, per tier (interactive, subagent, background), per person. Budget caps that halt a run rather than warn. Each agent’s declared tools listed, with one click to deny what it never uses.

Also included: PII detection on every call (six high-precision types; redaction is a policy you turn on), rate and budget limits, and a structured audit log you can query and export as CSV. On the framework path, the end user’s IdP token can be verified and carried through to your backend.

See the architecture

Next steps

  • Integration guides: Claude Code, Cursor, Codex CLI, Anthropic SDK, OpenAI SDK, CrewAI, LangGraph, and more
  • AgentGovBench: how ACP-paired frameworks score on 48 control scenarios
  • Comparison: when to use ACP vs an LLM gateway, an agent framework, or an API gateway
  • Agent recipes: four runnable Python agents with the control layer wired in, ~200 lines each
  • FAQ: identity, fail modes, data handling, and self-hosting
  • Pricing: free up to 5 agents, $100 a month for up to 25 agents (subagents are free)

Want to self-host?

The open-source modules are on GitHub. The hosted console, team approvals and cost X-ray are not open source; a self-hosted or VPC deployment of the full gateway is available on Enterprise, on request. See Pricing.