Agent Skills Explained: Solving the MCP Context Bloat Problem

From Tool Calling to Agent Skills: The Evolution of Agent Capability Extension

As enterprise AI applications shift from chatbots to autonomous agents, how to effectively extend an Agent's capability boundaries has become one of developers' top concerns. This article focuses on Anthropic's Agent Skills mechanism, systematically tracing the technical evolution of agent capability extension.

In a nutshell, the core purpose of Agent Skills is to extend the capabilities of an Agent. Understanding this positioning is crucial—Skills don't exist in isolation; they always serve Agent scenarios and address real pain points in tool calling.

Three Stages of Capability Extension

Looking back at the technical evolution of Agent capability extension, it has gone through roughly three stages:

1. Function Calling: The earliest approach to capability extension through directly defining tools for models to invoke. Function Calling was first introduced by OpenAI in June 2023 for the GPT API, allowing developers to define a set of function signatures (including function names, parameter types, and descriptions) in requests. The model determines whether to call a function based on user intent and returns call parameters in structured JSON format. Developers then execute the corresponding function locally and pass the results back to the model to complete the final response. The essence of this mechanism is upgrading large language models from "pure text generators" to "decision engines capable of interacting with external systems." However, its limitation lies in the fact that each API provider uses different function definition formats, and there's no unified standard for tool discovery and registration, making cross-platform reuse difficult.

2. MCP (Model Context Protocol): Anthropic's model context protocol standardizes tool capabilities into a protocol, making tool integration more systematic. MCP was open-sourced in November 2024, with its design inspired by LSP (Language Server Protocol)—just as LSP allows any IDE to interface with any programming language server, MCP aims to enable standardized integration between any AI model and any external tool/data source. MCP uses a client-server architecture: MCP Servers expose Tools, Resources, and Prompts, while MCP Clients embedded in AI applications handle communication with Servers via the JSON-RPC 2.0 protocol, supporting both stdio and HTTP+SSE transport methods. MCP dramatically reduces tool integration fragmentation—developers only need to write an MCP Server once for it to be callable by all MCP-compatible AI clients.

3. Agent Skills: To address problems exposed by MCP, Anthropic further introduced the Skills mechanism.

Interestingly, both MCP and Skills come from Anthropic. This means Skills aren't meant to replace MCP, but rather serve as a supplement and upgrade addressing MCP's shortcomings revealed in real-world usage.

MCP's Two Fatal Flaws

While MCP solved the tool integration standardization problem, it exposed two quite critical flaws in real enterprise scenarios.

Flaw #1: Insufficient Tool Calling Accuracy

The first issue is calling accuracy. Achieving "fast, precise, and decisive" tool calling is extremely difficult in practice. Developers commonly encounter two types of problems:

• The model fails to call a tool when it should, or calls tools when it shouldn't;
• Parameters are passed incorrectly during tool calls—"it just can't get the parameters right."

The root cause is that MCP only provides descriptions of "what a tool can do," while "when to use this tool" relies entirely on the model's own reasoning. To improve calling accuracy, developers often have to stuff system prompts with extensive trigger rules, few-shot examples, and Chain-of-Thought instructions, or repeatedly refine tool descriptions—if a description is poorly written, the call may fail.

Here, few-shot refers to the technique of providing a small number of input-output examples in the prompt to guide model behavior; Chain-of-Thought improves accuracy on complex tasks by having the model show intermediate reasoning steps. Both are core techniques in Prompt Engineering, but when heavily stacked in system prompts, they themselves exacerbate context bloat, creating a paradox of "trading context for accuracy."

Flaw #2: Context Bloat and Token Explosion

The second issue is even more challenging. MCP's loading mechanism injects all tool descriptions into the context at once. This means regardless of whether you have dozens or hundreds of tools, their descriptions are all crammed into the context window simultaneously.

When tool count grows, it triggers a chain reaction:

• Context window bloat (explosion): Massive tool descriptions consume precious context space;
• Context pollution: Irrelevant tool descriptions interfere with the model's understanding of core tasks, affecting subsequent reasoning quality;
• Skyrocketing token consumption: Directly driving up API costs. In the billing system of LLM APIs, tokens are the fundamental unit of measurement. In Agent scenarios, a complete task may involve dozens of conversation rounds and multiple tool calls, each carrying the full context history. If MCP injects descriptions for hundreds of tools, the tool description portion alone could occupy thousands or even tens of thousands of tokens. Taking Claude 3.5 Sonnet's pricing as an example (input $3/million tokens, output $15/million tokens), an Agent with 200 tools could incur $0.01-0.05 in additional costs per call just from tool descriptions. In high-frequency calling scenarios, this figure accumulates rapidly into a non-negligible operational expense;
• Inference latency and hallucinations: More tokens slow down inference speed and may exacerbate hallucination problems.

For context management principles that emphasize "precision and relevance," this full-load approach is clearly anti-efficient.

How Skills Break Through: Progressive Disclosure Mechanism

Anthropic introduced Skills precisely because they identified these problems. Skills address two areas:

First, improving tool calling accuracy. Through more structured skill definitions, the model gains clearer understanding of "when to use what."

Second, and most critically—adopting a Progressive Disclosure mechanism. This is the key design that distinguishes Skills from MCP.

Progressive Disclosure was originally a classic design principle from the Human-Computer Interaction (HCI) field, proposed by IBM researchers in the 1980s. The core idea is: interfaces should only reveal more details when the user needs them, avoiding information overload. This principle is widely applied in software UI design—for example, "Advanced Settings" buttons in operating systems, or "Show more options" in forms. Anthropic creatively migrated this concept to AI Agent tool management, representing a cross-disciplinary design innovation whose approach is highly consistent with "Lazy Loading" and "Demand Paging" in operating systems.

Unlike MCP's "all-at-once full loading," Progressive Disclosure follows a load-on-demand approach: the model initially sees only a brief overview of skills, and only loads the complete instructions and resources for a specific skill when it truly needs the detailed content. This way, the context window isn't stuffed with irrelevant information, token consumption is controlled, and context pollution is mitigated.

This design is essentially a Context Engineering approach—spending the limited context budget where it matters most, rather than letting the model get "lost" in massive tool descriptions. Context Engineering is a core concept that emerged in the AI engineering field in 2025, popularized by Shopify CEO Tobi Lütke and others. Unlike Prompt Engineering, which focuses on "how to write a good prompt," Context Engineering focuses on "how to provide the right information to the model at the right time," including a series of systematic decisions around context selection, compression, ordering, and caching. In Agent scenarios, even models supporting 200K tokens have effective utilization rates far below theoretical values, so how to maximize information density and relevance within a limited budget directly determines an Agent's task completion quality.

Industry Signals: Enterprises Are Fully Pivoting to AI Roles

Beyond the technology itself, this discussion also revealed two noteworthy industry trends, based on the author's three-day on-site research at Alibaba's headquarters in Hangzhou.

Signal #1: AI Positions Account for 80% of Hiring

According to the author's observations, approximately 80% of current hiring at Alibaba headquarters is for AI-related positions, mainly falling into three categories:

• Application Development roles;
• Product and Solutions roles;
• Algorithm and Senior Architecture roles.

Even more interesting is that for relevant positions at Alibaba headquarters, Alibaba Cloud's LLM ACP certification is listed as a mandatory requirement. The certification covers a comprehensive scope, ranging from Prompt engineering, RAG (Retrieval-Augmented Generation), and complex Agent task building, to model fine-tuning, and cloud-based inference deployment for production implementation.

RAG (Retrieval-Augmented Generation) is a technical paradigm proposed by Meta AI's research team in 2020. Its core approach is to retrieve document fragments relevant to the question from an external knowledge base before the LLM generates an answer, injecting them as context so the model generates responses based on real data rather than relying solely on parameterized knowledge learned during training. RAG effectively mitigates LLMs' "knowledge cutoff" and "hallucination" problems and has become the most mainstream knowledge enhancement solution in enterprise AI applications. A complete RAG system typically includes document parsing, text chunking, vector embedding, vector database indexing, semantic retrieval, reranking, and answer generation stages.

Certification exam questions are mostly directly related to "business scenario solutions based on LLMs," reflecting that enterprises value engineering-oriented logical capabilities rather than pure coding skills.

Signal #2: ModelScope OPC Developer Ecosystem

The second signal is ModelScope community's OPC (Open Developer Community) initiative for AI developers nationwide. Developers can apply for workstations at Alibaba Cloud's "Wisdom Cloud Valley" for approximately 300 RMB/month, and can exchange community credits for workstation access and computing resources.

The value of such offline workspace lies not only in the physical space but also in the concentration of technical experts and developers, facilitating face-to-face brainstorming and collaboration on product ideas and technical solutions. From these two signals, it's clear that the entire industry is accelerating its transformation toward AI-related positions, and developers need to build their AI tech stack and capabilities as early as possible.

Conclusion

The emergence of Agent Skills is the inevitable result of the evolution from "Function Calling → MCP → Skills" in agent capability extension. Through its Progressive Disclosure mechanism, it solves MCP's context bloat and calling accuracy problems, making it a key technology worth mastering when building enterprise-grade Agents. From Alibaba's hiring data and the ModelScope OPC ecosystem, AI engineering capabilities have become a core competitive advantage for technical professionals. For developers looking to pivot, starting from understanding foundational mechanisms like Agent Skills is undoubtedly a pragmatic path forward.