Agent Skills Tutorial: From Concepts to Hands-On AI Agent Development with LangGraph/MCP

As large models have evolved, the boundaries of what Agents can do are being redefined by an architecture called Agent Skills. This tutorial series on Bilibili condenses into a single lesson a complete walkthrough of Agent Skills — from concept to definition, from progressive disclosure to the differences in multi-agent collaboration. One judgment is repeated throughout: mastering the Skills architecture may be more valuable than learning yet another framework.

What Are Agent Skills: Plugging a Skill Pack into Your Agent

The tutorial gives a direct definition: Agent Skills equals "an agent under the skills architecture." It is not a different kind of Agent, but rather an open standard that gives Agents pluggable professional capabilities. According to the instructor, Agent Skills was released as an open standard in mid-October 2025, pointing toward a new Agent development ecosystem — Agents gain different professional knowledge and tool-usage capabilities by loading different skill packs.

Put more plainly: Skills are expansion packs for a general-purpose Agent. A base Agent may only have common-sense-level processing ability, and will falter when faced with legal documents, poster design, or ticketing system operations. The traditional solutions are just two — either send your secretary to law school and enroll them in a Photoshop course (time-consuming and labor-intensive), or hire a specialist (higher cost). Skills offers a third path: package professional capabilities into plug-and-play plugins that can be mounted when needed and unmounted when done, without occupying resources.

This explains why the instructor calls Skills "a truly era-defining design" — it lets a single-responsibility Agent expand into infinite capability combinations at low cost, while remaining modular and highly flexible.

Open standard here refers to an interface specification that is not tied to any single vendor and can be followed by different Agent frameworks and platforms. Its value lies in interoperability: once a skill pack is written to the standard, it can be loaded by Claude, GPT, or any other Agent that supports the standard, without rewriting it for each platform. This contrasts with earlier plugin ecosystems — tool integrations in the past were often bound to specific frameworks, with high migration costs. Standardization also brings division of labor within the ecosystem: skill authors focus on packaging vertical-domain knowledge, while Agent developers focus on orchestration and scheduling, with both sides connecting through a unified interface. For developers, this means you don't have to bet on which framework will win, and the skill assets you invest in have a longer lifecycle.

What Problems Do Agent Skills Actually Solve?

The instructor repeatedly emphasizes one point throughout the course: Skills solves the contradiction between a single Agent capability and the demands of specialized tasks.

Large models themselves don't have operational knowledge in vertical domains like law, design, or ticketing, and prompt engineering can only fill in so much. Skills' approach is to package domain knowledge, workflows, scripts, reference materials, and templates into a structured folder — including a SKILL.md as metadata and policy description, supplemented by scripts and resource files. When executing tasks, the Agent calls the corresponding skill on demand, without needing to stuff all knowledge into the context at once.

This brings two direct benefits: first, capabilities are composable — the Agent is no longer a single-responsibility "narrow AI"; second, resources can be released — after the task is complete, the skill can be "unmounted" and doesn't continuously occupy the context window. For developers working on Agent projects, this means you don't have to train an all-purpose model from scratch but can cover business scenarios through skill orchestration.

Progressive Disclosure: The Core Mechanism of the Skills Architecture

The tutorial highlights "progressive disclosure" as a key topic. Progressive disclosure means that the Agent does not need to load the full content of all skills at startup; instead, it first exposes skill metadata (name, description, applicable scenarios), and only when it determines that a particular skill is needed does it load that skill's detailed instructions and resources layer by layer.

This mechanism directly addresses the reality of limited context windows in large models. If every skill stuffed its full documentation into the system prompt, the context would quickly fill up, and large amounts of irrelevant information would dilute the model's attention. Progressive disclosure lets the Agent first "know what skills are available," then "go deeper on demand" — essentially splitting skill retrieval and skill execution into two stages.

From an engineering perspective, this requires skill definitions to be clear enough: metadata is used for recall, while the body is used for execution, and the two must not be mixed together. The tutorial's "how to define the Skills list and call the Skills tool" is precisely the hands-on content built around this layering.

Context window is the upper limit on the total amount of information a large model can process in a single inference, usually measured in tokens. It is consumed by two parts: the input side — conversation history, system prompt, tool definitions — and the output side — generated content. Once the window approaches its limit, earlier information is truncated or compressed, causing the model to "forget" key instructions; even if it doesn't overflow, irrelevant content dilutes attention and reduces the weight of key information. This is the fundamental motivation behind Skills' use of progressive disclosure — changing skill knowledge from "resident in the system prompt" to "retrieved and injected on demand." You can think of it as virtual memory in an operating system: rather than loading all programs into physical memory, they are paged in, swapping in whichever page is needed.

Differences Between Skills and Multi-Agent

At the end of the course, two paths are compared: Multi-Agent and Skills Agent.

The Multi-Agent approach splits complex tasks across multiple dedicated Agents, each with its own role, tools, and prompts, coordinating communication between them through an orchestration layer. It excels at processes that require multi-role collaboration and clearly defined boundaries of division, but the architecture is highly complex, and communication costs and state management are both challenges.

Skills Agent, on the other hand, dynamically mounts skill packs onto the same Agent entity. The Agent itself remains unified, and capabilities are extended through Skills. The advantages of this model are that it is lightweight, flexible, and easy to reuse — once a skill pack is written, it can be loaded by different Agents. The drawback is that for subtasks that need to run independently for long periods with their own memory and goals, Skills' "unmount when done" is less suitable than a dedicated Agent.

The two are not substitutes but fit different scenarios: process-oriented, decomposable tasks suit Multi-Agent, while capability-oriented, reusable scenarios suit Skills. The instructor saves this part for last, hoping learners won't go astray when making architecture choices in real projects.

MCP (Model Context Protocol) is an open protocol proposed by Anthropic in late 2024 to standardize how large models connect to external tools and data sources. Before MCP, every tool integration required writing an adapter layer in a specific framework's format, resulting in tight coupling between tools and models. MCP abstracts these connections into a unified client-server protocol: a data source or tool implements an MCP Server, and the Agent acts as a Client that discovers and invokes its capabilities through the protocol. Its division of labor with Skills can be understood this way — Skills encapsulates "the domain knowledge and workflows for how to do a certain kind of task," while MCP handles "how to standardize the retrieval of external data and execution of external actions." Only when the two are combined can an Agent have both professional judgment and the ability to actually operate on the external world.

Hands-On Coding and Tech Stack

The hands-on portion of the tutorial covers everything from building an Agent foundation to defining Skills, calling tools, combining LangGraph for workflow orchestration, and extending tool capabilities through the MCP protocol. The logic behind this tech stack combination is: LangGraph handles stateful process control, MCP handles standardized tool integration, and Skills handles modular packaging of vertical capabilities. Together, the three form an extensible Agent development framework.

For developers new to large models, the tutorial suggests first understanding the directory structure and metadata specification of Skills, then writing a minimal usable skill pack, and finally connecting it to an Agent to get the call chain working end to end. This order — from definition to invocation — makes it easier to build overall understanding than diving straight into framework source code.

Key Takeaways

• Agent Skills is a modular capability extension mechanism under an open standard; Agents gain vertical-domain capabilities by loading skill packs
• Progressive disclosure lets skills load on demand, preventing context from being filled with irrelevant information
• Skills and Multi-Agent are two different ways of organizing capabilities, suited respectively to capability reuse and multi-role collaboration scenarios
• The hands-on tech stack involves LangGraph workflow orchestration and MCP tool integration
• The official documentation is the most complete starting point for learning the Skills specification, and is recommended as priority reading

One-line Summary

Agent Skills is an open-standard architecture that gives general-purpose Agents vertical capabilities through pluggable skill packs.

Paragraph Summary

The article introduces a tutorial series on the Agent Skills architecture. Released as an open standard in October 2025, Agent Skills essentially lets a base Agent gain vertical-domain capabilities in law, design, ticketing, and more by loading structured skill packs (containing SKILL.md metadata, scripts, and resources), enabling plug-and-play and unmount-when-done, and avoiding the need to train an all-purpose model from scratch. Its core mechanism is progressive disclosure: first exposing skill metadata for recall, then loading detailed instructions and resources on demand, thereby saving context window. The article also compares two paths — Skills Agent and Multi-Agent — the former lightweight and flexible, suited to capability reuse, the latter suited to multi-role collaboration and complex process decomposition, with the two being scenario fits rather than substitutes. The hands-on tech stack combines LangGraph workflow orchestration, MCP tool integration, and Skills capability packaging.