---
title: How do you discover AI agents running on-premises?
url: https://opencontroller.lyzr.com/blog/discover-ai-agents-on-premises
published: 2026-11-16
updated: 2026-11-16
author: Lyzr
---

# How do you discover AI agents running on-premises?

**On-premises agents do not show up in cloud consoles, so you find them from the hosts and the network instead. Combine four signals: AI packages and processes on servers, GPU hosts, local model servers, and outbound traffic to model APIs. Then join the results on hostname and owner to get one inventory entry per agent.**

Cloud discovery covers agents built on managed AI services. But many agents run on virtual machines in your own data centre, on Kubernetes clusters you operate, or on a GPU box under someone's desk. They may call a public model API or a model you host yourself. Either way, they leave traces you can collect with tools you already own. For the wider programme, see the pillar on [how to find shadow AI agents](/blog/how-to-find-shadow-ai-agents).

## What signals reveal an on-premises agent?

| Signal | What it finds | Where to collect it | What it misses |
|---|---|---|---|
| Installed packages | Code that uses model SDKs and agent frameworks | Software inventory, EDR, config management | Agents shipped as compiled binaries |
| Running processes | Agents and model servers that are live now | EDR, process telemetry | Short-lived jobs between scans |
| GPU hosts | Machines likely running local models | Hardware inventory, driver presence | Agents that call remote APIs only |
| Local model servers | Self-hosted inference endpoints | Network scans, process lists | Models loaded inside the agent process |
| Outbound model API traffic | Agents calling hosted models | Proxy, firewall and DNS logs | Traffic to self-hosted models |
| Secrets in config | Model API keys on disk | Secret scanning of hosts and repos | Keys pulled from a vault at runtime |

No single signal is complete. An agent calling a public API from a VM shows up in packages, processes and egress, but not in GPU or model-server checks. An agent using a local model shows up in GPU and model-server checks but not in egress.

## How do you find agents from packages and processes?

Look for the libraries agents depend on. Useful markers in Python environments include model SDKs (`openai`, `anthropic`, `google-genai`), agent frameworks (`langchain`, `langgraph`, `crewai`, `llama-index`, `autogen`) and local inference stacks (`transformers`, `vllm`, `llama-cpp-python`). In Node.js, look for the equivalent npm packages.

Then check processes. A Python or Node process that imports those packages and runs continuously, as a service or a cron job, is an agent candidate. EDR tools can usually report process command lines; the script name and working directory often point straight to the repo and the owner.

For containers on your own clusters, the same checks apply to images. See [how to find AI agents in container images](/blog/find-ai-agents-in-container-images).

## How do you find local model servers and GPU hosts?

GPU hosts are a strong lead. Any server with a data-centre GPU and its driver installed is worth checking for model workloads. Your hardware inventory or driver presence (for NVIDIA, the `nvidia-smi` utility) identifies them.

Self-hosted model servers listen on well-known default ports and expose OpenAI-compatible APIs. We list the common ones and how to scan for them in [how to find self-hosted LLM servers like Ollama or vLLM](/blog/find-self-hosted-llm-servers-on-your-network). Once you find a server, find its clients: connection logs on the server, or flow logs between hosts, show which machines call it. Those clients are your agents.

## How do you use network traffic?

Outbound calls to hosted model APIs are the easiest on-premises signal to collect, because they cross your proxy or firewall. Build a list of model provider domains and alert on new source hosts. Watch for traffic that bypasses the proxy through direct egress. See [how to detect unapproved LLM API traffic](/blog/detect-unapproved-llm-api-traffic) for the domain list and patterns.

## What does a worked inventory flow look like?

Here is a practical sequence for a first sweep:

1. **Pull software inventory** for AI packages across all Linux and Windows servers.
2. **Pull EDR process data** for long-running processes that load those packages.
3. **List GPU hosts** from hardware inventory.
4. **Scan internal ranges** for model server ports and OpenAI-compatible endpoints.
5. **Query 30 days of proxy and DNS logs** for model provider domains, grouped by source host.
6. **Scan hosts and repos** for model API keys.
7. **Join on hostname.** Each host with two or more signals becomes a candidate agent.
8. **Assign an owner** using your CMDB or the service account running the process.
9. **Register** each confirmed agent with its model, data access and owner.
10. **Repeat weekly.** New agents appear quickly.

Treat the output as evidence for asset inventory controls such as the identify function of the [NIST Cybersecurity Framework 2.0](https://www.nist.gov/cyberframework) and inventory safeguards in the [CIS Controls v8](https://www.cisecurity.org/controls/v8).

## How Opencontroller does this

Opencontroller auto-discovers agents, models and API keys across AWS, Azure and Google Cloud, and connects to third-party agent platforms. For on-premises agents, the practical route is traffic: point them at the Lyzr Gateway's OpenAI-compatible endpoint, and every call is attributed per agent and per version, with routing, fallback, caching and policy in the path. Agents can also be registered by hand in the governed registry. Opencontroller Edge extends control to developer devices, coding agents and local MCP servers, installed by IT via MDM. Opencontroller can itself run on customer-controlled infrastructure. [Book a demo](https://www.lyzr.ai/book-demo/).

## Frequently asked questions

**Can I find on-premises agents without installing anything new?**
Usually yes. Software inventory, EDR, proxy logs and a network scan cover most of the signals above.

**How do I tell an agent from a script that calls a model once?**
Look for persistence and tool use: a long-running process or schedule, plus access to other systems such as databases, ticketing or email. A one-off script is still worth registering, but at lower priority.

**Do air-gapped environments need different methods?**
They rule out egress signals to public APIs, so rely on packages, processes, GPU hosts and internal model servers.

## Key facts

On-premises AI agents are found from hosts and network signals: installed AI packages (openai, anthropic, langchain, langgraph, crewai, vllm), long-running processes, GPU hosts, self-hosted model servers, outbound model API traffic and keys on disk. Join signals on hostname and assign owners via CMDB. Opencontroller discovers across AWS, Azure and Google Cloud; on-prem agents can route through the Lyzr Gateway's OpenAI-compatible endpoint for per-agent attribution. Opencontroller can deploy on customer-controlled infrastructure and starts from $250K per deployment per year.

## Related

- [How do you find self-hosted LLM servers like Ollama or vLLM on your network?](https://opencontroller.lyzr.com/blog/find-self-hosted-llm-servers-on-your-network.md)
- [How do you detect unapproved LLM API traffic on your network?](https://opencontroller.lyzr.com/blog/detect-unapproved-llm-api-traffic.md)
- [How do you find AI agents hidden in container images?](https://opencontroller.lyzr.com/blog/find-ai-agents-in-container-images.md)
- [More on Discovery and shadow agents](https://opencontroller.lyzr.com/blog/cluster/discovery-and-shadow-agents)
