Wire up five MCP servers and you're already carrying forty tool definitions the agent may never touch. Every one of those schemas sits in the context window on every turn, spending tokens and diluting the model's attention. Progressive tool disclosure is the 2026 answer: discover, load, and unload tool schemas on demand instead of front-loading all of them. Here's the problem it solves and how to think about it.
The tool-bloat problem
MCP made adding capabilities cheap — almost too cheap. Each server contributes several tools, each tool ships a JSON schema with descriptions and parameter definitions, and hosts have caps for a reason. Cursor stops loading tools past roughly forty. Beyond the hard cap there's a soft cost: a context window stuffed with schemas the agent won't use raises latency, raises spend, and measurably hurts tool-selection accuracy because the model has more near-duplicate options to sift. The failure mode is quiet — the agent still works, just slower, pricier, and more prone to picking the wrong tool.
What progressive disclosure changes
The pattern, now shipping in frameworks like agent-framework-core, flips the default from eager to lazy. Rather than injecting every server's full schema up front, the agent gets a lightweight index and pulls a tool's full definition in only when a task calls for it — then unloads it when the task moves on. Crucially, this happens while keeping the allowed_tools boundary intact: lazy loading is a context optimization, not a security hole, so a tool the policy forbids never becomes reachable just because it was loaded late. The agent's menu stays the same size; what changes is how much of it is in context at any moment.
When it matters most
The technique earns its keep exactly where MCP deployments grow painful. Multi-agent systems where a supervisor coordinates specialists, each owning several servers. Long-running sessions where the toolset needed at step one differs from step fifty. Enterprise setups behind a gateway aggregating many servers into one endpoint. In all three, the number of nominally available tools dwarfs the number used in any single turn — the exact gap progressive disclosure closes. It pairs naturally with the Tasks extension for long work and with call caching for repeated lookups.
How it relates to cost control
Tool schemas are input tokens, and input tokens are the bulk of most agent bills. Trimming what's resident is one of the cleaner levers you have — it cuts spend without cutting capability, unlike dropping servers outright. Treat it as part of the same discipline as agent token budget control and reducing agent API costs: measure how many tools are actually invoked per session, and let the framework load the rest on demand.
Where to go next
Progressive disclosure is native in Microsoft Agent Framework and increasingly common elsewhere. If tool count is your real problem, also prune with a curated stack: pick four to six servers that earn their slot from best MCP servers for Cursor or a ready-made loadout, rather than installing everything and hoping the window holds.