LangChain launches Deep Agents, a layer on top of LangGraph for long, complex tasks

LangChain has released Deep Agents, a standalone Python library for building "deep" agent systems on top of LangChain and LangGraph. The idea is to strip the routine work out of a typical agent project: hand-assembling graphs, managing context and delegating subtasks.

Not another graph

Many teams follow a similar path: they start with plain LangChain chains, hit the limits of simple pipelines, and move to LangGraph. There they have to build state, conditional transitions, loops, streaming and execution logic before the agent has started on the actual business problem. Deep Agents tries to raise the level of abstraction and take over that infrastructure layer. As a result, a team spends less time on plumbing and more on the agent's own logic.

LangChain describes Deep Agents as an agent harness: a wrapper that uses LangGraph under the hood but ships with more opinionated defaults. Developers get not a kit of primitives but a ready-made frame for long, multi-step scenarios. Getting started is very simple: one create_deep_agent() function, a list of tools and a system prompt, and the library runs the agent loop from there. That is why the release is pitched as a development accelerator, not as one more layer of abstraction for its own sake.

LangGraph provides the engine and the transmission.

Deep Agents provides the car.

What's in the box

The main bet of Deep Agents is not a new model or a new protocol, but a set of built-in mechanisms that every team usually has to design from scratch. That is what makes the release notable: LangChain is trying to standardize patterns that have become repetitive in production agents. This is not theory, but the typical bottlenecks that almost always surface in long agent sessions.

• write_todos for built-in planning: the agent breaks a task into steps, tracks their status and updates the plan as it works.
• A virtual file system with ls, read_file, write_file, edit_file, glob and grep, used to move long results out of the context window.
• A task tool for launching subagents that handle separate subtasks in an isolated context.
• Automatic summarization when the conversation history grows and approaches the model's window limit.
• Long-term memory across sessions and threads through the LangGraph Store backend.

The documentation includes a practical example: a research agent first builds a plan, then collects data from search, stores bulky results in the file system, delegates part of the work to a subagent when needed, and finally assembles a report. To the developer it looks like a single high-level harness, although LangGraph still runs inside. LangChain also promotes a CLI version of Deep Agents, a terminal coding agent built on the same SDK.

Where it helps

Deep Agents is clearly aimed not at chatbots with a single tool call, but at longer scenarios: researching a topic, coding assistants, autonomous workflows, and tasks with large volumes of intermediate data and memory across sessions. If an agent needs to plan, read and write files, save artifacts, split work into subtasks and not lose the thread after dozens of steps, such a layer can indeed save a lot of time.

But it is not a replacement for every stack. For simple agents, LangChain itself recommends staying with create_agent, and for very precise control over the graph topology, working directly with LangGraph. Deep Agents is a tool for cases where build speed and ready-made solutions matter more than full manual control over every state and transition. In essence, LangChain is offering a more opinionated approach to agents: less freedom, but also less engineering routine.

What this means

The Deep Agents release shows the agent market moving from basic demos toward standardized infrastructure. The next stage of competition is no longer just "the agent can call tools" but "the agent can work for a long time, remember, plan and not fall apart under the volume of context."