Skip to content
Agentic Control Plane

Frequently Asked Questions

What is an Agentic Control Plane? An Agentic Control Plane (ACP) is a check between a coding agent and the tools it calls. Before each tool call runs, a hook in the harness sends it to ACP, which answers **allow**, **ask**, or **deny** from your rules and writes the call to a log. The same layer can price the model calls behind the work. "Control plane" here means one place to set the rules and read the log for every agent you run, whichever harness, framework, or model it uses.
What problem does it solve? A coding agent runs with your credentials. The harness's permission prompt is the only thing between it and a force-push, a dropped table, or a curl that ships a secret, and that prompt is off in auto mode and in unattended runs. Most harnesses also keep no record of what the agent did. ACP adds a check before the call, a human approval path when a rule says ask, and one log across every harness. The same gap shows up in backend agents as the **Three-Party Problem**, where a shared API key hides which user an agent is acting for. [Learn more about the Three-Party Problem →](/for-teams#problem)
I already run my agents in a sandbox or auto mode. Do I need an ACP? They answer different questions. A sandbox (Docker, gVisor, a micro-VM, or your harness's built-in one) is a boundary around where the agent's code runs. It cannot see whether an action made with valid credentials was one you wanted: the PR merged, the cloud resource deleted with your own key, the model loop that cost $50. Auto mode and allowlists decide by tool name inside one harness, and nothing records what was decided. ACP reads the tool call itself. It holds force-pushes and destructive SQL for approval even in auto mode, lets you set stricter rules for unattended sessions than for the ones you watch, and writes every decision to one log with the cost beside it. Run the agent inside whatever sandbox you like and put ACP in its call path. [Why they compose →](/blog/sandboxes-and-control-planes)
What does ACP do by default? A connected workspace starts in **audit mode**: every call is recorded and nothing is blocked except by the safety floor. The floor holds a force-push, destructive SQL through a database client (`DROP`, `TRUNCATE`, `DELETE` without a `WHERE`), `curl` piped to a shell, and a recursive delete outside the project for your approval. It always blocks `rm -rf` of your home or root, `mkfs`, writing to a raw disk, and fork bombs. Your own rules (Allow, Ask first, Never, keyed by tool and command) start blocking when you run `/acp-enforce` or turn enforcement on in the console. Only Claude Code shows a hold inline. On every other harness the call is blocked, you approve it on the console or from the email, and the agent retries. The secret-in-curl detector ships off. [Rules that stop the scary things →](/docs/rules)
Does it cover my other harness too? Unevenly, and the coverage page says how for each one. One install detects the coding agents on the machine and hooks each one it supports (Claude Code, Codex CLI, Cursor, opencode, Hermes, Grok Build, Antigravity, DeepSeek Harness and others). All of them report to the same workspace, rules, and log. What differs is what each harness lets a hook do. Claude Code intercepts every native tool and MCP call and can show the approval prompt in the session. Codex intercepts shell only and has no inline ask. Some Cursor built-ins do not fire the hook at all. ACP is a hook on the client, so a harness setting that turns hooks off turns ACP off. [Coverage matrix →](/coverage)
What leaves my machine? In a connected workspace the hook sends each tool call's name and arguments to the gateway so it can decide, and after the call sends the output (up to 200 KB) for scanning. What is stored by default is metadata: tool name, the decision and the rule that made it, identity, timestamps, token counts and cost, harness and version, working directory, session ids. Input and output previews are stored only if you turn on input or output logging (the first 1,500 characters, secrets redacted). When a call waits for approval, up to 500 characters of its arguments are stored with the request and sent in the approval email. Audit records are kept for 12 months. With a `--local` install nothing is sent at run time: rules are evaluated on your disk and the log is `~/.acp/audit.jsonl`. [What ACP sees and stores →](/trust)
What happens if ACP is down? The hook waits up to 4 seconds for an answer. In Claude Code the plugin then **fails open for an interactive session**: the call runs and every call carries an UNGOVERNED banner until the gateway answers again. **Subagent, background and API sessions fail closed**: their calls are denied until the gateway is back, because nobody is there to see the banner. To block interactive calls during an outage too, run `echo closed > ~/.acp/failmode` (or set `ACP_FAIL_MODE=closed`) on that machine. The shared hook the other harnesses use reads the same setting. Without it, it fails open: it can usually tell a run is unattended only when `CI` is set. A `--local` install has no gateway to lose.
Is there AI in the decision path? Access control should be deterministic. **Rules decide, and a deny stays denied.** Deterministic rules are the floor: identity, per-tool and per-tier permissions, rate and budget limits, evaluated the same way on every call. A deterministic risk classifier sits on top and only tightens: it can turn an allow into a flag or an approval. There is also an optional LLM judge. Once it is calibrated for a workspace, it can clear an ask for read-only shell and read calls in attended sessions. It never touches a deny, an explicit allow, or a safety-floor hold, and unattended sessions stay held. Google's [Beyond Zero paper](https://arxiv.org/abs/2605.22985) (2026) describes the same split for the enterprise: static rules as the floor, dynamic reasoning on top.
Does it work with MCP servers? Yes, on harnesses whose hook fires for MCP tools: Claude Code, Grok Build, Antigravity, and recent Codex (see the [coverage page](/coverage)). Rules match them by server and tool name. The safety floor reads shell commands only, so an MCP call reaches your rules but not the floor. OpenAI's Apps SDK (ChatGPT Actions) is not covered.
Can MCP servers inject ads or instructions into my agent's tool results? Yes. A tool response goes from a third-party server straight into the agent's context, and the model reads it with the same authority as everything else there. Prompt injection is the hostile version; sponsored text appended by an ad SDK is the commercial one. ACP filters tool results at the two seams it already sits on: the model proxy's tool-result rewrite and the MCP gateway's output scan. A sponsored match is replaced with a visible placeholder, `[sponsored content removed by ACP]`, not silently dropped. Each removal is stamped on the request's audit row, and one toggle (Policies → Patterns → 'Block sponsored content') covers the known ad formats. PII found in the same pass is masked and never collected. [How the filter works →](/blog/ad-blocker-for-tool-responses)
Can agents call other agents through ACP? Yes. When Agent A delegates to Agent B, ACP keeps the chain: who started the action, which agents were involved, and what each was allowed to do. Every hop is logged. Agents find each other through standard well-known endpoints. [Agent-to-agent deep dive →](/agent-to-agent)
Can I create agents from the console? No. The console is where you see and control agents, not where you build them. ACP Cloud shows each agent's activity, cost, and declared tools, and lets you set rules, approve held calls, and manage the team from the browser. The agents themselves come from your harness (Claude Code, Codex, Cursor and the rest, via one install) or from your framework code via the SDKs and the REST API. Either way they get identity, policy checks, and a log without extra work.
What agent frameworks does it work with? Any framework that can call our HTTP endpoint before each tool call. First-party adapters exist for the frameworks listed on the [frameworks page](/frameworks) (LangChain, CrewAI, AutoGen, Mastra, Vercel AI SDK and others), and the [SDK source](https://github.com/agentic-control-plane/acp-governance-sdks) shows what an adapter does. There are two integration paths: wrap each tool with the SDK's decorator, or point an OpenAI-compatible client at the ACP proxy. [See all integrations →](/integrations)
How is this different from an API gateway? API gateways (Kong, Apigee, AWS API Gateway) manage HTTP traffic: routing, TLS, rate limiting. They do not know which agent or user is behind a call, who delegated to whom, or which tools that user may call. An ACP handles that layer. [Full comparison →](/comparison)
How is this different from an LLM gateway? LLM gateways (Portkey, LiteLLM, OpenRouter) route model calls: the cheapest or fastest provider, fallbacks, response caching. They sit between your app and the model. An ACP sits between the agent and the tools and services it calls. Different layer, different problem. [Full comparison →](/comparison)
How is this different from agent infrastructure? Agent infrastructure helps you **build and run** agents: frameworks, orchestration, hosting. ACP sits across all of it and decides and logs what those agents do. You can build with any framework (LangChain, CrewAI, AutoGen, custom code) and control them all the same way. ACP is to agents what IAM is to microservices.
What is the Three-Party Problem? The Three-Party Problem is an identity gap. The user signs in to an app that uses an LLM, but when the LLM calls your backend it sends a shared API key. Your backend cannot tell which user the request is for, what they are allowed to do, or who to hold accountable. This was the first problem ACP solved and it is still a core use case. ACP now covers the wider problem too: agent-to-agent delegation and one control layer across every harness and framework. [Full explainer →](/for-teams#problem)
Do I need to replace my existing infrastructure? No. ACP sits beside your API gateway, LLM gateway, and agent framework and adds the check and the log that none of them provide. You can start in audit mode, then turn on enforcement, rate limits, and budgets when you are ready.
Is ACP open source? The harness plugins are: one repo per harness under [github.com/agentic-control-plane](https://github.com/agentic-control-plane), MIT licensed, published as `@agenticcontrolplane/*` on npm and `acp-*` on PyPI. The gateway and console run as [ACP Cloud](https://cloud.agenticcontrolplane.com). [Architecture →](/reference-architecture)
What's the license? MIT for the enforcement modules and the harness plugins (one repo per harness under github.com/agentic-control-plane). The hosted control plane (console, policy engine, cost X-ray) is not open source.
What identity providers are supported? Any OIDC-compliant provider that issues RS256 access tokens: Auth0, Okta, Entra ID (Azure AD), Keycloak, Google, Firebase Auth, AWS Cognito, and others. The `identifiabl` module finds the JWKS endpoint through the standard `.well-known/openid-configuration` URL. [Agent identity deep dive →](/agent-identity)
Is it production-ready? The harness plugins and SDKs are published on npm and PyPI with tests in each repo. [Agentic Control Plane Cloud](/pricing) is a multi-tenant gateway with a console, integrations, and an audit view, and it is what the plugins talk to. Start in audit mode and read the log for a day before you turn enforcement on.
What's the latency overhead? In a connected workspace each tool call is one HTTP round-trip to the gateway before it runs, so the overhead is mostly your network distance to the gateway. The hook gives up after 4 seconds and applies the fail mode above. We do not publish a measured p50 or p95 yet. A `--local` install evaluates rules on your machine with no network call.
Does this work with Python, Go, or only Node.js? The gateway endpoint is HTTP, so the language of your agent does not matter. Harness plugins ship as npm or PyPI packages depending on the harness. Framework SDKs exist for Python (`acp-crewai`, `acp-langchain`, `acp-pydantic-ai`) and TypeScript (`@agenticcontrolplane/governance`). [Frameworks →](/frameworks)
Can I deploy on-prem? The hook can run without the cloud: install with `--local` and rules are evaluated on the machine, nothing is sent. The gateway and console are hosted as [Agentic Control Plane Cloud](/pricing). A self-hosted or VPC deployment of the full gateway is available on Enterprise, [on request](/pricing).

Running coding agents? ACP records each tool call its hook sees and makes the dangerous shell commands (a force-push, destructive SQL, curl | sh) wait for you. One command, free up to 5 agents:

macOS · Linux · WSL
curl -fsSL https://agenticcontrolplane.com/install.sh | bash
Windows · PowerShell
irm https://agenticcontrolplane.com/install.ps1 | iex

What the installer writes  ·  Getting started