LangChain Skills

LangChain Skills is the official Agent Skills pack from LangChain, giving AI coding agents current, first-party guidance for building with LangChain, LangGraph, and Deep Agents — 22 skills covering framework selection, agent construction, RAG, state persistence, human-in-the-loop approval, deployment, and evaluation, in both Python and TypeScript.

What are LangChain, LangGraph, and Deep Agents?

LangChain maintains three layered open-source tools, and the pack's ecosystem-primer skill exists specifically to help an agent pick between them:

• LangChain (bottom layer, the framework) — provider-agnostic abstractions for models, tools, and the agent loop. The easiest starting point.
• LangGraph (middle layer, the runtime) — low-level orchestration for durable execution, custom control flow, and stateful workflows. LangChain agents run on top of it.
• Deep Agents (top layer, the harness) — a batteries-included toolkit on LangChain plus LangGraph, shipping planning, file management, subagent spawning, and memory by default.
• LangSmith (cross-cutting) — observability and evaluation, framework-agnostic.

Higher layers depend on lower ones, but you do not use the lower ones directly — Deep Agents gives you durable execution without writing graph code.

What the 22 skills cover

• Getting started — ecosystem-primer (invoke first: framework selection, environment setup, and which skill to load next) and langchain-dependencies (package versions and dependency management for Python and TypeScript).
• Quickstarts — six thin wrappers around the official docs quickstarts: langchain-python-quickstart and langchain-typescript-quickstart (weather), langgraph-python-quickstart and langgraph-typescript-quickstart (math), and deepagents-python-quickstart and deepagents-typescript-quickstart (research).
• LangChain — langchain-fundamentals (agents via create_agent(), the @tool decorator, structured output, middleware basics), langchain-middleware (human-in-the-loop approval, custom middleware, Command resume patterns), and langchain-rag (document loaders, RecursiveCharacterTextSplitter, embeddings, and Chroma, FAISS, or Pinecone vector stores).
• LangGraph — langgraph-fundamentals (StateGraph, nodes, edges, state reducers, Command, Send, streaming), langgraph-persistence (checkpointers, thread_id, cross-thread memory), langgraph-human-in-the-loop (interrupts, review, approval workflows), and langgraph-cli (scaffold, dev, build, deploy, and langgraph.json config).
• Deep Agents — deep-agents-core (create_deep_agent(), harness architecture, SKILL.md format), deep-agents-memory (persistence and filesystem middleware), deep-agents-orchestration (subagents, task planning, human-in-the-loop), and managed-deep-agents (CLI deployment, SDKs, streaming runs, MCP tools, and React useStream UIs).
• Evaluation — eval-engineering, the largest skill in the pack, with references on discovery, task design, verifier design, calibration, synthetic data, world knowledge, multi-turn simulation, and a 37 KB patterns file, plus Harbor task templates and helper scripts. langsmith-online-eval-engineering covers building LangSmith online evaluators from traces.
• Utilities — swarm, which fans independent work items out to subagents in parallel and aggregates the results.

How it works

Each skill is a SKILL.md whose frontmatter tells the agent exactly when to load it — several are emphatic, such as "INVOKE THIS SKILL when writing ANY LangGraph code". The skills also correct outdated patterns directly: langchain-fundamentals states that agents must be built with create_agent() and that all other approaches are outdated, which is precisely the guidance a model trained on older LangChain content will not have.

Install with the skills CLI for any agent that supports the Agent Skills specification, or as a Claude Code plugin from the repository's own marketplace manifest.

Who it is for

Developers building LLM agents in Python or TypeScript with Claude Code, Cursor, Windsurf, Codex, or the Deep Agents CLI — particularly anyone who has watched an agent generate LangChain code from a deprecated API generation.

What you can build

Tool-calling agents with structured output, RAG pipelines over your own documents, stateful LangGraph workflows with checkpointing and cross-thread memory, approval gates that pause mid-run for a human, deployed LangGraph services, managed Deep Agents with streaming React UIs, and Harbor eval suites that measure whether any of it actually works.

Why it matters

LangChain's API surface has moved fast — create_agent() superseded earlier agent constructors, LangGraph became the runtime beneath it, and Deep Agents is newer than most training data. Models reproduce whichever generation they saw most, which is usually not the current one. These skills are maintained by LangChain itself, so the guidance an agent loads is first-party rather than reconstructed from old tutorials.

Note that the project describes itself as in early development, and its APIs and skill content may change.

Option 1 — skills CLI (works with any Agent Skills-compatible agent)

Install all skills into the current project:

npx skills add langchain-ai/langchain-skills --skill '*' --yes

Globally, for all projects:

npx skills add langchain-ai/langchain-skills --skill '*' --yes --global

Target a specific agent:

npx skills add langchain-ai/langchain-skills --agent claude-code --skill '*' --yes --global

Install just one skill:

npx skills add langchain-ai/langchain-skills --skill eval-engineering --yes

Option 2 — Claude Code plugin

/plugin marketplace add langchain-ai/langchain-skills
/plugin install langchain-skills@langchain-skills

Option 3 — Install script (Claude Code and Deep Agents CLI)

Clone the repository and run the bundled installer:

git clone https://github.com/langchain-ai/langchain-skills.git
cd langchain-skills

./install.sh                      # Claude Code, current directory
./install.sh ~/my-project         # Claude Code, specific project
./install.sh --global             # Claude Code, global
./install.sh --deepagents --global  # Deep Agents CLI, global, includes agent persona

Useful flags: --force to overwrite same-named skills, --yes to skip prompts.

Set your API keys

export OPENAI_API_KEY=<your-key>       # for OpenAI models
export ANTHROPIC_API_KEY=<your-key>    # for Anthropic models

Then run your coding agent from the install directory for a local install, or anywhere for a global one.

Eval engineering needs Harbor

The eval-engineering skill builds Harbor Tasks, so it needs Harbor running locally under Docker or in a supported cloud environment. See harborframework.com/docs.

Use it

Start with the primer, which the pack asks agents to invoke first:

Use the ecosystem-primer skill — should this project use LangChain, LangGraph, or Deep Agents?

Then work in plain language: "build a RAG pipeline over these PDFs with Chroma", or "add a human approval gate before the refund tool runs".