LangChain releases Deep Agents for multistep AI agents with memory and isolation

LangChain has released Deep Agents, a standalone library for building AI agents that need more than a short "request → tool call → response" loop. It targets longer tasks in which an agent has to plan steps, store intermediate results and avoid cramming everything into a single overloaded context.

What was released

On March 15, 2026, LangChain introduced Deep Agents as a standalone library built on top of its core agent components. LangGraph remains the foundation: it provides durable execution, streaming, human-in-the-loop scenarios and other runtime capabilities. In other words, this is not a new model or a new type of runtime, but a ready-made architectural harness for cases where an ordinary tool-calling agent starts to fall apart on multistep tasks with state and a large number of artifacts.

Deep Agents effectively closes a practical gap between simple agent demos and the custom orchestration that teams usually build themselves. Instead of manually adding a planner, a file layer, storage for intermediate artifacts and delegation of subtasks, developers get these mechanisms out of the box. LangChain also stresses that if a task is simple, you can stay with the regular `create_agent`, and if you need full control, you can move to your own workflow on LangGraph.

"Deep

Agents is an agent harness," is how LangChain describes the project in its documentation.

What is inside the runtime

The key idea behind Deep Agents is that the agent gets not only a model and a set of external functions but also a working environment for a long session. The standard package includes built-in tools for planning, file handling, command execution and delegation. This lets the agent work through a task in a more structured way instead of improvising each next step from the current prompt.

• `write_todos` — breaks a complex task into steps and tracks progress
• `read_file`, `write_file`, `edit_file`, `ls`, `glob`, `grep` — work with files and intermediate artifacts
• `execute` — runs shell commands in sandbox scenarios
• `task` — calls subagents with isolated context
• auto-summarization and pluggable long-term memory across threads

The file layer matters most. In many agent systems, "memory" sounds appealing, but in practice everything runs into an overfilled context window. Deep Agents takes a more down-to-earth approach: notes, code snippets, reports, search results and other large outputs can be moved into an internal file system and retrieved when needed. The documentation also describes several backend options, from in-memory state to local disk, store backends and sandbox environments.

Why developers should care

The main problem with long agent tasks has been known for a while: the more goals, temporary decisions, tool logs and side details pile up in one thread, the worse the agent holds its course. Deep Agents answers with two mechanisms at once. The first is explicit planning through a todo list. The second is subagents, which can take on separate subtasks without polluting the main context. For research, coding, analytics and report preparation, this looks noticeably more practical than endlessly growing a single prompt.

There is another important nuance: Deep Agents does not cut developers off from the LangGraph infrastructure. The `create_deep_agent(...)` function returns a ready-made compiled graph that works with streaming, checkpointers, Studio and other standard features of the stack. Put differently, it is not a closed layer on top of the runtime but a ready-made graph with preconfigured rules. That suits teams: they can start quickly, then gradually tune the model, permissions, human approval, memory store and their own tools for a production scenario.

Still, don't expect magic. Deep Agents does not automatically solve security, tool quality or the design of the workflow itself. If an agent gets overly broad permissions, a poor sandbox or a weak memory scheme, the problems will not go away. But as a starting point for multistep agents, the library looks noticeably more mature than most "agent in five minutes" templates.

What this means

The market for agent frameworks is shifting from simple tool calling toward more structured runtime approaches. For teams that want to take AI agents to real research, analytics and engineering tasks, Deep Agents can become a convenient intermediate layer between a toy demo and fully custom orchestration.