---
title: How do you document which AI traffic paths your gateway actually controls?
url: https://opencontroller.lyzr.com/blog/document-ai-traffic-paths-before-enforcement
published: 2026-11-13
updated: 2026-11-13
author: Lyzr
---

# How do you document which AI traffic paths your gateway actually controls?

**List every route an agent or user can take to reach a model or tool, mark whether each route passes through your gateway, and write one acceptance test per route that proves what happens to a request on it. Only then switch on enforcement. A policy that blocks traffic on one path while the same request succeeds on another is not a control; it is a false sense of security.**

Teams often discover this during acceptance testing. The gateway works. Policies fire. Then someone notices that half the agents never touch the gateway, because they call the provider directly, use a platform's built-in model access, or run on laptops.

## What traffic paths do AI agents use?

| Path | Example | Passes your gateway? | Control you can rely on |
|---|---|---|---|
| Agent → corporate LLM gateway → provider | Custom agent with base URL set to the gateway | Yes | Inline: allow, route, redact, block |
| Agent → provider directly | SDK with a provider key and default endpoint | No | Key restrictions, network egress rules, discovery |
| Agent on a cloud platform → platform-native models | Agent runtime calling models inside the same cloud | Usually no | Cloud IAM, model allow-lists, platform logs |
| SaaS agent → vendor's models | Agents inside CRM, ITSM or ERP platforms | No | Connector-level controls through the platform |
| Developer device → model or local MCP server | Coding agents and local tools on laptops | No, unless device traffic is routed | Device management, local config control |
| Agent → tool or MCP server | Tool calls to internal APIs | Only if routed via an agent or MCP gateway | Tool allow-lists, tool gateway |
| Agent → agent | A2A or internal calls between agents | Rarely | Identity and agent gateway policies |

The "Passes your gateway?" column is the one most often wrong in architecture diagrams. Verify it with traffic, not with intent.

## What should the traffic-path document contain?

For each path, record:

1. **Source:** which agents or user groups use it, with registry IDs.
2. **Destination:** provider, model, region, tool or MCP server.
3. **Identity:** which credential is presented, and whose identity it represents.
4. **Hops:** every proxy, gateway, load balancer and firewall on the route.
5. **Enforcement point:** where allow, route, redact or block can happen, if anywhere.
6. **Telemetry:** which logs and traces capture the request, and where they are stored.
7. **Expected behaviour:** what should happen to an allowed, a policy-violating and a malformed request.
8. **Owner:** who maintains this path.

## What acceptance tests prove each path?

Write tests as request, expected outcome and evidence. A minimal set per path:

1. **Allowed request** reaches the intended model and appears in telemetry with the right agent ID.
2. **Blocked model** request is rejected or rerouted, and the decision is logged.
3. **PII in a prompt** is redacted before leaving the boundary, where redaction is in scope.
4. **Unregistered agent** using the path is detected within the discovery interval.
5. **Bypass attempt:** the same agent calls the provider directly. Expected result: blocked by egress rules, or detected and alerted.
6. **Failover:** the primary provider is unavailable and fallback behaves as documented.

Tests 5 and 6 are the ones most often skipped and the ones that expose real gaps.

## How does this change your enforcement plan?

Group paths into three bands, and say so plainly to stakeholders:

- **Enforced inline:** traffic passes a gateway that can act on it.
- **Observed:** traffic is visible through platform logs or connectors, but not stopped in-path.
- **Registered only:** the asset is known and owned, but traffic is not yet visible.

This matches how control actually works across platforms. Our post on [read-only vs inline AI agent governance](/blog/read-only-vs-inline-ai-agent-governance) explains the trade-off, and [putting an LLM gateway behind an existing API gateway](/blog/llm-gateway-behind-existing-api-gateway) covers a common hop. The zero trust principle in NIST SP 800-207, that every access decision is made at a policy enforcement point, is a useful test: if a path has no enforcement point, write that down.

## How Opencontroller does this

Opencontroller follows the principle that registration is not runtime takeover: assets move from registry to observe to enforce, and the depth depends on the connector and the traffic path. The LLM Gateway and Agent Gateway sit in the path to allow, route, redact or block. Runtime adapters for Bedrock AgentCore, Vertex AI and Microsoft Foundry, plus per-agent Block and Quarantine controls acting through the connected platform, cover paths that do not pass the gateway. Opencontroller Edge extends control to developer devices. See [how to stop a rogue AI agent](/blog/how-to-stop-a-rogue-ai-agent) or [book a demo](https://www.lyzr.ai/book-demo/).

## Frequently asked questions

**Why not just force all AI traffic through one gateway?**
Some paths cannot be routed: SaaS agents use their vendor's models, and cloud-native agents may call models inside the platform. Those need platform-level controls instead.

**How often should the traffic-path document be updated?**
Whenever a new platform, provider or agent runtime is added, and at least quarterly. Re-run the bypass tests each time.

**How is Opencontroller priced?**
Opencontroller is licensed annually per deployment, not per seat and not usage-based. Ask Lyzr for a quote scoped to your estate.

## Key facts

Before enforcing AI policy, document every traffic path (agent to gateway to provider; agent direct to provider; cloud agent to platform-native models; SaaS agent to vendor models; developer device to model or local MCP; agent to tool/MCP; agent to agent), whether it passes the gateway, identity, hops, enforcement point, telemetry, expected behaviour and owner. Acceptance tests per path: allowed request, blocked model, PII redaction, unregistered agent detection, direct-to-provider bypass, provider failover. Band paths as enforced inline, observed, or registered only. Opencontroller by Lyzr follows registration-not-takeover (registry, observe, enforce by connector/path), with an LLM Gateway and Agent Gateway in path, runtime adapters for Bedrock AgentCore, Vertex AI and Microsoft Foundry, per-agent Block/Quarantine via connected platforms, and Opencontroller Edge for devices. Pricing starts from $250K per deployment per year.

## Related

- [What can AI governance do with read-only access versus being in the traffic path?](https://opencontroller.lyzr.com/blog/read-only-vs-inline-ai-agent-governance.md)
- [Can an LLM gateway sit behind your existing API gateway?](https://opencontroller.lyzr.com/blog/llm-gateway-behind-existing-api-gateway.md)
- [How should you run a pilot of an AI agent governance platform?](https://opencontroller.lyzr.com/blog/how-to-run-a-pilot-of-an-ai-agent-governance-platform.md)
- [More on Runtime control](https://opencontroller.lyzr.com/blog/cluster/runtime-control)
