Agentic AI identity dinner at Black Hat USA on August 4

At a glance

What this is: This is a private Black Hat USA dinner hosted by AuthMind for security leaders, centred on how agentic AI changes the identity attack surface and what practitioners need to rethink.

Why it matters: It matters because agentic AI pushes identity governance beyond static credentials and into runtime behaviour, which changes how IAM, PAM, and NHI teams define control boundaries.

Context

Black Hat USA is the setting, but the subject is broader: agentic AI identity governance and the operational questions it raises for security teams. The event is a small, private dinner rather than a product briefing, which makes the discussion itself the artefact of interest.

The practical issue is not whether AI is being adopted. It is whether identity programmes can govern runtime decision-making, tool use, and short-lived execution paths without relying on controls designed for static access models.

Key questions

Q: What breaks when agentic AI is governed like a normal application account?

A: Security controls break down because agentic systems do not behave like fixed-function applications. They can choose actions at runtime, combine tools in unexpected ways, and move faster than periodic review cycles. That means static roles, annual recertification, and one-time approvals do not fully describe the risk or contain the behaviour.

Q: Why do agentic systems change the identity risk model for security teams?

A: They change it because access is no longer the only question. When a system can choose tools, sequence actions, and execute without a human gate, the risk becomes behavioural as much as credential-based. That means security teams must manage what the actor can decide at runtime, not only what it was allowed to do on paper.

Q: How do security teams know if agentic AI controls are failing?

A: The main signs are session drift, repeated retry loops, unauthorized tool calls, and behaviour that diverges from the documented task sequence. If the agent keeps moving through steps after intent-to-tool alignment weakens, the system is drifting beyond its control envelope. In practice, teams should measure the full execution path, not isolated prompts.

Q: Should organisations rework IAM when AI systems begin to act on data?

A: Yes, because AI-connected workflows turn permissions into a runtime risk. IAM teams need to review delegated access, enforce least privilege, and make sure entitlements are traceable to an accountable owner. Without that, AI systems can inherit access that was never designed for autonomous or semi-autonomous use.

Background and context

Why agentic AI creates a different identity problem

Agentic AI is not just software that calls tools. In this context, the security issue appears when a system can decide what to do at runtime, choose among tools, and execute without a human approval gate between those decisions and actions. That combination changes identity from a provisioned state into an active decision surface. Conventional IAM and NHI controls assume access can be assigned, reviewed, and recertified against stable behaviour. Agentic execution breaks that assumption because behaviour is adaptive inside the session, not fixed at provisioning time.

Practical implication: Treat runtime authorisation as the control point, not only onboarding and periodic review.

Why static credentials are the wrong mental model

Static credentials are built for identities whose privileges stay predictable long enough to be governed centrally. Agentic systems can compress access request, tool invocation, and action execution into a single runtime sequence, which makes long-lived entitlements a poor fit for the actual risk. The issue is not only credential theft. It is that the credential becomes a proxy for a system that can vary its behaviour from one task to the next. That means privilege scope must be understood in relation to task boundaries, not just accounts or service names.

Practical implication: Map privileges to task scope and runtime context instead of assuming account-level policy is enough.

Why approval workflows need redesign for autonomous behaviour

Approval workflows work when the actor waits for human intervention before taking meaningful action. They lose force when the actor can select a tool, act, and move on before a review cycle even begins. In agentic environments, the governance question shifts from who approved access to what conditions are required before execution can proceed. That is an identity problem, but it is also a control-timing problem. If the system can re-plan or re-execute inside a session, governance has to keep pace with that runtime elasticity.

Practical implication: Design controls that constrain execution timing as well as privilege scope.

NHI Mgmt Group analysis

Agentic AI collapses the assumption that identity is stable long enough to govern it after the fact. The old model assumes access can be granted, observed, and then reviewed against a durable record of behaviour. That assumption fails when the actor can choose tools and actions at runtime without a human gate. The implication is that governance must move toward issuance-time and execution-time control boundaries, because retrospective review becomes too late to shape the behaviour that matters.

Runtime decision-making creates an identity governance gap that traditional NHI programmes do not fully cover. Service accounts and API keys already strain static models, but agentic systems add independent sequencing and timing into the access problem. That means the relevant unit is no longer just the credential, but the behaviour enabled by the credential in a live task. Practitioners need to distinguish machine identity control from autonomous execution control, or they will understate the risk.

Access review processes were designed for access that persists long enough to be reviewed. Autonomous or agentic actors can acquire, use, and discard privileges inside one session, leaving little meaningful evidence for periodic certification. That is a broken premise, not just a weak control. The practical conclusion is that governance needs live authorisation evidence, not only post hoc attestation.

The concept that matters here is runtime governance gap: the distance between policy written for static identities and the actual moment an agent decides and acts. That gap widens when tool use, delegation, and execution timing are all dynamic. For security leaders, the issue is not whether AI is powerful, but whether the identity stack can still express control at the point of action.

Black Hat discussions like this signal a category shift in identity security priorities. The market is moving from managing named accounts and credentials toward governing behaviour, delegation, and session-bounded authority. That does not replace NHI discipline. It extends it into autonomous execution, where least privilege has to be interpreted dynamically and accountability must follow the actor's runtime choices.

From our research library:

• 67% of organisations still rely heavily on static credentials despite the risks they pose to agentic AI deployments, according to the 2026 Infrastructure Identity Survey.
• Only 13% of organisations feel extremely prepared for the reality of agentic AI despite the majority racing toward autonomous adoption, according to the 2026 Infrastructure Identity Survey.
• Read next: Agentic AI Security Guide

What this signals

runtime governance gap: agentic AI exposes the distance between static identity policy and the moment an autonomous system decides to act. Security programmes that still centre on periodic review will miss the control point that matters most, which is the live decision boundary.

The practical consequence for IAM, PAM, and NHI teams is that policy has to become more conditional and more time-bound. When action can be selected at runtime, the old split between provisioning and review is no longer sufficient for governing risk.

For practitioners

• Map agentic execution paths Identify where AI systems can choose tools, sequence actions, and execute without a human approval gate. Separate those paths from ordinary automation so policy can distinguish autonomous behaviour from scripted workflows.
• Define runtime authorisation boundaries Set explicit conditions for when an agent may act, what data it may touch, and which tools it may invoke during a session. Account-level permissions alone will not capture the risk if the behaviour changes task by task.
• Review where access reviews stop helping Test whether your recertification process can meaningfully evaluate access that exists only briefly inside a single task. If it cannot, move governance earlier in the lifecycle and attach controls to issuance and execution.
• Separate machine identity from agent governance Treat service accounts, tokens, and certificates as necessary plumbing, but not as the full control model for autonomous behaviour. Add policy for decision timing, delegation, and tool selection so the governance model matches the actor.
• Instrument evidence at the point of action Log the task context, tool selection, and decision path that led to each action. That gives security teams evidence to investigate behaviour that would otherwise disappear before periodic review cycles can see it.

Key takeaways

• Agentic AI changes identity risk by introducing runtime decision-making, not just new software or more automation.
• Traditional access review and account-centric governance are too slow when an actor can choose tools and act inside a single session.
• Security teams need controls that evaluate authorisation at the point of execution, not only at onboarding or recertification.

Key terms

• Agentic AI: Autonomous AI systems capable of planning, deciding, and taking actions, including calling APIs, writing code, and orchestrating other agents, with minimal human oversight. Agentic AI introduces new NHI risks as agents must authenticate to external services.
• 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.
• Identity Governance: Identity governance is the set of controls that defines who approves access, who owns it, how it is reviewed, and when it is removed. In practice, it turns identity management from a deployment task into a durable control system that can withstand audits, organisational change, and operational growth.
• Governance Gap: A governance gap is the distance between knowing an asset exists and being able to enforce policy on it. In identity programmes, it appears when discovery, review, and enforcement are split across different tools or teams, leaving access partially visible but not truly controlled.

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.