TL;DR: C1.ai argues that identity security was built for a stable world of known users, known apps and tracked service accounts, but agentic AI has expanded the surface area into messy, runtime-driven identity creation. The old NHI playbook is necessary yet insufficient because agents need authorization per action, not only lifecycle control.
At a glance
What this is: NHI Mgmt Group's analysis, drawing on C1.ai's blog post: Identity programmes built for known users and tracked service accounts are being strained by agentic AI and runtime identity creation.
Why it matters: IAM, IGA and PAM teams now have to govern identities that appear outside traditional registration paths, with access decisions shifting toward action-time control rather than after-the-fact cleanup.
👉 Read C1.ai's analysis of runtime identity governance for agentic AI
Context
Identity security breaks down when the programme assumes identities are known before they act. That model worked when employees, applications and service accounts sat inside manageable inventories, but it no longer fits environments where new identities appear through builders, agents and ad hoc automation.
The governance gap is not simply more identities. It is that runtime behaviour now matters as much as the identity record itself, and identity governance challenges are visible in the gap between registration and actual use.
Key questions
Q: How should identity teams govern agents that act on behalf of employees?
A: Treat them as delegated access with a lifecycle, not as a one-time exception. Assign ownership, bound the use case, define what the agent can do, and review the scope as usage changes. That approach keeps delegation tied to business context and prevents agent permissions from drifting beyond the decision they were meant to support.
Q: Why do periodic access reviews miss fast-changing agentic access?
A: Periodic access reviews miss fast-changing agentic access because an AI agent can gain, use and relinquish tool permissions, tokens and data scope between review cycles. The real control point is event-time governance: policy checks at authorisation, step-up approval for sensitive actions, scoped credentials, session logging and immediate revocation when an agent’s task, model behaviour or accountable human changes.
Q: How can organisations tell whether their NHI controls are keeping up with AI agents?
A: Look for controls that can prove who requested access, which tool was used, what scope was granted, and whether the identity could be revoked cleanly. If those answers require manual reconstruction across logs, the programme is behind the behaviour it is trying to govern.
Q: How should security teams discover shadow AI agents in the enterprise?
A: Use endpoint artefacts first. Look for agent directories, service definitions, local ports, and process names that prove the software is installed and active. Network traffic alone is too ambiguous because legitimate browser and API activity can look identical to agent behaviour. Discovery should produce an inventory of where the agent runs, what it can reach, and whether it is sanctioned.
Technical breakdown
Why runtime authorization matters more than lifecycle cleanup
Traditional identity governance assumes the important question is who an identity is and what it should be allowed to access over time. Runtime governance changes the unit of control: the decision has to follow the action, not just the account record. That matters when an identity can be created quickly, used immediately, and discarded before a review cycle catches up. In that model, the access decision cannot rely on a static list of entitlements alone. It must account for the context of the action, the delegation chain, and the current task scope.
Practical implication: Shift authorization controls toward action-time decisions and away from periodic cleanup as the primary control point.
Why agent identities do not behave like ordinary service accounts
A service account usually supports predictable code or a bounded workload. An agent can behave differently at runtime, select actions dynamically, and inherit or request access in ways that are not fixed at provisioning time. That makes the familiar inventory-plus-rotation model necessary but incomplete. The core issue is not simply that an agent has credentials, but that those credentials may be used to initiate new action paths. That is why the control problem moves from static identity management to governed execution.
Practical implication: Treat agent identity as an execution problem, not only a credential inventory problem.
Why delegated authorization becomes the governance choke point
When an agent acts on behalf of a person, the hard question is not whether the agent can authenticate. It is how far the delegation extends, when it expires, and which actions require fresh authorization. That is different from a conventional NHI flow where ownership and access scope are usually easier to tie back to a system or team. Delegated authority becomes the point where identity, privilege and intent intersect, and the risk grows when that boundary is vague. See the Identity Security Programme Guide.
Practical implication: Define the scope and expiry of delegated authority before allowing agents to operate against sensitive systems.
NHI Mgmt Group analysis
Identity security is moving from inventory management to execution governance. The old model was built around known identities, known applications and controlled provisioning queues. Agentic systems weaken that model because creation can happen faster than registration, and use can begin before a normal review process has any meaningful visibility. Practitioners should treat runtime enforcement as the primary governance layer, not a refinement of the old one.
Agentic identity cannot be reduced to the NHI playbook. The NHI model still applies to credentials, secrets and machine access, but it does not fully describe identities that decide and act at runtime. This is where NHI standards and controls remain necessary while no longer being sufficient on their own. The implication is that teams need a separate governance view for action-bearing identities, not just a broader inventory of non-human accounts.
Runtime authorisation is the named concept that matters here. Access control is no longer only about who has a credential or which role was assigned at creation. The issue is whether the system can decide, at the moment of use, whether the action is still legitimate. That redefines governance from periodic certification toward event-time decisioning, which is the practical breakpoint for modern identity programmes.
The governance assumption that identities are knowable before execution is collapsing. That assumption was designed for a world where accounts were provisioned, recorded and then reviewed on a predictable cycle. It fails when agents and builders can create identity-bearing workloads on the fly, because the programme no longer sees a stable population to govern. The implication is not merely more monitoring, but a rethinking of what counts as an accountable identity in the first place.
Cross-domain identity oversight now has to include human, NHI and agent behaviour in one operating model. A programme that separates human IAM, NHI controls and AI oversight will miss the delegation chain that connects them. The strongest control points are where those domains meet: who created the agent, which credentials it inherited, and which actions require fresh approval. Practitioners need a single governance narrative that spans the full chain.
From our research library:
- 80% of identity breaches involved compromised non-human identities such as service accounts and API keys, according to the Ultimate Guide to NHIs.
- Only 5.7% of organisations have full visibility into their service accounts, according to the Ultimate Guide to NHIs.
- Read next: Ultimate Guide to NHIs — Key Challenges and Risks
What this signals
Runtime governance becomes the control plane for agentic identities. Programmes that still rely on quarterly cleanup will keep finding identities after they have already acted. The practical shift is toward deciding access at the moment of execution, because that is where the risk now concentrates.
Runtime identity governance: the critical control point is no longer whether an identity exists, but whether the organisation can still justify each action when it occurs. That changes how teams design approvals, logging and accountability across human, NHI and agent workflows.
Enterprises should expect the boundary between human IAM, NHI governance and AI oversight to keep blurring as builders create more identities outside formal workflows. Programmes that cannot connect delegated authority, runtime access and ownership will struggle to prove control over the full identity chain.
For practitioners
- Map identities at the point of use Identify where identities are created outside traditional provisioning flows and where actions begin before registration catches up.
- Separate delegated authority from standalone access Document which agents act on behalf of a human and which operate as independent non-human identities, then govern those two cases differently.
- Move approval logic closer to execution Require sensitive actions to pass a runtime authorisation check instead of relying only on initial enrolment or role assignment.
- Review shadow identity creation paths Look for builders, endpoints and ad hoc workflows that mint identities without central ownership, because those are the places where governance blind spots emerge.
- Rework recertification around actions, not just accounts Use recertification cycles to validate real activity, delegation scope and current task boundaries instead of only reconciling account inventories.
Key takeaways
- Identity programmes built around a stable catalog of users and service accounts are being outgrown by runtime identity creation.
- Agentic systems change the governance problem from account hygiene to action-level authorisation and delegated authority.
- Teams need one operating model that links discovery, ownership and execution-time controls across human, NHI and agent identities.
Related NHI Mgmt Group resources: Ultimate Guide to NHIs: Key Challenges and Risks · Identity Security Programme Guide
Standards & Framework Alignment
This section maps relevant standards and security frameworks to the operational risks and controls described in this guidance.
OWASP Agentic AI Top 10 and OWASP Non-Human Identity Top 10 address the attack and risk surface, while NIST CSF 2.0 and NIST SP 800-53 Rev 5 set the governance and control requirements practitioners need to meet.
| Framework | Control / Reference | Relevance |
|---|---|---|
| OWASP Agentic AI Top 10 | ASI03 — Identity & Privilege Abuse | Agentic identities can expand or misuse privileges at runtime, which is central to this topic. |
| Recommendation — Constrain agent privileges to the minimum action scope and verify delegation before execution. | ||
| OWASP Non-Human Identity Top 10 | NHI-05 — Overprivileged NHI | The piece argues that agent identities need more than static access models, because privilege can outgrow the original setup. |
| NHI-10 — Human Use of NHI | The article highlights human-built agents and delegated use of machine identities across the business. | |
| Recommendation — Review NHI access scope against actual runtime use and remove privilege that is broader than the task. Separate human delegation from non-human execution and govern each path explicitly. | ||
| NIST CSF 2.0 | PR.AA-05 — Access Permissions, Entitlements and Authorizations | Runtime identity governance depends on controlling entitlements at the point of action, not only at provisioning. |
| Recommendation — Apply entitlement checks at the moment of access and not just during account setup. | ||
| NIST SP 800-53 Rev 5 | IA-5 — Authenticator Management | The discussion includes credentials on endpoints and the need to manage identity material as creation accelerates. |
| Recommendation — Manage authenticators so exposed or stale credentials can be revoked and replaced quickly. | ||
Key terms
- Runtime Authorisation: Runtime authorisation is the practice of deciding access while a task is in progress, rather than only at provisioning time. It matters for NHIs because credentials and entitlements can change risk mid-session, especially when automation or AI agents interact with sensitive systems.
- Delegated Authorization: A model in which an application is allowed to act on a user’s behalf after explicit approval. In SaaS environments, delegated authorization is powerful but risky because excessive scope or weak revocation can turn a routine integration into durable non-human access.
- Agent Identity: An agent identity is the set of attributes, credentials and permissions assigned to an autonomous software entity. It is treated as a non-human identity because it can authenticate, act on systems and accumulate access over time, which creates governance, audit and lifecycle obligations similar to other production identities.
- Shadow AI: AI agents, copilots, or connected tools operating without full visibility or governance from security teams. Shadow AI becomes an identity problem when those systems authenticate with unmanaged tokens, service accounts, or OAuth apps that can reach production resources.
What's in the full article
C1.ai's full blog post covers the operational detail this post intentionally leaves for the source:
- How the vendor maps human, service account and agent identities across an environment
- The practical distinction between delegated authorization and standalone agent identity
- The runtime governance model used to decide access where actions happen
- How discovery, ownership and enforcement are sequenced in the vendor's approach
Deepen your knowledge
NHI governance, agentic AI identity, and machine identity lifecycle are core topics in our NHI Foundation Level course, the industry's only accredited NHI security programme. If you are building or maturing an IAM programme, it is worth exploring.
Published by the NHIMG editorial team on November 4, 2026.
NHI Mgmt Group, the independent authority on Non-Human Identity, IAM, and Agentic AI security. nhimg.org