server room

Photo by panumas nikhomkhai on Pexels

Most of the AI governance market was built for a world where the risky artifact was a model. You register the model, run an assessment, assign a risk tier, document the decision, and produce a report. That workflow made sense when the output of an AI system was a prediction a human would read. It makes far less sense now that the output is often an action taken directly against a production system, executed at machine speed, with no human in the loop to catch a bad call.

Gartner defines AI governance platforms as tools designed to ensure organizations comply with their responsible AI practices, organization policy, and regulations. Read that word again: ensure. A dashboard that tells you an agent violated policy is not ensuring compliance. It is producing a record of non-compliance after the fact. The distinction between a platform that advises and a platform that enforces is the central design question in this category, and it is the one most buyers fail to ask about until an incident forces the conversation.

What AI governance actually has to cover

The common definition is that AI governance refers to the policies, processes, and software tools that ensure AI systems are developed, deployed, and monitored responsibly. Software vendors in the category describe their products as supporting secure, ethical, and legal deployment of AI, and as helping organizations define policies, assign accountability, inventory AI systems, assess risk, and document decisions.

All of that is necessary. None of it is enforcement. Policy definition, accountability assignment, inventory, and risk assessment are inputs to governance. They describe what should happen. The question a runtime governance layer answers is different: given this specific agent, this specific identity, this specific action, and this specific target system, should the action execute right now?

That question cannot be answered by a document. It has to be answered by a control plane sitting between the agent and the systems it wants to touch.

The advisory trap: why documentation alone fails in production

Advisory governance works when humans are the enforcement layer. A policy says an analyst must not approve their own vendor onboarding. The analyst knows the rule, the manager watches for it, and the control holds because the analyst moves at human speed and understands the consequences.

Now replace the analyst with an autonomous agent that has been granted credentials to the procurement system and the payment system so it can “streamline vendor onboarding.” The agent has no internalized sense of the rule. It has tool access. If nothing stands between the agent and the payment API, the segregation-of-duties control that looked airtight in the governance register evaporates the moment the agent is deployed.

This is the gap OWASP catalogues as excessive agency, listed as LLM06:2025 in its Top 10 for LLM applications. Excessive agency is not a prompt problem. You cannot fix it by telling the model to be careful, because the model is not the entity holding the credentials. The agency lives in the agent’s identity, its scopes, and its tool permissions. Those are runtime facts, and they require a runtime control.

Three tiers: documentation, observation, enforcement

Vendors in this category describe their capabilities in similar language, which makes evaluation difficult. A useful way to separate platforms is to ask which tier of control they actually operate at.

Tier What the platform does Where it breaks
Documentation Records policy, inventory, risk assessments, and decisions. Produces evidence of intent. Policy and production drift apart with no mechanism to detect or correct the gap.
Observation Monitors activity, detects shadow AI, alerts on anomalies, and reports on control health. Detection happens during or after the action. Alerts require a human to respond, and agents do not wait.
Enforcement Evaluates each action before execution and allows, blocks, or escalates based on deterministic policy. Requires deep integration with identity, systems of record, and data classification to be accurate.

Many platforms claim all three. The tell is whether the platform can stop something. If every control path terminates in a notification, a ticket, or a dashboard tile, the platform is advising. That is a legitimate product, but it is not a control plane, and buying it as one leaves a gap exactly where risk concentrates.

data center

Photo by panumas nikhomkhai on Pexels

Why agents broke the governance spreadsheet

Agents introduce three properties that legacy governance tooling handles poorly.

The first is identity sprawl. Every agent needs credentials, and those credentials are often long-lived service accounts with broad scopes inherited from whatever human set them up. A platform that inventories models but cannot inventory non-human identities is missing the majority of the attack surface. AI agent identity governance has to be part of the same system that governs the agent’s behaviour, otherwise you are tracking two disconnected truths.

The second is delegated authority. An agent acting on behalf of a user inherits some portion of that user’s permissions, but the delegation chain is rarely explicit. When an action is later reviewed, the question “who authorized this” has no clean answer. Runtime governance resolves this by capturing the acting agent, the delegating principal, and the scope of the delegation at the moment of execution.

The third is emergence. Agents combine tools in ways nobody specified. An agent with read access to a customer data store and write access to an email tool can exfiltrate records without either permission looking unusual in isolation. Only a layer that sees the combination, in context, at runtime, can flag or block it.

The three questions a platform must answer per request

Enforcement is not vague. It reduces to three questions that must be answered before an action executes, every time.

  • Who is acting? The agent’s identity, its owning team, the human or system that delegated authority, and the scope of that delegation.
  • What is it allowed to do? The applicable policy, evaluated deterministically, including segregation-of-duties constraints and any limits on agency.
  • What is it touching? The target system of record and the classification of the data involved, resolved through integrations with configuration management databases, identity providers, and data catalogs.

A platform that cannot answer all three at request time is guessing. Guessing is fine for a risk assessment workshop. It is not fine for an agent that can move money, change a patient record, or provision infrastructure.

security team

Photo by Anil Sharma on Pexels

Deterministic beats probabilistic for authorization decisions

There is a tempting shortcut here: use another model as a guardrail. Point a classifier at the agent’s proposed action and let it judge whether the action looks safe. This is useful for content moderation. It is a poor foundation for authorization.

Any probabilistic classifier has a nonzero bypass rate, and that rate is not stable under adversarial pressure or unusual inputs. Worse, the decision is not reproducible. When an auditor asks why an action was permitted in March, “the classifier scored it low risk” is not a defensible answer, because you cannot reconstruct the exact conditions that produced that score. Enforcement decisions need to be deterministic, explainable in terms of named policy rules, and replayable from logs. That is what makes an enforcement layer auditable rather than merely observable.

Enforcement without a kill switch is only half a control

The ability to block a single action is valuable. The ability to stop an entire agent, or a class of agents, mid-flight is what separates a control plane from a firewall. Incident response for autonomous systems has to include runtime revocation of credentials, suspension of an agent identity, and containment of everything that agent touched. If your governance platform’s containment story is “open a ticket and follow the runbook,” you have documented the incident rather than contained it.

The same logic applies to shadow AI. Detection is the entry point, not the outcome. Once an unregistered agent is discovered, the platform should be able to classify it, attach it to an owner, and apply policy, including blocking it, without waiting for a human to complete a spreadsheet row.

What to ask before you buy an AI governance platform

  1. Does the platform sit in the request path between agents and systems of record, or does it consume logs after the fact?
  2. Can it attribute an action to a specific agent identity and delegation chain, or only to a model or application?
  3. Which systems of record does it integrate with, and how does it resolve data classification at decision time?
  4. Can it block, throttle, or revoke in production without a code change or a human approval step?
  5. Can it reconstruct and replay a past decision from logs well enough to satisfy an auditor?
  6. How does it detect agents that were never registered in the first place?
  7. What is the realistic time to containment when an agent starts behaving outside policy?

Vendors that lead with inventory and assessment will answer the first question with a diagram of a pipeline. Vendors that lead with enforcement will answer it with an architecture showing where the decision point sits. The difference in those two answers tells you which tier you are actually buying.

office meeting

Photo by Kampus Production on Pexels

Sequence matters: discover, classify, enforce, expand

Runtime enforcement depends on accurate context, so the rollout order is not arbitrary. Start with discovery of agents and non-human identities, including the ones nobody registered. Then classify each agent by owner, purpose, reachable systems, and data sensitivity. Only then turn on enforcement, beginning with high-consequence actions such as payment approval, record modification, and privilege changes, where a block is worth more than an alert. Expand coverage as policy accuracy improves.

Organizations that reverse this order, writing ambitious policy first and looking for somewhere to apply it later, end up with a governance program that exists primarily in slide decks. The systems that will actually hold under pressure are the ones where the policy is expressed as a runtime decision and the decision is enforced by something other than good intentions.

Frequently Asked Questions

What is the difference between an advisory and an enforcing AI governance platform?

An advisory platform records policy, assesses risk, and alerts humans when behaviour drifts. An enforcing platform evaluates each agent action against policy before it executes and can allow, block, or escalate it. The practical difference is whether a violation becomes a prevented event or a documented incident that someone reviews afterwards.

Why is documentation alone not enough for AI compliance?

Documentation captures intent, and auditors do need evidence of intent. But the question that matters in production is whether the policy was applied to a specific action at a specific time. Without a runtime control point, there is no reliable link between the written policy and what an autonomous agent actually did with its credentials.

How does excessive agency relate to runtime governance?

OWASP lists excessive agency as LLM06:2025 in its Top 10 for LLM applications. The risk comes from an agent holding permissions broader than its task requires, combined with tool access it can chain in unexpected ways. Runtime governance constrains that agency by limiting scope, evaluating each action against policy, and revoking access when behaviour falls outside the intended boundary.

Can observability tools provide the same control?

Observability answers what happened. Enforcement answers what is allowed to happen. Monitoring is valuable for detection, investigation, and tuning policy, and an enforcing platform should feed the same telemetry. The distinction is that observability alone cannot prevent an action, because by the time the signal exists, the agent has already acted.

What should a first enforcement milestone look like?

Pick one agent population and one high-consequence action, such as payment approval or a privilege change. Confirm the platform can identify the agent, resolve the target system and data classification, evaluate policy deterministically, and block the action when required. A narrow control that demonstrably holds is a better foundation than broad coverage that only reports.