AI agent access control decides which systems, tools and data an AI agent may use, and enforces that decision each time the agent acts. It has two halves. Access governance decides what the agent should have: who owns it, what it is granted, who approved that, when it is reviewed and when it ends. Runtime enforcement checks every tool call against that decision while the agent runs. You need both, because a grant that nothing checks and a check against rules nobody reviews each leave half the problem open.
Why agents need their own approach
On the surface agents look like service accounts, since they authenticate with a credential and hold permissions. The difference is that a script calls the same endpoints on every run, while an agent decides which tools to call, in which order and with which arguments, based on what it reads. Its permissions describe what it may do, not what it will do.
What it reads matters too. An agent working through an inbox can be steered by text in one of the emails, and access control is what limits how far a steered agent can reach.
Agents also tend to act for a specific person, which creates a subtler problem. If that person cannot approve a payment but their agent can, the person can get the payment approved anyway, through the agent, unless your rules cover the two together.
The building blocks
Identity per agent
Each agent needs its own identity, registered with a type, a status and a named owner. When several agents share one API key, you lose the ability to say which agent did what.
Least privilege, per tool
Grant tools on specific servers rather than whole systems. A grant that says the agent can search tickets and add comments is one you can reason about in a review, whereas “has the helpdesk API key” tells you almost nothing. Credentials should be short-lived and scoped to what was granted.
Policy on intent, not only on identity
Some decisions depend on what the agent is trying to do and to which resource. Reading a repository is routine, but deleting one is not. Policies that match the action and the resource, and say allow, deny or hold for approval, express that, and a call that matches no policy should be denied.
Human approval for sensitive actions
However well an agent is scoped, some actions should not run without a person, payments and deletions being the obvious ones. A hold puts the call in front of an approver and lets it continue only when they agree.
Separation of duties
The classic rule is that one person should not both create and approve a payment. For agents the rule has to stretch further. It should catch one agent holding both tools, but also an agent and the person it acts for holding one half each, or two agents belonging to the same person splitting the task between them.
Enforcement on the call path
Grants and policies only matter if something checks them on every call. That is the job of an inline checkpoint such as an MCP gateway, which verifies the agent, checks the tool, applies rate limits and inspects the payload before the call reaches the server.
Reviews and revocation
Agents belong in access reviews, reviewed by the person who owns them, with context such as when each tool was last used. Every grant also needs a revocation path that works quickly, and that includes tokens already issued under it.
Lifecycle
An agent’s access should end when its purpose does, and its owner leaving should reach it too. The joiner, mover, leaver article covers that in more detail.
Access control vs access governance vs access management
People use the three terms loosely, and often for the same problem. Access management usually means authentication and authorisation at the moment of access: who is this, and may they make this call? Access governance is the set of processes around it, such as requests, approvals, reviews, separation of duties, lifecycle and evidence. Access control is the umbrella that covers the rules and the mechanisms that enforce them.
For agents the labels matter less than making sure both halves exist and share the same identity, grants and audit trail.
A practical rollout
- Inventory the agents that exist and the credentials they hold, and register each one with an owner.
- Replace broad keys with per-tool grants and short-lived tokens.
- Put a checkpoint in the call path in observe mode, and read what it would have denied.
- Write policies for the actions that matter most, starting with deny and hold-for-approval rules.
- Switch to enforcement one server at a time.
- Review agent access on a schedule, and wire agents into your leaver process.
How AtmanID approaches it
AtmanID governs humans and AI agents on one identity model and one tamper-evident audit trail (What is AtmanID).
An agent registered through the API has a named owner and starts in a pending-review state until an administrator approves it (register an NHI with curl). To call tools, it mints a token for one MCP server and a set of that server’s tools, and if any requested tool is outside its grant, the whole request fails. Tokens can be bound to the agent’s key with DPoP, and suspending or deprovisioning an agent makes its tokens inactive on the next check (MCP bearer-token flow).
Every agent → MCP call passes through the AtmanID gateway, which checks scope, rate limits and payloads and applies intent policies that allow, deny or hold a call for approval. A call that matches no policy is denied, and new enforcement starts in shadow mode (MCP gateway).
Agent SoD rules name pairs of MCP tools, or a tool and an entitlement held by the person the agent acts for, and the findings include two agents of one person and agents that can call each other (Separation of duties for AI agents). An Agent Access Review puts agents’ tool grants into a certification campaign assigned to each agent’s owner, who sees when the agent last called each tool through the gateway. Revoking there removes the grant and the tokens issued under it.
When a person leaves, the leaver workflow deactivates the AI agents they own, or flags them for a new owner when a team manages them (joiner, mover and leaver events).
FAQ
What is AI agent access control?
It is the set of rules and mechanisms that decide which tools, systems and data an AI agent can use, and that check each of its actions against those rules as it runs. It covers the agent’s identity and grants, the policies and approvals that apply, and how access is reviewed and revoked.
Is RBAC enough for AI agents?
Roles are a useful way to grant access, but they are coarse for agents, because a role describes what an agent may touch and says nothing about what it is trying to do with it. Per-tool grants, intent policies and runtime checks fill that gap.
Should an AI agent use its owner’s credentials?
No. With its own identity, an agent can be scoped, reviewed and revoked on its own, and its actions can be told apart from the person’s in the audit trail. Record the person it acts for alongside the agent instead.
How do you revoke an AI agent’s access quickly?
Revoke the grant, and make sure the tokens issued under it stop working as well; short-lived or introspected tokens make that fast. If you are not sure which grant is the problem, suspending the agent itself is the broader option.
What is AI agent access governance?
It is the governance half of agent access control: registering agents, assigning owners, approving and reviewing their access, separation of duties, lifecycle and audit evidence, run with the same discipline you apply to people.
Related: What is an MCP gateway? · Just-in-time privileged access for AI agents · How to govern AI agents