What Is an Agentic Control Plane (AI Agent Control Plane)?
An agentic control plane (ACP) sits between an AI agent and the tools it uses. It is also called an agent control plane. Each tool call is checked against your rules before it runs, priced, and recorded, in each harness or framework you install it on: Claude Code, Codex, Cursor, CrewAI, LangGraph and others on the integrations page.
What each harness can do with an “ask” differs. Claude Code shows the question inline. Elsewhere the call is blocked, you approve it on the console or by email, and the agent retries.
See this on your own agents in about a minute. One command adds it to Claude Code, Codex, Cursor and the other harnesses it finds on your machine:
curl -sf https://agenticcontrolplane.com/install.sh | bash
No account? Add --local and every decision stays on your machine. Full getting-started guide →
Think of it as the permission system your agents would have if they all shared one.
Agents make chains of calls
Say you ask Claude Code to review a PR. It hands the job to a security subagent, which runs a SAST scan. Three hops down, a tool call hits your repo. If nothing tracks the chain, identity is dropped at the first hop, scopes widen, and your audit log is one row that says api_key=sk-shared.
A control plane keeps the checks and the record attached across those hops. The example below is illustrative.
budget $5.00
budget $5.00 (narrowed)
budget $1.00 (narrowed)
ALLOW · 2.3s · $0.14
Each hop gets a narrower slice of the user’s permission. On the MCP endpoint and the model proxy, ACP rebuilds this chain on every call (root identity, depth, scopes, remaining budget) and checks it. Coding-agent hook calls carry the workspace key and the agent’s identity instead of a chain key. Either way, the audit log shows who and what was behind each call.
What an ACP does: record, learn, control
Three things, on every call in the harnesses you’ve installed it on.
Underneath those three: identity (a workspace key for coding agents, the end user’s IdP token on the framework path), rate and budget limits, and a structured, queryable audit log. PII detection and redaction is on by default on the model proxy. For hook-governed tool calls it is a policy you turn on.
What goes wrong without one
Where it fits in your stack
For coding agents the plane is a hook inside the harness plus the gateway it reports to; for framework agents it is an SDK wrapper around your tools plus a proxy in front of the model. Same rules, same audit trail, one console.
- Not an LLM gateway. Portkey, LiteLLM, and OpenRouter choose which model answers. An ACP decides whether the user is allowed to ask.
- Not an agent framework. LangChain, CrewAI, AutoGen decide what an agent does. An ACP decides whether it’s allowed.
- Not an API gateway. Kong and Apigee manage HTTP traffic. An ACP propagates verified human identity through the AI layer and produces identity-attributed audit trails.
Use all of them. They solve different problems at different points in the request flow. Full comparison →
How identity works on the framework path
If your agent runs inside an app you built (CrewAI, LangGraph, the Anthropic or OpenAI SDKs), the user signs in with your identity provider (Auth0, Okta, Entra ID, Firebase, any OIDC provider) and gets a signed JWT. A typical payload (an example, not a spec):
{
"sub": "auth0|8f3a2b1c9d4e5f6a",
"aud": "https://api.yourapp.com",
"scope": "tool:crm:read tool:jira:write",
"org_id": "org_acme_corp",
"exp": 1739145600
}
Without a control plane, your tools only see a shared key, so every call looks like it came from the same caller. With one, each tool call is recorded against the person behind it, along with the scopes and chain it ran under. That is what lets you answer “who did this?” per user instead of per key.
Coding agents on a laptop skip this. They are identified by their workspace key and agent identity.
When you need one
- You run a coding agent for hours a day and can’t say what it did, what it could have done, or what it cost
- You’re about to let an agent run unattended, and the checks you rely on live in a prompt
- Your agents take real actions: create tickets, modify records, push code, process transactions
- Every team ships in a different harness or framework and there is no one set of rules across them
- Your model spend surprises you, and per-key limits can’t tell you which agent or which step
- You work in a regulated industry and need a record of who was behind each call
Get started
--local: no account, decisions on your machine, every call logged to a file. What each mode writes, file by file.init() prices the model calls.Background: where this category started (the three-party problem)
Traditional web apps have two parties: a user and a backend. Authentication is solved. Access control follows. AI apps added a third party, the LLM runtime. The user authenticates with the LLM, the LLM calls your backend with a shared API key, and the backend has no idea *who* made the request. Identity is severed. Every control failure in production AI systems traces back to this. We call this the **three-party problem**: user, LLM, backend — and identity has to flow across all three. It's the clearest framing for *why* the control layer needs to exist. The delegation-chain framing above is the same idea, extended: when an agent calls another agent, identity has to flow across every hop, not just the first one. Three-party trust is the foundation; delegation chains are how it scales. For the longer write-ups, see [agent-to-agent control](/agent-to-agent) and [agent delegation chains](/what-is-an-agent-delegation-chain).Frequently asked questions
What is an agent control plane?
The layer in the call path between an AI agent and the tools it uses. In each harness you install it on, every tool call is checked against your rules (allow, ask or deny) before it runs, priced, and recorded with the identity behind it. Agent control plane, AI agent control plane and agentic control plane name the same layer.
What does an AI agent control plane control?
Tool calls and model calls. It records each one in order with its cost, latency, decision and identity; turns any recorded call into a standing rule; and applies allow, ask or deny per tool, per tier (interactive, subagent, background) and per person. Budget caps can halt a run if you enable halting. Your own rules start in audit mode, and the safety floor is on from the first call.
agentic ai control plane vs agent gateway: what's the difference?
A gateway routes traffic. An agentic AI control plane decides, per call, whether this agent may run this tool with these arguments for this user, and keeps the record. The MCP-specific version of the same comparison is on What is an MCP control plane.
When do you need an agent control plane?
When you can’t say what a coding agent did, could have done, or cost; when an agent is about to run unattended and its checks live in a prompt; when agents take real actions such as pushing code or modifying records; or when every team runs a different harness and there is no one set of rules across them.
Related concepts
- Agent delegation chains: the record that follows a task across agent hops
- Agentic data plane: the execution layer, separate from the control layer
- MCP control plane: the same idea for MCP traffic
- Runtime authorization: per-call policy checks, the decision model behind “Control”
- Agent identity: how individual agents are identified
- Three-axis control: tool, agent and user policy
- Reference architecture: the six composable modules in detail
Get started → · Agent-to-agent control → · Reference architecture → · GitHub →