A non-human identity (NHI) is any identity that software uses to authenticate and act, rather than a person. Service accounts, API keys, OAuth clients, CI/CD pipeline credentials, bots and AI agents are all non-human identities. They log in, hold permissions and change data, but nobody types a password for them.
NHI governance is the practice of knowing which non-human identities exist, who is accountable for each one, what each can access, and how to take that access away.
The kinds of non-human identity
The oldest kind is the service account, which one system uses to call another, such as a billing service reading the customer database. Close behind are API keys and tokens, long-lived secrets handed to an integration or a script. OAuth clients and app registrations are a newer variant: an application is granted delegated or application permissions in a SaaS tenant or identity provider, often by whoever clicked “allow”.
Infrastructure adds its own. A CI/CD job or a container uses a workload identity to deploy or read secrets, and servers prove who they are with certificates. Scheduled jobs, RPA bots and chat integrations fill out the list.
AI agents are the newest kind and the hardest to reason about. An agent decides for itself which tools to call and in what order, so what it does is not fixed in advance the way a script’s behaviour is.
Non-human identity vs human identity
A person and a service account can hold exactly the same permission and still be governed very differently.
People sign in with SSO and MFA. Non-human identities present a secret, key, certificate or token, usually with no second factor, so a leaked credential is often enough on its own. The lifecycle differs too: HR drives a person’s, from hire to transfer to termination, while a non-human identity’s lifecycle is driven by whoever created it, and often nobody ends it.
Accountability works differently as well. A person answers for their own actions, whereas a non-human identity needs a named person to answer for it. AI agents sit awkwardly between the two, because they authenticate like a machine but vary their behaviour from run to run in a way that needs watching more like a person.
Why non-human identities are a security problem
Most identity programs were built around people. A person joins, gets access for their role, has that access reviewed and loses it when they leave, and non-human identities slip through at each of those steps.
The first gap is ownership. A service account belongs to whoever created it, and when that person changes team or leaves, the account usually keeps working with no one responsible for it. There is also no natural end date, since people leave but scripts do not; credentials created for a one-off migration can still be live years later.
Permissions tend to be broad because it is easier to grant an integration admin rights than to work out the narrow set it needs. Access reviews then skip those accounts, often because no human signs in with them. Secrets in config files rarely rotate, so they last as long as the system they live in.
AI agents add one more problem. An agent with access to ten tools may call any of them, in any combination, so its permissions on paper do not tell you what it will actually do. Put together, you end up with a growing number of identities that have real power and very little oversight.
Where NHIs come from, and why inventories go stale
Non-human identities get created in many places. A developer registers an OAuth app, a platform team creates a cloud service account, or someone connects an AI assistant to a SaaS tool, and few of those paths go through the identity team. An inventory built once from a spreadsheet is out of date within weeks.
What works better is making registration part of how the identity is created, in the pipeline or infrastructure-as-code that creates it, and then comparing your registry with what connected systems report.
What good NHI governance looks like
- Keep an inventory. Every non-human identity is registered with what it is, what it can access and where its credentials live, because you cannot govern what you cannot see.
- Give every identity an accountable owner, a named person, and decide in advance what happens when that person leaves so the identity is reassigned rather than orphaned.
- Grant least privilege and review it. Non-human identities belong in access reviews like everyone else.
- Rotate credentials on an interval, and make overdue ones visible.
- Keep a revocation path, so every grant can be taken away quickly.
- Use one audit trail for people and machines, so “who did this?” has an answer even when the actor was software.
A starting checklist
If your team is starting from nothing, this order tends to work:
- List the systems where non-human identities are created, and who can create them.
- Register what exists today, with a type, an owner and an environment for each.
- Find identities with no owner, or an owner who has left, and assign them.
- Set a rotation interval for each credential type and work through the overdue list.
- Add non-human identities to your next access review.
- Write into the leaver process what happens to a person’s non-human identities when they go.
How AtmanID approaches it
AtmanID treats humans, service accounts and AI agents as first-class identities on one identity model and one tamper-evident audit trail (What is AtmanID). Non-human identities are registered with an owner and a rotation interval, and overdue credentials are surfaced (rotation policies). For an overdue NHI, an administrator chooses whether quarantine sets it inactive or pushes a new secret to the linked application.
An agent registered through the API starts in a pending-review state, and an administrator approves it before it becomes active (register an NHI with curl). When a person leaves, the leaver workflow flags the machine identities they own as orphaned and deactivates the AI agents they own. The exception is an agent with a managing team, which is flagged for a new owner instead (joiner, mover and leaver events).
For AI agents the governance also applies at runtime. Agent tokens are scoped to specific MCP servers and tools, and every call passes through the AtmanID gateway (MCP gateway).
FAQ
What is an NHI in cybersecurity?
NHI stands for non-human identity: an identity used by software rather than a person, such as a service account, API key, OAuth app or AI agent. Because NHIs hold permissions and act in your systems, they need the same governance as user accounts.
Is an AI agent a non-human identity?
Yes. An agent authenticates with a credential and acts with permissions, like any service account. The difference is that it chooses its own actions, so its permissions alone do not tell you what it will do, which is why agents usually need runtime checks on top of the usual NHI controls.
Who should own a non-human identity?
A named person who can answer for what it does, usually the engineer or team lead who asked for it. Recording the team is useful context, but someone specific has to be accountable, and ownership has to move when that person leaves.
How often should NHI credentials be rotated?
It depends on the credential type and your risk appetite, and many organisations set a different interval per type. More important than the exact number is that every credential has an interval and that overdue ones are visible and acted on.
What is non-human identity governance?
It is identity governance applied to software. You keep an inventory of NHIs, assign an owner to each, grant least privilege and review it on a schedule, rotate credentials, keep a revocation path, and record what each identity did.
Related: AI agent access control · Joiner, mover, leaver · What is an MCP gateway?