What is AI sprawl? Three kinds, three different risks
AI sprawl is the growth of models, MCP servers, and agents that nobody has inventoried, owns, or controls. In a recent Kong poll, MCP sprawl ranked first, model sprawl second, and agent sprawl a close third. Each one fails in its own way.
Model sprawl
Having many models isn't the problem. The trouble starts when teams or agents call models directly, with no governance, visibility, or access-control layer in between. You can spot it with one question: how much are you spending on models? A common answer is: "we have no idea what models are being used. We find out about a new one every other day."
MCP sprawl
MCP servers spread fastest on laptops. "MCP is just proliferated everywhere, especially on things like local machines." Many of them sit on top of APIs or data stores, so an unmanaged server is an unmanaged door into your data and you open yourself up to massive security compliance risk.
There's a cost problem too. "MCP on its own is not very token efficient." Servers built inconsistently can flood a model with "too much context or outdated context," which burns tokens, slows responses, and hurts answer quality. Kong's engineering team shows gateway-level patterns for this in [MCP tool governance: security meets context efficiency](https://konghq.com/blog/engineering/mcp-tool-governance-security-meets-context-efficiency)MCP tool governance: security meets context efficiency.
Agent sprawl
Teams spin up agents for their own tasks, and nobody can count them. Duplicates follow, because nobody can see what already exists: "if there's an agent that already exists, but folks don't know that it exists, well, they're just gonna go build their own."
This is the API sprawl story again. Teams that couldn't find an existing API built a new one, and some ended up behind a gateway while others didn't. Kong's [MCP registry explainer](https://konghq.com/blog/learning-center/what-is-an-mcp-registry)MCP registry explainer draws the same line: it's the sprawl microservices had before API gateways, except now the consumers are autonomous agents.
How to fix AI sprawl: discover, consolidate, standardize, curate
The four steps build on each other. Each one produces the input the next one needs, so run them in order.
Step 1: Discover what's running
There are two ways to find AI assets. The first is shadow AI detection, which means watching network traffic or running an agent on machines to spot MCP servers and models in use. "There is a place for that, and we believe organizations should do that... But it's not the only long time durable solution."
The durable fix is to make assets visible by design: "put these things behind gateways, see and watch the traffic, and then start to build an inventory."
Step 2: Consolidate the duplicates
Once the inventory exists, the waste shows up. You may find duplicate MCP servers, or one that "hasn't been built to deliver context in the most token efficient manner." The fix is to generate a better one, or reuse a token-efficient server that already exists, and then register it as "the approved MCP server for x, y, and z at the org."
Sprawl shrinks because there's less to sprawl, and the approved option becomes the easy one to find.
Step 3: Standardize how new assets get built
This is where MCP servers go wrong most often. As per Drag's rule: don't throw "every single API endpoint for every API as a tool at an MCP server." It's "very token inefficient," and it makes the model parse every endpoint when the agent needs one or two. He named four techniques:
- Progressive tool disclosure. Kong's code mode exposes only the tools that match the intent of the prompt.
- Multi-API server generation. One MCP server exposes selected endpoints across several APIs.
- Composite MCP servers. One interface sits on top of several MCP servers. For example, there can be a single software-development-lifecycle server in front of servers like GitHub, so those agents hit one endpoint.
- Tool filtering and access control. Each agent or user sees only the tools they're cleared to use.
A good generation method isn't enough on its own. When someone creates an API and wants an MCP server for it, policy should force the approved generation path. Kong's [MCP Traffic Gateway](https://konghq.com/solutions/mcp-governance)MCP Traffic Gateway covers the traffic side of this.
Step 4: Curate access
Now you hold what Drag calls the "gold standard governed inventory of consistent standardized MCP servers." The last step is opening it to the wider agent estate, with something like a developer portal.
- Publish approved models, MCP servers, and agents in one place people and agents can browse.
- Set who can read each registry. Sales agents, for example, probably shouldn't discover the servers your engineering team uses.
- Put the registry behind your gateway and enforce authentication and authorization on every call.
Where a gateway fits: one control point for everything agents call
A way to picture the problem starts with what an agent has to reach to get a job done. Let’s split it into two estates:
- The intelligence estate is the reasoning layer: models, plus other agents.
- The context estate is the data and tools that feed that reasoning: MCP servers, the API estate behind most of them, and your events and data.