Why non-human identities are the fastest-growing AI security risk

At a glance

What this is: This blog argues that AI-driven enterprises are creating more non-human identities than human controls can track, with machine credentials and standing access emerging as the core risk.

Why it matters: It matters because IAM, PAM, and governance teams need to treat NHI discovery, lifecycle control, and secret containment as first-class programme work, not a side effect of automation.

By the numbers:

• Non-human identities outnumber human employees by a ratio of at least 45 to 1 in enterprise environments.

Context

Non-human identity sprawl is the governance gap created when service accounts, API keys, OAuth tokens, and bot identities accumulate faster than teams can inventory and control them. In AI-driven enterprises, that gap widens because automation and agentic workflows create new identities as part of normal operations.

The problem is not only volume. The article describes a control model built for people, then applied to machine identity estates that are non-interactive, fast-moving, and often invisible to central directories. That mismatch leaves privileged access, lifecycle ownership, and secret exposure outside normal IAM oversight.

Key questions

Q: What breaks when non-human identities are not governed like human accounts?

A: Service accounts, API keys, tokens, and AI agents can retain access long after the original task ends because they do not naturally pass through joiner-mover-leaver processes. That creates hidden privilege accumulation, weak ownership, and poor revocation discipline. The result is broader attack surface and slower response when access needs to be removed.

Q: What problem does ownership attribution solve for service accounts and API keys?

A: It closes the gap between exposure detection and accountable remediation. Many organisations can find the secret, but not the human who introduced it, maintains it, or can safely replace it. Ownership attribution gives security teams a practical way to assign action without relying on informal knowledge that disappears during staff changes.

Q: How can organisations tell whether NHI governance is actually working?

A: NHI governance is working when every machine identity has an owner, a purpose, a minimum-necessary entitlement, and evidence of rotation and review. If teams can produce that chain without manual reconstruction, the programme is mature enough to withstand audit pressure. If they cannot, the governance model is still fragmented.

Q: What should organisations do when autonomous workflows create new identities on the fly?

A: Treat identity issuance as part of the runtime control plane, not as a back-office approval task. If an autonomous workflow can create resources and the identities that govern them, security teams need guardrails on creation, scope, and expiry before the task completes.

Technical breakdown

Why machine identity scale breaks human IAM assumptions

Human IAM assumes identities are relatively stable, individually managed, and tied to a person who can approve, recertify, or offboard access. NHIs are different: they are created by code, spread across clouds and SaaS tools, and may exist in huge volumes with no direct owner. Once the estate reaches that scale, directory-centric governance loses completeness because many identities never pass through the systems where human access is normally reviewed. The technical issue is not merely sprawl. It is that identity registration, privilege assignment, and revocation all happen closer to runtime than to HR events, so the control plane must shift from periodic approval to continuous discovery and enforcement.

Practical implication: build NHI inventory and lifecycle control around cloud, CI/CD, and SaaS sources, not around the human directory alone.

How static secrets and bearer tokens enlarge blast radius

Machine identities commonly authenticate with bearer tokens, API keys, or other static secrets because MFA is not workable for non-interactive access. That design means possession equals authority. If a key is copied from code, logs, or a config file, the attacker can use it from elsewhere without needing another factor or device. Standing privileges make the problem worse because the stolen credential may already have broad permissions. In effect, the attack path is short: locate secret, validate it, and act as the workload. This is why secret leakage and over-provisioning are tightly coupled in NHI security.

Practical implication: shorten credential lifetime and scope before trying to detect every place a secret might appear.

Why autonomous workflows create recursive identity creation

The article’s strongest signal is not simple automation but recursive identity creation. An autonomous AI agent can decide it needs additional infrastructure, spin up resources, and create the identities needed to operate them. That changes the governance problem from provisioning an identity to governing a chain of machine decisions that produces more identities mid-workflow. Traditional review cycles assume there is time to observe, certify, and revoke access after the fact. When the actor creates and consumes identities inside a single task, those assumptions stop holding. The relevant technical boundary is not just access control. It is whether the system can govern identity issuance at the same speed as the workload itself.

Practical implication: enforce runtime guardrails for identity issuance in agentic workflows, not only post-hoc access review.

Threat narrative

Attacker objective: The attacker aims to turn one leaked machine credential into broad, low-noise access to cloud systems and sensitive data.

1. Entry begins when an attacker harvests an API key or similar secret from code repositories, logs, or exposed storage.
2. Credential use follows immediately because the stolen machine identity can authenticate non-interactively from attacker infrastructure.
3. Escalation occurs when the compromised identity exposes additional secrets or over-provisioned cloud permissions.
4. Impact is data exfiltration through apparently legitimate machine-to-machine traffic, often hidden as routine synchronization or backup activity.

Breaches seen in the wild

• Sisense breach 2024: A credential in Sisense's GitLab reportedly opened S3 buckets of customer tokens, passwords and certificates; CISA urged a full reset.
• Dropbox Sign breach 2024: A compromised back-end service account gave attackers Dropbox Sign customer data, including API keys, OAuth tokens and MFA information.

Read our 52 NHI Breaches Analysis report for a comprehensive view of breaches impacting Non-Human Identities including AI Agents.

NHI Mgmt Group analysis

Machine identity governance is now a volume, speed, and ownership problem, not just an authentication problem. The article shows that NHIs are created by code, spread across clouds and SaaS tools, and often never re-enter central identity workflows. That means the old assumption that every important identity can be named, reviewed, and offboarded like a person no longer holds. Practitioners should treat NHI inventory completeness as a control objective, not a reporting feature.

Secret leakage and standing privilege are the same failure mode once machine access becomes default. A leaked bearer token is enough to impersonate the workload, and over-provisioned permissions convert that access into lateral movement and exfiltration potential. The governance gap is not simply that secrets exist, but that their authority often outlives the task that justified them. Practitioners need to model blast radius per credential, not per user.

Recursive identity creation is the named concept this article surfaces. The AI-driven enterprise no longer just provisions machines faster; it allows machines to create the identities of other machines inside the same operational flow. That breaks the assumption that least privilege can be determined entirely at provisioning time, because the workload’s next action may not exist yet. Practitioners should reframe governance around issuance-time control and machine-timed decision loops.

The central NHI governance assumption that fails here is that an identity remains stable long enough to be reviewed and retired. That assumption was designed for slower human and workload lifecycles. It fails when automation and AI agents can create, use, and discard access at machine speed, leaving review cycles with no durable state to examine. The implication is that lifecycle governance must move closer to runtime than traditional IGA assumes.

Traditional IGA is structurally misaligned with non-human identity estates. Quarterly access reviews, manager attestation, and directory-first workflows are built around human accountability chains. The article shows that many NHIs never live in those systems at all, so the real control failure is invisibility before review. Practitioners should align governance with where machine identities are actually born and used, not where human processes are most convenient.

From our research library:

• NHIs outnumber human identities by 25x to 50x in modern enterprises, according to the Ultimate Guide to NHIs.
• Read next: Ultimate Guide to NHIs — Key Challenges and Risks

What this signals

Recursive identity creation: AI-driven automation can create new machine identities inside the same workflow that consumes them, which means governance has to shift from periodic review to issuance-time control. That is a structural change for IAM, not a tuning exercise.

Machine identity programmes now need to be designed around visibility, ownership, and expiry. When secrets are embedded in code, cloud consoles, and agentic workflows, the control that matters most is the one that can find, scope, and retire them before they become standing risk.

For practitioners

• Implement continuous NHI discovery Scan cloud platforms, CI/CD pipelines, application logs, and SaaS tenants to maintain a live inventory of service accounts, API keys, OAuth tokens, and bot identities.
• Replace standing secrets with short-lived credentials Reduce the lifetime and blast radius of machine access by moving workloads toward ephemeral credentials and federation instead of reusable static keys.
• Bind privileges to workload purpose Review every over-provisioned service account and trim permissions to the minimum task scope, especially where the identity can access databases, object storage, or admin APIs.
• Automate offboarding for orphaned machine identities Destroy identities and revoke credentials when a workload, project, or cloud resource is retired so abandoned accounts do not persist indefinitely.
• Add runtime anomaly detection for machine behaviour Baseline normal machine access patterns and alert on sudden changes in data volume, source IP, or service-to-service reach that suggest secret abuse or scope drift.

Key takeaways

• The article frames non-human identity sprawl as a governance failure caused by machine speed, secret reuse, and human-centric control models.
• It cites analyst estimates that NHIs outnumber human employees by at least 45 to 1, which helps explain why manual review cycles are not keeping pace.
• The practical response is to pair continuous discovery with short-lived credentials, strict lifecycle control, and runtime monitoring for machine behaviour.

Key terms

• Non-Human Identity (NHI): A digital identity assigned to a non-human entity such as a software application, service account, API key, bot, machine, or AI agent that enables it to authenticate and interact with systems without direct human involvement. NHIs now outnumber human identities in most enterprises by 25 to 50 times.
• Standing Privilege: Standing privilege is access that remains active even when no immediate task requires it. For NHI programmes, it is a common failure mode because long-lived credentials and persistent roles create unnecessary exposure. Reducing standing privilege usually means tighter expiry, on-demand access, and clearer review of who or what still needs access.
• Secrets Sprawl: The uncontrolled proliferation of sensitive credentials, API keys, tokens, passwords, certificates, across codebases, cloud environments, CI/CD pipelines, and configuration files. In 2024, over 50 million leaked secrets were found on the dark web.
• Recursive Identity Creation: Recursive identity creation happens when an automated system, script, or AI agent provisions additional identities as part of its own workflow. This creates governance pressure because access issuance can spread faster than manual review or traditional directory-based controls can track.

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.