The Rise of NHIs: Non-Human Identities

2:14 AM, the enterprise looked completely secure. But somewhere inside, an attacker was already moving. The dashboards were green. No ransomware alerts, no flagged logins, nothing unusual anywhere on the network. By every measure the SOC normally watches, it was a quiet night.

It hadn't been, for hours.

Earlier that day, a developer had shipped a small internal tool: A Slack assistant built on an open-source agent framework, meant to pull files and summarize data on request. To get it running fast, they dropped a GitHub personal access token straight into a config file and left its supporting server unauthenticated, just until the demo was done. That token never got the chance to be temporary. An info stealer already sitting on the developer's laptop harvested it along with everything else in reach.

At 2:14 AM, someone used it. Not by guessing a password or tricking anyone, they simply connected to the unauthenticated server with a token that looked to every system checking it, completely legitimate. No SSO. No MFA prompts. Tokens don't ask twice.

In seven minutes, the attacker discovered the token held full administrative rights to the org's code repositories, cloned the source, planted a backup credential for later, and pulled over 360 gigabytes of proprietary data out through a cloud storage bucket, all using access that was, technically, valid. The SOC's first alert wasn't for an intrusion. It was for unusual egress volume, the kind of signal that shows up after the stories already finished.

Nobody broke in. Something already inside, and already trusted, simply did what it was quietly authorized to do.

What Actually Broke That Night

The real failure wasn't the developer's shortcut, that kind of shortcut happens on every engineering team, every week. It's that nobody could see it happen.

The Slack assistant was a non-human identity, or NHI: a digital identity belonging to software rather than a person, capable of authenticating and acting entirely on its own. That's a genuinely different kind of identity to defend than the ones security teams have spent decades building processes around. A human employee gets onboarded, trained, and eventually offboarded through an HR-driven lifecycle. An NHI gets provisioned by a developer under deadline pressure, and then, more often than anyone would like to admit, forgotten.

NHIs come in a few recognizable shapes worth knowing, because governance tends to fail differently for each one:

• Service accounts: persistent connectors like CRM or ITSM integration, quietly syncing data around the clock.
• Workload identities: short-lived credentials issued to containers and serverless functions so they can talk to each other securely.
• Infrastructure identities: tied to a VM or cloud instance's own lifecycle, like an AWS instance profile.
• Device identities: certificates and hardware-bound keys on routers, sensors, and IoT hardware.
• Agent identities: the newest and fastest-growing category: autonomous AI agents that choose their own tools and actions at runtime, without a script dictating every step-in advance.

That one assistant touched three of these categories at once, an agent identity, riding on a service account's worth of GitHub access, running on infrastructure that carried its own identity too. Most security programs still don't formally track any of the three.

How the Machines Quietly Outnumbered Us

Every time an application gets broken into microservices, what used to be an internal function call becomes an authenticated network request and every one of those needs its own identity, its own secret, its own certificate. Add cloud infrastructure, CI/CD pipelines, and now a wave of agentic AI deployments on top, and the machine population doesn't just grow. It compounds, quietly, in the background, while the humans managing it stay roughly the same in number.

The numbers are stark. Non-human identities outnumber humans roughly 45 to 1 in the average enterprise, climbing to around 144 to 1 in cloud-native, automation-heavy environments, and as high as tens of thousands to one in the most complex distributed architectures. Across the broader market, organizations are estimated to carry somewhere around 80 machine identities for every employee on payroll, a ratio that would be unthinkable for human staff, and yet barely registers as unusual for machines.

And unlike a human employee, a machine identity doesn't leave when a project ends. People are onboarded and offboarded through a structured process someone owns. Service accounts and API keys are usually just left a proof of concept gets shelved, an integration gets abandoned, and the credential that powered it keeps sitting there, active and forgotten, a ghost with standing access to something that used to matter. Industry research suggests most secrets ever exposed in public code repositories are still live and un-rotated years later, and AI-specific credentials, model API keys, agent configuration tokens are the fastest-growing category of all, as more teams wire up agents the same way that developer wired up a Slack assistant: quickly, and with a credential dropped straight into a config file.

When the Ghost Wakes Up

A compromised NHI gives an attacker machine speed, not human speed, and a few patterns show up again and again:

• Standing "god mode" access. Under deadline pressure, it's faster to grant broad admin rights than to scope permissions carefully. A large share of NHI credentials across enterprise environments carry far more privilege than they ever use which is exactly what let this attacker move from one token to total repository control in minutes, not days.
• Persistence that survives rotation. A privileged NHI can be used to quietly plant a new, legitimate-looking credential on an existing application. So even if the original stolen key gets rotated the moment someone notices, the attacker simply switches to the one they planted, which passes every check because it was never technically stolen.
• Supply-chain propagation. Modern enterprises run on SaaS-to-SaaS integrations, each backed by an OAuth token that skips SSO and MFA for every request it makes once issued. That design is efficient, and it's also why a single compromised integration can ripple outward fast security researchers have documented real incidents where attackers who compromised one vendor's integration tokens used them to authenticate directly into hundreds of downstream customer environments simultaneously, without a single MFA prompt ever firing, because every one of those tokens was already fully authorized.
• Living off legitimate logic. An AI agent doesn't need to be infected with malware for an attacker to abuse it, they can simply let it keep doing exactly what it was built to do: querying data, calling tools, chaining actions. Buried in an agent's normal background activity, that abuse can run for a long time before anyone notices it doesn't belong.

None of this required a zero-day. Every step used access the organization had, at some point, already granted.

Closing the Gap

None of this makes NHIs the enemy, they're why modern software works at all. The goal was never fewer machine identities. It's closing the specific gap this piece keeps circling back to making sure nothing stays valid for longer than it stays watched.

Five practices consistently do that. Continuous, automated discovery catches new identities as they're created, instead of relying on a quarterly audit that's already stale by the time it's finished the "watched" half, built to keep pace with the "valid" half. Clear ownership means no credential exists without someone accountable for it, which stops a shelved pilot from quietly becoming a permanent ghost.

Least privilege, actively enforced means checking granted access against real usage on an ongoing basis, shrinking how much damage a valid-but-unwatched credential can do. Short-lived credentials in place of static ones remove the problem at its root if validity itself expires quickly, the watching gap never opens as wide. And centralized secrets management, paired with a tested revocation playbook, turns "we noticed a compromised credential" into a problem solved in seconds, not hours.

Run any one of those five against the story above, and it ends differently the token never sits in a config file, the over-privileged access gets flagged before it's used, or the egress alert fires in minutes instead of after the fact.

Back to 2:14 AM

That's an uncomfortable place for a security program to sit, but it isn't permanent not for teams willing to treat non-human identities as a first-class part of the identity perimeter, rather than an afterthought bolted onto a human-centric IAM program built for a different era.

At HarkX, this is exactly the kind of ghost we're built to find mapping the relationships between human identities, service accounts, cloud workloads, and AI agents, so that when a credential starts behaving even slightly out of character, an investigation begins in minutes, grounded in real context, instead of the full story only becoming visible in a post-mortem.

Go back to where this piece started. Nothing was hacked, in the way that word usually implies. A credential simply sat there, valid and unwatched, until something found it.

If there's one thing worth carrying out of this piece, it's this: the number of non-human identities in your environment was never really the risk. The gap between how many is valid and how many are actually watched- that's the number that decides whether the next 2:14 AM story happens to your organization, or to someone who closed that gap first.

See how HarkX brings identity and asset context into every investigation. Explore the HarkX platform →

Additional Resources

• How Context-Aware Investigations Are Reshaping Modern Security Operations
• How SOC Teams Can Govern Autonomous Security Operations
• Agentic AI in SOC: Separating Reality from Hype

Frequently Asked Questions

What exactly counts as a non-human identity (NHI)?

Any digital identity belonging to software rather than a person, service accounts, API keys, OAuth tokens, device certificates, and increasingly, autonomous AI agents that authenticate and act on their own. The defining test is that it can both authenticate and be granted permissions to act programmatically; a static inventory record isn't an NHI, but a service account with live API access is.

How many non-human identities does the average enterprise actually have?

Far more than most inventories show. Research generally puts the ratio at around 45 machine identities for every human in a typical enterprise, climbing to roughly 144 to 1 in cloud-native environments, and into the tens of thousands to one in the most complex distributed architectures.

Why are non-human identities such an attractive target for attackers?

Because they bypass the defences built for people. NHIs authenticate with tokens that skip SSO and MFA entirely once issued, they're frequently over-provisioned with more access than they use, and nobody offboards them when a project ends, so a forgotten credential can stay valid and unmonitored for years, giving attackers a much quieter way in.

How is AI agent adoption changing non-human identity risk?

Significantly. Each AI agent an organization deploys can generate its own credentials, often with broader access than it strictly needs, since narrowly scoping permissions takes time few teams have budgeted for. That's part of why AI-related credentials is now the fastest-growing category of exposed secrets tracked by security researchers.

What's the first practical step toward reducing NHI risk?

Start with visibility you can't govern what you can't see. That means continuous, automated discovery across cloud environments, repositories, and pipelines, rather than a periodic manual audit. From there, assigning clear ownership to every identity found matters most, since credentials with no accountable owner are consistently the ones that go unreviewed longest.