Deep Agents vs LangGraph

Deep Agents is an open source agent harness — an opinionated agent that runs out of the box. Extend, override, or replace any piece.

Principles:

• Opinionated — defaults tuned for long-horizon, multi-step work
• Extensible — override or replace any piece without forking
• Model-agnostic — works with any LLM that supports tool calling: frontier, open-weight, or local
• Production-ready — built on LangGraph (streaming, persistence, checkpointing) with first-class tracing, evaluation, and deployment via LangSmith

Features include:

• Sub-agents — delegate tasks to agents with isolated context windows
• Filesystem — read, write, edit, or search over pluggable local, sandboxed, or remote backends
• Context management — summarize long threads and offload tool outputs to disk
• Shell access — run commands in your sandbox of choice
• Persistent memory — pluggable state and store backends for cross-session recall
• Human-in-the-loop — approve, edit, or reject tool calls before they run
• Skills — reusable behaviors the agent can load on demand
• Tools — bring your own functions or any MCP server

Deep Agents is available as a JavaScript/TypeScript library — see deepagents.js.

[!NOTE]
Deep Agents Code — a pre-built coding agent in your terminal, similar to Claude Code or Cursor, powered by any LLM. Install with curl -LsSf https://langch.in/dcode | bash. See the documentation for the full feature set.

Quickstart

uv add deepagents

from deepagents import create_deep_agent

agent = create_deep_agent(
    model="openai:gpt-6-astra",
    system_prompt="You are a research assistant.",
)
result = agent.invoke({"messages": "Research LangGraph and write a summary"})

The agent can plan, read/write files, and manage its own context. Add your own tools, swap models, customize prompts, configure sub-agents, and more. See the documentation for full details.

[!TIP]
For developing, debugging, and deploying AI agents and LLM applications, see LangSmith.

FAQ

How is this different from LangGraph or LangChain?

LangGraph is the graph runtime. LangChain's create_agent is a minimal agent harness on top of it. Deep Agents is a more opinionated harness on top of create_agent — same building blocks, but with filesystem, sub-agents, context management, and skills bundled in. For how the three relate, see the LangChain ecosystem overview.

Does this work with open-weight or local models?

Yes. Any model that supports tool calling works — frontier APIs (OpenAI, Anthropic, Google), open-weight models hosted on providers like Baseten or Fireworks, and self-hosted models via Ollama, vLLM, or llama.cpp. Use any LangChain chat model.

Can I use this in production?

Yes! Deep Agents is built on LangGraph, designed for production agent deployments. Pair it with LangSmith for tracing, evaluation, and monitoring. See Going to production for the full guide.

When should I use Deep Agents vs. LangChain or LangGraph directly?

All three are layers in the same stack — see the LangChain ecosystem overview for how they relate. Use Deep Agents when you want the full harness — planning, context management, delegation — out of the box. Use LangChain's create_agent when you want a lighter harness without the bundled middleware. Drop to LangGraph when the agent loop itself isn't the right shape and you need a custom graph.

The layers compose: any LangGraph CompiledStateGraph can be passed in as a sub-agent to a Deep Agent, so custom orchestration plugs in alongside the harness's defaults.

Resources

• Examples — working agents and patterns
• Documentation — conceptual overviews and guides
• Changelog — release notes for the Python SDK
• LangChain ecosystem overview — how Deep Agents, LangChain, LangGraph, and LangSmith fit together
• API reference — complete reference for all public classes, functions, and types
• Discussions — community forum for technical questions, ideas, and feedback
• LangChain Academy — Comprehensive, free courses on LangChain libraries and products, made by the LangChain team.
• Development Guide — local setup and package-specific checks
• Contributing Guide — how to contribute and find good first issues
• Release policy — releases and support
• Versioning policy — version numbering and compatibility
• Code of Conduct — community guidelines and standards

Acknowledgements

Inspired by Claude Code: an attempt to identify what makes it general-purpose, and push that further.

Security

Deep Agents follows a "trust the LLM" model. The agent can do anything its tools allow. Enforce boundaries at the tool/sandbox level, not by expecting the model to self-police. See the security policy for more information.

Trusted by companies shaping the future of agents – including Klarna, Replit, Elastic, and more – LangGraph is a low-level orchestration framework for building, managing, and deploying long-running, stateful agents.

pip install -U langgraph

[!TIP]
If you're looking to quickly build agents, check out Deep Agents — a higher-level package built on LangGraph for agents that can plan, use subagents, and leverage file systems for complex tasks.

For an equivalent JS/TS library, check out LangGraph.js and the JS docs.

Why use LangGraph?

LangGraph provides low-level supporting infrastructure for any long-running, stateful workflow or agent:

• Durable execution — Build agents that persist through failures and can run for extended periods, automatically resuming from exactly where they left off.
• Human-in-the-loop — Seamlessly incorporate human oversight by inspecting and modifying agent state at any point during execution.
• Comprehensive memory — Create truly stateful agents with both short-term working memory for ongoing reasoning and long-term persistent memory across sessions.
• Debugging with LangSmith — Gain deep visibility into complex agent behavior with visualization tools that trace execution paths, capture state transitions, and provide detailed runtime metrics.
• Production-ready deployment — Deploy sophisticated agent systems confidently with scalable infrastructure designed to handle the unique challenges of stateful, long-running workflows.

[!TIP]
For developing, debugging, and deploying AI agents and LLM applications, see LangSmith.

LangGraph ecosystem

While LangGraph can be used standalone, it also integrates seamlessly with any LangChain product, giving developers a full suite of tools for building agents.

To improve your LLM application development, pair LangGraph with:

• Deep Agents – Build agents that can plan, use subagents, and leverage file systems for complex tasks.
• LangChain – Provides integrations and composable components to streamline LLM application development.
• LangSmith – Helpful for agent evals and observability. Debug poor-performing LLM app runs, evaluate agent trajectories, gain visibility in production, and improve performance over time.
• LangSmith Deployment – Deploy and scale agents effortlessly with a purpose-built deployment platform for long-running, stateful workflows. Discover, reuse, configure, and share agents across teams – and iterate quickly with visual prototyping in LangSmith Studio.

Documentation

• docs.langchain.com – Comprehensive documentation, including conceptual overviews and guides
• reference.langchain.com/python/langgraph – API reference docs for LangGraph packages
• LangGraph Quickstart – Get started building with LangGraph
• Chat LangChain – Chat with the LangChain documentation and get answers to your questions

Discussions: Visit the LangChain Forum to connect with the community and share all of your technical questions, ideas, and feedback.

Additional resources

• Guides – Quick, actionable code snippets for topics such as streaming, adding memory & persistence, and design patterns (e.g. branching, subgraphs, etc.).
• LangChain Academy – Learn the basics of LangGraph in our free, structured course.
• Case studies – Hear how industry leaders use LangGraph to ship AI applications at scale.
• Contributing Guide – Learn how to contribute to LangChain projects and find good first issues.
• Code of Conduct – Our community guidelines and standards for participation.

Acknowledgements

LangGraph is inspired by Pregel and Apache Beam. The public interface draws inspiration from NetworkX. LangGraph is built by LangChain Inc, the creators of LangChain, but can be used without LangChain.