ecosystem-primer

LangChain offers three different tools for building AI agents, each stacked on the one below; this is the starting point that picks the right one for the job and says what to read next.

WHEN TO USE

SCOPE

USE FOR

Decide whether a new agent-building task calls for LangChain, LangGraph, or Deep Agents.
Turn on LangSmith tracing for a new project with the current environment variable names.
Combine two layers in one project, such as a Deep Agents orchestrator delegating to a LangGraph subagent.
Find the right documentation page or next skill to load for LangChain, LangGraph, or Deep Agents.

This is a saved copy of the skill's SKILL.md instructions. It may differ from the upstream file or the version you install.

In this document (6)

LangChain Inc. maintains three layered open-source tools for building agents, plus LangSmith for observability. The stack, top-down:

Deep Agents (top layer, harness) — batteries-included toolkit built on LangChain + LangGraph. Ships with planning, file management, subagent spawning, and memory out of the box.
LangGraph (middle layer, runtime) — low-level orchestration for durable execution, custom control flow, and stateful workflows. LangChain agents run on top of LangGraph.
LangChain (bottom layer, framework) — abstractions for models, tools, and the agent loop. Provider-agnostic, easiest to start with.
LangSmith (cross-cutting) — observability and evaluation platform. Framework-agnostic; always recommended alongside any of the above.

Higher layers depend on lower ones, but you don't need to use lower layers directly. Deep Agents gives you LangGraph's durable execution without writing graph code. LangChain gives you models and tools without managing graph edges.

Step 1 — Choose Your Tool

Evaluate these conditions in order and stop at the first match:

If the task needs planning, file management across a long session, persistent memory, subagent delegation, or on-demand skills → Deep Agents
Else, if the task needs custom control flow (deterministic loops, branching logic) → LangGraph
Else, if it's a single-purpose agent with a fixed set of tools → LangChain (create_agent function)
Else, if it's a pure model call, retrieval pipeline, or simple prompt chain with no agent loop → LangChain (direct model / chain)

This is your layer. BUT you are not done: later in Step 4, you MUST load the layer-specific skill before writing any agent code.

Tool Profiles

LangChain — agent framework

Best for:

Single-purpose agents with a fixed tool set
RAG pipelines and document Q&A
Model calls, prompt templates, structured output

Not ideal when:

The agent needs to plan across many steps or manage large context
Control flow is conditional, iterative, or parallel
State must persist across sessions

All LangChain agents use create_agent(model, tools=[...]).

LangGraph — agent runtime

Best for:

Custom control flow — deterministic loops, reflection cycles, parallel fan-out
Complex workflows combining deterministic and agentic steps
Human-in-the-loop with precise interrupt and resume points
State that must survive failures or span long sessions

Not ideal when:

You want planning, file management, and subagent delegation out of the box (use Deep Agents instead)
The workflow is simple enough for a straight tool loop

All LangGraph graphs use StateGraph(State) with explicit nodes, edges, and conditional edges.

Deep Agents — agent harness

Best for:

Long-running tasks that require planning and decomposition
Agents that read, write, and manage files across a session
Delegating subtasks to specialized subagents
Persistent memory across sessions
Loading domain-specific skills on demand

Not ideal when:

The task is simple enough for a single-purpose agent
You need precise hand-crafted control over every graph edge (use LangGraph directly)

All Deep Agents use create_deep_agent(model, tools=[...]).

Mixing Layers

The tools are layered, so they can be combined in the same project. Common patterns:

Deep Agents orchestrator → LangGraph subagent — when the main agent needs planning and memory but one subtask requires a deterministic graph.
LangGraph graph wrapped as a tool or subagent — when a specialized pipeline (e.g. RAG, reflection loop) is called by a broader agent.

A compiled LangGraph graph can be registered as a named subagent inside Deep Agents — the orchestrator delegates to it via the task tool without knowing its internal structure. LangChain tools and retrievers work freely inside both LangGraph nodes and Deep Agents tools.

Step 2 — Set Environment Variables

Always set these for observability. These are the current LangSmith env var names. Copy them as-is. OLDER NAMES NO LONGER WORK.

LANGSMITH_API_KEY=<your-key> LANGSMITH_TRACING=true LANGSMITH_PROJECT=<project-name>

Model-provider and tool-specific keys (ANTHROPIC_API_KEY, OPENAI_API_KEY, TAVILY_API_KEY, etc.) depend on your stack — set them as needed.

Step 3 — How the Docs Work

All documentation lives at docs.langchain.com, organized into two top-level sections:

OSS — LangChain, LangGraph, Deep Agents. Python (/oss/python/) and TypeScript (/oss/javascript/) trees in parallel.
LangSmith — observability, evaluation, deployment, prompt engineering.

Each product has its own page tree: overview → quickstart → how-to guides → reference.

Canonical landing pages

Start here rather than tree-searching from root (swap python → javascript for TypeScript):

LangChain — /oss/python/langchain/overview
LangGraph — /oss/python/langgraph/overview
Deep Agents — /oss/python/deepagents/overview
LangSmith — /langsmith/home (no language split)

Accessing docs in an agent context

If the LangChain Docs MCP server is connected (mcp__docs-langchain__* tools are available), query it directly:

tree /oss/python -L 2                        # explore Python structure
tree /oss/javascript -L 2                    # parallel TypeScript structure
cat /oss/python/langchain/quickstart.mdx     # read a specific page
rg -il "checkpointer" /oss/python/langgraph/ # search by keyword

If the MCP server is not available, use the llms.txt index:

Fetch https://docs.langchain.com/llms.txt — structured list of all pages with descriptions
Identify the 2–4 most relevant pages for the question
Fetch those pages directly for accurate, up-to-date content

Always prefer fetching live docs over relying on training-data knowledge — these libraries evolve fast and APIs change often.

Step 4 — Load the Right Skill Next

If the user only wants a minimal local working agent (new project, stub tool, provider key), load the matching quickstart first:

LangChain → langchain-python-quickstart or langchain-typescript-quickstart
LangGraph → langgraph-python-quickstart or langgraph-typescript-quickstart
Deep Agents → deepagents-python-quickstart or deepagents-typescript-quickstart

Otherwise load the skill below that matches your layer from Step 1. This is required — the layer-specific skill carries the current API; the primer alone does not.

LangChain

langchain-fundamentals — building any LangChain agent
langchain-rag — adding RAG / vector store retrieval
langchain-middleware — structured output with Pydantic
langchain-dependencies — package versions, installs, or dependency management questions

LangGraph

langgraph-fundamentals — any LangGraph graph
langgraph-human-in-the-loop — human-in-the-loop or approval workflows
langgraph-persistence — state that must survive restarts, or cross-thread memory

Deep Agents

Always load deep-agents-core first. Then, as needed:

deep-agents-orchestration — subagent delegation or orchestration
deep-agents-memory — cross-session persistent memory

This skill ships inside the LangChain Agent-Building Skills plugin.

Install just this skill

Run this outside your AI tool, using Node.js 22.20.0 or newer. Skills CLI 1.7.2 skips skill selection; prompts cancel installation without an interactive terminal. If choosing Project when asked about installation scope, open your project's folder before running this.

Install checklist

Check selected tools if a picker appears; Claude Code may be unchecked under Additional agents. ↑/↓ moves, Space toggles selections, Enter confirms.
Without a tool picker, check Installing to: for your intended tool. Stop if it names a different tool.
If asked, choose Symlink (Recommended) for shared files or Copy to all agents for separate copies; review the summary before confirming installation.
Install the find-skills skill? defaults to Yes, adding another skill for all projects. Choose No if you don't want that extra installation.

Skills CLI 1.7.2 sends install data to skills.sh by default, including the source, skill names, target tools and file details; GitHub sources are reported only when GitHub confirms the repository is public, while other remote sources can also be reported. Confirmed-public GitHub sources also trigger a security-audit request. Before installing, set the environment variable DO_NOT_TRACK=1 or DISABLE_TELEMETRY=1 to disable both.

npx skills add langchain-ai/langchain-skills --skill "ecosystem-primer" --full-depth

After installing for Claude Code, open it in the installation project if you chose Project; Global makes the skill available across projects on this computer. Once Claude Code loads the skill, its description helps Claude decide when to use it.

If installation created a top-level skills folder that did not exist when your Claude Code session started, run /reload-skills in that session. Run it again after later changes in that folder.

Install the whole plugin

This route installs the LangChain Agent-Building Skills plugin package selected for your AI tool.

Claude Code

Add LangChain's marketplace, then install the plugin

Type both lines inside a Claude Code session, not at your shell prompt. The first adds LangChain's marketplace, which is this repository; the second opens the details of the langchain-skills plugin, and Claude Code installs it once you pick one of the install options shown. Afterwards, LangChain's README asks you to set OPENAI_API_KEY or ANTHROPIC_API_KEY, for whichever of those model providers you build with.

/plugin marketplace add langchain-ai/langchain-skills

/plugin install langchain-skills@langchain-skills

Open plugin page ↗

View on GitHub

Step 1 — Choose Your Tool

Tool Profiles

LangChain — agent framework

LangGraph — agent runtime

Deep Agents — agent harness

Mixing Layers

Step 2 — Set Environment Variables

Step 3 — How the Docs Work

Canonical landing pages

Accessing docs in an agent context

Step 4 — Load the Right Skill Next

LangChain

LangGraph

Deep Agents

Account or credentials required

Install just this skill

Install the whole plugin

Add LangChain's marketplace, then install the plugin

More skills

deep-agents-core

deep-agents-memory

deep-agents-orchestration

deepagents-python-quickstart

deepagents-typescript-quickstart

eval-engineering