Skip to content
Agentic Control Plane

The incidents you're one bad tool call away from

An agent can refund the wrong 200 customers, delete the wrong table, or email the wrong person's data. Hand-rolled checks tend not to hold when you're not watching. Here is each failure mode and what ACP does about it.

Six failure modes, one choke point

The refund fan-out

An agent misreads a policy and starts refunding customers. Each refund is valid on its own and the total is a disaster. Flat daily caps don't help, because the agent spends them to zero. ACP can gate money tools on the outliers: an unusual size asks a human, the Nth call in an hour trips, and routine calls keep flowing.

Stop your agent from making payments without approval →

The destructive write

rm -rf, DROP TABLE, repo.delete: the calls you can't undo. Prompt rules are advisory, and a model can ignore them under pressure or after a poisoned tool response. ACP checks the call itself, outside the model, and rules can be scoped by agent and by who it's acting for. Out of the box it records in audit mode and the built-in floor holds the worst shell commands for approval. You set deny rules for the other tools you care about.

Stop your agent from deleting your database →

The wrong customer's data

An agent acting for user A pulls something only user B should see, because the backend saw a valid service token and not a person. ACP ties every call to the user the agent is acting for, can scope access to what that user can touch, and can redact PII when your policy says so.

The three-party identity gap →

The runaway bill

A loop that retries, re-plans and re-reads until the invoice arrives. ACP meters every tool and model call and shows which step is burning the money (it's usually one). You can set hard budgets that warn the agent before cutting it off mid-task.

The loop tax: why agents are expensive →

The talked-into-it agent

A poisoned web page or tool response tells your agent to do something it shouldn't, and anything in the prompt can be talked past. ACP's check sits outside the model, so whatever the agent was convinced of, the call still meets your policy on the way through. Out of the box ACP records in audit mode, and the built-in floor pauses only shell commands such as force-pushes, curl | sh and destructive SQL. Set deny rules for the other tools you care about.

What's actually inside 7,522 agent skills →

“Prove what every agent did, and why it was allowed”

You can't answer that when your logs say service_account: 200. ACP logs the decision as well as the action: who asked, which agent acted, which rule allowed it, and what it cost, for each call.

What 285,000 governed tool calls look like →

The same checks, any industry

The failure modes above don't depend on your business. Only the data changes. A few examples:

Healthcare SaaS

Diagnostic assistants query patient records with the physician's identity verified on every call and access scoped by license type. PII is redacted when your policy says so, and every query is logged: identity-attributed evidence for the reviews HIPAA work involves. ACP is not HIPAA-certified.

Fintech & lending

Credit queries scoped to each officer's assigned borrowers, per-officer rate limits on data pulls, and identity on every row. SSNs can be masked per policy on harnesses whose post-call hook can rewrite tool output (see coverage).

SaaS shipping AI features

Every tool call arrives with the customer's verified identity, tenant isolation is enforced at the gateway, and per-customer budgets catch abuse. You can ship the AI integration without building the control layer first.

Internal copilots

SSO identity through every request, tool access scoped by role, per-user spend limits, and every action attributed. That answers “what did the copilot just do, and as whom?”

Put a control plane between your agents and the incident

Self-host with the MIT-licensed modules, or use ACP Cloud. After one install, your next agent run shows up in the console.