In this article11 +
- What agent sprawl actually is
- Agent sprawl by the numbers
- Nobody needs your agent: reading the adoption math
- We have been here before: spreadsheets, Access databases and shadow IT
- The dependency line: when a personal tool becomes infrastructure
- When two agents give two different answers
- What Microsoft shipped at Ignite 2026
- Five questions to ask before an agent becomes a dependency
- A minimum viable agent register for a small business
- Walkthrough: one refund request, from side project to infrastructure
- The real adoption question
*Last updated: November 19, 2026*
Building an AI agent is no longer the hard part. A sales rep can put one together over lunch. So can a support lead, or an analyst who is tired of copying numbers between tabs. Many of these agents work well enough that colleagues ask for a copy. This week at Microsoft Ignite (November 17 to 19, 2026), one of the biggest software companies in the world spent stage time on a less exciting job: finding agents that nobody owns any more, spotting agents that duplicate each other, and switching off the ones nobody needs.
That is the new shape of AI adoption. The question has moved past whether people can build agents or whether the agents work. They can, and many do. The harder questions are these. Which agents does the business actually depend on? Who answers for them? What happens on the day one stops?
Our argument fits in two sentences. Most agents don't need heavy governance, because almost nobody needs them. The few that matter need it badly, and the real skill is noticing the moment an agent crosses from the first group into the second.
This article explains what agent sprawl is and gives the numbers behind it. It covers the earlier time businesses went through the same thing (with spreadsheets), a simple "dependency line" for deciding when an agent needs real oversight, what Microsoft shipped this week, and a lightweight agent register a small business can start using tomorrow.
What agent sprawl actually is
Agent sprawl is the uncontrolled growth of AI agents inside an organization. Agents get built faster than anyone can track who owns them, what they can access, whether they overlap and whether anyone still uses them.
It is related to shadow AI, but it is not the same thing. Shadow AI means people using tools IT never approved, like a personal chatbot account used for work. Agent sprawl often happens entirely inside approved platforms. A company buys an enterprise AI plan with an agent builder, encourages everyone to experiment, and a year later has thousands of agents. Each one was allowed. Taken together, nobody is in charge of them.
Three things make agents riskier to sprawl than the chat prompts that came before them:
- They hold permissions. An agent connected to a CRM, a mailbox or a payment system can act with whatever access its creator gave it, and that access usually stays in place after people stop using the agent.
- They run without being watched. Many agents run on a schedule or a trigger, so they keep working whether or not anyone is looking at the output.
- They can be copied in minutes. A useful agent gets duplicated, tweaked and passed around. You end up with five slightly different versions of the same tool, each giving slightly different answers.
Agent sprawl by the numbers

The scale of agent creation in large companies is no longer hypothetical. These are the figures that leaders and analysts have put on the record:
- FICO: Mike Trkay told The Wall Street Journal in May 2026 that the company's roughly 3,500 employees were creating dozens of new agents every day, at every level of the organization.
- DaVita: the kidney-care provider's CIO, Madhu Narasimhan, told the same paper that employees had created more than 10,000 agents, adding that because the company cares for patients, it has to "scale with safety."
- Magnum Ice Cream: Michael Friedlander, CIO for the Americas, predicted that because everybody can build agents, many people will end up with the same kinds of agents. He expects to condense and centralize them, citing security risk and token costs.
- BBVA: the Spanish bank reported that employees had built more than 20,000 custom GPTs on its ChatGPT Enterprise rollout. About 4,000 of them were used frequently, and around 700 were published to an internal store open to all staff.
- Gartner (April 2026): the average global Fortune 500 company will have more than 150,000 agents in use by 2028, up from fewer than 15 in 2025. Only 13% of IT application leaders surveyed strongly agreed they had the right governance in place to manage agents.
- Gartner (June 2025): more than 40% of agentic AI projects will be canceled by the end of 2027, because of rising costs, unclear business value or weak risk controls.
- MIT NANDA (2025): the "GenAI Divide" study found that about 95% of organizations saw no measurable return from their generative AI pilots. It also found that workers at more than 90% of the companies studied used personal AI tools for work, while only about 40% of companies had bought an official subscription.
Put these side by side and a picture forms. Agent creation is exploding. Governance is lagging far behind. Measurable value is hard to find.
Nobody needs your agent: reading the adoption math
The BBVA numbers are the most revealing, because they come from a company that did adoption well. Its rollout is widely cited as a success, and the bank reports high daily engagement. Even so, only about one agent in five saw frequent use.
Read honestly, that means most agents nobody needs. They were built for one person's one problem, tried a few times, and quietly abandoned. This is not a scandal. It is what experimentation looks like. When building something costs an afternoon, you should expect most attempts to go nowhere, the same way most spreadsheets, documents and internal wiki pages go nowhere. The 20% that stick were found because the other 80% were allowed to exist.
So we would argue that counting agents is the wrong metric. A company with 10,000 agents is not necessarily in more trouble than one with 500. Two other numbers matter more:
- Dependencies: how many agents have quietly become something a team, a process or a customer relies on, without anyone deciding that they should?
- Standing permissions: how many agents, used or not, still hold live access to systems, data or money?
An abandoned agent with read-only access to a shared drive is clutter. An abandoned agent that still holds a token able to send email as the CFO is a risk. A popular agent that the finance team now trusts for month-end numbers is infrastructure, whether anyone has admitted it or not. Good governance treats these three cases very differently.
We have been here before: spreadsheets, Access databases and shadow IT

Agent sprawl looks new, but the pattern is decades old. In the 1990s and 2000s, business teams who were tired of waiting in IT's queue built their own tools: spreadsheets with macros, Access databases, Lotus Notes apps, scripts on someone's desktop. The industry called it end-user computing, and it delivered real value for the same reason agents do. The people closest to the problem could solve it themselves.
Most of those tools were harmless. A few became load-bearing without anyone noticing, and the most famous example is expensive. In 2012, JPMorgan Chase's chief investment office lost about $6.2 billion on the "London Whale" trades. The bank's own task force later found that a new risk model behind those trades ran on a series of Excel spreadsheets filled in by hand, with data copied and pasted from one sheet to another. One formula divided by a sum where the modeler meant to divide by an average. That muted the measured volatility and made the position look less risky than it was. The spreadsheet itself was not the villain. The failure was that something critical was running on a tool nobody had registered as critical.
Banks and regulators responded with end-user computing policies: inventories of spreadsheets and models, criticality tiers, named owners, change control for the important few, and a light touch for everything else. Put that list next to Gartner's 2026 advice on agent sprawl, which is to set policies, build a central agent inventory, manage identity, permissions and lifecycle, govern the data agents can reach, monitor behavior and encourage responsible use. It is nearly the same playbook.
The difference is speed. A spreadsheet waited for a human to open it. An agent acts on its own, runs on a schedule, holds credentials and can be cloned across a department in an afternoon. The journey from "my handy tool" to "the thing month-end depends on" that once took years can now take weeks.
The dependency line: when a personal tool becomes infrastructure

If most agents don't need governance and a few need a lot of it, the practical question is how to tell them apart. We find it useful to think of three stages, separated by one important line.
Stage 1: personal. One person built it, one person uses it, and that person checks every output before it goes anywhere. Governance here should be almost invisible: approved platforms, approved connectors, and basic data rules about what can and cannot be pasted in. Anything heavier simply kills experimentation.
Stage 2: shared. Other people use it, but a human still reviews each output before acting on it. The agent now needs a named owner and a line in the register, so someone knows it exists and who to ask.
Stage 3: depended on. This is the far side of the dependency line. Work, decisions or customers now rely on the agent's output without anyone checking it each time. In practice, an agent is on this side if any of these is true:
- people notice, and complain, when it stops working
- its output is pasted straight into reports, emails or decisions without review
- it runs on a schedule or a trigger rather than when someone asks
- it writes to a system of record (CRM, ERP, accounting, billing) rather than only reading
- it talks to customers, suppliers or anyone outside the company
- another agent or automation consumes its output
Once an agent crosses this line, it deserves the same care as any other production software. That means an owner and a backup, the smallest set of permissions that works, monitoring, a measured baseline, and an off switch that someone has actually tested.
The danger is that nobody announces the crossing. No one files a ticket saying "this agent is now critical." It just happens: a colleague starts relying on it, then a team, then a process. The point of the dependency line is to give people a shared vocabulary for noticing, so that "I think the invoice agent is now stage 3" becomes a normal thing to say in a team meeting.
When two agents give two different answers

One of the clearest signs of sprawl is two agents that both work correctly and still disagree.
Picture a growing software company. The support team builds an agent that counts "active customers" as anyone who opened a ticket or logged in during the last 90 days. The finance team builds one that counts anyone billed in the last month. Both agents are accurate against their own definitions. Then the CEO asks each team for the active-customer number before a board meeting, gets two different answers, and loses half a day finding out why.
A better model will not fix this, because the disagreement is not a model error. It is an organizational one: the business never decided on one definition. Agents just make the gap visible faster and more often, because they answer questions on demand that used to take a week of reconciliation.
The fix is old-fashioned data discipline. Keep one agreed definition for each business number in one place, whether that is a metrics layer in your data warehouse, a shared API, or at minimum a written glossary every agent's instructions point to. The rule we would give any team is simple: an agent that reports a business number should fetch it, not compute its own version of it. Agents that read from a shared source agree with each other automatically. Agents that each calculate their own version drift apart.
What Microsoft shipped at Ignite 2026

The vendor response to sprawl is now concrete. Microsoft introduced Agent 365 at Ignite 2025 as a control plane for a company's "agent estate." At Ignite 2026 it extended the product in ways that map almost one-to-one onto the problems above:
- Ownerless and inactive agents: a new action center will first surface inactive agents and ownerless agents for review and cleanup. Microsoft expects it to enter private preview in December.
- Duplicates: Agent Map adds business use-case and task classification (in preview) to identify agents doing similar work, so companies can decide which to keep and which to consolidate.
- Invisible local agents: Entra Agent ID (in preview) will automatically assign an identity to discovered local agents, starting with Claude Code and GitHub Copilot CLI. Intune can flag devices running unapproved agents as noncompliant and block them from company data.
- Risk: Dynamic Agent Risk (in preview) combines runtime signals, security posture and "blast radius" into one low, medium or high risk level per agent.
- Cost: Agent 365 cost management (in preview) shows what is driving AI spend and lets admins set spending policies, limits and alerts.
The other big platforms are heading the same way: most vendors selling an agent builder now also offer, or promise, some form of agent inventory.
Two cautions are worth keeping in mind. First, Gartner's Max Goss has warned against simply blocking or restricting agent tools, because employees will work around the restrictions and create more risk, not less. MIT's finding that workers at more than 90% of companies already use personal AI tools shows how easily they route around a locked-down official option. Second, a registry tells you which agents exist. It cannot tell you which ones matter. Whether an agent is a personal toy, a shared helper or something month-end depends on is a business judgment, and no dashboard makes it for you.
Five questions to ask before an agent becomes a dependency

Whether you run Agent 365 or a shared spreadsheet, these five questions sort the agents that need attention from the ones that don't. Ask them whenever an agent looks like it is crossing the dependency line, and again at a regular review.
1. If it stopped tomorrow, who would notice first, and how fast? This is the off-switch test, and it is the quickest way to measure dependency. If the honest answer is "probably nobody," the agent is a candidate for retirement. If the answer is "a customer, within the hour," it is critical, whatever its origin.
2. Who owns it, and who covers when they leave? Every stage 2 or 3 agent needs a named owner and a backup. The most common way agents go ownerless is completely ordinary: someone changes teams or leaves the company, and the agent keeps running on their credentials.
3. What can it read, write, send or spend? This is the blast radius. Read-only access to internal documents is low risk. Writing to a system of record is higher. Sending messages outside the company or moving money is the highest. Give each agent the smallest set of permissions that works, and remove access it no longer uses.
4. Does it produce a number someone else relies on, and from which definition? If yes, it should fetch that number from the agreed source (see above), and the owner of that definition should know the agent exists.
5. Is it better than what we would do without it? Measure it against the alternative, not against zero. Look at time per task, error or rework rate, and the full cost per task, including tokens and the human time spent checking its output. An agent that saves ten minutes but needs eight minutes of review is barely worth keeping. Value is also where most of the "no measurable return" findings come from: few teams ever wrote down the baseline.
A minimum viable agent register for a small business

You don't need an enterprise control plane to manage agent sprawl in a 20- or 200-person company. Small businesses sprawl too, just in different places: automation flows in Zapier, Make or n8n, custom GPTs and Claude projects, Copilot agents, and the occasional script on someone's laptop with an API key pasted into it.
A shared spreadsheet is enough to start. Give it one row per agent or automation, with these columns:
- Name and one-sentence job: what it does, in plain words.
- Owner and backup: two named people, not a team.
- Stage: personal, shared or depended on.
- Systems and permissions: what it connects to, and whether it reads, writes, sends or spends.
- Credentials: whose account or key it runs on, and where that key is stored.
- Trigger: on demand, scheduled, or event-driven.
- Fallback: what people do if it is switched off.
- Last reviewed: the date someone last answered the five questions for it.
Then hold a 30-minute review once a month. Retire anything nobody has used in 60 days. Revoke credentials that no running agent needs. Move agents that have crossed the dependency line up to stage 3 and give them the full treatment. That is most of what an enterprise registry does, at a fraction of the effort, and it creates the habit that matters most: knowing what you have.
Walkthrough: one refund request, from side project to infrastructure
Here is how the dependency line plays out in a single, ordinary example.
A 30-person online store has a support rep who is tired of writing the same refund replies. She builds an agent that reads a customer's email and order history and drafts a reply. She reviews every draft. That is stage 1, and it needs nothing more than an approved tool.
A month later, the whole support team uses it, and each rep still reviews the drafts before sending them. That is stage 2. The agent gets a line in the register with her as owner and the support lead as backup.
Then someone connects it to the store's admin so it can issue refunds under $50 by itself, "to save a click." Nobody calls a meeting. But the agent has just crossed the dependency line: it moves money, it acts without review, and customers experience its decisions directly. This is the moment that matters, and in most companies it passes without anyone noticing.
Run the five questions on it:
- Off switch: customers waiting on refunds would notice within hours. It is critical.
- Ownership: the rep who built it is about to go on parental leave. The support lead needs to take real ownership now, not after something breaks.
- Blast radius: it can move money out of the business. Its API key should be limited to refunds only, with a per-refund cap and a daily total cap, and every action should be logged.
- Numbers: the weekly report includes a "refund rate." Does the agent's count match the definition finance uses? Someone needs to check.
- Value: compare handling time, refund errors and chargebacks against the month before. If the numbers hold up, keep it. If not, drop back to drafts with human approval.
The outcome is not "ban the agent." It's a useful agent the business has deliberately chosen to depend on, with the limits, owner and fallback that a dependency deserves.
The real adoption question
The adoption debate has been framed as "how do we get more people using AI?" Inside most companies, that problem is solving itself. Employees are building agents faster than anyone can count them.
The better question is the one this article keeps returning to: if one of our agents stopped tomorrow, who would notice first? A company that can answer that for every agent it depends on has turned experimentation into infrastructure on purpose. One that can't is accumulating dependencies it has never seen, on credentials it has never reviewed, in definitions it never agreed on.
That is less exciting than another agent demo. It is also where the return on all those agents finally shows up.
“Counting agents is the wrong metric. Count the ones your business depends on, and the permissions the rest still hold.”
Agent sprawl is not a sign that AI adoption has failed. It is a sign that it worked: people closest to the work can now build their own tools, and most of what they build will be tried, outgrown and forgotten. That part needs a light touch. The part that needs real attention is the small set of agents that quietly become something a team, a process or a customer depends on.
Draw the dependency line, keep a simple register, and ask the off-switch question about anything on the far side of it. That turns thousands of experiments into a handful of deliberate, owned and measurable pieces of infrastructure, which is where the return on AI finally becomes visible.
Turning an experimental agent into something your business can rely on? Talk to our team about designing the permissions, ownership, monitoring and fallback before it becomes critical. See also our AI agent development services and our breakdown of what an AI agent costs to build.
FAQ
Frequently asked questions
What is agent sprawl?
Agent sprawl is the uncontrolled growth of AI agents inside an organization, where agents are created faster than anyone can track who owns them, what systems and data they can access, whether they duplicate each other and whether anyone still uses them. It is growing fast: Gartner expects the average Fortune 500 company to have more than 150,000 agents in use by 2028, while only 13% of IT application leaders strongly agree they have the right governance in place.
How is agent sprawl different from shadow AI?
Shadow AI means employees using AI tools that IT never approved, such as personal chatbot accounts used for work. Agent sprawl often happens entirely inside approved platforms: a company rolls out an enterprise agent builder, everyone experiments, and soon there are thousands of overlapping agents, many with no clear owner and permissions that outlive their use. Both problems call for visibility, but sprawl is mostly about ownership, duplication and standing access rather than unapproved tools.
How do you govern AI agents without slowing down experimentation?
Match governance to dependency rather than applying it to every agent. Personal agents whose output the creator checks need only approved tools and basic data rules. Shared agents need a named owner and a register entry. Agents that work, decisions or customers rely on without review, or that write to systems of record, contact outsiders or move money, need production-grade care: an owner and backup, least-privilege permissions, monitoring, a measured baseline and a tested off switch.
What tools can help manage agent sprawl?
Large organizations are adopting agent control planes such as Microsoft Agent 365, which at Ignite 2026 added an action center for inactive and ownerless agents, task classification to find duplicate agents, automatic identities for local agents and per-agent risk levels. Smaller businesses can start with a shared spreadsheet register listing each agent's job, owner and backup, stage, permissions, credentials, trigger, fallback and last review date, reviewed monthly.
