AI agents

Govern every AI agent, and every agent it calls.

Agents don't wait for a person to press send. They plan, call tools and models in loops, pass data between each other and act on the results. agentKeyRoute gives every agent its own identity and policy, checks every step it takes, and records all of it.

Why agents need governance

An agent makes hundreds of decisions you never see.

They act in loops

One task can mean dozens of model calls, each a chance for data to leave.

Tool results carry data

A database row or a file an agent reads goes straight back into its next prompt.

They call each other

In multi-agent systems, data moves between agents with different jobs and different rights.

Costs run away

An agent stuck in a loop can burn through a month's budget overnight.

Every agent governed

Each agent gets an identity, a policy, a budget and an off switch.

Register each agent as a workload and give it its own key. From then on, every call it makes is tied to that agent, its team and its governance profile, whichever framework it's built with.

Its own identity

A key per agent carries its team, its workload and its governance profile, so two agents in the same system can follow different rules.

An autonomy level

Mark an agent as assistive, human-in-the-loop or autonomous. Autonomous agents score higher risk, and the EU AI Act framework holds autonomous high-risk agents for human oversight.

Every step checked

Every message an agent sends is scanned, including the tool results it passes back to the model, and redacted or blocked before it leaves.

A budget per agent

Set a monthly budget on the agent's workload. When it's spent, the agent's requests stop with a clear error instead of a surprise bill.

Kill switches

Stop one agent, revoke one key, or stop every agent in the organisation at once, from the console.

Answers the agent can read

Responses carry the decision, the rule that applied, the risk score and a request ID, so agents and their developers know exactly why something was redacted or blocked.

Multi-agent systems

One system, many agents, each with its own rules.

An orchestrator hands work to specialist agents. With agentKeyRoute in the middle, each agent's calls follow that agent's policy, not the most permissive one in the system, and everything lands in one audit trail.

  • Separate keys, separate rules. The research agent can use any model; the patient-records agent never leaves your servers.
  • Data checked between hops. Whatever one agent hands to another is scanned again when it goes to a model.
  • Cost per agent. See which agent in the system spends what, against its own budget.
  • One timeline. Every agent's requests and decisions in the same tamper-evident log.

Team-wise policies

Different teams, different rules, one place to manage them.

Rules match on team, agent or app, data type and task, and the first matching rule decides. Give each team the protection its work needs instead of one policy that's too loose for some and too strict for others. Some examples:

Team · Clinical

When
Health data (PHI) in any request
Then
On-premises models only. Values redacted before anything leaves.

Profile: HIPAA · Clinical

Team · Engineering

When
Coding agents with confidential source code
Then
Private-cloud models only (your Azure, Bedrock or Vertex). Secrets always blocked. $1,500 monthly budget.

Profile: Coding agents & developer tools

Team · Customer support · EU

When
EU personal data from customer chats
Then
Models that process data in the EU, with zero-retention providers preferred.

Profile: GDPR · EU personal data

Team · Finance

When
Card or bank details
Then
Redacted, and routed only to models that hold a PCI DSS attestation.

Profile: PCI DSS · Payments

Team · Marketing

When
Public content with no sensitive data
Then
Any approved model, cheapest first. Images and video through the same gateway.

Profile: Marketing & communications

Team · Data science

When
Experiments in the evaluation sandbox
Then
Simulated or low-cost models, no content capture, a tight budget.

Profile: Evaluation & sandbox

Examples of rules you can set up. Rules are ordered, versioned with snapshots and rollback, and anything no rule allows is denied.

Audit everything

Every agent, every request, every change, on the record.

Nothing an agent does through agentKeyRoute goes unrecorded. Each request keeps its full decision trace: who or what sent it, what data was found, which rule applied, which model and account actually served it, what it cost and how long it took.

Changes to the rules are recorded too: policies, profiles, keys, providers, budgets and settings, along with who made them and who approved them. Support access is read-only and appears in your own log. Entries are hash-chained, and an integrity check shows if any were altered.

  • RequestsEvery call from every agent, app, person and tool
  • DecisionsAllowed, redacted, held or blocked, and the reason
  • RoutingThe model, provider and account that really answered
  • CostPer request, rolled up by agent, team and person
  • ChangesWho changed which rule, key or setting, and who approved it
  • EvidenceControl checks and evidence packs for your auditors

Works with the agent frameworks you already use.

Anything that calls the OpenAI or Anthropic API can run through agentKeyRoute: Claude Code, Codex, Cursor, LangChain, the OpenAI and Anthropic SDKs, and agents you've built yourself. Change the base URL, give each agent its key, and it's governed.

See every supported model →

Put your agents under your policy.

Register your first agent, give it a key and a profile, and watch every step it takes in the request explorer.