Identity has traditionally answered questions about people and systems: who they are, what they can access and what they are allowed to do.
As AI agents begin to act autonomously, those same questions move to the centre of AI governance.
Key Takeaways
- AI agents create a new governance layer between intention and action.
- Identity provides the mechanisms for establishing actors, authority, delegation and accountability.
- Runtime authorisation allows organisations to make access decisions closer to the moment of action.
- Identity does not replace AI governance; it provides an enforceable control layer for parts of that governance.
AI governance needs an enforcement layer
AI governance frameworks can define principles around responsible development, risk management, human oversight and accountability.
NIST's AI Risk Management Framework, for example, provides a voluntary framework for incorporating trustworthiness considerations throughout the AI lifecycle. Its Generative AI Profile extends those considerations to risks associated with generative AI systems.
But a policy is only useful if an organisation can operationalise it.
Consider a simple policy:
An AI agent may access customer information only when that information is required to complete an authorised task.
That statement establishes an intention.
Identity and authorisation provide part of the mechanism for enforcing it.
They can establish which agent is requesting access, who it represents, what authority has been delegated and whether the requested action falls within that authority.
This is where identity starts to look less like an access-control function and more like a control plane.
The control plane follows the actor
In traditional architectures, identity often sits at the boundary of applications.
Authenticate the user.
Determine their permissions.
Allow access.
Agentic architectures make the flow more complex.
A human may initiate a task. An orchestrator may invoke an agent. The agent may call a tool. The tool may access an API. Another agent may become involved.
Trust can move through the chain.
The identity model needs to move with it.
Ping's current agent identity guidance describes this as preserving identity and authority through agent delegation, runtime decisions, least privilege and auditability.
The goal is to prevent a valid starting point from becoming an unrestricted chain of trust.
Runtime changes the question
Consider two requests arriving at the same API.
Both come from authenticated agents.
One is performing a legitimate task.
The other is requesting an action that exceeds the authority originally delegated to it.
Authentication alone cannot distinguish the two.
Runtime authorisation can consider the request in context.
Which agent?
Acting for whom?
Which resource?
Which action?
What authority?
What conditions?
Is additional approval required?
That is the practical significance of runtime identity.
The security decision moves from:
“Was this identity trusted when access was granted?”
towards:
“Should this identity be permitted to perform this action now?”
The control plane also needs accountability
Control is only one part of governance.
The organisation also needs evidence.
If an agent changes a customer record, the audit trail should ideally allow investigators to reconstruct the action and its authority.
If an agent initiates a sensitive transaction, the organisation should know whether additional approval was required and whether it occurred.
If one agent delegates work to another, the relationship should remain visible.
This is why identity, authorisation and auditability need to be considered together.
A control that blocks an action but provides no useful context may protect the system in the moment while making investigation difficult later.
A detailed audit record without effective enforcement may explain an incident without preventing it.
Governance requires both.
The control plane must operate at enterprise scale
The challenge is not only technical.
As organisations deploy more agents, manual governance becomes increasingly difficult.
Teams need to know which agents exist, who owns them, what they can access and whether those permissions remain appropriate.
They also need consistent policy across applications, APIs, tools and agent-to-agent interactions.
That is why the emerging identity model for agents is built around familiar governance disciplines — discovery, ownership, lifecycle management, least privilege and auditability — combined with runtime controls for autonomous actions.
From identity management to identity governance for AI
The broader shift is therefore subtle but important.
Identity is no longer only about managing who gets access.
It is increasingly about governing how authority is exercised.
For human users, that distinction has always existed, but the pace and autonomy of AI agents make it impossible to ignore.
An agent may be authenticated correctly and still make an inappropriate decision.
It may have legitimate access and still exceed the intended scope of a task.
It may act on behalf of a real user and still require additional approval before taking a high-impact action.
Identity needs to provide the context necessary to make those distinctions.
That is why identity is becoming a control plane for agentic AI.
Not because identity replaces AI governance.
Not because every AI risk is an IAM problem.
But because an organisation cannot govern autonomous action without being able to establish who or what is acting, under whose authority, with what permissions and with what accountability.
As agentic AI moves from experimentation into enterprise operations, that may become one of the most important identity questions of all.
