LangChain Revamps Skills in Deep Agents with Tool Binding and Pinning

Why LangChain changed skills

A skill is a folder of instructions, scripts and reference files that teaches an agent how to do a task, such as prepping for a customer meeting or reviewing call transcripts. At its core, LangChain says, a skill is a markdown file. Agent Skills are an open standard that works with any model and is supported by dozens of agent products, according to the company.

Skills rely on progressive disclosure. The agent sees only each skill's name and description up front and reads the full instructions when a task needs them. This keeps context small. LangChain says it is seeing enterprise skill registries grow to thousands of skills, shared across teams and agents, and that this growth changes what teams need.

The post uses LangChain's own GTM agent as an example. It is built on Deep Agents and has a library of more than 50 skills covering a sales rep's recurring work, including meeting-prep, call-transcripts and competitive-intel-card.

Binding tools to skills

Until now, skills and tools were disclosed separately. Tool schemas could be kept out of context with tool search, but nothing tied a tool to the skill that explains it. An agent could call a tool without reading its skill, or read the skill and still have to search for its tools.

Now a skill can have tools bound to it. A bound tool is not added to context until the agent reads its skill, and a call to it before then fails as an unknown tool. Tools are listed in the skill's frontmatter under metadata.include_tools and passed to SkillsMiddleware instead of the agent. In the GTM example, reading call-transcripts unlocks search_calls and get_transcript.

The tools arrive in a new system message, so the cached prefix above it stays unchanged. LangChain says Anthropic and OpenAI now let newer models accept tools mid-conversation. On those models, Deep Agents adds a skill's bound tools right after the skill is read without breaking the prompt cache. On other models, the tools are appended to the request as before.

For more control, a skill can list a label instead of tool names, and a function passed to SkillsMiddleware turns each label into tools. This allows a whole tool group, such as every tool on an MCP server, to be disclosed under one name. It also allows tools to be gated on runtime permissions. In LangChain's example, pipeline-forecast gets CRM tools, but only managers can update the forecast.

Pinned skills and mid-thread reloading

When a user already knows which skill they want, such as typing /meeting-prep for a call tomorrow, the model would normally see only the description and have to read the skill first. That adds a round trip and does not guarantee the right skill is loaded.

With pinned skills, the app finds skill names in the message, or parses them from a UI, and passes them in pinned_skills. The middleware then adds each skill's instructions to the conversation before the next model call. Deep Agents does not parse messages itself, so developers choose the syntax. According to LangChain, the agent starts work on model call 1 instead of model call 2, which cuts latency and makes behavior more predictable. Each pinned skill is added once as a tagged message, so earlier messages never change, the prompt cache stays valid, and a chat UI can show the skill as a label instead of its full text.

Skills are loaded at the start of every thread and kept in agent state. Setting skills_metadata to None when invoking the agent now invalidates that list, so the next run rescans every source and picks up added skills. Because the reset is just run input, an app can offer a client-side /reload command. It can also reset from update_state or from middleware.

A reload that finds new skills changes the system prompt and invalidates the prompt cache. LangChain argues that for an idle thread this cost is usually already paid, since provider caches typically expire within minutes to an hour of inactivity.

What it means for teams

According to LangChain, the updates mean tools load only when a skill needs them, the skills a workflow needs load up front, and long-running threads stay current as a library changes. Because skills are an open standard, skills a team writes work across models and agents, the company says.

All of the features are available in the latest deepagents release. LangChain points developers to its skills docs and invites feedback via GitHub issues, the forum or X.