Skip to content
Agentic Control Plane

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.

● Human
Alice
github.* · slack.* · jira.*
budget $5.00
◆ Agent
PR Reviewer
github.pr.*
budget $5.00 (narrowed)
◆ Subagent
Security Scanner
secrets.scan
budget $1.00 (narrowed)
■ Tool
sast.run
user: alice
ALLOW · 2.3s · $0.14
ILLUSTRATIVE · CHAIN d=3 · root=alice · tool=sast.run SCOPE NARROWED 3× · ROOT IDENTITY PRESERVED

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.

/ 01
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 blocks the catastrophic and holds the destructive from the first call, and your own rules apply once you turn on enforce.
/ 02
Learn
Any row becomes a standing rule in one click. Agents propose rules from the denials they hit, and you confirm them. Your rules don't block until you switch to enforce. The floor is already on.
/ 03
Control
Allow, ask, or deny per tool, per tier (interactive, subagent, background), per person. Budget caps that can halt a run when you enable halting. Each agent's declared tool surface, one click to deny what it never uses.

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

Shadow AI
Shared API keys passed around Slack. No idea which user made which request. When something breaks, no way to trace it.
Data leakage
SSNs, PHI and access tokens flow into LLM prompts unchecked, straight to a third-party model with no record.
No audit trail
"Who accessed patient data through the AI last Tuesday?" If the answer is "we don't know," an auditor will notice.
Runaway cost
One agent loop, 10,000 calls, a month's budget gone overnight. Request counting isn't cost control.

Where it fits in your stack

User
SSO / OAuth
→
LLM Runtime
ChatGPT, Claude, agent framework, MCP
→
Agentic Control Plane
Record · Learn · Control
→
Your Backend
APIs · DBs · tools

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


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.



Get started → · Agent-to-agent control → · Reference architecture → · GitHub →