SailPoint Entro changes NHI governance for machine credentials

At a glance

What this is: This is SailPoint’s analysis of how Entro extends governance to machine credentials, with a key finding that discovery, lineage, and runtime defense are needed together to manage NHI sprawl.

Why it matters: It matters because IAM, IGA, PAM, and NHI teams need one governance model for secrets, service accounts, and AI-driven workloads before hidden credentials expand attack paths and audit gaps.

By the numbers:

• SailPoint says Entro adds discovery for over 1,200 credential types.
• SailPoint reports an estimated 50 percent improvement in operational management after its internal rollout.

👉 Read SailPoint’s analysis of securing non-human identities with Entro

Context

Machine credentials are the non-human identities that power automation, software delivery, and AI workflows, including API keys, tokens, service account secrets, and certificates. The governance problem is that these identities are often created faster than they are discovered, owned, or retired, which leaves security teams with access they cannot fully inventory or explain.

SailPoint’s Customer Zero framing is an internal validation story, but the underlying issue is broader than one vendor or one platform. Enterprises that deploy AI agents and automation without a machine identity model inherit a hidden access layer that standard human IAM controls do not cover well.

The article is typical of the current market moment: discovery is no longer the hard part by itself, but linking each secret to a business owner, runtime use case, and revocation path remains inconsistent across most programmes.

Key questions

Q: How should security teams govern machine credentials across cloud and CI/CD environments?

A: Security teams should treat machine credentials as production identities with owners, scopes, and lifecycles. That means inventorying service accounts, API keys, tokens, and certificates, mapping where they are used, and enforcing rotation and revocation through automated workflows rather than manual exception handling.

Q: Why do non-human identities become a bigger risk in AI-speed attacks?

A: Because NHIs often provide the shortest route from discovery to real access. Service accounts, tokens, and API keys are machine-readable, frequently over-privileged, and sometimes poorly owned, so an AI-driven attacker can pivot through them quickly after finding an initial weakness. Effective governance turns these identities into controlled boundaries rather than reusable entry points.

Q: What breaks when machine credentials are discovered but not linked to business owners?

A: Discovery without ownership produces inventory, not governance. Teams can see that a secret exists, but they cannot decide who can revoke it, what depends on it, or whether it should still be active. That creates a common failure mode where exposed credentials remain usable because no one can safely remove them.

Q: Should organisations treat agentic AI access differently from service account access?

A: Yes. Service accounts are usually persistent and can be managed through lifecycle controls, while agentic AI access is often ephemeral, runtime-selected, and initiated on demand. The right governance model is different because the identity behaviour is different. Treating both as the same class leads to control gaps and delayed policy decisions.

Technical breakdown

Why machine credential discovery has to include lineage mapping

Finding a secret is only the first step. Lineage mapping ties a token, API key, or service account back to the application, script, or agent that uses it, which turns a raw inventory into an identity graph. Without that relationship, teams can detect exposure but still cannot answer who depends on the credential, what breaks if it is revoked, or whether the identity still has a legitimate purpose. That makes orphaned credentials and inherited access difficult to retire cleanly.

Practical implication: build discovery pipelines that record ownership, runtime dependency, and revocation path for every non-human credential.

Runtime defense for non-human identities

Static scanning finds secrets at rest, but runtime defense watches behaviour after credentials are issued. For machine identities, that means observing token use, unexpected tool calls, and access patterns that diverge from the known workload or agent. This matters because a leaked credential can remain dangerous even if the original exposure is patched. Runtime signals create the only practical way to detect abuse that happens after issuance and before the next review cycle.

Practical implication: pair secret discovery with live monitoring for anomalous token use and suspicious downstream actions.

Why AI agents multiply the NHI governance problem

AI agents are not just another workload because they can generate additional tool calls, service interactions, and credential requests as part of normal operation. That means every new agent can introduce more secrets, more delegated access, and more runtime complexity than a traditional automation job. If governance is built only for fixed scripts, it will miss the moving parts that agentic systems create across tool use, timing, and scope.

Practical implication: classify AI agents as governed non-human identities and review their secret dependencies before production rollout.

Threat narrative

Attacker objective: The attacker wants to hijack trusted machine access so they can reach systems, tools, and data without triggering human authentication controls.

1. Entry occurs when a machine credential is exposed in code, configuration, or an unmanaged workflow and becomes reachable to an attacker.
2. Escalation follows when the credential is reused across services or remains unrotated, giving the attacker persistent access to adjacent systems.
3. Impact lands when the attacker uses the credential to move into sensitive applications, exfiltrate data, or interact with AI tooling as a trusted identity.

Breaches seen in the wild

• Sisense breach — unauthorized GitLab access led to exfiltration of access tokens, API keys and certificates.
• IOS app secrets leakage report — iOS apps leaking hardcoded secrets and credentials endangering user privacy.

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 credentials have become a governance class, not a tooling edge case. When API keys, tokens, and service accounts outnumber human identities, the identity programme must treat them as first-order assets with lifecycle, ownership, and review requirements. Traditional IAM that stops at human authentication cannot explain runtime behaviour or revoke what it cannot fully inventory. The practitioner conclusion is that NHI governance now sits inside the core identity operating model.

Lineage mapping is the missing control that turns discovery into accountability. Discovering a secret without knowing which application, script, or agent depends on it only creates a list of exposures. SailPoint’s emphasis on historical correlation points to the real operational gap: organisations need to know where a credential came from, who owned it, and what business process still depends on it. The practitioner conclusion is that ownership metadata is no longer optional for machine identities.

Hidden credential estates create trust debt that compounds as AI adoption grows. The more automation and AI agents an enterprise deploys, the more credentials it creates and the harder it becomes to prove which ones are still legitimate. Trust debt: the accumulated risk created when non-human identities remain active, undocumented, or unverifiable longer than their business purpose. The practitioner conclusion is that AI scale without NHI governance increases blind spots faster than it increases productivity.

Customer Zero testing is a governance signal, not a product story. Internal validation matters because NHI controls fail differently in live enterprise environments than they do in slideware. If a control can only prove itself in theory, it will not withstand the complexity of developer pipelines, legacy integrations, and unmanaged service accounts. The practitioner conclusion is that teams should test governance controls against their own machine identity estate before they rely on them for audit or incident response.

From our research:

• 28.65 million new hardcoded secrets were detected in public GitHub commits in 2025 alone, a 34% year-over-year increase and the largest single-year jump ever recorded, according to the State of Secrets Sprawl 2026.
• From our research: 64% of valid secrets leaked in 2022 are still valid and exploitable today, according to the State of Secrets Sprawl 2026.
• From our research: Read Guide to the Secret Sprawl Challenge for the operational patterns behind discovery, rotation, and revocation.

What this signals

Machine credential governance is moving from a specialist cleanup task to a programme-level control surface, especially as AI agents and automation multiply the number of secrets in play. With 28.65 million new hardcoded secrets detected in public GitHub commits in 2025 alone, the structural issue is not whether secrets exist but whether identity teams can attribute, rotate, and retire them before they become reusable access paths.

Trust debt: hidden non-human identities accumulate when discovery, ownership, and revocation are not aligned. That debt now spans code repositories, runtime workflows, and AI-assisted development, which means identity teams need a single control model that connects IGA, PAM, secrets management, and workload identity.

Enterprises should watch for the point where secret discovery produces more alerts than the team can operationalise. At that stage, the next step is not another scanner but tighter integration between identity lifecycle controls and runtime evidence, backed by the NHI lifecycle guidance in Ultimate Guide to NHIs , Static vs Dynamic Secrets.

For practitioners

• Map every machine credential to an owner and dependency Create a live inventory that ties each API key, token, certificate, and service account to the application or workflow that uses it, plus the business owner responsible for revocation decisions.
• Add lineage checks to revocation workflows Do not retire credentials until you know which scripts, agents, and integrations depend on them, then document the fallback path for each dependency before decommissioning.
• Combine secret discovery with runtime monitoring Track not only where secrets are stored but also how they behave in production, including unusual token use, new tool calls, and access to unexpected services.
• Treat AI agents as governed non-human identities Require the same lifecycle controls for agents that you already apply to service accounts, including ownership assignment, access review, and retirement when the business task ends.
• Validate controls against your own environment Run internal proofs on your developer repositories, identity graph, and service account estate before accepting a platform claim about visibility or remediation.

Key takeaways

• Machine credentials are now a core identity governance problem, not a niche secrets-management issue.
• Discovery only matters when it is tied to ownership, lineage, and revocation decisions.
• AI adoption raises the number of non-human identities faster than legacy IAM controls can safely absorb.

Key terms

• Machine Credential: A machine credential is a secret or identity artifact used by software rather than a person. It includes service account credentials, API keys, tokens, and certificates. In practice, the main risk is not just exposure, but unmanaged lifecycle, unclear ownership, and overbroad access.
• Lineage Tracking: Lineage tracking records how a model or dataset was created, changed, and reused over time. It gives security, compliance, and engineering teams a defensible history of dependencies, which is essential when proving what was tested, approved, and deployed.
• Trust debt: Accumulated security risk created when access assumptions are not revalidated quickly enough for the pace of modern automation. In identity programmes, trust debt appears when roles, secrets, or agent permissions persist longer than the environment that justified them.
• Runtime Defense: Runtime defense is the set of controls that inspect, constrain, and stop unsafe AI behavior while the system is operating. For hospitality deployments, it covers both incoming prompts and outgoing responses, plus the tool calls that agents may trigger after a model decides to act.

What's in the full article

SailPoint's full blog covers the operational detail this post intentionally leaves for the source:

• Internal Customer Zero validation results from SailPoint's own environment and developer repositories
• How Entro categorises findings into one-touch remediation versus AI-guided remediation
• The internal correlation method used to link credentials back to people, applications, and business processes
• What the unified identity graph is used to show auditors and cyber insurers during governance reviews

👉 The full SailPoint post covers the Customer Zero validation, lineage mapping detail, and remediation workflow examples.

Deepen your knowledge

NHI governance, agentic AI identity, and machine identity security are core topics in our NHI Foundation Level course, the industry's only accredited NHI security programme. If you are responsible for identity security strategy or NHI governance in your organisation, it is worth exploring.