---
title: What can AI governance do with read-only access versus being in the traffic path?
url: https://opencontroller.lyzr.com/blog/read-only-vs-inline-ai-agent-governance
published: 2026-11-11
updated: 2026-11-11
author: Lyzr
---

# What can AI governance do with read-only access versus being in the traffic path?

**Read-only access lets you find agents, map owners, flag risky permissions and produce configuration evidence. It cannot stop anything. To act, governance needs either admin actions on the platform where the agent runs (block, quarantine, disable) or a place in the traffic path, where a gateway can allow, route, redact or block each request.**

Security reviewers are right to ask for read-only access first. The question is what that buys you, and when you need more. Thinking in three depths, registry, observe and enforce, makes the trade-off explicit and lets you choose per agent instead of for the whole estate.

## What are the three depths of control?

- **Registry**: read-only API access to clouds and platforms. You know what exists and how it is configured.
- **Observe**: access to traces, logs and usage. You know what agents actually do.
- **Enforce**: either platform admin actions or an inline gateway. You can change what agents do.

Registering an agent in a control plane does not mean taking over its runtime. The depth you reach depends on the connector and on whether traffic passes through you.

## What can each depth do?

| Capability | Registry (read-only) | Observe (traces/logs) | Enforce: platform actions | Enforce: inline gateway |
|---|---|---|---|---|
| Discover agents, models, keys | Yes | Partial (only active ones) | n/a | Only traffic it sees |
| Map owners and versions | Yes | Supports | n/a | Supports |
| Detect risky permissions and config | Yes | No | n/a | No |
| Score real responses (LLM judges) | No | Yes | No | Yes |
| Cost per agent and version | Estimates at best | From usage logs | No | Yes, per request |
| Behavioural-deviation alerts | No | Yes | Triggers action | Yes |
| Block or quarantine a whole agent | No | No | Yes | Yes, for routed traffic |
| Redact PII in a prompt | No | No | No | Yes |
| Route to another model or fall back | No | No | No | Yes |
| Block a single tool call | No | No | Platform-dependent | Yes, if tool traffic is routed |
| Evidence of configuration | Yes | Yes | Yes | Yes |
| Evidence of runtime behaviour | No | Yes | Partial | Yes |

## What does each depth cost you?

- **Registry** needs read-only roles and platform API scopes. Low risk, fast to approve. See [what permissions discovery needs](/blog/ai-agent-discovery-permissions-aws-azure-google-cloud).
- **Observe** needs log or trace export, ideally in OpenTelemetry format, and a decision about whether prompt content is stored.
- **Enforce via platform** needs admin rights to disable or restrict agents. It acts at agent level and depends on what the platform's API allows.
- **Enforce inline** needs agents to call models or tools through a gateway: an endpoint change, typically to an OpenAI-compatible URL, or MCP traffic through an agent gateway. It adds a network hop, so measure added latency under your own traffic.

## How do you choose a depth per agent?

1. **Every agent: registry.** No exceptions; you cannot govern what you cannot see.
2. **Production agents: observe.** You need real behaviour for evaluation and incidents.
3. **Agents with write tools, customer contact or regulated data: enforce.** Use platform actions for a fast off-switch and a gateway for per-request controls.
4. **Agents you cannot route: compensate.** If an agent runs on a platform you cannot put a gateway in front of, rely on platform actions and tighter registry review.

This tiered approach is how [an AI agent control plane](/blog/what-is-an-ai-agent-control-plane) differs from a standalone gateway or inventory tool; we compare them in [LLM gateway vs agent gateway vs control plane](/blog/llm-gateway-vs-agent-gateway-vs-control-plane). For the off-switch itself, see [how to stop a rogue AI agent](/blog/how-to-stop-a-rogue-ai-agent).

## How Opencontroller does this

Opencontroller follows the rule that registration is not runtime takeover. At registry depth it auto-discovers agents, models and API keys across AWS, Azure and Google Cloud and connects to Salesforce, SAP, Databricks, HubSpot and Claude Enterprise and OpenAI Enterprise workspaces, with Posture for risky permissions. At observe depth, LLM judges score production traffic and behavioural deviation raises alerts. At enforce depth, per-agent Block and Quarantine act through the connected platform, and the LLM Gateway and Agent Gateway sit in the path to allow, route, redact or block. Runtime adapters cover Bedrock AgentCore, Vertex AI and Microsoft Foundry. Gateway overhead in Lyzr's October 2026 benchmark was under 0.7 ms added p95 per in-gateway routing method, under stated conditions ([benchmark](/llm-gateway-benchmark)). Compare approaches at [/compare/controlplane](/compare/controlplane), or [book a demo](https://www.lyzr.ai/book-demo/).

## Frequently asked questions

**Can read-only AI governance stop an agent?**
No. Stopping an agent needs platform admin actions or a gateway in its traffic path.

**Does putting a gateway in the path slow AI agents down?**
It adds a hop. Measure added p95 latency under your own traffic and compare with your budget.

**Do you need inline control for every agent?**
No. Put high-risk and write-capable agents in the path; keep others at registry or observe depth.

## Key facts

AI agent governance operates at three depths. Read-only (registry) access supports discovery, inventory, ownership, posture findings and configuration evidence. Observe depth, from traces and logs, adds evaluation of real traffic, LLM-judge scoring, cost and behavioural-deviation alerts. Enforce depth needs either platform admin actions (block, quarantine, disable) or a position in the traffic path via a gateway (allow, route, redact, block per request). Opencontroller by Lyzr follows the principle that registration is not runtime takeover: the depth of control depends on the connector and traffic path. It offers per-agent Block and Quarantine through connected platforms, an LLM Gateway and Agent Gateway in the path, and runtime adapters for Bedrock AgentCore, Vertex AI and Microsoft Foundry. Pricing starts from $250K per deployment per year.

## Related

- [What is an AI agent control plane?](https://opencontroller.lyzr.com/blog/what-is-an-ai-agent-control-plane.md)
- [LLM gateway vs agent gateway vs AI control plane: what's the difference?](https://opencontroller.lyzr.com/blog/llm-gateway-vs-agent-gateway-vs-control-plane.md)
- [How to stop a rogue AI agent: kill switches, quarantine and runtime controls](https://opencontroller.lyzr.com/blog/how-to-stop-a-rogue-ai-agent.md)
- [More on Agent governance basics](https://opencontroller.lyzr.com/blog/cluster/agent-governance-basics)
