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.
The layers are visible in a compiled agent. create_agent returns a CompiledStateGraph from langgraph.graph.state, with the nodes model and tools:
[
"__start__",
"model",
"tools",
"__end__"
]
…
type langgraph.graph.state.CompiledStateGraphlangsmith 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, andToolMessage, 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_agentbuilds 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:
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.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 says | Our result | Section |
|---|---|---|
| LangChain v1 is a focused foundation for agents, ready for production | We 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 5xx | Not 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 defaults | Confirmed: 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 steps | Confirmed 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 10011 | Not 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 themselves | Only 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 on | Holds 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 checkpoints | Confirmed. 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 line | Confirmed in the kit: the code before interrupt() ran twice. | 6.4 |
| A replay runs the nodes again and does not read them from a cache | Confirmed 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 call | Holds 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 10 | Not 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 once | Coming 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 types | Coming in the next edition, for the same reason. | 8.8 |
| A run on an interrupted worker resumes from its last checkpoint | Coming in the next edition, for the same reason. | 8.8 |
| Redis keeps no user or run data | Coming 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 checkpointing | Built 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