AI Agent Sprawl: How to Audit Every AI Agent in Your Company (2026)

What is AI agent sprawl?

AI agent sprawl is the uncontrolled accumulation of AI agents, copilots and automations across a company — each with its own credentials, data access, memory and bill — with no central inventory of what exists, who owns it, or what it can touch. It is the 2026 descendant of shadow IT, with one important difference: the shadow now acts. These tools read inboxes, write to CRMs, merge code and message customers, which is why the cure is not a ban but an audit — one that produces a living inventory of every agent in the building.

Sprawl is nobody's fault, which is why every company has it. Adoption is bottom-up: a sales lead expenses a ChatGPT seat, an engineer turns on GitHub Copilot, a marketer builds a custom GPT on last year's messaging docs, an ops person wires a Zapier automation with an AI step, and a SaaS vendor flips on an "agent" feature inside a tool you already pay for. Each decision is individually sensible; the sum is a fleet nobody can enumerate. We ran the audit below on our own stack before writing about it, and the pattern we see everywhere held for us too: the first guess undercounts, usually by a lot, and the most interesting rows are the ones nobody remembered creating.

How the seven-step audit works

The audit moves from visible to invisible: inventory the seats you pay for, hunt the agents nobody procured, then attach an owner, a scope, a cost and a memory location to every row — and finish by putting a review date on the whole thing. The output is a register with one row per agent; a spreadsheet is a perfectly good first vehicle. This is the first pillar of the wider discipline we cover in our complete guide to AI agent governance, and the reference model lives on our AI agent governance page. Budget one focused week for the first pass: the goal is 80 percent coverage this week, not 100 percent coverage never.

Step 1: Inventory the obvious seats

Start with the AI subscriptions the company already pays for — the visible half of sprawl and the easiest rows to fill in. In most companies five names cover it: ChatGPT (including ChatGPT Enterprise and Team workspaces), Microsoft 365 Copilot, GitHub Copilot, Claude and Cursor.

Three sources enumerate them in an afternoon. Finance's invoice and expense list catches both the central contracts and the seats individuals quietly expense on cards. Your identity provider — Okta, Microsoft Entra or Google Workspace SSO — shows which AI applications are assigned to whom. And each vendor's own admin console gives you the authoritative seat count, the workspace admins and, on enterprise tiers, usage data. Record four things per product: seat count, admin owner, plan tier and renewal date. Then note the gap between the lists — employees using personal, unmanaged accounts on work data are not a footnote; they are your first entries for the shadow half of the register.

A few vendor-specific notes from running this ourselves. ChatGPT Enterprise and Team give admins a workspace view of members and of the custom GPTs built inside the workspace — grab both while you are in there, because you will want the GPT list again in Step 2. Microsoft 365 Copilot seats live in the Microsoft 365 admin center alongside your other licences, and GitHub Copilot seats are listed per organization in GitHub's settings, which also shows who has actually used the seat recently — a quiet way to find the licences paying for nothing. Claude workspaces and Cursor business plans expose member lists in their respective consoles. None of this takes tooling; it takes an afternoon and the discipline to write down what you find.

Step 2: Hunt the shadow agents

The dangerous half of sprawl is the agents nobody procured: automations and bots acting on company data with no licence line and no owner of record. In our experience six surfaces hide almost all of them, and each has a specific place to look.

Automation platforms deserve the closest look because they industrialize agency: Zapier now ships agents outright alongside classic zaps, Make chains AI steps into multi-app scenarios, and n8n makes self-hosted workflows easy enough that they never touch procurement at all — a single enthusiastic builder can stand up dozens. The two fastest wins in this step are the Slack installed-apps review, because every bot with a channel-history scope is effectively an agent with a memory, and the OAuth grant review in Google Workspace or Microsoft Entra, which surfaces every third-party AI tool an employee has ever connected to a company account. Expect surprises; that is the point of the exercise.

Complement the console sweeps with a declared-agents amnesty: one announced week during which anyone can register an automation, GPT or extension they built, no questions asked. It works because most shadow AI is not malicious — it is enthusiastic — and its builders are usually proud to show their work once it is clear the goal is a register, not a purge. In our experience the amnesty surfaces exactly the automations no console will ever show you: the personal-account zap wired to a work spreadsheet, the local script running on someone's laptop, the browser extension half the sales team quietly adopted. Pair the carrot with clarity going forward: new agents get registered at birth, and registered agents get support — proper credentials, a budget line, a place on the map — that unregistered ones do not.

Step 3: Map every agent to an owner, its tools and its data scopes

A row without a named human owner is a liability, so this step turns the list into a register: every agent gets an owner, a purpose, and an explicit statement of what it can call and what it can read or write. These are the columns we use for every row:

• Name and vendor/model — what it is and what it runs on.
• Owner — one human, by name, who answers for it.
• Purpose — one sentence; if it takes three, that is a finding.
• Tools it can call — Slack, GitHub, CRM, email, file storage.
• Data scopes — what it reads and, separately, what it can write.
• Memory location — where what it has learned actually lives.
• Monthly cost — seat price or metered spend; Step 4 fills this in.
• Next review date — the column that keeps the register alive.

Ownership is the single highest-leverage control in the whole audit: orphaned agents get thirty days to find a claimant or they are retired. Write scopes deserve a second pass of their own — an agent that can read your CRM is a privacy question, while an agent that can write to it is an operational one. The finished register is what we call an AI agent registry, and it is deliberately shaped like an org chart: agents are the new joiners, and this is their HR file.

Once the columns are filled, tier the rows by blast radius rather than by cost. Tier one is anything that writes to external-facing systems — email, customer messages, your CRM, production code. Tier two reads sensitive data but writes nothing. Tier three is everything else. The tiers set the review depth you will apply in Step 7: tier one earns a real quarterly review with its owner in the room, tier three a yearly attestation. This is also the moment to reconcile the register against your identity provider one final time — every service account and OAuth grant should now map to a row, and anything that does not is either a fresh discovery or a candidate for revocation.

Step 4: Meter what each agent actually costs

Agent cost comes in two shapes — seats and tokens — and the audit has to capture both, because they hide in different places. Seat costs are the easy half: per-seat licences for ChatGPT, Microsoft 365 Copilot, GitHub Copilot, Claude and Cursor come straight off the invoices you collected in Step 1. Token-metered spend is the slippery half: a dozen homegrown agents can share one OpenAI or Anthropic invoice, which makes every individual agent look free and the total look mysterious. The fix is per-agent API keys, so that provider dashboards — and observability layers such as Helicone or Langfuse, if you run them — can attribute usage to individual rows. We've written up how we run per-agent cost tracking and compared the wider market in our guide to the best LLM cost tracking tools. The deliverable for this step is simple: a monthly cost figure on every row, and a budget owner for every cost figure.

Step 5: Consolidate the memory

Agent sprawl is also memory sprawl: every agent has been quietly accumulating knowledge about your company in its own silo, and the audit must record where each of those memories lives and who can read it. ChatGPT keeps its memory in OpenAI's cloud, Claude keeps projects and memory in Anthropic's, Cursor keeps rules files per repository, and every custom bot has a vector store or a prompt file somewhere. Scattered memory is a governance problem twice over: it is company knowledge you cannot audit, and it is duplicated, contradictory context your agents cannot share. We've compared how ChatGPT and Claude handle memory for teams, and the ownership question — who owns your AI memory when it lives in a vendor's cloud — is worth sitting with before you renew anything. The practical consolidation mechanism is the Model Context Protocol: give the fleet one governed, MCP-accessible shared memory, then treat per-app memories as caches rather than systems of record. The audit's job is the map; consolidation is the follow-through.

Step 6: Keep, merge or retire

Every row now gets one of three verdicts, and this is where the register earns its keep for the first time. Keep the agents with an owner, a purpose and a defensible scope — most of your official seats land here. Merge the duplicates: when three teams have each built a meeting-notes agent, consolidate on one with a shared memory, and keep the best prompt. Retire the rest — the zap whose author left last spring, the extension with inbox access nobody recognizes, the experiment that never officially ended — and revoke their credentials the same day, because a retired agent with live credentials is not retired. Our rule of thumb is blunt: if nobody claims an agent within thirty days, it is not infrastructure, it is debt.

Step 7: Set the review cadence

An audit that runs once is a snapshot, and sprawl regrows in about a quarter — so the final step is making the register a process rather than a project. Three habits do it: a quarterly review in which every owner re-attests that their agent still exists, still needs its scopes and still earns its cost; an intake step so new agents enter the register at creation (a two-minute form, deliberately easier to fill in than to skip); and alerts wired to the cost meter, so a new spend line or an unfamiliar API key triggers a new row instead of a surprise. Teams that skip this step run the whole audit again from scratch a year later; teams that keep it spend an hour a quarter.

The cadence also needs a forcing function for departures, because offboarding checklists cover laptops and licences but rarely agents: when a builder leaves, their zaps keep running and their API keys keep billing. Add one line to the leaver process — reassign or retire every register row they own — and the most common source of orphaned agents disappears. The same applies to reorganizations: when a team dissolves, its agents should not become ghosts.

What the audit usually finds

Every audit we have seen or run converges on the same handful of findings, so it is worth knowing them in advance. Expect duplicate agents doing the same job in different teams, because nobody could see across the org to reuse what already existed. Expect at least one automation with write access that its own team forgot, still firing on schedule. Expect the seat lists and the identity provider to disagree, with personal accounts filling the gap. Expect memory scattered across more silos than you have official tools, and expect metered API spend to become attributable to specific agents only after you re-key them. None of these findings is a scandal; all of them are invisible until someone builds the register. The useful mindset is an archaeologist's, not a policeman's — you are documenting a city that grew without a plan, so that it can grow with one from here.

From audit spreadsheet to a living AI Organization Map

The endgame of the audit is a register that maintains itself — a live map instead of a decaying spreadsheet. That is precisely what the Teams plan of Fleece AI Brain is built for: an AI Organization Map that draws agents, tools and people on one canvas, AI Cost Tracking that attaches budgets and per-agent costs to the same entities, and a shared company brain with SSO, admin controls and an audit log. Steps 3, 4 and 5 of this audit — the register, the meter and the memory — become one living product instead of three artifacts, and we've written up how the map works day to day in our AI Organization Map deep dive.

The design is deliberately local-first. Fleece AI Brain is a desktop app for macOS and Windows, and every note, fact and agent memory is a plain Markdown file on your own disk — the software is a map and a meter over those files, not a cloud that owns them. Twenty connectors — Slack, GitHub, Gmail, Google Drive, Notion, Jira, Confluence, Salesforce, HubSpot, Zendesk and more — sync sources directly to your machine, and documents never rest on Fleece's servers. Your AI apps connect over MCP with one copy-paste config — Claude Desktop, Cursor, Fleece AI App, Fleece AI Teams and custom agents — and get tools like brain_remember, brain_recall, brain_traverse and brain_diff, so the whole fleet reads and writes the one memory you consolidated in Step 5. Teams is €49 per user per month; Solo (€12/month) and Pro (€24/month) cover individuals, and yearly billing saves two months on both. There is a 14-day trial, no card required — see pricing or download the app, and for a larger rollout our Enterprise Brain overview walks through the full picture.

When a spreadsheet is enough

Honestly: if you run fewer than about ten agents and one person can name them all, a well-kept spreadsheet plus a quarterly calendar reminder is real governance, and we would rather you do that than buy software you will not open. Likewise, if your fleet is entirely homegrown and your pressing problem is debugging what your agents do, an observability platform — Langfuse, LangSmith, Helicone — is the better first purchase. The moment to graduate to a living map is when the sheet develops three owners, two clouds and a stale tab — roughly, the moment it starts lying to you.

The bottom line

AI agent sprawl is inevitable; blindness to it is optional. Seven steps — inventory the seats, hunt the shadows, assign owners and scopes, meter the cost, consolidate the memory, prune the fleet, and put reviews on the calendar — turn an unknowable estate into a register you can defend to a board, an auditor or a customer. Keep the register alive and it compounds; let it rot and you will be back here next year. And when you are ready for the register to maintain itself, Fleece AI Brain Teams turns it into an AI Organization Map with per-agent costs and one governed, local-first memory — the audit, made permanent.