How Agent Control Room fits your application or platform

You can connect a single application directly to Agent Control Room for AI agent authorization. Your application asks before an agent acts; Agent Control Room applies your rules and answers one step at a time. Your application checks the signed, unexpired permit bound to the exact work before carrying it out. No gateway, external registry, orchestrator or scanner is required: your backend simply calls the API before taking action.

If your organisation already runs those systems, Agent Control Room fits alongside them. Gateways keep routing traffic, registries keep listing agents, and scanners and policy engines keep supplying their findings. Agent Control Room provides the decision on whether this business step, by this agent, on this resource, may go ahead now — so agents can work with useful autonomy inside the boundaries your business has set. The system that does the work stays yours.

Agent Control Room can only govern the actions that pass through it. Start with how your platform must be built so that every governed step asks first.

Build the enforcement point →

The pattern

AgentYour application or gatewayAgent Control Room decidesSigned permitYour system checks it and actsOutcome reported

The answer is always one of three: allow, refuse, or ask a person first. Most steps are allowed or refused by rules; a person is asked only where a rule says so.

Also fits existing automation

The same action-authorisation pattern can govern consequential steps initiated by RPA bots or conventional workflows—not only AI agents.

Keep your existing automation and its built-in controls. Where you need a common business-permission policy across workflows, connect the sensitive steps to Agent Control Room. A trusted execution point must request a decision and enforce the resulting permit, refusal or hold before the work proceeds.

Four places it fits

These are optional connection points, not a required stack. Use the ones that match the systems you already run; a direct application connection follows the same decision pattern.

See the four connection points working together in a concrete bank-transfer example, from an agent’s request to the bank system’s reported outcome.

Follow the example step by step →

Starter recipes cover all four connection points: an MCP server interceptor, agent-orchestration hand-offs, an API gateway plug-in, and security-scanner integrations — each a short code skeleton to adapt and test in your own platform.

Browse the plug-ins →

Building your own agent? See a complete one in code: three governed steps, a safe hold when a person must decide, and two ways to check a grant.

Reference blueprint: anatomy of a governed agent →

API and AI gateways

Already does: Authenticate callers, route traffic, apply quotas and filter content.

Agent Control Room adds: Every governed call gets its own business decision, not just a connection check. Before the call passes, the gateway asks for a decision, checks the signed permit locally with the published key, and reports whether the step was executed.

GatewaydecideActionCheck permit locallyForwardreportExecutionOutcome

decideActiongetGrantVerificationKeyreportExecutionOutcome

Example technologies ▾
  • Kong Gateway
  • Envoy
  • Cloudflare AI Gateway
  • NGINX
  • Apigee
  • AWS API Gateway
  • Azure API Management
  • LiteLLM Proxy

Representative examples only — not prerequisites or endorsements.

Starter recipe: API gateway plug-in →

MCP gateways

Already does: Expose tools to agents and control which agent may list or call which tool.

Agent Control Room adds: Each tool call becomes one business decision, so an agent's reach through a tool stays inside the boundaries you set. The gateway sends the tool name and arguments as they are; Agent Control Room computes the fingerprint and never stores the arguments. When a person must decide, the gateway receives a hold token instead of a permit.

Tool calldecideToolCallPermit, refusal or holdRun toolreportExecutionOutcome

decideToolCallgetApprovalStatusreportExecutionOutcome

Example technologies ▾
  • Cloudflare MCP
  • Kong AI Gateway
  • Azure API Management (MCP)
  • IBM ContextForge
  • Open-source MCP proxies

Representative examples only — not prerequisites or endorsements.

Starter recipe: MCP server interceptor →

Agent orchestration and hand-offs

Already does: Start agents, pass work between them and keep the chain running.

Agent Control Room adds: Work passed between agents stays governed end to end. The orchestrator reports the hand-off chain as standard facts, so a rule can refuse long chains or ask a person when no person started the work. Each hand-off can also name the grant it came from: Agent Control Room checks that grant against its own record, and permissions can only shrink down the chain — a delegated step never outlives, outreaches or outspends the grant above it. Workspace circuit breakers cap how fast one chain, and the whole fleet, may be granted work, so a runaway cascade is held rather than amplified. Afterwards, the full chain can be retrieved as a verifiable execution graph of decisions and reported outcomes — evidence of what was authorised, not a judgement of intent.

Agent Ahands off to Agent BOrchestrator adds chain factsdecideAction

decideAction

delegation.initiator_agentdelegation.via_agentdelegation.hop_countdelegation.human_origin

Example technologies ▾
  • LangGraph
  • CrewAI
  • LangChain
  • Microsoft Agent Framework
  • Google ADK
  • AWS Strands Agents
  • LlamaIndex Workflows
  • PydanticAI

Representative examples only — not prerequisites or endorsements.

Starter recipe: agent hand-offs →

Policy engines and security scanners

Already does: Answer generic access questions and inspect content for personal data, secrets or injected instructions.

Agent Control Room adds: Their findings inform your business rules without taking over the decision. Verdicts arrive as standard context facts; rules can use them, but a verdict never grants on its own: Agent Control Room never scans content itself.

Scanner or policy engineVerdict as a factdecideActionPermit or refusal

decideActiondescribePolicyEngine

sec.dlp_verdictsec.pii_detectedsec.prompt_injection_scoreauthz.external_verdict

Example technologies ▾
  • Open Policy Agent
  • Cedar
  • Cerbos
  • OpenFGA
  • Presidio
  • Lakera (Check Point)
  • NVIDIA NeMo Guardrails
  • Guardrails AI

Representative examples only — not prerequisites or endorsements.

Starter recipe: security-scanner integrations →

Where IAM and trusted facts fit

Identity and access management — such as Microsoft Entra ID or Okta — is not a fifth place in the path above, and Agent Control Room does not replace it. It works before any step is proposed: it signs people and services in, issues their tokens and holds their groups and roles.

Example technologies ▾
  • Microsoft Entra ID (formerly Azure AD)
  • Okta
  • Auth0
  • Ping Identity
  • CyberArk (privileged access)

Representative examples only — not prerequisites or endorsements.

The two answer different questions. Identity and access management proves who is asking and what they are broadly entitled to. Modern identity platforms can also weigh context such as device, location or sign-in risk. Agent Control Room decides whether this exact business step, by this agent, with this payload, may go ahead now — under your own business rules, with a person asked only where a rule says so, a signed permit bound to the work and a record of every decision.

This separation means agents need no standing authority to act. In traditional integrations, agents and service accounts are granted broad roles and permissions upfront — standing authority that accumulates over time and quickly outlives anyone's memory of why it was issued. With Agent Control Room, the agent holds no standing authority to execute a governed step. Authority is granted on demand for one specific step, bound to the exact work proposed, and expires shortly after.

The credentials your platform uses to reach downstream systems still exist; they sit behind your gate, not with the agent. Keep them in a secret manager and, where a system supports it, exchange them for short-lived, narrowly scoped tokens. Agent Control Room governs whether a step may run; it does not issue or hold those credentials.

Main question
Identity and access management: Who is asking, and is their sign-in valid?
Agent Control Room: May this exact business step run now?
Level of detail
Identity and access management: Identities, groups, roles and scopes
Agent Control Room: Individual actions, amounts, limits, hand-off depth and rate
The work itself
Identity and access management: Sees the caller and its token, not what the step will do
Agent Control Room: Binds each permit to a one-way fingerprint of the exact work, without receiving the content
Privilege model
Identity and access management: Standing permissions: broad roles, scopes or credentials assigned upfront and held continuously
Agent Control Room: No standing authority for agents to act: single-use, short-lived permits issued on demand for one exact payload
Hand-offs between agents
Identity and access management: Can pass an identity along a chain
Agent Control Room: Lets permissions only shrink down a chain, caps its depth and limits how fast it may be granted work
When a person is involved
Identity and access management: Sign-in and step-up checks when a session starts
Agent Control Room: Holds one specific step for a person only where a rule says so

In standard architecture terms

Security architects often describe access control with three roles. Mapped onto your systems, they look like this:

Policy decision point (PDP)
Agent Control Room
Applies your rules to one proposed step and answers allow, refuse or ask a person first.
Policy enforcement point (PEP)
Your backend, gateway or orchestrator
Asks before the step, checks the signed permit and only then carries out the work.
Policy information point (PIP)
Your identity provider and systems of record
Know the facts. Identity facts — who is asking, their tenant and roles — come from your identity provider through the validated token. Business facts — balances, customer tenure, risk levels, account limits and recent activity — come from your own databases, CRM or event streams. The enforcement point reads both and sends the result as context facts.

Agent Control Room is deliberately not an information point: it does not query your directory, databases or event streams. That keeps it independent of those systems, and it receives only the facts you choose to send. No fact may come from the agent's prompt or reasoning text.

Three kinds of trusted facts

In practice, the facts an enforcement point sends come in three kinds. All three travel the same way — as context facts, ideally stating who observed each one and when — and none may come from the agent.

Identity
Who is asking?
The person or service, their tenant, groups and roles.
Read from your identity provider's validated token.
Business records
What is true about this customer or account?
Customer tenure, balances, account limits, risk tier.
Looked up in your own databases, CRM or core systems at the moment of the request.
Real-time activity
What has just been happening?
Refunds to this customer in the last five minutes; payments to one account in the last hour.
Read from a stream-processing system that keeps rolling totals over your business events.

Agent Control Room already counts the permits it issues itself, so a rule can cap how often it grants. Real-time activity covers what it cannot see: work done through other channels, by people, or by systems it does not govern. A rolling total goes out of date quickly, so a workspace can require such a fact to say who observed it and when; one older than the agreed age leaves the step not decided, and it does not go ahead.

See real-time activity at work: a refund agent at a bank, rolling totals from a stream-processing system, and one refund followed from proposal to reported outcome.

Blueprint example: real-time activity facts for a refund agent →

How they connect

Your enforcement point validates the token issued by your identity provider — the information point for identity — takes the verified claims, such as the person or service, their tenant, groups and roles, and sends them as context facts with each decision request. Your rules can then use them, for example to require a finance role above a set amount. Business facts follow the same pattern: when a rule depends on a balance, how long someone has been a customer, a risk level or how much was refunded in the last few minutes, the enforcement point looks it up in your own database, CRM or stream-processing system at the moment of the request. Agent Control Room judges the facts it is given but cannot tell where they came from, so they must come from the validated token or your own systems, never from what the agent wrote.

Register directly, or keep your registry as the master

Agent Control Room keeps only a thin enforcement record: who the agent is, whether it is active, and which actions it may ask for. You can register agents directly in your workspace management console or through API operation registerAgent. If you already have an agent registry, it stays the master: your deployment pipeline can keep the enforcement record in sync through the same call. An agent that was never registered is refused and recorded for an administrator to review.

registerAgentlistAgents

Who owns what

Your systemsAgent Control Room
Identity and sign-in, routing and quotasRules for each business action
Agent inventory and lifecycleApprovals when a rule asks a person
Content scanning and dataSigned, short-lived permits
Doing the workThe decision record and its evidence

What it is not

  • Not a proxy or gateway
  • Not a model router
  • Not a content scanner
  • Not a model inventory

Optionally, the Complyee Policy Library reads your written corporate policies into the same decision, with cited evidence. Advisory readings never change the answer; a gate can only hold or refuse work the written policy does not support, never grant.

Running several agents that hand work to each other? See how delegation, cascades and evidence are controlled at the execution boundary.

Multi-agent governance →