AI governance is becoming runtime infrastructure, not policy theater

At a glance

What this is: This is an analysis of why enterprise AI governance is moving from paper controls to runtime oversight, with the key finding that static policies cannot keep pace with agentic workflows and tool use.

Why it matters: It matters because identity, access, audit, and approval controls now have to govern AI systems that act like operational actors, not just passive models, across NHI, autonomous, and human identity programmes.

By the numbers:

• Only about one-third of organisations have scaled AI programs across the enterprise, while roughly 23% are scaling agentic AI systems and 39% remain in experimentation.
• 56% of CEOs believe AI has delivered no measurable cost or revenue benefit, and only one in eight sees improvement on both dimensions.
• More than 70% of enterprise AI usage lacks proper oversight, according to Lenovo.
• A community audit of scanned MCP servers found near-zero authentication across nearly 2,000 servers.

👉 Read Obot's full analysis of AI governance, MCP, and runtime oversight

Context

AI governance has become a runtime security problem because modern systems do not just generate outputs, they call tools, move data, and trigger actions. That changes the control model from reviewing documents and policies to governing identity, access, auditability, and approval in the execution path itself.

In practical terms, the gap is between what organisations approve on paper and what AI systems actually do in production. Where AI systems touch customer data, internal systems, or revenue workflows, the governance issue overlaps with IAM, PAM, secrets management, and NHI control because those systems need attributable, least-privileged access just like human users do.

The article’s starting point is typical of the market right now: most enterprises have outgrown policy-only governance before they have built the operational controls to match it.

Key questions

Q: How should security teams govern agentic AI as it moves into production?

A: Security teams should govern agentic AI as a class of non-human identity, not as a generic application feature. That means assigning ownership, scoping permissions tightly, logging every tool action, and revoking access on a defined lifecycle. Production rollout should require clear approval points for high-risk actions and continuous monitoring for drift.

Q: When does AI governance become an IAM and NHI problem?

A: It becomes an IAM and NHI problem as soon as autonomous systems use credentials, APIs, or delegated access to perform actions. At that point, the quality of identity assignment, privilege scope, logging, and lifecycle control determines whether the system can be governed and audited responsibly.

Q: What breaks when organisations rely on static AI governance policies?

A: Static governance breaks when agents can change behaviour, data paths, or tool usage faster than the policy can be reviewed. Manual review cannot scale across distributed agent estates, and paper controls do not stop a live tool call. The result is governance debt, where each new use case adds more exceptions and less visibility.

Q: Who is accountable when an AI system makes a harmful decision?

A: Accountability should follow the identity chain that authorized, configured, or triggered the action, including the human owner, the platform team, and any delegated agent or tool account. If the organisation cannot name that chain, the governance model is too weak for regulated AI use.

Technical breakdown

Why document-centric governance fails for agentic AI

Document-centric governance assumes systems change slowly enough for periodic review to matter. Agentic AI breaks that assumption because it can call tools, route data, and make decisions in real time, often across multiple services in a single workflow. That means risk emerges at the point of execution, not just at the policy layer. Runtime governance therefore has to sit between the agent and the tools it can use, with identity, policy enforcement, logging, and approval checkpoints available at the moment action is taken.

Practical implication: move governance from annual review cycles into the execution path with enforceable policy gates and audit logs.

How MCP changes the identity problem for AI systems

Model Context Protocol standardises how agents discover and use tools, which is useful only if the tool layer is governed. Without identity binding, access scoping, and policy metadata, MCP can become a fast path to uncontrolled integration sprawl. The technical issue is not the protocol itself, but whether organisations treat MCP servers, skills, and agent sessions as governable entities with owners, permissions, and revocation paths. In that sense, MCP turns AI tooling into an identity management problem as much as an integration problem.

Practical implication: attach ownership, access scope, and revocation to every MCP-connected tool before it is exposed to agents.

Why shadow AI and tool sprawl defeat manual oversight

Shadow AI appears when teams wire agents to databases, APIs, or external services without central approval or inventory. Once that happens, manual review becomes unscalable because the number of models, tools, and agent paths keeps changing. Governance debt then accumulates as each new integration adds another policy exception, another access path, and another audit burden. The control failure is visibility. If security cannot enumerate the AI estate, it cannot classify risk, enforce least privilege, or prove compliance.

Practical implication: build an AI inventory and governed tool registry before trying to tighten policy enforcement.

NHI Mgmt Group analysis

Runtime governance is now the only credible model for agentic AI. Agentic systems are no longer confined to generating recommendations, because they can execute actions across tools, data stores, and business workflows. That means traditional governance artefacts, such as policy PDFs and annual reviews, are too slow to control real exposure. The field should treat tool invocation, access scope, and approval checkpoints as first-class governance objects.

AI systems are becoming identity subjects, not just model outputs. When an agent authenticates through OAuth, uses a service credential, or accesses internal APIs, it is participating in an identity and access control plane. That creates a genuine overlap with IAM and NHI governance, because the identity of the system now determines what it can see, change, and exfiltrate. Practitioners should stop treating AI access as a special case and bring it under the same lifecycle discipline as other machine identities.

Governance debt is the named concept enterprises are underestimating. Governance debt is the gap that forms when AI adoption scales faster than inventories, policy automation, and runtime controls. The article shows how that debt accumulates through tool sprawl, fragmented oversight, and manual review bottlenecks. Once it exists, each new agent or integration increases friction and risk. The practical conclusion is to design control planes early, before exceptions become the operating model.

Shadow AI is a control-plane problem, not a policy-compliance problem. Banning unapproved AI use does not remove demand, and it often pushes activity further underground. The more durable response is to make governed channels easier than unsafe workarounds by combining discovery, identity controls, and auditable tool access. That aligns with broader NIST Cybersecurity Framework and NIST AI Risk Management Framework thinking, where visibility and governance precede effective control.

Board scrutiny is forcing evidence-based AI governance. As boards ask where AI is embedded, what it can touch, and how decisions are traced, organisations need artefacts rather than intentions. Inventories, logs, classifications, and approval records become the proof points. The governance function now has to produce evidence that stands up in security, legal, and regulatory review, which means operational controls must be designed for audit from the start.

What this signals

AI governance programmes will increasingly be judged on runtime evidence rather than policy intent. Teams that cannot show identity-bound access, tool-level approvals, and audit-grade logs for agent actions will struggle to satisfy security, legal, and board review expectations.

Governance debt: the accumulation of unmanaged AI tools, exceptions, and manual review burdens that makes each additional deployment harder to secure. Organisations should treat discovery and control-plane design as prerequisites for scale, not as follow-on tasks.

Where agent workflows touch infrastructure or customer data, the control conversation now overlaps with NHI governance and zero-trust design. That is why the NIST Cybersecurity Framework 2.0 and NIST AI Risk Management Framework both matter here: visibility, accountability, and continuous oversight have become operational requirements rather than optional assurance layers.

For practitioners

• Build a governed AI inventory Map every agent, model, MCP server, tool, and external integration, then assign an owner, risk tier, and revocation path before production use.
• Enforce runtime policy gates Place policy enforcement between agents and tools so destructive actions, sensitive data access, and production changes require explicit approval.
• Bind identity to every AI session Require SSO, OAuth, or equivalent identity binding for agent sessions, and log every tool call with attributable identity and context.
• Reduce shadow AI through governed defaults Offer approved AI channels with easier access, better usability, and clear policy controls so teams do not route around governance.
• Align AI governance to existing control frameworks Map runtime oversight, logging, and approval controls to NIST AI Risk Management Framework, NIST Cybersecurity Framework 2.0, and identity lifecycle processes.

Key takeaways

• Static AI governance cannot control systems that call tools, change data, and act at runtime.
• The strongest risk signal is not model accuracy but whether AI access, approvals, and audit trails exist at execution time.
• Enterprises that treat AI agents as governable identities will scale more safely than those that rely on document-first oversight.

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.
• Shadow AI: AI agents, copilots, or connected tools operating without full visibility or governance from security teams. Shadow AI becomes an identity problem when those systems authenticate with unmanaged tokens, service accounts, or OAuth apps that can reach production resources.
• Runtime Oversight: Runtime oversight is the monitoring and intervention layer that evaluates behaviour after a system is deployed. It covers logging, approvals, rollback, and escalation when an AI system interacts with live data, live users, or live tools, and it is essential when behaviour can change during execution.
• Governance Debt: The accumulation of unresolved identity control weaknesses created when teams prioritise speed over lifecycle design. In NHI environments, it shows up as accounts with unclear ownership, undocumented purpose, stale credentials, and no reliable retirement path, all of which make later security work harder.

What's in the full article

Obot's full analysis covers the operational detail this post intentionally leaves for the source:

• A runtime governance architecture for agent-tool oversight, including how central gateways enforce policy between AI systems and enterprise services.
• Implementation detail on MCP-based access control, including identity integration, audit logging, and connector governance.
• Practical examples of human-in-the-loop checkpoints for destructive actions such as transfers, deletions, or production changes.
• An enterprise AI maturity path from scattered pilots to governed control planes, useful for planning rollout sequencing.

👉 Obot's full article covers the governance architecture, shadow AI controls, and operational AI best practices in more detail.

Deepen your knowledge

The NHI Foundation Level course, the industry's only accredited NHI security programme, covers NHI governance, machine identity security, and secrets management. It is designed for practitioners who need to connect identity controls to real operational risk.