Progressive disclosure in agent context definition

Progressive disclosure in AI agent context means giving an agent a map before the territory. Short descriptions of skills, tools, or documents sit in the context window, and the full material loads only when a task calls for it. In Sanity Context, an agent's first call returns a compressed schema overview or a Knowledge Base outline (Knowledge Bases are in beta). The agent reads full documents or entries only after it has chosen which ones the question needs.

How does progressive disclosure work in Agent Skills?

Progressive disclosure in Agent Skills works in three levels, and each level loads only after the one before it proves relevant. Anthropic's Agent Skills documentation defines them this way. At level 1, metadata, the skill's name and description from its YAML frontmatter are always loaded, at about 100 tokens per skill. At level 2, instructions, the body of the SKILL.md file loads when the skill is triggered, and it should stay under 5k tokens. At level 3 and beyond, resources, bundled files load only when needed. Scripts run through bash, so only their output enters context.

Anthropic's engineering post on Agent Skills compares this to "a well-organized manual that starts with a table of contents, then specific chapters, and finally a detailed appendix." It adds that, because of this design, "the amount of context that can be bundled into a skill is effectively unbounded." An agent can have many skills installed and pay only the metadata cost for the ones it never opens.

Agent Skills became an open standard in December 2025. The Agent Skills specification requires a name of up to 64 characters and a description of up to 1,024 characters. It recommends keeping SKILL.md under 500 lines and keeping file references one level deep. Since level 1 is all the agent sees at first, the description decides whether the skill gets opened.

Why does progressive disclosure make agents more accurate and cheaper?

Progressive disclosure makes agents more accurate because models do better with smaller, higher-signal contexts. It makes them cheaper because tokens kept out of the window are never billed. Anthropic's guide to effective context engineering describes context rot: "as the number of tokens in the context window increases, the model's ability to accurately recall information from that context decreases." The guide says the goal is "the smallest possible set of high-signal tokens." Chroma's Context Rot report (July 2025) tested 18 LLMs and found that performance degrades as input length grows, in non-uniform ways, and that distractors make it worse.

Tool selection shows the effect most clearly. In Anthropic's post on advanced tool use, five MCP servers with 58 tools took up about 55K tokens before a conversation started. Deferring tool definitions until the agent searched for them cut token usage by 85% in Anthropic's internal testing. Accuracy on its internal MCP evaluations rose from 49% to 74% for Opus 4 and from 79.5% to 88.1% for Opus 4.5. In a separate post on code execution with MCP, loading only the needed tool definitions cut one workflow from 150,000 tokens to 2,000, which saved 98.7% in time and cost.

The cost adds up over an agent loop. An agent re-sends its context window on every step, so anything preloaded gets billed again on each turn, a point TrueFoundry makes about just-in-time context.

How is progressive disclosure different from context compression?

Progressive disclosure controls what gets into the context window. Context compression (also called compaction) shrinks what is already in it. For example, a compression step might summarize a long conversation as it nears the model's limit, keeping the main points and dropping detail. Progressive disclosure acts earlier: full content stays out until the agent asks for it, so there is nothing to summarize later. The two techniques pair well. A long-running agent can use progressive disclosure to start with a lean context and compression to manage the history that builds up over many turns.

Progressive disclosure overlaps with retrieval-augmented generation (RAG), but it differs in who decides what to load. Classic RAG runs a retriever before the model answers and inserts the matching chunks into the prompt. Progressive disclosure gives the agent a map, such as descriptions, an outline, or file paths, and lets the agent decide what to open. Anthropic's context engineering guidance describes a related "just in time" approach, where an agent keeps lightweight identifiers and loads the data behind them only when it needs that data.

How does progressive disclosure relate to context engineering?

Progressive disclosure is one technique within context engineering. Anthropic defines context engineering as "the set of strategies for curating and maintaining the optimal set of tokens (information) during LLM inference" in its guide on the topic. Context engineering covers everything that shapes what a model sees, including system prompts, tool design, retrieval, compaction, structured note-taking, and sub-agents. Within that discipline, progressive disclosure answers one question: when should each piece of information enter the window?

Progressive disclosure differs from prompt engineering. A prompt is a fixed set of instructions written for a conversation. In Anthropic's words, "Unlike prompts (conversation-level instructions for one-off tasks), Skills load on demand."

The pattern works across both main ways of extending an agent. Agent Skills package know-how, while the Model Context Protocol (MCP) connects an agent to tools and data. With skills, progressive disclosure means short metadata first and full instructions later. With MCP, it means deferred tool loading: the `defer_loading: true` setting in Anthropic's Tool Search Tool keeps full tool definitions out of the context window until the agent looks for them.

When does progressive disclosure not help?

Progressive disclosure helps least when the material is small enough for the agent to read directly, or when the agent's harness already finds information well. The arXiv paper "Is Progressive Disclosure All You Need for Long-Context Agents?" (He, Zhao, Wang, and Chen, July 2026) reports what it calls the first controlled study of the pattern. The authors ran it on InfiniteBench with three agent harnesses and three model families.

On a single book, the benefit depended on the harness. It was large when the agent was poor at working through raw documents, and close to zero when the harness was strong. Across many books, working through raw documents broke down, while one level of progressive disclosure "degrades more slowly and pulls ahead." The study also found that "a second, deeper routing level never helps and sometimes breaks accuracy outright, so one level is enough."

The authors sum it up this way: "Progressive disclosure buys context, not intelligence." The pattern lets an agent handle a much larger body of material without overloading its window, but it will not make a model reason better. A larger context window does not replace it either, because Chroma's Context Rot report found that performance drops as input gets longer even on long-context models. Progressive disclosure is worth the most when there is too much material for the agent to read end to end.

How does structured content support progressive disclosure for agents?

Structured content supports progressive disclosure because typed fields and references show an agent the shape of the content before it reads the content itself. The agent can scan a small overview, pick a document type or entry, and then fetch only the fields it needs. Sanity is the AI Content Operating System, and Sanity Context delivers content to agents through Context MCP, a hosted, read-only MCP server that works through this kind of staged sequence.

In GROQ mode, which queries the live dataset, the `initial_context` tool returns a compressed schema overview plus instructions for querying the content. The agent then calls `schema_explorer` to get the full schema for one type, including its fields and references. It runs `groq_query` to fetch only the fields it needs, and it uses `array_field_reader` to pull large array fields or Portable Text body content from the one document it picked.

In Knowledge Base mode, an opt-in beta, `initial_context` serves an outline of entry paths for each Knowledge Base. Sanity's documentation says the outline is small enough to keep in context for a whole conversation. The agent checks the outline, reads the entries it needs with `knowledge_base_read` (up to 20 paths per call), and uses `knowledge_base_search` when the outline does not show where an answer lives. The Sanity Agent Toolkit and Sanity Context skills also use the open Agent Skills format, so they load on demand instead of being explained from scratch in every conversation.

Last updated: November 5, 2026