LangChain, LangGraph or Deep Agents: Choosing the Right Level

LangChain, LangGraph and Deep Agents tend to show up in the same breath, so newcomers assume they're rivals. They aren't. They sit at different levels of control, and the real question is which level your problem needs.

Think about planning a technical blog series. Some days you just want an assistant to help you write. Other days you want a defined process with several steps. And sometimes the job grows: gather notes, draft outlines, keep intermediate work somewhere, assemble a publishing plan. That progression, from a simple agent to a controlled workflow to a full agent workspace, maps neatly onto the three tools.

What each one gives you

LangChain supplies the core building blocks of an agent application. LangGraph adds control over the workflow and its state. Deep Agents is a higher-level harness for tasks that need planning, context management, files, memory and delegation.

Definitions only go so far, and the confusion is rarely about what each tool does. It's about picking one for a specific job. So the clearest comparison is to build the same thing three times and watch how the code changes.

A running example

The test project is an AI content strategy assistant. You hand it a request like this:

Create a content strategy for a blog series about LangChain, LangGraph, and Deep Agents.

and it should answer five questions: who the target audience is, which angle works best, what the outline looks like, what risks to keep in mind, and what to do next.

Nobody's aiming for a production-ready application here. The point is to see how one idea changes shape under three different frameworks.

LangChain: the plain agent loop

LangChain suits applications that look like an ordinary agent loop:

User question -> Model -> Tools -> Final answer

For the strategy assistant, that means one agent with a couple of tools to call:

lookup_audience_profile()
suggest_content_angles()

It's the quickest path when you want a model, tools, prompts and structured output working together, and it's where you'd start building.

LangGraph: an explicit process

Now suppose you don't want the model deciding everything inside one hidden loop. You want visible steps:

identify_audience
generate_angles
select_angle
draft_outline
review_strategy

That's LangGraph's territory. You spell out the workflow yourself: what runs first, which state moves between steps, and where a review or a branch belongs. It's the difference between asking an assistant to do everything and defining a process the assistant works inside.

Deep Agents: a workspace for bigger jobs

Deep Agents earns its place once the task stops being a single answer. Instead of asking for this:

Create one content strategy.

you ask for this:

Plan a four-part article series.
Create notes, choose angles, outline each article, and prepare a publishing checklist.

Now you've got something closer to a miniature project folder. Along the way the agent might draft a plan, juggle a lot of context, save scratch files, remember earlier decisions, or pass chunks to helpers. Deep Agents ships features for that deeper kind of job. The code stays minimal in the examples that follow, since the capabilities matter more than the volume of code.

Order of attack

Start with LangChain, because it's the easiest way to see the basic agent pattern. Rebuild the same assistant in LangGraph next, then look at the Deep Agents version. By the end you should have a practical sense of when each one fits: LangChain for a quick agent, LangGraph for a controlled flow, Deep Agents for long, multi-part work.