Deep Agents

Deep Agents sits on top of LangChain's create_agent, which runs on the LangGraph runtime. create_deep_agent returns a compiled LangGraph graph, so streaming, checkpointing and deployment work the same way as any LangGraph app; behaviour is added through middleware (filesystem, subagents, summarization, skills, and to-do planning, which is opt-in since 0.7).

Multi-agent work is supervisor-style. The main agent calls a task tool naming a subagent; the subagent runs with its own instructions, tools and context window and hands back only its final answer. Async subagents run as separate threads on Agent Protocol servers and can be steered or cancelled, and any compiled LangGraph graph can be plugged in as a subagent.

Short-term state lives in LangGraph checkpoints per thread. Files the agent writes go to a backend you choose, from ephemeral graph state to local disk or a LangGraph store, and long-term memory is simply files on a persistent route that are loaded into the prompt or read on demand.

Pass interrupt_on to create_deep_agent, mapping tool names to True, False or an InterruptOnConfig with allowed decisions and an optional when predicate. When a listed tool is called, the run stops with an __interrupt__ entry describing the pending actions; the app resumes with Command(resume={"decisions": [...]}) using approve, edit, reject or respond. A checkpointer and the same thread_id are required. Async subagents can also be steered or cancelled mid-run.

pip install deepagents

from deepagents import create_deep_agent
from langchain.tools import tool
from langgraph.checkpoint.memory import MemorySaver
from langgraph.types import Command

@tool
def publish(text: str) -> str:
    """Publish the final text."""
    return "published"

reviewer = {"name": "reviewer", "description": "Checks drafts for errors.", "system_prompt": "List factual or spelling errors.", "tools": []}
agent = create_deep_agent(model="anthropic:claude-sonnet-4-6", tools=[publish], subagents=[reviewer],
                          interrupt_on={"publish": True}, checkpointer=MemorySaver())

config = {"configurable": {"thread_id": "demo-1"}}
result = agent.invoke({"messages": [{"role": "user", "content": "Draft a 2-line changelog, get it reviewed, then publish it."}]}, config=config)
if result.get("__interrupt__"):  # a human approves the publish call
    result = agent.invoke(Command(resume={"decisions": [{"type": "approve"}]}), config=config)
print(result["messages"][-1].content)

• Set the key for your model provider (for example ANTHROPIC_API_KEY or OPENAI_API_KEY); models are named as provider:model.
• Human-in-the-loop needs a checkpointer, and the resume call must reuse the same thread_id.
• Since 0.7.0 the to-do planning middleware is opt-in: pass middleware=[TodoListMiddleware()] to get write_todos back.
• MCP tools need langchain[mcp]>=1.4.0, whose langchain.mcp namespace is beta.
• Since 0.7.0, FilesystemBackend and LocalShellBackend default to virtual_mode=True, so paths outside root_dir raise ValueError.
• The default backend keeps files in thread state only; choose a filesystem, store or composite backend for persistence, and a sandbox backend before letting the agent run shell commands.

Per the README, LangGraph is the graph runtime, LangChain's create_agent is a minimal harness on top of it, and Deep Agents is a more opinionated harness on create_agent with filesystem, subagents, context management and skills bundled.

MCP tools load through LangChain's MCPAdapter. A2A is server-side only, via Agent Server's /a2a endpoint. AG-UI works by serving the agent as a LangGraph server behind the @ag-ui/langgraph adapter.

The library is MIT-licensed. LangChain sells LangSmith (tracing, evaluation and deployment), which the docs recommend for production but which is optional.

Yes. interrupt_on pauses chosen tools; you resume with approve, edit, reject or respond decisions. It requires a checkpointer and the same thread_id.

Yes, the README points to deepagents.js, a separate JavaScript/TypeScript library.