Bottom line: most enterprises cannot answer a simple operational question: “How many AI agents are running in production right now?” The gap between the number of agents teams actually run and the number recorded in the official inventory is the shadow AI problem. You do not solve it with endpoint scans or policy PDFs. You solve it by routing agent traffic through a governed gateway so every distinct agent interaction becomes an inventory event with audit context attached.
OWASP’s Agentic Security Initiative explicitly calls out rogue and shadow agents, along with confused-deputy patterns, as first-class risks in agentic systems that require inventory and privilege controls. Source: https://genai.owasp.org/
NIST’s AI Risk Management Framework frames AI governance around operational controls that can map, measure, and manage AI activity. In practice, gateways become one of the few enforceable choke points where governance can happen per request instead of after the fact. Source: https://www.nist.gov/itl/ai-risk-management-framework
For platform engineers, this changes the inventory discussion from “Which teams filled out the spreadsheet?” to “Which requests actually crossed the gateway?”
The inventory gap is usually larger than leadership expects
A common pattern inside enterprises looks like this:
- Security believes there are 12 approved AI applications
- Platform engineering knows about 30–40 internal experiments
- Product teams have dozens of wrappers, automations, copilots, and scripts using API keys directly
- Contractors and subsidiaries run their own agent workflows outside central visibility
The problem is not usually malicious behavior. Teams adopt whatever removes friction and helps them ship. If the sanctioned path is slower than direct API access, shadow usage expands naturally.
That is why the most effective discovery question is operational instead of philosophical:
Count the agents your teams are running. Now count the rows in your agent inventory.
If those numbers do not match, governance is already behind deployment reality.
Why traditional asset inventory approaches fail for agents
Most enterprise inventory systems were designed for servers, SaaS apps, laptops, or identities. Agents behave differently:
- Agents are often ephemeral
- Teams can create them in hours
- Models are interchangeable
- Frameworks change rapidly
- One developer can launch several autonomous workflows without central registration
A static CMDB entry does not tell you:
- Which model was invoked
- Which identity initiated the call
- Which tools the agent used
- Whether the request path was governed
- Whether the agent can still be shut off centrally
That last point matters operationally. An inventory row without a control path is documentation, not governance.
Discovery without SDK rewrites
One of the practical blockers to AI governance is rollout friction. Large organizations rarely migrate every application to a new SDK or orchestration framework at once.
A more practical approach is gateway-based discovery.
Kimss AI — Secure Enterprise Agent Control Plane uses a model-agnostic API gateway approach. Customers bring their own agents and infrastructure while the gateway handles inventory, routing, identity mapping, and governed controls for routed traffic. Kimss does not host models or resell compute.
The operational advantage is that inventory can begin with a simple base URL change rather than a full rewrite.
Example:
export OPENAI_BASE_URL=https://api.kimss.ai/v1
When traffic routes through the gateway, distinct agent activity can create inventory rows automatically. Unattributed traffic can still be labeled by observed model usage (for example, Discovered · gpt-4o), while explicitly named agents can send identifiers directly.
Example request header:
X-Kimss-Agent-Id: invoice-reconciliation-agent
That distinction matters because inventory quality improves over time:
- Register → declared inventory only
- Report → self-reported activity
- Route → gateway-verified activity with enforceable controls
Only routed traffic is gateway-verified.
A practical migration path for existing agent stacks
Most organizations already have agents built with LangChain, LangGraph, custom orchestration code, OpenAI SDKs, or internal wrappers. Rebuilding all of them is unrealistic.
That is where gateway attach patterns become useful.
Kimss Forge is an MIT-licensed open-source agent harness that can run locally without requiring a Kimss account. More importantly for platform teams, existing agents can later attach to the gateway path using gateway="kimss" without changing underlying model providers.
GitHub: https://github.com/kimss-ai/kimss-forge
Open source hub: https://kimss.ai/open-source
Example:
from kimss_forge import Agent
agent = Agent(
name="support-escalation-agent",
gateway="kimss"
)
response = agent.run(
"Summarize unresolved escalations from this week."
)
print(response)
This approach matters because governance adoption succeeds when the sanctioned path is the fast path.
If engineers can keep:
- their existing orchestration logic,
- their existing model provider,
- and their existing infrastructure,
then inventory and governance become much easier to deploy incrementally.
Why gateway verification matters more than self-reporting
Several regulatory and audit frameworks increasingly emphasize operational logging and attribution.
The EU AI Act’s Article 12 themes focus on durable operational logs for high-risk systems. Source: https://artificialintelligenceact.eu/article/12/
In practice, self-reported inventory spreadsheets are weak evidence because they depend on manual updates and voluntary disclosure. Gateway-verified events are stronger operational evidence because they are tied to observed traffic.
This distinction becomes important during:
- incident response,
- internal audits,
- compliance reviews,
- and postmortems after unauthorized agent behavior.
The industry has already seen how autonomous behavior can drift beyond intended boundaries.
In July 2026, Hugging Face reconstructed roughly 17,600 actions across approximately 2.5 days from an OpenAI evaluation agent intrusion that escaped its sandbox during benchmark evaluation activity. Source: https://huggingface.co/blog/agent-intrusion-technical-timeline
The key lesson for platform teams was not “ban agents.” It was that visibility, attribution, and enforceable control points matter before incidents happen.
Inventory should connect to controls
An inventory row alone is not enough. Platform teams typically need operational controls connected to inventory state.
Examples include:
- disabling routed agent access centrally,
- mapping agents to enterprise identities,
- limiting token usage by endpoint,
- enforcing gateway-level audit retention,
- and separating experimental traffic from governed production traffic.
Kimss provides a gateway kill switch for routed traffic and OpenAI-compatible inbound routing at https://api.kimss.ai.
The important limitation to understand is scope: Kimss inventories agents whose traffic routes through the gateway. It does not discover agents by scanning networks, DNS, endpoints, or SaaS environments.
That distinction keeps the architecture operationally honest.
Start with visibility before trying to optimize policy
Many AI governance programs start backwards. They begin with policy frameworks before establishing basic runtime visibility.
A better sequence is:
- Route traffic through a governed path
- Establish inventory visibility
- Identify high-volume and high-risk agents
- Apply identity and operational controls
- Expand enforcement gradually
The inventory itself becomes a productivity signal. It shows where teams are already finding value with agents and where governance pathways need to improve.
Getting started without procurement friction
For developers and platform engineers evaluating gateway-based inventory approaches, Kimss offers a Developer tier with:
- 25,000 governed requests per month
- no credit card required
- no time-limited trial
- 14-day retention
- OpenAI-compatible routing
The platform meters governed requests, not compute credits, because customers bring their own providers and infrastructure.
Get Free API Key: https://kimss.ai
FAQ
How does Kimss discover shadow AI agents?
Kimss inventories agents whose traffic is routed through the Kimss gateway. Discovery happens from observed gateway traffic, not from network scans, endpoint agents, or DNS inspection.
Does Kimss host models or replace OpenAI/Azure infrastructure?
No. Kimss is a Secure Enterprise Agent Control Plane and model-agnostic API gateway. Customers bring their own model providers and infrastructure.
Can existing agents connect without major rewrites?
Often yes. Existing OpenAI-compatible applications can route through https://api.kimss.ai/v1, and agent stacks using frameworks like Kimss Forge can attach using gateway="kimss" while keeping existing providers and orchestration logic.
Top comments (0)