Summary
Your employees are building AI agents without telling IT. These aren't just chatbots they're talking to—these are active systems that make decisions, access your data, and take actions on their own. The problem: you probably don't know they exist. This guide breaks down eight different ways to find these shadow agents before they become a security problem.
The Problem
Imagine your company installed a filing system. Sounds great. But then employees started building their own custom filing systems on top of it—without asking anyone. Some file documents automatically. Some pull from multiple systems. Some even make decisions about what to file where. Now IT finds out these systems exist, but IT doesn't know how many there are, who built them, what data they're accessing, or if they're even still needed.
That's the shadow AI agent problem.
Every employee can now create agents inside familiar tools like Microsoft Copilot Studio, Salesforce Agentforce, or automation platforms like Zapier. These agents get their own credentials. They connect to your business systems. They act independently. And IT often has no idea they exist.
What's Happening
What is an AI agent anyway?
An AI agent is software that uses AI to figure out what to do next, then takes action to complete a task. Unlike a chatbot you type into, agents work on their own. They might:
- Pull data from your CRM
- Send an email
- Update a spreadsheet
- Make decisions without asking a human first
The appeal is obvious. Agents promise to automate repetitive work and let small teams do more. But here's the catch: agents don't just sit there. They do things. They access your data. They take actions. They do this with whatever permissions someone gave them—which might be way too much.
Why this matters for IT and security
An unknown agent isn't just an ungoverned tool. It's an ungoverned actor with real access to your systems. Shadow agents create blind spots. You don't know:
- What agents exist
- Who built them
- What data they can access
- Whether they're still running after their creator left the company
- If they're exposing sensitive information
Deep Dive: Three Key Concepts
1. The Credential Problem: Non-Human Identities
Every agent needs credentials to operate: API keys, passwords, tokens. Think of it like employee badges. An employee badge lets one person in one door. But an agent credential can operate 24/7, access multiple systems, and do things without a human reviewing each action.
The problem: these credentials are hard to track. A developer creates an agent locally, gives it API keys to access your database, and then leaves the company. The agent keeps running. The credentials still work. No human is there to stop it.
2. The Surface Problem: Agents Are Everywhere
Agents run in different places:
- Browser agents: Employees use web-based builders like Copilot Studio to create agents inside their browser
- Desktop agents: Developers use tools like VS Code to build custom agents on their computers
- Cloud agents: Agents run on cloud platforms like AWS or Azure, operating entirely in the background
- Embedded agents: Agents built inside Salesforce or Microsoft 365, deployed by business users without IT review
Each location requires a different way to find it. Network monitoring finds cloud agents. Browser extensions find web-based agents. But no single method finds them all.
3. The Governance Problem: No Owner, No Accountability
When you discover an agent, you need to know: Who's responsible for this? If nobody knows, it's a zombie process taking actions on its own. If the person responsible left, who maintains it? If it's broken or dangerous, who do you tell to fix it?
Without governance context, discovery is just a list of unknowns. With it, you can actually do something.
Real-World Examples
Example 1: The Accidental Data Pipeline
A sales analyst creates an agent in Copilot Studio to automatically update the CRM when new leads come in. The agent works great. IT finds it six months later by accident. They discover the agent has access to your customer database, pulls email addresses, and syncs everything to a third-party AI tool for analysis. No approval. No security review. The analyst left two months ago but the agent still runs.
Example 2: The Orphaned Agent
A developer builds a custom agent on AWS to automate API testing. The agent runs every night, calling your internal APIs. The developer gets promoted, then leaves the company. The agent is never offboarded. Three years later, IT discovers it's still running with the same credentials, even though nobody remembers what it does.
Example 3: The Supply Chain Risk
Your company uses a workflow automation platform. An employee builds an agent there that pulls data from your HR system and sends it to an AI service for analysis. The AI service gets hacked. Now a third party has access to your HR data—through an agent IT never knew about.
How to Find Them: Eight Discovery Methods
Method 1: Network Traffic Monitoring
Look at data flowing from your network to AI services. If you see unusual connections to ChatGPT, Claude, or other AI APIs, something is calling them. This catches agents making external calls, but misses agents that run entirely inside your company's systems. It's like catching a phone call to the outside but not conversations happening in the room.
Method 2: Browser Extensions
Install a browser extension on managed computers. It watches for employees using web-based agent builders like Copilot Studio or Agentforce. This is the fastest way to catch shadow agents before they become formal deployments. But it only works on managed devices and managed browsers.
Method 3: Endpoint Monitoring
Monitor managed computers for AI tools and agent frameworks running locally. This shows you who's building agents on their machine. It's like watching a workshop to see who's building something, but not what they do with it once they leave.
Method 4: Code Repository Scanning
Scan your code repositories for agent frameworks and AI service calls. This finds agents before they go into production. But it misses agents built through no-code tools or inside SaaS platforms.
Method 5: Runtime Observability
Monitor what agents actually do when they run. See the data they access, the decisions they make, the systems they touch. This is the closest you get to seeing reality. But it requires setup and only covers systems you've instrumented.
Method 6: Third-Party Risk Management
Ask vendors: do you use AI agents? Get them to document what agents they deploy and what they do. This builds contractual accountability but relies on vendors being honest and telling you about every new agent.
Method 7: Identity-Centric Discovery
Find agents by the credentials they use. Look for API keys, OAuth tokens, service accounts. This tells you: who authorized this, what systems can it access, is the person still here. It directly answers governance questions.
Method 8: SaaS API Integration
Query the APIs of platforms like Salesforce, Microsoft 365, and ServiceNow. These platforms know about agents created inside them. The APIs tell you: this agent exists, this user built it, it has access to these systems, these credentials authorize it.
What You Should Actually Do
Pick multiple methods. No single approach catches everything.
Start here:
- Week 1: Query your SaaS platforms (Salesforce, Microsoft 365, ServiceNow) using their APIs. You'll find agents embedded in systems you already own.
- Week 2: Deploy browser extensions to managed devices to catch employees using web-based agent builders.
- Week 3: Query network logs for unusual traffic to AI services.
Then layer on:
- Identity-centric discovery to understand permissions and ownership
- Code repository scanning if you have development teams
- Runtime observability if you're running agents in production
Make it work for governance:
- Map every discovered agent to a human owner
- Document what systems it can access
- Set an approval status (approved, needs review, needs remediation)
- Create a process to offboard agents when creators leave
- Review permissions regularly—do agents still need the access they were given?
Questions to ask vendors:
- What discovery methods do you actually use?
- Can you tell me who created each agent?
- Can you show me what systems and data each agent can access?
- Can you detect agents with excessive permissions or public exposure?
- Do you help with offboarding agents when the creator leaves?
- What blind spots do you have? (Every vendor has them.)
Bottom Line
Shadow AI agents are real. They're probably already in your environment. You need to find them, understand who built them, know what they can access, and make sure someone is responsible for maintaining them. Pick the right combination of discovery methods, build governance into your process, and you'll turn an unknown risk into a managed asset.
The goal isn't to ban AI agents. It's to know they exist, understand what they do, and make sure they're not creating security or compliance problems.