Agent Skills from Scratch

Summary

This tutorial explores the mechanics of AI agent skills using the open-source framework, LangChain Deep Agents. Unlike closed-source coding agents (such as Claude Code, Cursor CLI, or Manus) where the internal workings are hidden, the open-source nature of Deep Agents allows for a thorough examination of the underlying code.

The lesson is structured around three layers of abstraction to build a comprehensive understanding:

• Layer 0 (Usage): Focuses on practical application by learning to add and use skills via the Deep Agents CLI.

• Layer 1 (Tracing): Involves analyzing the agent's execution trace and LLM calls using the LangSmith observability platform to understand the execution flow.

• Layer 2 (Source Code): Delves directly into the Deep Agents source code to examine how mechanisms like progressive disclosure are actually programmed.

By progressing through these three layers, learners will acquire the knowledge necessary to use, analyze, and independently implement agent skills.

Summary

This tutorial demonstrates how to use the LangChain Deep Agents CLI to install and interact with external agent skills, representing the first layer of understanding agent capabilities. The process begins by installing the Deep Agents harness using the uv tool and configuring it with an Anthropic API key to enable communication with the LLM.

To illustrate how skills function in practice, the remotion-dev/skills package is installed globally via the npx skills command. Remotion is an open-source tool for programmatically creating videos using React. After confirming that the Deep Agents CLI successfully recognizes the newly installed skill, the agent is prompted to generate a video about "agent skills."

The workflow highlights the concept of dynamic disclosure: the agent automatically reads the relevant skill documentation, scaffolds a new project, writes the necessary TypeScript and React code, and renders the final video. By auto-approving the agent's actions, the tutorial showcases how easily an AI agent can be equipped with specialized capabilities to execute complex, real-world tasks seamlessly.

Summary

This tutorial focuses on analyzing the execution of AI agent skills using LangChain tracing. First, LangSmith is configured to monitor the Deep Agents CLI by generating an API key and exporting the necessary environment variables, enabling the system to trace every LLM call.

Once tracing is activated, the process of "progressive disclosure" is observed in LangSmith. When the agent session begins, a "before agent middleware" scans and discovers available skills—like the previously installed remotion-best-practices—loading only their metadata (name, description, and file location) to save context window space.

Before each LLM call, a separate "skills middleware" injects this metadata into the system prompt, alongside instructions telling the agent how to use skills. When prompted to "create a gif with Remotion," the LLM recognizes the relevant skill from its metadata and deliberately uses a read tool to open the specific skill.md file. This action expands the agent's context with specific instructions, allowing it to subsequently read more detailed markdown files (like those for animations or timings). The tutorial emphasizes that this dynamic disclosure pattern—where the agent decides when and what to read based on initial metadata—is a standard mechanism used across many advanced AI agents. The next step is to examine the source code implementing this behavior.

Summary

This tutorial delves into the core mechanics of AI agent skills, starting with a review of the standard agent loop. In a typical loop, an LLM call processes a question and decides whether to use a tool, executing it if necessary, before reasoning again to finalize an answer or use another tool.

The video then explains how the LangChain Deep Agents harness modifies this process with specific mechanisms:

1. Skill Discovery (Before Agent Middleware): When a session starts, all available skills are loaded into the agent's memory. This process identifies which skills are accessible, their names, and their locations, storing this information in the agent's state.

2. System Prompt Modification: A second middleware runs before every LLM call. It appends a "skill system's appendix" to the system prompt. This appendix provides the agent with information about all available skills, their locations, and instructions regarding progressive disclosure.

As a result, the agent processes each request with this enriched system prompt, allowing it to make informed decisions about whether to utilize a specific skill or a standard tool. The subsequent video will explore the code that implements this entire workflow.

Summary

This tutorial explores the source code of LangChain's Deep Agents to understand the underlying mechanics of its agent skill system, specifically focusing on a file named skills.py. The video breaks down the implementation into two main phases, mirroring the agent execution loop:

1. Skill Discovery (before_agent): At the beginning of a session, the harness runs a function that scans configured backends (like a local file system) to find available skills. It parses the metadata (such as names and file paths) from these skills, like the YAML frontmatter in a skill.md file, and stores this information in the agent's state. Crucially, it only loads the metadata, not the full contents of the skill files.

2. Context Injection (wrap_model_call & modify_request): Before every call to the Large Language Model (LLM), a middleware intercepts the request. It retrieves the stored skill metadata from the agent's state and uses a predefined template (SKILLS_SYSTEM_PROMPT) to inject instructions and the list of available skills directly into the LLM's system prompt.

The video highlights that the code primarily consists of straightforward file system traversal and parsing. The key design principle of this architecture is the separation of responsibilities: the agent harness acts merely as a provider, building an "index" of available skills via metadata, while the LLM is given the autonomy to decide which specific files to read and execute based on the user's request.