Skip to content
Agentic Control Plane

Getting started with ACP

ACP gives every AI agent in your stack identity-verified, policy-enforced, audit-logged tool calls. Three steps from zero to first audit row. This is the canonical start page — it routes by what you run:

  • AI coding client (Claude Code, Cursor, Codex CLI, DeepSeek Harness) — Path A below, one command.
  • Agent framework (CrewAI, LangGraph, OpenAI Agents SDK, …) — Path B below, one decorator.
  • No code at all — create and run agents entirely in the browser: create your first agent →
  • You are an AI agent spawning subagents — the delegation chain primitive: agents-building-agents quickstart →

1. Install for your stack

Free up to 5 agents — and there’s a fully on-device option that needs no account at all. Pick the path that matches what you run.

Path A — AI coding clients (Claude Code, Cursor, Codex CLI, DeepSeek Harness)

Start connected — the installer opens your browser to provision a free workspace: your policy 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 run on-device from ~/.acp/policy.json, every call is logged to ~/.acp/audit.jsonl, and nothing leaves your box:

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

The installer detects your runtime, registers PreToolUse and PostToolUse hooks, and verifies. The workspace mode covers Claude Code, Cursor, Codex (non-Bash tools included), opencode, and Hermes (native pip plugin); --local covers Claude Code, Cursor, and Codex’s shell calls fully on-device. Either way, one command, whatever you run.

Piping a script to bash deserves scrutiny — so here’s exactly what it writes to your machine, every file, in plain language, and how --local differs from the connected install.

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

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 intercepts every wrapped tool call, applies your policies, logs the audit row, and returns control to your agent — typically in 5-15ms. Same @governed decorator pattern across CrewAI, LangGraph, OpenAI Agents SDK, Anthropic SDK, Google ADK, Vercel AI SDK, Mastra, Pydantic AI, and AutoGen.

See all integration guides →

2. See your first audit row

Run any tool call from your AI client or agent.

  • Connected workspace (default): open the activity log at cloud.agenticcontrolplane.com/activity, and sign in if you haven’t (a workspace was provisioned when you ran the installer).
  • Local install (--local): tail -f ~/.acp/audit.jsonl — every decision, on-device, in real time.

Every call through ACP is logged with:

  • Identity — the verified user from the JWT (or workspace key in dev)
  • Decision — allow / deny / redact / rate-limit + 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. Verified identity, delegation-chain provenance, and cost attribution come with a connected workspace — that’s the upgrade.

ACP Activity log: one row per tool call — 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.

Set policies when you’re ready, or let audit run on its own for a while. The default policy allows everything and logs it — you tighten it as you understand your traffic.

What control you get

Every call passes through six gates, in order:

  1. Identity — RS256 JWT verified against your IdP’s JWKS on every call
  2. Safety — PII scan and secret redaction on input and output
  3. Policy — runtime authorization, deny-by-default, scopes per call
  4. Usage — per-user rate limits and budgets, agent-runaway detection
  5. Routing — x-user-uid propagated to your backend; SSRF guard outbound
  6. Audit — structured, immutable log streamed to the console (or your SIEM)

See the architecture →

Next steps

  • Integration guides — Claude Code, Cursor, Codex CLI, Anthropic SDK, OpenAI SDK, CrewAI, LangGraph, and more
  • AgentGovBench — see how ACP-paired frameworks score on 48 control scenarios
  • Comparison — when to use ACP vs LLM gateway vs agent framework vs API gateway
  • Agent recipes — four runnable Python agents with the control layer wired in, ~200 lines each
  • FAQ — common questions on identity, fail modes, data handling, and self-hosting
  • Pricing — free up to 5 agents; flat bands above (you pay for agents that start work, everything they delegate is free)

Want to self-host?

If you’d rather run the control plane on your own infrastructure, the open-source reference implementation is on GitHub.