Progressive disclosure might replace MCP (Claude Agent Skills)

Anthropic recently released Claude Agent Skills, a way to bring additional context and tooling to agents. It uses a progressive disclosure technique, progressively discovering new context and tools rather than pre-loading everything into the context window the MCP way.

Progressive disclosure does a lot right to preserve context window and improve tool use accuracy. It is similar to how popular coding agents like Claude Code and Codex discover new files on their own. However, there are still many factors that makes MCP a superior choice of context delivery especially around runtime performance and authorization.

In this article, we'll cover the tradeoffs of both progressive disclosure and MCP.

Claude Agent Skills provide the same utility as MCP

Creating a Claude Agent skill is just creating a folder on your desktop. The folder contains a SKILL.md, which contains context info like how to use the skill, and the skill structure. The skill can also contain resources and tools (scripts) that the agent can use to run actions. This markdown file is just context to guide the agent to discover even more context.

This is the file structure of creating a Claude Agent skill:

pdf-skill/
├── SKILL.md (main instructions)
├── FORMS.md (form-filling guide)
├── REFERENCE.md (detailed API reference)
└── scripts/
    └── fill_form.py (utility script)

A SKILL.md file might provide the following context:

# PDF Processing

Extract text and tables from PDF files, fill forms, merge documents.
Use when working with PDF files or when the user mentions PDFs, forms,
or document extraction.

## Quick start

Use pdfplumber to extract text from PDFs:

```python
import pdfplumber
with pdfplumber.open("document.pdf") as pdf:
    text = pdf.pages[0].extract_text()
```

For advanced form filling, see FORMS.md.

You can also give the agent tools by writing scripts and provide additional resources with more markdown files. Notice that agent skills is just another way to achieve what MCP does: provide tools and context to the LLM.

The novelty of MCP is in its ability to distribute and standardize agent tools. A company like Figma can remotely host an MCP server, providing any agent Figma tools through a single connection. Agent skills are also shareable by bundling the skill as a zip folder. Currently, custom skills are individual to each user, but it opens the door to creating a Claude agent skill marketplace.

What agent skills does right that MCP doesn't

The use of progressive disclosure allows agent skills to load resources and tools when needed, whereas MCP loads everything into the context window on initiation. We're seeing a lot of MCP developers even at enterprise build MCP servers that expose way too much, consuming the entire context window and leading to hallucination. Agents using MCP can realistically only connect to 2-3 MCP servers before we see a significant drop in tool use accuracy.

Progressive disclosure allows us to build much more sophisticated agents without having to worry about context window bloat. As long as instructions and metadata are well written, the agent should have no problem with discovering what resources it needs to accomplish a task. This means skills can include entire API documentation, large datasets, entire libraries of references.

Creating an agent skill is also far more accessible than creating an MCP server. Writing markdown and organizing folders is a lot more accessible for non-developers than serving an MCP server.

What MCP excels at

The advantage to loading the context and tools on initiation instead of using progressive disclosure is the runtime performance. If you've ever used a coding agent, you'll notice that it takes a lot of time for the agent to discover relevant context. The agent has to use the filesystem tool to scour through folders, and can take minutes to achieve one task.

MCP's runtime performance is great. The LLM can instantly reason what tools to call when loading all tools up front with MCP. Counting usage of the filesystem tool, MCP uses probably 3 to 4 times less tools than progressive disclosure.

We're also seeing a rich ecosystem being built around MCP. OAuth is maturing that allows a way to provide authenticated tool access. MCP-UI and OpenAI Apps SDK is providing a way for MCP to serve UI to the client. It provides a standard communication protocol for any agent to access any tool. It's still early for Claude agent skills to provide these capabilities, but it's not to say it's impossible.

The distribution of MCP is also far superior than an agent skill. Agents can connect to MCP servers and get instant remote tool access. There is no concept of remote tool access with skills. Agent skills are downloaded locally and distributed through zip files. Large skills can take up significant local memory.

Where MCP is going

It's great that Anthropic is exploring new techniques such as progressive disclosure is a great thing for the agent ecosystem. We shouldn't naively mass adopt MCP without exploring alternative ways to efficient context loading. A proof of concept of progressive disclosure does reveal the weaknesses of MCP. Down the line we might discover that the optimal solution is somewhere in between MCP and progressive disclosure.

Check out Klavis

One project I find really interesting is Klavis' Strata. Their tagline is "One MCP server for AI agents to use tools reliably at scale". Klavis does a hybrid approach where they use MCP as a delivery method, but use progressive disclosure as a way to discover tools efficiently. I highly recommend trying out Strata to see progressive disclosure at play yourself.

Make your MCP server context efficient

We built the MCPJam inspector to help with the efficient context of MCP servers. We've helped developers reduce their MCP server's context window usage by an average of 30%.

We help with MCP tool ergonomics, that is how well you design your server's tools such that an LLM can understand how to use it. Servers that bloat the context window by exposing too many tools tend to not have great ergonomics, causing LLMs to hallucinate. MCPJam's LLM playground helps you test for this, where you can visualize how much context your MCP server is using.