Narrative Goldmine

Progressive Disclosure Harnesses

25 min read

Properties

Type
  • Class
Resource
  • urn:ngm:class:progressive-disclosure-harnesses
Domain
  • ai
Status
  • stable
Maturity
  • emerging
Is a
Has part
Requires
Enables
Generated
  • by: process:vault-migrate/1.0 · at: 2026-09-22T12:41:39.024503178Z
Contrasts with
Depends on
Implemented in layer
Implements
Links
Page resource
  • urn:visionflow:page:progressive-disclosure-harnesses
Related to
Standardized by
Supports
Uses

Formats, runtimes, and patterns that reveal context, tools, or instructions to agents in layers — index first, details on demand — to control token usage and improve agent focus — includes MCP-Zero, ToolGen, ToolRAG, langgraph-bigtool, agents.md, and awesome-cursorrules.

Semantic Classification

Content

Compositional Relationships (Components)

SubClassOf(ai:ProgressiveDisclosureHarnesses
  ObjectSomeValuesFrom(ai:hasPart ai:ToolIndex))
SubClassOf(ai:ProgressiveDisclosureHarnesses
  ObjectSomeValuesFrom(ai:hasPart ai:SchemaLoader))
SubClassOf(ai:ProgressiveDisclosureHarnesses
  ObjectSomeValuesFrom(ai:hasPart ai:SemanticRouter))
SubClassOf(ai:ProgressiveDisclosureHarnesses
  ObjectSomeValuesFrom(ai:hasPart ai:CapabilityCategories))
SubClassOf(ai:ProgressiveDisclosureHarnesses
  ObjectSomeValuesFrom(ai:hasPart ai:EmbeddingIndex))
SubClassOf(ai:ProgressiveDisclosureHarnesses
  ObjectSomeValuesFrom(ai:hasPart ai:DemandLoader))
SubClassOf(ai:ProgressiveDisclosureHarnesses
  ObjectSomeValuesFrom(ai:hasPart ai:InstructionLayerSpec))
SubClassOf(ai:ProgressiveDisclosureHarnesses
  ObjectSomeValuesFrom(ai:hasPart ai:FallbackFullLoader))

Dependency Relationships

SubClassOf(ai:ProgressiveDisclosureHarnesses
  ObjectSomeValuesFrom(ai:requires ai:ModelContextProtocol))
SubClassOf(ai:ProgressiveDisclosureHarnesses
  ObjectSomeValuesFrom(ai:requires ai:Embeddings))
SubClassOf(ai:ProgressiveDisclosureHarnesses
  ObjectSomeValuesFrom(ai:requires ai:LargeLanguageModels))
SubClassOf(ai:ProgressiveDisclosureHarnesses
  ObjectSomeValuesFrom(ai:requires ai:ContextWindow))
SubClassOf(ai:ProgressiveDisclosureHarnesses
  ObjectSomeValuesFrom(ai:requires ai:FunctionCalling))
SubClassOf(ai:ProgressiveDisclosureHarnesses
  ObjectSomeValuesFrom(ai:dependsOn ai:AgentLoop))
SubClassOf(ai:ProgressiveDisclosureHarnesses
  ObjectSomeValuesFrom(ai:dependsOn ai:VectorDatabase))
SubClassOf(ai:ProgressiveDisclosureHarnesses
  ObjectSomeValuesFrom(ai:dependsOn ai:FoundationModel))

Capability Relationships

SubClassOf(ai:ProgressiveDisclosureHarnesses
  ObjectSomeValuesFrom(ai:enables ai:AgenticWorkflow))
SubClassOf(ai:ProgressiveDisclosureHarnesses
  ObjectSomeValuesFrom(ai:enables ai:TaskAutomation))
SubClassOf(ai:ProgressiveDisclosureHarnesses
  ObjectSomeValuesFrom(ai:enables ai:MultiAgentSystem))
SubClassOf(ai:ProgressiveDisclosureHarnesses
  ObjectSomeValuesFrom(ai:enables ai:PlanningAndScheduling))
SubClassOf(ai:ProgressiveDisclosureHarnesses
  ObjectSomeValuesFrom(ai:enables ai:ToolUse))
SubClassOf(ai:ProgressiveDisclosureHarnesses
  ObjectSomeValuesFrom(ai:supports ai:TerminalCodingAgents))
SubClassOf(ai:ProgressiveDisclosureHarnesses
  ObjectSomeValuesFrom(ai:supports ai:IDECodingAgents))
SubClassOf(ai:ProgressiveDisclosureHarnesses
  ObjectSomeValuesFrom(ai:supports ai:MultiAgentOrchestrationFrameworks))
SubClassOf(ai:ProgressiveDisclosureHarnesses
  ObjectSomeValuesFrom(ai:supports ai:AISafety))

Implementation Relationships

SubClassOf(ai:ProgressiveDisclosureHarnesses
  ObjectSomeValuesFrom(ai:implements ai:RetrievalAugmentedGeneration))
SubClassOf(ai:ProgressiveDisclosureHarnesses
  ObjectSomeValuesFrom(ai:implements ai:SemanticSearch))
SubClassOf(ai:ProgressiveDisclosureHarnesses
  ObjectSomeValuesFrom(ai:implements ai:ApproximateNearestNeighbourSearch))
SubClassOf(ai:ProgressiveDisclosureHarnesses
  ObjectSomeValuesFrom(ai:uses ai:FunctionCalling))
SubClassOf(ai:ProgressiveDisclosureHarnesses
  ObjectSomeValuesFrom(ai:uses ai:ToolUse))
SubClassOf(ai:ProgressiveDisclosureHarnesses
  ObjectSomeValuesFrom(ai:uses ai:Embeddings))
SubClassOf(ai:ProgressiveDisclosureHarnesses
  ObjectSomeValuesFrom(ai:uses ai:PromptEngineering))

Reduction Relationships

SubClassOf(ai:ProgressiveDisclosureHarnesses
  ObjectSomeValuesFrom(ai:reducesTo ai:AgentHarness))
SubClassOf(ai:ProgressiveDisclosureHarnesses
  ObjectSomeValuesFrom(ai:contrastsWith ai:HarnessConfigurationPacks))
SubClassOf(ai:ProgressiveDisclosureHarnesses
  ObjectSomeValuesFrom(ai:contrastsWith ai:InContextLearning))
SubClassOf(ai:ProgressiveDisclosureHarnesses
  ObjectSomeValuesFrom(ai:bridgesTo ai:AgentMemoryLayers))
SubClassOf(ai:ProgressiveDisclosureHarnesses
  ObjectSomeValuesFrom(ai:bridgesTo ai:AgenticRAG))
SubClassOf(ai:ProgressiveDisclosureHarnesses
  ObjectSomeValuesFrom(ai:bridgesTo ai:TerminalCodingAgents))

About

  • The progressive disclosure problem in agent harness engineering arises directly from the structural tension between two properties of transformer-based Large Language Models: the soft limit on useful information density within the Context Window and the expanding surface area of tools, capabilities, and instructions that production agent deployments require. In 2022-2023, most agents operated with fewer than 20 tools, and injecting all tool schemas was feasible. By 2024-2025, agent deployments began routinely integrating hundreds of Model Context Protocol servers, each exposing dozens of tools — a production deployment serving 300+ tools faces a 40,000-100,000 token context burden from tool schema injection alone before any task-specific content enters the window. Empirical research documented the accuracy degradation: models receiving more than 30-40 simultaneous tool descriptions show statistically significant drops in tool selection accuracy, task completion rates, and Chain of Thought coherence (Speakeasy 2025, solo.io analysis 2026, matthewkruczek.ai benchmark 2025). The lost-in-the-middle phenomenon — where Attention Mechanism weights assign lower influence to information positioned in the middle of a long context — was specifically identified as a driver of tool selection errors when tool schemas were densely packed into a single massive context prefix.
  • The progressive disclosure pattern resolves this by applying a layered information architecture borrowed from human-computer interaction design, where the term “progressive disclosure” was coined by J.M. Carroll and Mazur (1986) to describe interfaces that present minimal information at entry and reveal additional complexity only when users explicitly request it. Applied to agent harnesses, this translates to: at the start of each Agent Loop step, the agent receives a compact summary-level index of available tool categories and capability areas — typically under 500 tokens regardless of the total tool surface; when the agent determines it needs a specific tool, it issues a retrieval request specifying the capability it needs; the harness returns the full JSON schema for only the matched tools, typically 1,000-3,000 tokens rather than 40,000-100,000 tokens for the full library. The net result is a context window that remains predominantly allocated to task-relevant content rather than tool specification overhead.
  • Three distinct implementation philosophies have emerged. The passive retrieval approach (langgraph-bigtool, ToolRAG, Toolshed) positions progressive disclosure as a retrieval problem: tool schemas are stored in a Vector Database with Embeddings; at each step the harness embeds the agent’s current query or state description and retrieves the top-k most semantically similar tools, injecting only those schemas into the window. This approach requires no model modification, works with any Foundation Model, and achieves 85-100x token reduction. The active discovery approach (MCP-Zero, arXiv:2506.01056) inverts the locus of control: rather than the harness retrieving tools for the agent, the agent itself issues structured natural-language tool requests describing the capability gap it needs to fill; the harness routes these requests via a two-stage hierarchical semantic routing algorithm to the appropriate MCP server and tool. MCP-Zero achieves 98% token reduction at ~2,800 tools while maintaining strong multi-turn consistency (approximately 3% accuracy drop versus over 20% in passive retrieval baselines). The generative unification approach (ToolGen, arXiv:2410.03439, ICLR 2025) embeds tool knowledge directly into Fine-Tuning-adjusted model weights rather than injecting schemas at inference time: each tool is represented as a unique vocabulary token; the model retrieves and calls tools by generating the appropriate token sequence, with no schema injection at inference time. ToolGen demonstrates superior performance at 47,000+ tools — a scale at which both passive retrieval and active discovery face practical challenges — at the cost of requiring model fine-tuning for each new tool addition.
  • The instruction format dimension of progressive disclosure is equally significant: agents.md, .cursorrules, and Claude Code Skills all embody the same layered disclosure principle applied to system prompts and capability specifications rather than to API tool schemas. These formats use a tiered structure — frontmatter name and one-sentence description always present, full body content loaded only when task relevance is confirmed — enabling harnesses like Claude Code to maintain awareness of hundreds of skills without injecting their full specifications into the context. The blog.buildbetter.ai 2026 guide to AGENTS.md vs. .cursorrules vs. Claude Code Skills documents how this format competition has converged on the progressive disclosure pattern as the effective standard, with differences primarily in specificity of format and scope of supported harnesses.

Components / Architecture

  • Tool Index / Capability Catalogue
    • The foundational component: a structured registry of all available tools, grouped by capability category (file operations, web access, code execution, data retrieval, communication), with each entry containing only name, one-line description, and category tag — no full JSON schema. Total size: typically 200-800 tokens for 50-500 tools. The index is injected into the Context Window on every step; the full schemas are not.
    • Implementation: a structured JSON or Markdown list maintained by the Agent Harness, updated when new Model Context Protocol servers are registered. In langgraph-bigtool, the index is stored in LangGraph’s built-in persistence layer with support for in-memory and Postgres backends.
  • Embedding-Based Semantic Router
    • Converts the agent’s current task description or tool request into a dense vector using an Embeddings model (typically a lightweight bi-encoder such as MiniLM-L6-v2 at 384 dimensions for low-latency retrieval). Runs Approximate Nearest Neighbour Search over the Vector Database-backed tool index to retrieve the top-k most semantically similar tools. Returns the full JSON schemas of only those tools.
    • Performance target: under 20ms retrieval latency for tool selection, adding negligible overhead to the Agent Loop step. langgraph-bigtool uses LangGraph’s InMemoryStore with embedding-based retrieval; Toolshed (arXiv:2410.14594) uses a dedicated tool knowledge base with advanced RAG-tool fusion for better precision on complex tool selection scenarios.
  • Active Tool Request Interface (MCP-Zero Model)
    • Rather than a passive retrieval lookup, the agent issues a structured natural-language request: “I need a tool that can [capability description]“. The harness runs a two-stage hierarchical semantic routing algorithm: stage 1 filters candidate MCP servers by category match; stage 2 ranks specific tools within those servers by semantic alignment to the capability description. MCP-Zero’s iterative capability extension then allows the agent to progressively build a cross-domain toolchain across multiple request cycles without injecting any previously used schemas unless re-requested.
    • Token budget: MCP-Zero reports 98% reduction versus full-schema injection at 2,800 tools — from approximately 280,000 tokens to approximately 5,600 tokens per step.
  • Schema Loader / On-Demand Resolver
    • Triggered by the semantic router or active request interface, the schema loader fetches and injects the full JSON schema for one or more selected tools into the current step’s context. For MCP-compliant tools, this is a standard MCP tool-describe call. For locally registered tools, it is an in-process lookup. The schema loader maintains a per-session cache of previously loaded schemas so that tools used in prior steps are not re-loaded redundantly.
    • The “describe_tools” meta-tool pattern (synapticlabs.ai 2025) provides the schema loader as an explicit agent-callable tool: the agent calls describe_tools(category=“file_operations”) to receive schemas for all file operation tools, enabling self-directed progressive disclosure without modifying the harness architecture.
  • Instruction Layer Specifications (agents.md / .cursorrules / SKILL.md)
    • The progressive disclosure principle applied to system prompts: instruction specifications are structured as layered files where outer layers (frontmatter, one-line descriptions) are always loaded and inner layers (detailed procedures, examples) are loaded only when relevance is confirmed by the harness routing logic. Claude Code Skills (SKILL.md files in the agentbox) implement this pattern explicitly: each skill has a one-line trigger description for the routing layer and a full specification body loaded when the skill is invoked.
    • The 2026 AGENTS.md vs. .cursorrules vs. Claude Code Skills comparison (blog.buildbetter.ai) documents that all three formats have converged on the progressive disclosure principle, with differences in: scope of harness support (AGENTS.md for Codex/Copilot Workspace; .cursorrules for Cursor; SKILL.md for Claude Code); instruction specificity; and the degree to which the format supports versioning and team-shared skill libraries.
  • Bounded Context Packs (Meta-Tool Pattern)
    • An advanced progressive disclosure variant (synapticlabs.ai 2025) that groups related tools into “context packs” — each pack is a single meta-tool that, when called, injects the schemas of a coherent set of related tools. A “file_operations_pack” meta-tool injects schemas for read, write, delete, search, move — but only when the agent explicitly invokes that meta-tool. This reduces the two-stage retrieval (index lookup → schema load) to a single agent call at the cost of coarser granularity.
    • MCP Tool Schema Bloat analysis (layered.dev 2025) identifies bounded context packs as the highest-impact single optimisation for agent deployments with fewer than 100 tools, achieving 85-95% token reduction with minimal retrieval overhead.
  • Fallback Full-Load Mode
    • Every progressive disclosure harness must implement a graceful degradation path: if the semantic router fails to identify a suitable tool, or if the task explicitly requires comprehensive awareness of all available capabilities, the harness falls back to injecting all tool schemas in the conventional manner. This ensures progressive disclosure never causes agent failure through tool blindness — it is a performance optimisation with a safe fallback, not a constraint on agent capability.

Use Cases / Major Families

  • Large MCP Tool Ecosystem Management — Production agent deployments routinely connect to 10-50+ MCP servers, each exposing multiple tools. Without progressive disclosure, injecting all schemas before each model call would consume the entire usable context budget. MCP Progressive Disclosure (solo.io 2026 guide) is the canonical deployment pattern: a compact tool index is injected once, and full schemas are retrieved on demand. Claude Code v2.1.7 (2026) automatically enables progressive disclosure via MCP Tool Search when tool descriptions would exceed 10% of available context — loading tools via search on demand rather than preloading. Token Optimize (tokenoptimize.dev 2025) documents 85% token reduction for large tool libraries, with tool definitions dropping from 10K+ tokens to approximately 3K per request.
  • Large-Scale Coding Agent Tool Access — Terminal Coding Agents such as Claude Code, Codex CLI, Aider, and Gemini CLI operate over codebases that may require hundreds of distinct file operation, build system, testing, linting, documentation, and deployment tools. Progressive disclosure enables these agents to maintain awareness of the full capability surface without context saturation. The Speakeasy dynamic toolset comparison (speakeasy.com 2025) documented 160x token reduction with dynamic toolsets versus static toolsets at 400 tools, with stable success rates as toolsets grow — demonstrating that progressive disclosure removes what had been a practical ceiling on useful agent tool surface size.
  • IDE Agents with Plugin-Rich Environments — IDE Coding Agents in environments such as Cursor, Copilot Workspace, and Windsurf operate within plugin-rich IDEs that expose language servers, linting tools, debuggers, test runners, and build systems as agent-callable capabilities. Progressive disclosure enables the agent to maintain a lean context while accessing the full plugin surface on demand. The .cursorrules format (awesome-cursorrules collection: github.com/PatrickJS/awesome-cursorrules, 48K+ GitHub stars as of 2026) implements progressive disclosure for rule specification — each rule file has a compact header loaded at all times and a detailed body loaded when relevant task context is detected.
  • Multi-Agent Tool Routing — In Multi-Agent System architectures with specialist subagents (a web search agent, a code execution agent, a database query agent, a file management agent), the orchestrator agent uses progressive disclosure to route subtasks to appropriate specialists: it receives an index of available specialist agents with one-line capability descriptions, selects the relevant one, then retrieves the full interaction specification for that specialist only when dispatching a task to it. This pattern is implemented by LangGraph DeepAgents (langchain-ai/deepagents, the “batteries-included agent harness”) and by MCP-Zero’s iterative capability extension mechanism.
  • Instruction Progressive Disclosure in CLAUDE.md / agents.md Systems — The CLAUDE.md, agents.md, and SKILL.md patterns implement progressive disclosure for system prompt composition. In the agentbox environment, the Claude Code harness loads a compact index of available skills (name + one-line trigger description) at the start of each session; when a user command matches a skill trigger, the full skill specification is loaded into the context. This prevents the accumulated total of all system-level instructions from consuming the context budget before the user’s task is even stated. The skill-creator pattern extends this to user-generated skills, enabling teams to build progressive disclosure libraries of custom capabilities without modifying the core harness.
  • ToolGen-Style Unified Tool Calling — For very large tool surfaces (10,000+ tools), token-optimisation approaches that inject schemas at inference time — however efficiently — face practical limits. ToolGen (arXiv:2410.03439, ICLR 2025) embeds tool knowledge directly into model weights via multi-stage Fine-Tuning (tool memorisation, retrieval training, end-to-end agent task training). The model retrieves and calls tools by generating tool-specific vocabulary tokens rather than selecting from injected schema JSON. ToolGen demonstrated superior performance at 47,000+ tools in both tool retrieval accuracy and autonomous task completion, with zero token cost for tool schema injection. The limitation is that adding new tools requires fine-tuning iteration — a deployment model better suited to stable enterprise tool surfaces than rapidly evolving toolchains.

Academic Context

  • The human-computer interaction concept of progressive disclosure was formalised by Carroll & Mazur (1986) “The Navigator’s Dilemma” and by Nielsen (1994, Usability Engineering) as a fundamental principle for managing interface complexity. Its application to AI agent context management is a 2024-2026 engineering innovation, not explicitly anticipated in the original UX literature.
  • The tool use and Function Calling research tradition — Schick et al. (2023) Toolformer, Yao et al. (2023) ReAct, Qin et al. (2023) ToolLLM — established the baseline problem: agents with access to large tool surfaces face selection difficulty as tool count grows. ToolLLM (Qin et al., arXiv:2307.16789, 2023) specifically demonstrated that providing all tool documentation inline degrades performance above a threshold of approximately 20-30 tools, establishing the empirical motivation for progressive disclosure.
  • ToolGen (Ren et al., arXiv:2410.03439, ICLR 2025) provided the first rigorous evaluation of a generative unified tool retrieval and calling approach at 47,000+ tool scale, establishing that embedding tool knowledge in model weights rather than schema injection achieves both better tool retrieval accuracy and better end-to-end task completion than retrieval-augmented approaches — at the cost of requiring fine-tuning.
  • Toolshed (arXiv:2410.14594) proposed tool knowledge bases as a RAG-tool fusion approach — maintaining a structured knowledge base of tool documentation that could be queried by the agent’s tool selection logic — providing a middle path between pure schema injection and full fine-tuning.
  • MCP-Zero (Fei, Zheng, Feng, arXiv:2506.01056, submitted June 2025, revised June 2025 to v4) is the most recent landmark paper directly addressing progressive disclosure in the Model Context Protocol era. Its three core mechanisms — active tool request (agent-generated capability gap description), hierarchical semantic routing (two-stage server-then-tool ranking), and iterative capability extension (cross-domain toolchain building) — represent the current state-of-the-art for active progressive disclosure. The 98% token reduction at 2,800 tools result is the strongest published token efficiency benchmark for MCP-native progressive disclosure.
  • The Online-Optimized RAG for Tool Use and Function Calling (arXiv:2509.20415, 2025) explores adaptive approaches to tool selection that optimise retrieval quality based on observed task outcomes — an early signal of learned progressive disclosure policies analogous to the learned memory policies emerging in Agent Memory Layers.
  • Tool-to-Agent Retrieval (arXiv:2511.01854, 2025) extends the progressive disclosure concept from individual tool selection to agent-to-agent delegation in Multi-Agent System architectures — demonstrating that the same index-first, detail-on-demand principle scales from single-agent tool selection to multi-agent capability routing.
  • UK academic context: the UKRI AI Safety Institute (AISI, launched 2023) has evaluated tool-calling agents using GAIA benchmark levels 1-3 in the Inspect AI evaluation framework, with progressive disclosure identified as a variable affecting benchmark performance. The Alan Turing Institute’s work on interpretable and safe AI agents encompasses tool selection transparency — progressive disclosure’s explicit on-demand schema loading provides a natural audit log of which tool capabilities the agent accessed, supporting the AI Safety and Human-in-the-Loop interpretability requirements emphasised in ATI research.
  • Key venues: ICLR, NeurIPS, ICML for the machine learning foundations; ACL, EMNLP for language model tool use; UIST, CHI for the HCI progressive disclosure ancestry; industry blogs (solo.io, speakeasy.com, layered.dev, matthewkruczek.ai, tokenoptimize.dev) are the primary venues for 2025-2026 production benchmarks given the pace of engineering innovation.

Current Landscape (2026)

  • By June 2026 progressive disclosure has moved from engineering insight to industry standard for large-tool-surface agent deployments. The maturation is evidenced by native harness adoption: Claude Code v2.1.7 (Anthropic, 2026) introduced automatic progressive disclosure that triggers MCP Tool Search when tool descriptions would consume more than 10% of the available context budget — loading tools via search on demand rather than preloading all tool definitions, with no user configuration required. LangGraph DeepAgents (langchain-ai/deepagents, 2025/2026) is marketed explicitly as “the batteries-included agent harness” with progressive tool disclosure as a first-class feature.
  • The benchmark landscape documents the performance improvements definitively. Speakeasy’s dynamic toolset comparison (speakeasy.com 2025) measured 160x token reduction with dynamic toolsets versus static at 400 tools, with task success rates stable as toolset size grew from 40 to 400 tools — demonstrating that progressive disclosure removes the practical ceiling on agent tool surface. Matthew Kruczek’s independent benchmark (matthewkruczek.ai 2025) documented 85x token savings from progressive MCP server schema disclosure with higher agent accuracy. The Token Optimize guide (tokenoptimize.dev 2025) reports 85% token reduction for large tool libraries, with tool definitions dropping from 10K+ tokens to approximately 3K per request. MCP-Zero (arXiv:2506.01056, June 2025) demonstrates 98% token reduction at 2,800 tools.
  • The instruction format competition has largely resolved: AGENTS.md (broad ecosystem support including Codex CLI, Copilot Workspace, Jules, Gemini CLI), .cursorrules/.cursor/rules/ (Cursor-specific, 48K+ stars on awesome-cursorrules), and Claude Code Skills (SKILL.md) are the three dominant instruction progressive disclosure formats as of 2026 (blog.buildbetter.ai 2026 comparison), with all three implementing the same index-first, detail-on-demand pattern and differing primarily in supported harnesses.
  • The Model Context Protocol ecosystem has added tool search as a standard extension in the 2025-2026 period, formalising progressive disclosure as a protocol-level concern rather than an application-level workaround. This is the clearest signal that progressive disclosure has achieved canonical status in the Agent Harness ecosystem.
  • The ToolRAG/ToolGen research lineage continues to advance: a 2025-2026 literature wave including ToolDreamer (arXiv:2510.19791, instilling LLM reasoning into tool retrievers), Ego-Graph Ensembles for enterprise tool retrieval (arXiv:2508.05888), and the Online-Optimized RAG for Tool Use (arXiv:2509.20415) demonstrates active research investment in making tool retrieval more accurate, adaptive, and computationally efficient.

UK Context

  • The UK AI Safety Institute (AISI, launched April 2024 as the world’s first national AI safety institute) operates the Inspect AI evaluation framework, within which progressive disclosure is a variable in agent Tool Use evaluation. GAIA benchmark levels 1-3 testing of tool-calling agents implicitly evaluates tool selection accuracy under varying context conditions, making progressive disclosure an empirically relevant variable in UK government AI safety evaluation.
  • The Alan Turing Institute’s programme on interpretable AI agents encompasses the specific question of tool selection transparency: when an agent selects a tool, can a human auditor reconstruct why? Progressive disclosure’s on-demand schema loading creates a natural step-level audit trail — the log of which tool schemas were requested and loaded at each Agent Loop step provides an interpretable record of the agent’s capability access pattern, supporting both AI Safety analysis and Human-in-the-Loop oversight requirements that ATI emphasises.
  • UCL’s Centre for Artificial Intelligence and the UKRI national Generative AI Hub have published on context-efficient inference and long-context reasoning, directly relevant to the progressive disclosure problem. UCL researchers are participants in the EU AI Act implementation advisory bodies, where Tool Use transparency and Provenance requirements for AI agent actions are active policy concerns — progressive disclosure’s audit trail property is relevant to EU AI Act Article 13 transparency obligations.
  • The University of Edinburgh’s Informatics group has longstanding contributions to Information Retrieval and dynamic context management, including work on adaptive document retrieval that anticipates the progressive disclosure pattern in the document context rather than the tool context. Edinburgh’s AARG group works on tool-equipped agent evaluation.
  • Manchester’s industrial ecosystem — particularly the Northern England financial services sector — is an active deployment context for Terminal Coding Agents and compliance automation agents that operate over large tool surfaces. The GDPR and FCA data residency concerns in this sector push toward self-hosted progressive disclosure implementations (langgraph-bigtool with on-premise Postgres backend; self-hosted Qdrant for the tool embedding index) rather than cloud-managed MCP servers, creating a distinct UK deployment pattern.
  • Sheffield Robotics and the broader UK robotics community are beginning to encounter progressive disclosure as a practical engineering concern in embodied agent systems: robots equipped with many sensing and actuation tools face the same context bloat problem as software agents, and the same index-first, detail-on-demand pattern is emerging as the design response.

Future Directions (2026-2030)

  • Learned Tool Routing Policies — The current generation of progressive disclosure harnesses uses heuristic similarity search (Semantic Search via Approximate Nearest Neighbour Search) for tool selection. The next generation will use reinforcement learning-trained routing policies that optimise tool selection based on observed task outcomes, token budgets, and latency constraints. Online-Optimized RAG for Tool Use (arXiv:2509.20415, 2025) is an early signal of this direction; production learned tool routers are expected by 2027-2028.
  • Multi-Modal Tool Discovery — Current progressive disclosure operates over textual tool descriptions and query states. As agents become multimodal — operating over images, audio, and structured data as well as text — tool selection will require matching multimodal agent state descriptions to multimodal tool capability descriptions. This requires multimodal Embeddings and retrieval infrastructure extending the current text-only tool index approach.
  • Tool Composition and Capability Synthesis — Advanced progressive disclosure will move from selecting existing tools to composing novel tool sequences for capability gaps. MCP-Zero’s iterative capability extension is an early step; future systems will synthesise multi-step tool chains for capabilities not explicitly available in any single registered tool — bridging progressive disclosure and Planning and Scheduling.
  • Cross-Agent Tool Sharing — Tool-to-Agent Retrieval (arXiv:2511.01854) points toward a future where progressive disclosure operates at the agent level in large Multi-Agent System architectures: an orchestrator maintains an index of available specialist agents and retrieves the most relevant one for each subtask. This transforms agent catalogues into the tool libraries of the future, with progressive disclosure scaling from dozens of tools to hundreds of specialist agents.
  • Privacy-Aware Tool Access Control — As tool surfaces include access to sensitive data APIs (healthcare records, financial data, personal communications), progressive disclosure indices will need to integrate access control: each tool’s index entry will carry access classification labels, and the semantic router will filter retrieval results by the querying agent’s Agent Identity permissions before presenting the tool index. This connects progressive disclosure to GDPR, Privacy, and enterprise data governance — EU AI Act obligations for tool use transparency will drive this integration.
  • Protocol Standardisation — The Model Context Protocol tool search extension is a first step toward standardising progressive disclosure at the protocol level. Further standardisation — including a common tool index schema, standard capability category taxonomies, and standard token budget negotiation between agents and MCP servers — is expected by 2027, following the adoption pattern of REST APIs in the web era. This will enable interoperability between progressive disclosure harnesses and tool registries across vendors.

Key Terminology

  • Context Bloat — The condition in which tool schema injection, system prompt verbosity, or prior conversation history consumes an excessive fraction of the Context Window, leaving insufficient space for task-relevant content and degrading model performance.
  • Tool Index — The compact registry of available tools — name, one-line description, category — injected on every step without full schema; the entry-point layer of progressive disclosure.
  • Schema Loader — The harness component that fetches and injects the full JSON schema for a specific tool on demand, triggered by the semantic router or agent tool request.
  • Active Tool Discovery — The MCP-Zero model in which the agent generates structured natural-language requests specifying capability gaps; the harness routes these to the appropriate tools autonomously.
  • Meta-Tool Pattern — Exposing a group of related tools as a single meta-tool; invoking the meta-tool injects schemas for all tools in the group — a bounded context pack.
  • ToolGen — The generative approach that embeds tool knowledge into model weights via Fine-Tuning, enabling tool retrieval and calling by token generation rather than schema injection (ICLR 2025).
  • MCP-Zero — Active tool discovery framework for MCP-native agents; hierarchical semantic routing; iterative capability extension; 98% token reduction at 2,800 tools (arXiv:2506.01056, June 2025).
  • langgraph-bigtool — LangGraph library for embedding-based tool retrieval in agents with large tool registries; supports in-memory and Postgres backends; semantic similarity retrieval via InMemoryStore.
  • awesome-cursorrules — Community collection (48K+ GitHub stars) of .cursorrules instruction files for Cursor IDE implementing progressive disclosure for AI coding assistance instruction sets.
  • agents.md — Instruction format supported by Codex CLI, Copilot Workspace, Jules, and Gemini CLI for progressive disclosure of agent operating instructions in repository context.
  • SKILL.md — Claude Code Skills format for progressive disclosure of custom harness capabilities; name and trigger-description always loaded; full body loaded on invocation.

Research & Literature

Provenance

Graph View

Backlinks