Progressive Discovery
Context ManagementDefinition
An agent-environment interface design where a lean surface is exposed up front and the agent fetches additional detail on demand, rather than front-loading every tool, schema, and document into context (monolithic context). Progressive discovery is the scalable pattern for large integrations; monolithic context is acceptable only when the full set is small and stable.
Why It Matters for the Claude Certification Exams
CCAR-P integration and CCDV-F tools/MCP items reward a lean first surface. The trap is loading every MCP tool and schema into the opening context "so the agent has everything."
In Depth
Progressive discovery is an agent-environment interface pattern: expose a lean surface up front and let the agent fetch more detail on demand. Instead of injecting every tool schema, every resource template, and every policy document into the first turn, you give Claude a small catalog (names, one-line descriptions, a describe or read tool) and let it pull the full schema only for the tools it actually needs.
Why the first-turn dump fails
A fat first context has three costs the exams care about:
- Tokens. Tool JSON is expensive. Twenty MCP servers with verbose schemas crowd out the user's request and the working memory of the task.
- Selection quality. A model that sees forty near-duplicate tools is more likely to pick the wrong one. Capability bloat and progressive discovery are paired ideas: fewer, clearer tools at the point of decision.
- Staleness. A schema baked into the system prompt drifts from the live server. Fetching the schema at call time keeps the agent aligned with the current interface.
How it shows up with Claude and MCP
MCP's tools primitive can list tools cheaply and return full input schemas when asked. A well-designed MCP server and a well-designed agent loop use that: list → select → get schema → call. The same idea applies to Skills and to internal docs: a search_docs tool that returns a path plus a short blurb beats pasting the wiki into CLAUDE.md.
The contrast is front-loading: stuffing the full OpenAPI spec into the system prompt "just in case." That can be right for a tiny, stable API. It is wrong for a platform with dozens of endpoints or for an agent that only needs one of them per session.
Progressive discovery is not the same as hiding capabilities from the user. It is about when the bytes enter context, not whether the agent is allowed to use them. Pair with Capability bloat and MCP tools primitive.
Frequently Asked Questions
Is progressive discovery the same as giving the agent fewer permissions?
No. Permissions (allow/deny) are a security control. Progressive discovery is a context-design control: the agent may still be allowed to call a tool, but it loads the schema only when that tool is a candidate.
When should I still front-load a full schema?
When the surface is small, stable, and used on almost every turn — a single structured-output tool, for example. Front-load the one interface the loop always needs; discover the long tail.