Imperium — AI Governance & Control
AI Agent Control: Why Enterprises Cannot Afford to Lose Control of Autonomous Systems
Almost every organization can revoke an AI agent’s access eventually. The question that decides an incident is how quickly, and how completely, that authority can be withdrawn.

When an AI agent starts doing something it should not, the question that decides the size of the incident is simple: how long until it can no longer act?
In its October 2026 survey of 900 senior technology leaders in the UK and US, Gravitee asked exactly that. Of the organizations that had deployed agents, 6.3% said they could revoke an agent’s access to all systems and data within an hour. Another 47.1% said the same day. Roughly 46% said it would take a few days or longer.
The finding is easy to misread, so it is worth being precise. It does not show that most organizations cannot stop their agents. Almost all of them said they could revoke access eventually, and more than half said they could do it by the end of the same day. What the survey measured is the speed and completeness of revocation across every system an agent can reach. That narrower measure is the one that matters, because an agent does not pause while an organization works out where its credentials live.
Revocation that eventually succeeds is not the same as control. Control is measured in how much an agent can still do after you decide it should stop.
What the number does and does not tell us
The figure comes from a vendor survey. Gravitee sells agent management technology, the fieldwork was run by Opinion Matters between 8 and 19 October 2026, and the answers are self-reported. Respondents were CIOs, CTOs, engineering and platform leaders at organizations with 250 or more employees. Self-assessment tends to flatter: an organization that believes it could revoke access within the hour has rarely tested that belief under incident conditions.
Even with those caveats, the shape of the result is consistent with what architects see in practice. In the same survey, policy was enforced on only about half of the agents organizations run, and only one in eight respondents said they could fully reconstruct what an agent did 30 days earlier. Revocation speed, enforcement coverage and reconstruction are three views of one underlying question: does the organization hold authority over its agents, or does it merely know they exist?
Why an hour is a long time for an agent
A human operator who goes off course is limited by typing speed, working hours and the need to understand each system before touching it. An agent has none of those limits. Within one hour, an agent with ordinary engineering permissions can plausibly do any of the following:
- Run thousands of queries against production data.
- Execute commands on the hosts it can reach.
- Change infrastructure through the APIs it was given.
- Call external services and send data to them.
- Hand work to other agents, each with credentials of its own.
This is an illustration, not a forecast. Most agents will never misbehave in a way that matters. But control is designed for the cases that do, and in those cases the window between detection and effective revocation is the window in which damage accumulates.
The weakness is rarely the model. It sits in the architecture around the model: how the agent is identified, where its authority comes from, which credentials it carries and who can withdraw them.
Identity models built for people, stretched over software that decides
Enterprise identity and access management was built around two kinds of subject. Humans log in, are reviewed periodically and leave the organization through a joiner-mover-leaver process. Services and applications run under service accounts with fixed, predictable behavior.
An AI agent fits neither category. It acts on behalf of a person, but it is not that person. It runs like a service, but it chooses its own sequence of actions. When organizations force it into one of the existing boxes, the usual result is a static API key or a shared service account that many agents use at once.
That choice determines what revocation looks like later. If ten agents share one key, revoking the key stops all ten, including the nine that were behaving. If an agent uses a developer’s personal token, revoking it locks out the developer. Under that pressure, teams hesitate, and the hour passes.
Each agent therefore needs its own identity, distinct from the human who started it and from the other agents in the same workflow, so that one agent can be suspended without collateral damage. Each identity also needs a named owner: a person who can be asked what the agent is for and who is accountable when it acts.
Delegated authority has to narrow, never widen
Agents increasingly hand work to other agents. A coordinating agent breaks a task into parts and gives each part to a specialist. Each hand-off is a delegation of authority, and in many current systems it happens implicitly: the sub-agent simply inherits the credentials of the agent that called it.
Two rules make delegation governable. First, a delegated agent should receive at most the authority of its delegator, and normally less, scoped to the sub-task. Second, the chain should be recorded, so that every action can be traced back through each delegation to the person or policy that authorized the original work. When the root grant is withdrawn, everything derived from it should fall with it.
Without those rules, revocation becomes a search problem. The organization has to discover every place the original authority was copied before it can be sure the agent has stopped.
Credentials that expire by design
Long-lived credentials make revocation an active, manual operation that someone has to perform, under pressure, in every system that trusts the credential. Short-lived credentials invert that. If an agent’s token is valid for minutes rather than months and must be renewed through a broker, stopping the agent becomes partly a matter of declining to renew.
A credential broker adds a second protection. When the agent never holds the underlying secret, such as a model provider key, a database password or a cloud access key, there is nothing for it to leak and nothing to hunt down afterwards. The broker hands out narrow, expiring access for each request and remains the single place where that access can be refused.
Short lifetimes do not remove the need for explicit revocation. A token that lives for fifteen minutes is still fifteen minutes of exposure. But they bound the damage, and they turn the inventory problem, finding every credential an agent holds, into a much smaller one.
Enforcement has to sit on the execution path
Many organizations now have AI policies. Fewer have policies that are enforced at the moment an agent acts.
There is a meaningful difference between a decision point and an enforcement point. A policy engine that evaluates a request and records "deny" has made a decision. Unless something on the execution path then refuses to forward the request, nothing has been controlled. Observe-only modes are useful while policies are tuned, but they must not be mistaken for control.
Runtime enforcement means that every consequential action an agent takes passes through a point that can refuse it: calls to models, invocations of tools, access to data and changes to infrastructure. The decision must be made outside the agent, because an agent cannot be relied upon to police its own instructions. A prompt that says "do not delete production data" is guidance. A gateway that refuses the delete is control.
Stopping an agent has layers
"Stop" sounds like a single action. In practice it is a sequence, and each layer closes a different gap:
- Admission
- refuse new requests from the agent at the gateway, immediately and without a redeployment.
- Sessions
- end the agent’s active sessions and the processes running on its behalf.
- Credentials
- invalidate the tokens it holds and stop renewing them.
- Delegations
- withdraw the authority it handed to other agents, so the work it spawned stops too.
- Outstanding work
- identify requests already submitted to external systems, some of which cannot be recalled.
A kill switch that covers only the first layer is still valuable: it stops the bleeding. But the organizations that can answer "within an hour" honestly are those that have rehearsed all five layers, know which systems sit outside their reach, and measure time-to-revoke the way they measure time-to-restore. A revocation path that has never been exercised is an assumption.
Evidence and accountability
When the incident is over, someone will ask what the agent did, on whose authority and with what effect. The answer has to come from records written at the time, not from reconstruction afterwards. That means an append-only record of each decision and action, linked to the agent’s identity, the delegation chain and the policy that allowed it, and protected so that changes to the record are detectable.
Records are necessary but not sufficient. Operational accountability means that for every agent in production there is a named person who owns it, a defined process for approving its high-impact actions, and a clear answer to who is entitled to stop it. In the Gravitee survey, fewer than one in ten organizations running agents reported having a named person formally accountable for them. That gap is organizational rather than technical, and no gateway closes it on its own.
A baseline for agent control
Taken together, these controls form a practical baseline. None of it requires exotic technology. It requires treating agents as a distinct class of actor and designing their authority to be withdrawable from the start.
| Control | The question it answers |
|---|---|
| Agent identity | Which agent did this, separately from the person who started it? |
| Delegated authority | Who authorized this agent, and did authority narrow at each hand-off? |
| Short-lived credentials | If we stop renewing, how quickly does access end on its own? |
| Runtime enforcement | Is there a point outside the agent that can refuse this action now? |
| Layered stop | Can we stop admission, sessions, credentials and delegations, and have we rehearsed it? |
| Audit record | Can we reconstruct what happened from records written at the time? |
| Ownership | Who answers for this agent, and who may approve its high-impact actions? |
Where TRACSTON IMPERIUM stands
IMPERIUM is TRACSTON’s control plane for enterprise AI. Because the argument above is easy to make and hard to implement, here is a plain account of what it does today and how the same architecture extends.
Implemented today
- An agent registry in which every agent has an accountable human owner, a declared operating envelope and a lifecycle; an agent can be suspended and its access tokens revoked.
- A credential broker for model providers: agents and users never hold provider API keys. Model-access tokens are bound to a consumer and carry an expiry and rotation.
- A policy engine that evaluates each request at the gateway and returns allow, deny or require-approval. Denials are applied when the gateway runs in enforce mode; an observe-only mode exists for rollout.
- Per-tool authorization for agents that request tool access through the tool registry, and a human approval queue in which decisions expire.
- A global stop that can halt all AI traffic, all agents, a single agent or a scope, or disable tool access, without a restart, and records the action before applying it.
- An append-only, hash-chained audit record of each stage of an execution. It is tamper-evident, not yet tamper-proof.
How the architecture extends
- Per-sub-agent identity: delegated tokens that can only narrow authority, expire within minutes and fall when the parent is revoked.
- Short-lived, scoped tokens for workloads and service accounts beyond model access.
- A stop that also invalidates credentials and interrupts work already in flight, and that applies across a whole cluster at once. Today the global stop blocks new requests at admission on each node.
- Cryptographically verifiable agent identity and signed execution evidence.
- Routing approval requests to each agent’s accountable owner, and control over tool calls made inside model responses by agents that do not use the tool registry.
The second list applies the same principles this essay describes. We keep the two lists separate because a governance product that overstates its own controls would be making the problem it claims to solve.
Control has to outlast the agent
The survey figure that started this essay will change. As more organizations deploy agents at scale, they will be pushed to make revocation fast, either by planning or by incident. The question is which of the two gets them there.
Enterprises do not need to slow down their adoption of agents to stay in control of them. They need to design authority that can be withdrawn quickly and completely, enforce it outside the agent, and keep a record good enough to explain afterwards what happened.
TRACSTON | Infrastructure for the Intelligent Organization
References
- Gravitee, “The State of AI Agent Security 2026”, October 2026 survey of 900 senior technology leaders (UK and US, organizations with 250+ employees), fieldwork by Opinion Matters, 8–19 October 2026. Revocation question base: organizations with agents deployed (n=893).
- Jorge Ruiz, “AI Agents Are in Production. Agent Accountability Is Not.”, Gravitee, 12 November 2026.
Tracston works on these questions in IMPERIUM and OBSERVATORY.





