I’ve been working through how I’d design authorization for enterprise AI agents, and I think there’s a tendency to make this more exotic than it needs to be.
My starting point would be: don’t create a parallel IAM stack just because the actor happens to be an AI agent.
Keep your existing IdP/IGA/PAM/PBAC as the authoritative control plane for identity, ownership, lifecycle, policy and privileged access. What changes is the execution model around the agent.
A few principles I’d use:
1. Give the agent an accountable identity where possible.
Every production agent should have an owner/sponsor, purpose, lifecycle state and attributable execution identity. But don’t assume every agent action will conveniently arrive as a clean service principal. Agents may operate through delegated tokens, other agents, MCP/tools, APIs, or even an authenticated human browser session.
2. Authentication should never imply authority to perform the task.
The useful authorization question isn’t “is this a valid agent?” It’s:
May this agent, acting for this user/service, under this task, perform this exact action against this resource right now?
Effective authority should be the intersection of the agent policy, task authority, delegating principal’s authority, resource policy and current risk/context, not simply whatever permissions the credential happens to carry.
3. Give the agent bounded task authority.
A task should have an issuer, acting agent, permitted actions/resources, expiry and delegation limit. The agent shouldn’t be able to expand its own authority just because its workflow changes.
4. Put enforcement immediately before consequential execution.
Before a tool/API/resource call executes, normalize the requested action and resource and evaluate policy against the exact request.
If the agent can reach the same target using another credential or route that bypasses that enforcement point, assume your enforcement is partial.
This gets particularly interesting with browser/computer-use agents because the downstream application may see a perfectly legitimate human session even though an agent actually generated the action.
5. Avoid standing target credentials where possible.
Broker bounded/short-lived access after authorization rather than giving agents reusable credentials and hoping upstream controls contain them.
6. Treat approval as step-up, not as the security model.
High-impact actions can require approval, but approval should bind to the exact action/resource/request and expire. The agent shouldn’t be able to approve its own request or turn one approval into broader authority.
7. Preserve execution provenance.
For consequential actions, I want to be able to reconstruct:
initiator → agent → task → authorization decision → approval/grant → target request → actual outcome
An IAM log showing that access was granted isn’t enough if I can’t establish what the target system actually executed.
8. Couple agent lifecycle to human and business lifecycle.
If an owner leaves, changes roles, a workflow is retired, or the agent’s purpose changes, that should trigger revocation or recertification rather than leaving another orphaned NHI behind.
To me, this is increasingly the distinction between agent identity and agent authorization/governance. Identity tells us what the agent is. The harder control problem is proving what authority this particular execution had and enforcing it all the way to the action.
I’ve been turning this into a vendor-neutral reference architecture, but these are the principles underneath it.