---
title: "AI agent governance guide"
description: "Find, Ship, Run and Improve, with ownership, identity, evaluations, runtime enforcement and change review."
canonical: https://opencontroller.lyzr.com/ai-agent-governance
last-updated: 2026-11-16
---

# AI agent governance guide

Enterprise field guide / Opencontroller by Lyzr

# AI agent governance

A practical framework for governing what acts on your behalf, from the first discovery to the next release.

By Lyzr · Published 28 October 2026

[01

## Find

What do we have?

Inventory + ownership](#find)[02

## Ship

What can it do?

Identity + release evidence](#ship)[03

## Run

Who can stop it?

Enforcement + traceability](#run)[04

## Improve

What should change?

Feedback + evaluated changes](#improve)

Evidence feeds the next release

## What is AI agent governance?

AI agent governance is the set of responsibilities, policies and technical controls that determines who owns an agent, what it may access or do, how it is approved for use, and how its actions are monitored and corrected. It covers the entire lifecycle, not just the model behind an agent.

An agent that retrieves a document presents a different risk from one that updates a customer record or initiates a payment. Governance should reflect those differences. Start with the business action, the data involved and the consequences of an incorrect decision, then choose the controls.

### Why model governance alone is not enough

Model evaluations help assess responses. Agents also select tools, use credentials and change external systems. A good answer does not prove that the resulting action was authorized. Enterprise governance needs both quality checks and enforceable boundaries around actions.

The framework below follows Opencontroller’s four lifecycle phases: Find, Ship, Run and Improve. It is practical implementation guidance, not a regulatory certification or a claim that any one product completes your compliance obligations.

01 / Find

## Discover agents and give each one an owner

You cannot govern an agent you do not know exists. Build an inventory across cloud services, frameworks, business applications and internally deployed agents. Include prototypes and unapproved agents, rather than treating the production register as the entire estate.

* **Record purpose and ownership.** Name the business owner, technical maintainer, intended users and operational contact. Ownership must include authority to approve changes and stop the agent.
* **Map dependencies.** Document models, tools, APIs, data sources, credentials and downstream systems. Track where the agent runs and which version is active.
* **Classify risk.** Consider data sensitivity, external exposure, autonomy, reversibility and business impact. Read-only assistance and irreversible writes should not share the same approval path.
* **Keep discovery current.** Reconcile new deployments and observed activity against the inventory. Investigate unknown callers and stale ownership records.

**Evidence to retain:** an agent register with an accountable owner, deployment location, version, dependency map and risk classification.

**Checkpoint:** Can your team identify who owns an active agent and what systems it can reach without searching several consoles?

Opencontroller’s Discover block is the inventory entry point. The [capability reference](/capability-reference) documents discovery and the other control blocks.

02 / Ship

## Make authorization and evaluation part of release

Shipping an agent should mean releasing a versioned package of behavior, permissions and evidence. Treat prompt changes, model substitutions, new tools and expanded access as meaningful changes, not just application settings.

* **Register a version.** Capture configuration, instructions, tool definitions and the evaluation results that support release. Keep an explicit approval record.
* **Assign an agent identity.** Avoid shared, broad credentials. Scope access to the tools, resources and operations the agent actually needs, with a way to revoke it.
* **Evaluate the task and its boundaries.** Test representative workflows, incorrect inputs, attempted unauthorized actions, sensitive data handling and failure recovery. Choose acceptance criteria for the specific use case.
* **Define human review.** Specify which consequential actions need approval, who can approve them, and what happens if an approval is unavailable.
* **Plan reversal.** Retain a known-good version and document how to pause, roll back or retire the release.

**Evidence to retain:** a version record, scoped identity, test results, approver and rollback procedure.

**Checkpoint:** Could a reviewer explain why this version is approved and prove that an out-of-scope action is denied?

In Opencontroller, the Ship phase brings together Register, Identity, Evals and Deploy. Use these as separate review responsibilities even if one team operates them.

03 / Run

## Enforce policy where actions happen

A policy written in a prompt is not the same as an access boundary. Runtime governance should check identity, permissions and relevant policy before a tool or API performs the action. Monitoring after execution provides evidence, but cannot undo every consequence.

* **Control the action path.** Apply authorization at the enforcement point and restrict direct paths that bypass it. Decide whether a call is allowed, blocked or held for approval.
* **Protect data movement.** Identify sensitive inputs and outputs. Apply appropriate redaction and destination controls; validate these on your own data categories and workflows.
* **Set operational budgets.** Attribute model and tool usage to agents and owners. Define spend and rate limits, escalation paths and the behavior when a limit is reached.
* **Keep decision evidence.** Connect the agent and version to the request, tool call, policy decision, approval and outcome. Avoid collecting unnecessary sensitive content in traces.
* **Prepare incident response.** Give an authorized operator a way to pause the agent, revoke access and investigate affected systems. Exercise that procedure before relying on it.

**Evidence to retain:** correlated traces, authorization decisions, approval records, usage attribution and incident actions, under your organization’s access and retention rules.

**Checkpoint:** Can an operator stop the agent and reconstruct why a consequential action was allowed?

Opencontroller groups Agent Gateway, Lyzr Gateway, Guardrails and Observability in Run. A model gateway addresses model traffic; governing tool access, ownership and releases requires a broader control plane. See the [control plane comparison](/compare/controlplane) and [gateway comparison](/compare/llmgateway) for the documented distinctions.

04 / Improve

## Turn operational evidence into evaluated changes

Governance does not end at launch. Agents encounter new data, users, tools and failure patterns. Improvement should use runtime evidence to propose changes while preserving the release controls that made the original deployment accountable.

* **Review outcomes with the owner.** Inspect task completion, errors, policy violations, human overrides, cost and latency. Choose metrics that reflect the business purpose, not activity alone.
* **Convert failures into tests.** Add representative failure cases to an evaluation set, using appropriately authorized and sanitized material.
* **Compare changes against a baseline.** Re-evaluate a new prompt, model, policy or tool configuration before release. Check whether quality or safety regresses while optimizing cost.
* **Return to Ship.** Record the change, obtain the relevant approval and deploy with a reversal path. Revisit inventory and permissions when the purpose or dependencies change.

**Evidence to retain:** a reviewed issue, evaluation case, baseline comparison, approved change and post-release outcome.

**Checkpoint:** Can you link a production problem to a tested improvement and identify the version that introduced it?

Opencontroller’s Refine block closes this feedback loop. For a concrete example of performance and cost evaluation, the [Lyzr Gateway benchmark report](/llm-gateway-benchmark) states its workloads and test conditions. Treat those measurements as scoped evidence, not predictions for your deployment.

Illustrative workflow / not customer results

## A customer-service agent that proposes refunds

Suppose an agent reads support cases and proposes a refund. The following is an example governance design, not a description of a live customer deployment.

Find: establish accountability
:   Record the support owner, refund service, case data source and deployment version. Classify the financial write separately from reading the case.

Ship: approve a bounded workflow
:   Allow access only to the relevant case records and refund operation. Test policy exceptions, repeated requests and attempts to use a different tool. Require approval for the actions your business classifies as consequential.

Run: check before executing
:   Verify agent identity and policy before the refund call, link the approval to the request, and record the outcome. If authorization or required approval is missing, do not execute the write.

Improve: learn without bypassing review
:   Use rejected proposals and operator corrections to create regression cases. Evaluate the revised agent, approve the new version and monitor its outcomes.

## How to start an enterprise governance program

Begin with a bounded workflow that has a clear owner and observable outcomes. Avoid expanding autonomy before you can demonstrate control over that workflow.

### Agree who is responsible

The business owner defines acceptable outcomes and approves material risk. The engineering team maintains the agent, evaluations and release process. Security reviews identity, access and enforcement. Operations owns monitoring and incident response. Involve privacy or legal reviewers when the data or use case requires it. Document the handoffs rather than assuming that a shared platform transfers accountability.

### Check the minimum evidence

* Every in-scope agent has a recorded owner, purpose and dependency map.
* A reviewer can find the active version, permissions and release evaluation.
* Unauthorized actions and missing required approvals are tested at the action boundary.
* Operators can attribute usage, reconstruct a decision and pause or revoke access.
* Changes re-enter the evaluation and approval process, including retirement of unused agents.

Review discovery coverage, release evidence coverage, policy-denied actions, unresolved incidents and the time needed to stop an agent. Set targets according to business risk and observed behavior. There is no single universal threshold that makes every agent safe.

Opencontroller organizes these responsibilities into one lifecycle. Explore the [capability reference](/capability-reference) to map the documented blocks to your enterprise’s requirements.

## Sources and further reading

This guide combines the documented Opencontroller lifecycle with general governance recommendations. External sources provide context, not endorsements of Opencontroller.

* [Opencontroller overview](/): Find, Ship, Run and Improve and their control blocks.
* [Opencontroller capability reference](/capability-reference): documented product capabilities and the separately identified roadmap.
* [Microsoft: governance and security across the organization](https://learn.microsoft.com/en-us/azure/cloud-adoption-framework/ai-agents/governance-security-across-organization).
* [Palo Alto Networks: what is agentic AI governance?](https://www.paloaltonetworks.com/cyberpedia/what-is-agentic-ai-governance)

Put the framework into practice

## Map your agent estate to Opencontroller.

[Book a demo](https://www.lyzr.ai/book-demo/)

## Your privacy choices

With your permission, we and our service providers use cookies and similar technologies to recognize returning visitors, measure how the site is used, and support marketing. Essential website functions remain available if you decline. [Read our privacy policy.](/privacy)
