1.1

LangChain, LangGraph, LangSmith, and Deep Agents

LangChain builds the agent, LangGraph runs it as a graph with checkpoints, LangSmith records it, and Deep Agents adds a harness, each in packages with their own versions.

You search for how to build an agent with LangChain and find four product names, three install commands, and code from four years. One answer imports AgentExecutor, another create_react_agent, a third create_deep_agent. All three names still exist at the pin. Only create_react_agent is deprecated, and AgentExecutor lives on in langchain-classic.

When you finish this section, you can say what each of the four projects does and which package holds it. You can also set each headline claim of the project beside what our runs showed, and find the section that proves it.

Four projects, four version numbers

The documentation describes the stack in four lines, one for each project:

  • Deep Agents is a harness that adds planning, subagents, file tools, and context management on top of LangGraph.
  • LangChain is the framework, with the interfaces and integrations for models, tools, and the agent loop.
  • LangGraph is the runtime that gives durable execution, streaming, human review, and persistence.
  • LangSmith is the platform for traces, evaluations, prompts, and deployments, for any framework.

LangChain: the agent framework, in the packages langchain and langchain-core. langchain holds create_agent, the middleware, and init_chat_model. langchain-core holds messages, tools, the base chat model, and the fake models.

LangGraph: the runtime that runs an agent as a graph of nodes, in the package langgraph. It holds StateGraph, the loop that runs it, checkpoints, interrupts, and streaming.

LangSmith: the hosted platform for traces, evaluations, prompts, and deployments, and its client package langsmith. Agent Server, the server that runs a graph behind an HTTP API, belongs to LangSmith.

Deep Agents: a harness built on create_agent, in the package deepagents. It adds file tools, subagents, and summarization to an agent.

The four sets of packages do not share version numbers. At the pin, langchain is 1.5.0, langchain-core is 1.8.0, langgraph is 1.2.22, deepagents is 0.7.38, and langsmith is 0.14.17. A sentence that says "LangChain 1.5" without a package name is ambiguous, because langchain-core had its own, earlier 1.5.0 release, by the release history on PyPI. Figure 1.1 shows which package each layer is in.

Fig. 1.1the four projects and their packages at the pinlayers
The four projects and their packages at the pin Six bands stacked from top to bottom, each one project with its package and version from the pin: Deep Agents in deepagents 0.7.38 drawn dashed because it is optional, LangChain in langchain 1.5.0, LangGraph in langgraph 1.2.22, the provider packages such as langchain-openai 1.8.0, LangChain core in langchain-core 1.8.0, and Python 3.13 with pydantic 2.14.3. Inside the LangGraph band is the graph that create_agent returned, a CompiledStateGraph with the nodes __start__, model, tools, __end__. Four numbered arrows: create_deep_agent calls create_agent, create_agent returns that graph, the model node calls a chat model class from a provider package, and that class subclasses BaseChatModel in core. At the side, LangSmith 0.14.17 is olive. A dashed olive arrow from core says that a traced agent turn sent 7 POST /runs and 7 PATCH requests, and that tracing stays off until you turn it on. EACH LAYER IMPORTS THE ONES BELOW IT Deep Agents deepagents 0.7.38 create_deep_agent optional LangChain langchain 1.5.0 create_agent(model, tools) middleware init_chat_model LangGraph langgraph 1.2.22, checkpoint 4.3.2 a CompiledStateGraph dashed amber: a conditional edge __start__ model tools __end__ provider packages langchain-openai 1.8.0 ChatAnthropic ChatOpenAI ChatOllama langchain-ollama 1.1.0 LangChain core langchain-core 1.8.0 messages BaseChatModel BaseTool callbacks Python 3.13 pydantic 2.14.3, langchain-protocol 0.0.21 The kit runs this Python. The packages need 3.11 or later. 1 2 3 model.invoke 4 subclasses LangSmith langsmith 0.14.17 the client: traceable, tracing_context, evaluate the platform: traces, datasets, Agent Server POST /runs 7, PATCH 7 for one traced turn. Tracing is off until you turn it on. Numbers: 1 calls, 2 returns the graph, 3 calls the model class, 4 that class subclasses the core class.
An agent from create_agent is a LangGraph graph, so every LangChain agent depends on LangGraph, and LangSmith sits beside the stack. Each band is one project, with its packages and versions at the pin. Read from the top down: each layer imports the one below it. LangSmith sits at the side because langchain-core imports its client, and tracing stays off until you turn it on. The numbered arrows follow one call through the layers.

The layers are visible in a compiled agent. create_agent returns a CompiledStateGraph from langgraph.graph.state, with the nodes model and tools:

outputthe type and the nodes of an agentFull log
[
  "__start__",
  "model",
  "tools",
  "__end__"
]
…
type langgraph.graph.state.CompiledStateGraph
Cut to the node list and the type line. The edges, the Mermaid text, and the config are cut.

langsmith is a dependency of langchain-core, so it is installed with every agent. An agent sends nothing until an environment variable turns tracing on. Two parts of langsmith send without that variable: evaluate and the pytest plugin, as section 7.7 shows. The capture kit sets LANGSMITH_TRACING=false, and a LangSmith run tree is built only in memory.

What the stack standardizes

LangChain gives you five things with fixed names and shapes.

  • One message format. SystemMessage, HumanMessage, AIMessage, and ToolMessage, with standard content blocks across providers. Section 3.3 shows them.
  • One tool interface. A function with type hints becomes a tool with a JSON schema. Section 3.4 shows the schema the model sees.
  • One agent loop. create_agent builds a graph that calls the model, runs the tools it asks for, and stops when the model asks for none. Section 1.3 follows one run.
  • One checkpoint interface. A checkpointer saves the state of the graph after each step, in memory, in SQLite, or in Postgres.
  • One set of stream modes. updates, values, messages, custom, and four more name what a stream yields at each step.

What it leaves to you

The model and its package

LangChain calls no model by itself. You install a provider package, such as langchain-openai or langchain-ollama, and pass a model or a model string. Each provider package has its own version and its own retry defaults. Section 3.2 counts the retries of one of them.

Persistence

An agent keeps no conversation unless you pass a checkpointer. The release notes for v1 say that conversations persist across sessions by themselves, through built-in checkpoints. The agents page says that a thread keeps its history only with a checkpointer, which you pass yourself when you run locally. The code agrees with the agents page: the checkpointer parameter of create_agent defaults to None. On Agent Server, the server provides the checkpointer.

Side effects that run twice

A checkpointer makes a run resumable. It does not make a tool call happen once. A tool that ran before a crash can run again on the resume, and the tool must make that safe.

We measured this on the Mac with a three-node graph whose middle node appends one line to a file. We set a kill at five points, for three durability modes and two savers, five times in each cell. In 10 of the 150 trials the kill point never came. In 80 of 150 trials the line was written twice. With an idempotency key in the node, it was written twice in 0 of 150. Raw runs

We measured the same five points on the x86 server guest, on a create_agent agent with Qwen3 4B whose tool inserts a charge into PostgreSQL. With no key, 331 of 560 killed trials charged the order twice. With a key on the thread and the order id, 0 of 140 did. Section 5.3 shows each cell, and section 2.3 shows the code path. Raw runs

Retries

Two layers retry a failed model call: the client of the provider package, and ModelRetryMiddleware. They multiply. Section 3.2 shows 9 attempts through a relay in front of Ollama for one model call with both layers at their defaults. ChatOllama made 1 attempt with no middleware.

The server

Agent Server, which runs a graph behind an HTTP API with a task queue, is part of LangSmith. langgraph dev runs it in memory on your machine with no key. The full stack under langgraph up, with Postgres and Redis, refused to start for us without a LangSmith API key or a license key:

outputthe API container under langgraph up, with no keyFull log
ValueError: License verification failed. Please ensure proper configuration:
- For local development, set a valid LANGSMITH_API_KEY for an account with LangGraph Cloud access in the environment defined in your langgraph.json file.
The first two lines of the error.

What the project says, and what we measured

The project makes short statements in its documentation and on its product pages. Most have no conditions. The table sets each statement beside our result.

We measured every result in this table on the Mac or on the x86 server guest, or recorded it with the capture kit. Each row names its machine and the count. The two machines differ, so do not compare a number from one row with a number from another. Raw runs

The project saysOur resultSection
LangChain v1 is a focused foundation for agents, ready for productionWe tested behaviour, not this phrase. One rule of its own release policy did not hold: langchain 1.5.0, a minor release, raised the Python floor to 3.11.3.1
Chat models retry a failed call up to 6 times for network errors, 429, and 5xxNot at the pin for ChatOpenAI from langchain-openai 1.8.0: 3 attempts through a relay in front of Ollama, then an error. ChatOllama: 1. The x86 server guest, 3 runs for each of a dropped connection, a refused port, and a timeout.3.2
ModelRetryMiddleware makes 3 attempts in total with its defaultsConfirmed: 3 attempts with the client retries off. With the client default left on, the layers made 9 attempts. The x86 server guest, 3 runs each.3.2
From langgraph 1.1.4, the default recursion limit is 10,007 stepsConfirmed for a StateGraph: the kit stops at 10007. create_agent sets its own limit of 9999. A Qwen3 4B agent made 121 model calls without stopping, until the script stopped it at 1200 s, in one run on the x86 server guest.1.3
The default recursion limit of Agent Server is 10011Not seen. Under langgraph dev, a looping graph stopped at 10007 steps, in one run on the x86 server guest.8.1
Conversations persist across sessions by themselvesOnly with a checkpointer that you pass. The default of create_agent is no checkpointer, as the agents page says.1.3
With durability="sync", LangGraph writes each checkpoint before the run goes onHolds at the step boundary only. With no key, a kill after the tool step repeated the charge in 0 of 40 agent trials. A kill after the tool returned and before its writes were saved repeated it in 24 of 40. Qwen3 4B, the x86 server guest.5.3
With durability="async", a crash has a small chance to lose checkpointsConfirmed. With no key, a kill after the tool step repeated the charge in 38 of 40 agent trials. Qwen3 4B, the x86 server guest.5.3
On a resume, the node that called interrupt() runs again from its first lineConfirmed in the kit: the code before interrupt() ran twice.6.4
A replay runs the nodes again and does not read them from a cacheConfirmed in the kit: a replay from the checkpoint before the tool ran the tool again.6.6
Structured output comes from the main loop, with no extra model callHolds on Claude, and fails on Ollama when the agent has tools. On Qwen3 4B with lookup tools, ToolStrategy returned no object in 39 of 39 tasks, and ProviderStrategy raised in 10 of 10. One extra extraction call worked on both providers. The Mac and the Anthropic API.4.3
A queue worker runs up to N_JOBS_PER_WORKER runs at one time, and the default is 10Not under langgraph dev, whose default is 1. 20 background runs of 2 s took 41.0 s with 1 run at a time, and 5.1 s with the setting at 10. With Qwen3 4B on CPU, 10 background agent runs took 47.1 s with 1 job and 44.4 s with 10, because the model served one call at a time. The x86 server guest, one run each.8.1
The Postgres task queue of Agent Server runs each task exactly onceComing in the next edition. The full server needs a license key. Our runs of the library alone showed no exactly-once side effect: 80 of 150 trials wrote twice, and 10 of them were never killed.8.8
Agent Server recovers from short Redis or Postgres outages on both deployment typesComing in the next edition, for the same reason.8.8
A run on an interrupted worker resumes from its last checkpointComing in the next edition, for the same reason.8.8
Redis keeps no user or run dataComing in the next edition, for the same reason.8.8
The LangChain product page says that LangChain runs on a durable runtime with built-in persistence and checkpointingBuilt in only when you pass a checkpointer, as above.1.3

Five statements match our runs as written. Four hold only under a condition that the page does not state: a checkpointer that you pass, the point of the crash, or the provider. Four did not match at the pin. They are the retry count, the server recursion limit, the jobs default, and the Python rule of the release policy. Four need the full Agent Server, and section 8.8 lists them with the runs planned for the next edition.

Three of these results change how you build. Count the retries of your own provider package. Make each side effect safe to repeat. Test structured output on your own provider with tools bound.

When this is the wrong tool

LangChain fits an agent that calls tools in a loop and needs to pause, stream, or resume. It costs some Python time on each model call, and disk space.

We measured both on the Mac. On a real Qwen3 4B run of three model calls, create_agent added 15.6 ms to a run of 1.8 s. That is about 5 ms per call, from 40 shuffled runs. A fresh install of langchain with langchain-openai held 44 packages in 54,312 KiB, and openai alone held 14 packages in 26,356 KiB. Section 3.1 has the install and the import times. Raw runs

If your program makes one model call with no tools and no state, the provider SDK alone does the same job with less code.

LangChain (Python): langchain, langchain-core, langgraph, deepagents, langsmith 1.5.0 · c2f4036 · 2026-11-11 · Edition 2026.11