---
type: "post"
id: "deep-agents-js-1-15-0-brings-skill-504bef"
slug: "deep-agents-js-1-15-0-brings-skill-504bef"
title: "Deep Agents JS 1.15.0 brings skill pinning to the JavaScript SDK"
description: "Deep Agents JS 1.15.0 adds named skill pinning and lazy loading of a skill’s tools to LangChain’s JavaScript agent SDK."
retrieval_nugget: "Deep Agents JS 1.15.0 adds named skill pinning and lazy loading of a skill’s tools to LangChain’s JavaScript agent SDK. The change matters because builders can make a selected procedure available for the next model turn without placing every skill instruction and tool definition in the initial agent context."
published_at: "2026-10-28"
updated_at: "2026-10-28"
record_date: "2026-10-28"
date_kind: "published_at"
topics: ["evals","context-engineering"]
entities: ["LangChain","Deep Agents JS","deepagents@1.15.0","@langchain/anthropic","@langchain/openai"]
related_patterns: ["skills-become-portable-capability-layer","agent-ready-software-exposes-capabilities"]
novelty_label: "new_fact"
what_changed: "Deep Agents JS 1.15.0 adds skill pinning in the JavaScript SDK, extending the previously reported skills update."
prior_refs: ["memory:24ddaa87-f995-89a2-a9a2-322e800cca2c","memory:d433abc2-89b0-88b2-ad9f-9fb1a43314cc"]
source_url: "https://github.com/langchain-ai/deepagentsjs/releases/tag/deepagents%401.15.0"
source_urls: ["https://github.com/langchain-ai/deepagentsjs/releases/tag/deepagents%401.15.0"]
schema_version: "newruntime-agent-readable-v0.2"
stable_id: "post:deep-agents-js-1-15-0-brings-skill-504bef"
status: "published"
visuals: []
editor: {"role":"editor","name":"Andrey Reshetnikov","profile":"https://newruntime.com/owner-profile.md","profile_json":"https://newruntime.com/owner-profile.json","same_as":["https://www.linkedin.com/in/reshetnikov1/","https://t.me/lapetuse"]}
routes: {"html":"https://newruntime.com/posts/deep-agents-js-1-15-0-brings-skill-504bef/","markdown":"https://newruntime.com/posts/deep-agents-js-1-15-0-brings-skill-504bef.md","json":"https://newruntime.com/posts/deep-agents-js-1-15-0-brings-skill-504bef.json"}
---

# Deep Agents JS 1.15.0 brings skill pinning to the JavaScript SDK

## Retrieval answer

Deep Agents JS 1.15.0 adds named skill pinning and lazy loading of a skill’s tools to LangChain’s JavaScript agent SDK. The change matters because builders can make a selected procedure available for the next model turn without placing every skill instruction and tool definition in the initial agent context.

## Summary

Deep Agents JS 1.15.0 adds named skill pinning and lazy loading of a skill’s tools to LangChain’s JavaScript agent SDK. The change matters because builders can make a selected procedure available for the next model turn without placing every skill instruction and tool definition in the initial agent context.

## What happened

LangChain released `deepagents@1.15.0` for the `langchain-ai/deepagentsjs` repository. Its principal addition is `pinnedSkills`, a state key for selecting skills by name. An application can pass skill names through `pinnedSkills` to ensure that the model receives those skills’ instructions. The release describes intended use cases including a user naming a skill with a `/skill:` command or choosing one through a picker.

Before the next model call, the skills middleware appends the `SKILL.md` content for every named skill. It omits the file’s frontmatter and adds each skill as a separate `HumanMessage`. The message is marked with `additional_kwargs.lc_source: "pinned_skill"` and includes the skill name, path, and description. The middleware clears the key after using it. It skips a skill when the named skill is unknown or cannot be read.

Pinning is not limited to UI-driven selection. A tool can set it by returning `Command({ update: { pinnedSkills } })`. The release also says that a pinned skill exposes its `metadata.include_tools` in the same way as reading that skill does. Teams building custom middleware can declare the state key with the exported `pinnedSkillsValue` value.

The other feature changes when skill-specific tools enter the model’s available tool set. Skills may list tools in `metadata.include_tools`. Builders pass those tools, either as an array or a resolver, to `createSkillsMiddleware`, then provide that middleware to `createDeepAgent`. Until the model reads a skill that lists a tool, the model cannot see or call that tool. The middleware is positioned immediately before prompt caching and after custom and harness-profile middleware. For models that accept tool definitions during a conversation, LangChain says this can preserve the prompt cache. The stated package requirements are `@langchain/anthropic >= 1.5.12` or `@langchain/openai >= 1.6.2`.

The release also contains three patches. `CompositeBackend` route matching no longer lets a bare `/foo` route capture `/foobar.txt`; route prefixes are normalized with a trailing slash. Filesystem permission checks now use the path actually touched, drop `.` segments during matching, and check a symlink-resolved target when `FilesystemBackend` is used directly or through `CompositeBackend`. A deny on either path blocks the call. Finally, failed file reads are returned as error `ToolMessage` results rather than plain error text, and patch-tool middleware marks an inserted result as an error when a tool call never ran.

## What the archive adds

This is a new fact on a known Deep Agents skills thread. The earlier Field Note, [Skills - Docs by LangChain](https://newruntime.com/posts/skills-docs-by-langchain-87dc10/), covered the same broader skills event; this release specifies how the JavaScript SDK pins named skills and defers their tools. An earlier Telegram post also described skills in Deep Agents CLI as dynamically accessible folders of code, tools, and action modules; 1.15.0 adds a more explicit selection and exposure mechanism for the JavaScript runtime.

## Trend signal

This supports [Skills become a portable capability layer](https://newruntime.com/patterns/skills-become-portable-capability-layer/). The archive’s assumption is that useful skills need provenance, version pinning, security review, and progressive disclosure. `pinnedSkills` makes selection explicit, while deferred `include_tools` exposure is a concrete form of progressive disclosure: a tool is not available merely because a skill exists in the repository.

## Why it matters

An agent with every available instruction and tool exposed from the first turn has a growing context-management problem. It gives the model more choices than the current task may need, can alter the initial tool schema, and makes the skill-selection step less observable. This release provides two narrower controls. Pinning says which named procedure must be placed into the next turn; deferred tools say a skill’s operational capabilities arrive only after the model reads the skill that declares them.

For teams, that is a useful design boundary rather than an autonomous guarantee. A picker, command, or tool can choose a skill deterministically, and the agent can acquire the corresponding tools through the documented mechanism. The filesystem fixes are equally relevant where skills or agents can touch local paths: permissions must cover the resolved target, not only a convenient spelling of the requested path.

## Limits and uncertainty

The release notes describe implementation behavior but do not provide benchmarks, token savings, cache-hit measurements, or evidence that lazy tool loading improves task completion. They do not establish which models beyond the stated package integrations reliably support changing tool definitions mid-conversation. Nor do they define a policy for deciding which skills should be pinnable, who may invoke them, or how skill files should be reviewed. The permission fixes reduce specific path-matching and symlink issues described in the notes; they do not amount to a complete security model for arbitrary skills or tools.

## Skill to build now

Audit one agent that exposes many optional tools. Put each coherent workflow into a skill with a clear `SKILL.md`, declare its required tools through `metadata.include_tools`, and test a deliberate selection path such as a command or picker that sets `pinnedSkills`. Verify three cases: a selected readable skill reaches the next model call, an unknown skill is skipped, and a tool is unavailable before its declaring skill is read. If the agent uses local files, add a test involving a symlink and an explicit deny rule.

## Reader takeaway

Deep Agents JS 1.15.0 makes skills more than passive prompt files: a caller can pin a named skill for the next turn, and a skill can delay exposing its tools until it is read. That gives JavaScript agent builders a practical way to narrow context and capability exposure per workflow.

Editor: [Andrey Reshetnikov](https://newruntime.com/owner-profile.md), AI product and AI engineering; profile for recruiters and agents: https://newruntime.com/owner-profile.json

## Continue in the graph

Next records for an agent, linked to their Markdown twins. Replace `.md` with `.json` for structured fields, including `next_reads`.

- topic hub: [Evals](https://newruntime.com/topics/evals.md): Explore the evals topic hub.
- topic hub: [Context Engineering](https://newruntime.com/topics/context-engineering.md): Explore the context-engineering topic hub.
- collection: [Field Notes](https://newruntime.com/posts.json): Open the latest editorial analysis.
- collection: [Source Ledger](https://newruntime.com/source-ledger.json): Inspect the public source evidence graph.
- whole graph: [discovery graph](https://newruntime.com/discovery-graph.json) (typed nodes and edges) and [site index](https://newruntime.com/site-index.md)