LangChain vs LangGraph vs Deep Agents: which one do you need?

In this guide

• The three layers at a glance
• What is LangChain?
• What is LangGraph?
• What is Deep Agents?
• Is LangChain built on top of LangGraph?
• Which is better, LangChain or LangGraph?
• Where LangSmith fits
• Which do you need?
• One WhatsApp message through all three layers
• Common mistakes
• How Olano helps

What is LangChain?

LangChain is the framework you build an agent with: a common interface to chat models from Anthropic, OpenAI, Google, Mistral, local Ollama servers and many more, tools the model can call, and create_agent, which runs the model-calls-tools loop until the job is done. LangChain's documentation describes create_agent as "a minimal, highly configurable harness". A complete agent on LangChain 1.4:

from langchain.agents import create_agent

def order_status(order_id: str) -> str:
    """Look up the delivery status of an order."""
    return f"Order {order_id} is out for delivery."

agent = create_agent(
    "anthropic:claude-sonnet-4-6",
    tools=[order_status],
    system_prompt="You answer questions about orders.",
)
agent.invoke({"messages": [{"role": "user", "content": "Where is order 4711?"}]})

Change the model string to openai:... or ollama:... and the same agent runs on another provider: that independence is most of what the framework layer is for.

What is LangGraph?

LangGraph is "a low-level orchestration framework and runtime for building, managing, and deploying long-running, stateful agents", in its own documentation's words. A run is a graph of nodes that update a shared state, and the runtime adds three things production needs: every step is saved to a checkpoint keyed by thread, so a run survives a restart; output streams as it happens; and a run can stop at an interrupt and wait, for minutes or days, until a person decides. Its strength is mixing plain code with model calls. Here one Python node routes a message and the checkpointer keeps the thread:

from langgraph.graph import StateGraph, MessagesState, START, END
from langgraph.checkpoint.memory import InMemorySaver

def route(state: MessagesState):
    text = state["messages"][-1].content.lower()
    team = "billing" if "refund" in text else "support"
    return {"messages": [{"role": "ai", "content": f"Routed to {team}."}]}

builder = StateGraph(MessagesState)
builder.add_node(route)
builder.add_edge(START, "route")
builder.add_edge("route", END)
graph = builder.compile(checkpointer=InMemorySaver())

graph.invoke({"messages": [{"role": "user", "content": "I want a refund"}]},
             {"configurable": {"thread_id": "customer-4711"}})

InMemorySaver forgets everything when the process restarts; production needs a database-backed saver, covered in our guide to debugging LangGraph checkpointers.

What is Deep Agents?

Deep Agents is an agent harness: the same tool-calling loop as create_agent, with the equipment for long jobs attached. Its package description puts the stack plainly: "LangGraph is the graph runtime. LangChain's create_agent is a minimal agent harness on top of it. Deep Agents is a more opinionated harness on top of create_agent." In version 0.7 a new deep agent gets file tools (ls, read_file, write_file, edit_file, delete, glob, grep), a task tool that hands work to subagents, and summarisation as the conversation nears the model's context window. An execute tool appears when the backend can run commands; skills, memory files and approval interrupts switch on when you pass them.

from deepagents import create_deep_agent
from langchain.agents.middleware import TodoListMiddleware

agent = create_deep_agent(
    model="anthropic:claude-sonnet-4-6",
    tools=[order_status],
    system_prompt="You resolve order problems end to end.",
    middleware=[TodoListMiddleware()],  # planning is opt-in since 0.7
)

Note the last line: since Deep Agents 0.7 the write_todos planning tool is no longer in the default stack, so tutorials written for earlier versions describe an agent that plans by default. The rest of what the harness does, and leaves to you, is in LangChain Deep Agents in production.

Is LangChain built on top of LangGraph?

Yes, since LangChain 1.0 (October 2025). create_agent returns a compiled LangGraph graph, so a LangChain agent takes a LangGraph checkpointer, streams in LangGraph's modes and stops at LangGraph interrupts. Deep Agents calls create_agent in turn: LangGraph runs it, LangChain shapes the agent, Deep Agents equips it. LangChain's comparison page adds that you do not need to know LangGraph to use LangChain. One trap in older tutorials: LangGraph's prebuilt create_react_agent is deprecated since LangGraph 1.0, and its warning points to from langchain.agents import create_agent.

Which is better, LangChain or LangGraph?

Neither, because they do different jobs and you use LangGraph either way. LangChain is better when the job is one agent calling tools: less code, the standard loop, ready middleware. LangGraph is better when you need control over the order of steps, such as a workflow that must always validate before it posts. LangChain's documentation suggests Deep Agents for a batteries-included agent, create_agent for a customisable harness, and LangGraph for "advanced needs combining deterministic and agentic workflows".

Where LangSmith fits

LangSmith is not a fourth library. It is LangChain's platform for tracing, evaluation, prompts and deployment, and it works with agents built on any of the three layers. Tracing is switched on with environment variables and sends each run, full conversation included, to LangSmith; LangSmith Deployment hosts an agent as a managed service, in LangChain's cloud or your own infrastructure. The libraries run without either. Olano does not switch LangSmith on, so conversations stay inside the customer's deployment; our guide to debugging LangChain agents covers traces and local alternatives.

The pattern generalises: LangGraph owns state and time, LangChain owns talking to the model, Deep Agents owns how the agent works through a job, and everything touching the outside world sits outside all three.

Common mistakes

• Hand-building the agent loop in LangGraph. "Call the model, run its tools, repeat" already exists as create_agent, and it is still a LangGraph graph. Write raw LangGraph for the parts that are not that loop.
• Using Deep Agents when one tool-calling agent is enough. The harness adds file tools, a subagent tool and their instructions to every request: worth it for a long job, overhead for a lookup bot.
• Forgetting the checkpointer, or using the in-memory one in production. Without one, each call starts from nothing and an approval has nothing to resume from. With InMemorySaver, the next deploy erases every thread.
• Assuming a deep agent writes to disk. The default backend keeps files in the thread's state, invisible to other threads, and there is no shell until the backend can run commands.
• Copying a tutorial from another version. Planning became opt-in in Deep Agents 0.7; create_react_agent gave way to create_agent at 1.0.
• Treating LangSmith as part of the library. It is optional, and switching tracing on sends full conversations out of your environment. Decide that deliberately with customer data.

How Olano helps

Olano runs all three layers for you. Every Olano agent is a LangChain agent: LangChain for the models, LangGraph for durable, resumable runs, Deep Agents for planning, files and subagents. We add what the libraries leave out: managed model tiers or your own keys per agent, encrypted checkpoints in production storage, an isolated container for each agent's tools on managed deployments, 15+ messaging channels, an Approvals inbox whose riskiest rules hold even in automatic modes, a per-agent credential vault, and schedules and Cortex for unattended work. See how Olano is built on LangChain and the Olano platform.

The limit: Olano agents are configured in a dashboard or by chat, not programmed in Python against these libraries. If the agent code is your product, build on the libraries directly.