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, 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. 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.