You searched "LangChain vs LangGraph vs Deep Agents" because three names showed up in three tutorials and nobody said which one you were supposed to install. The instinct is to treat it like a bracket: read the feature tables, pick a winner, write off the other two. That instinct is wrong here in a specific and useful way. There is no bracket. There is a ladder, and all three rungs are bolted to the same rail.

We covered the bottom two rungs before — LangChain vs LangGraph is a choice of altitude on one stack, not a fight between two products. Deep Agents is the rung above both, and it is the one most likely to be mistaken for a separate thing, because it has its own package name, its own repo, and its own marketing. So start with the claim that resolves the whole question:

Deep Agents adds no new runtime. It is a curated stack of the same middleware you'd otherwise pass to create_agent yourself, wired to a long system prompt. The "framework" is a preset.

The three rungs, bottom to top#

LangGraph is the runtime. You define State (a typed schema), Nodes (functions that read and write it), and Edges (which can branch and loop). It owns the unglamorous machinery — checkpointing, durable execution that survives a crash, streaming, interrupt-based human gates. Everything above it eventually executes here.

create_agent is LangChain 1.0's standard agent harness, and since the 1.0 releases it compiles down to and runs on LangGraph. You don't subclass it; you hand it a model, some tools, and a middleware array. The prebuilt middleware is the real surface: SummarizationMiddleware (summarize old turns when the context gets long), HumanInTheLoopMiddleware (pause for tool approval), ModelCallLimitMiddleware and ToolCallLimitMiddleware (budget caps), ModelFallbackMiddleware (retry on a backup model), PIIMiddleware (redact). These are the features middleware was designed to expose — the things that never show up in a demo and decide whether the thing survives production.

Deep Agents (pip install deepagents, v0.6.12 as of late June 2026) is, in LangChain's own words, "the batteries-included agent harness." It is built on create_agent. What it adds is opinion: a planning tool (the agent maintains a write_todos list so it doesn't lose the thread on a twenty-step task), a pluggable filesystem (local, sandboxed, or remote backends the agent can read and write), sub-agents with isolated context windows so a research detour doesn't pollute the main conversation, summarization on by default, persistent memory across sessions, and approval gates — all behind a deliberately long default system prompt tuned for long-horizon autonomy.

Why this isn't a fourth framework#

Look at that Deep Agents feature list again and notice what's familiar. Summarization, human approval, tool limits — those are create_agent middleware. The planning tool, the filesystem, the sub-agent dispatcher are additional middleware and tools the Deep Agents package ships and pre-wires. Strip the bundle and you are left with create_agent plus a configuration you assembled yourself.

That is the non-obvious point the tutorials bury: "Deep Agents vs LangChain" is "a tuned preset vs assembling the preset." It is the relationship between a distribution and a kernel, not between two operating systems. The question is never "which is more powerful" — they bottom out on the same runtime, so the power ceiling is identical. The question is how much default opinion you want to inherit, and how much of it you intend to override.

This reframing also tells you the failure mode. Reach for Deep Agents and you inherit a heavy system prompt and a pile of behavior you didn't write. If your task is simpler than "autonomous multi-step worker with a scratchpad and a filesystem," those defaults are weight, not lift — the agent narrates a todo list for a job that needed one tool call. The opinion is the product, which means it's also the cost.

The move that proves they're one stack#

Here is the detail that should end any remaining "but which do I commit to" anxiety: the layers compose downward. A LangGraph CompiledStateGraph — a hand-drawn control-flow graph with your own branches and retries — can be passed into a Deep Agent as a sub-agent. Your bespoke orchestration doesn't replace the harness; it slots in next to the bundled defaults as one more delegate the planner can call.

So the real architecture in a serious 2026 codebase is all three at once, each at the altitude it was built for: StateGraph where the control flow is the product, create_agent for the individual tool-calling agents, Deep Agents when one of those agents needs to run a long autonomous errand with a plan and a filesystem. You'll see all three import lines in the same file. That isn't a mistake to clean up. It's the seam working as designed.

How to actually decide#

Skip the table. Answer one question about the shape of your task:

You are not betting on a framework that might lose. You are choosing a rung, and you can climb up or down later without leaving the stack — because it was one stack the whole time. The comparison worth agonizing over is with a genuinely different ecosystem, like the Claude Agent SDK or a from-framework-to-harness rethink. LangChain vs LangGraph vs Deep Agents was never that fight.