# Deep Agents

> Source: https://aiwiki.ai/wiki/deep_agents
> Updated: 2026-07-14
> Categories: AI Agents, Developer Tools, Open Source AI
> License: CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/)
> From AI Wiki (https://aiwiki.ai), the free encyclopedia of artificial intelligence. Reuse freely with attribution to "AI Wiki (aiwiki.ai)".

| Field | Value |
| --- | --- |
| Developer | [LangChain](/wiki/langchain) |
| Type | Open-source agent harness / framework |
| Written in | Python; JavaScript / TypeScript |
| Built on | [LangGraph](/wiki/langgraph); LangChain `create_agent` |
| Initial release | 2025 (concept and `deepagents` package introduced July 30, 2025) |
| Stable release | v0.6 series (June 2026); v0.6.12, June 25, 2026 |
| License | MIT |
| Repositories | github.com/langchain-ai/deepagents (Python); github.com/langchain-ai/deepagentsjs (JS/TS) |

**Deep Agents** is an open-source [agent](/wiki/ai_agent) [harness](/wiki/harness) developed by [LangChain](/wiki/langchain) for long-running, complex, multi-step, non-deterministic tasks such as research, coding, and go-to-market automation.[1][2] It is a deliberately opinionated harness layered on top of LangChain's `create_agent` constructor, bundling in a virtual filesystem, sub-agents, context-management middleware, and skills so that a working autonomous agent runs out of the box rather than having to be assembled from primitives.[2][3] Deep Agents is built on the [LangGraph](/wiki/langgraph) runtime, is model-agnostic, and ships in both Python and JavaScript/TypeScript under an MIT license.[2][4]

## What it is

LangChain describes Deep Agents as "the batteries-included agent harness."[2] A harness, in this context, is the scaffolding around a [large language model](/wiki/large_language_model): the system prompt, the set of tools, the loop that feeds tool results back into context, and the machinery that manages memory and delegation. Where the lower-level LangGraph library gives developers primitives to build agents from scratch, and LangChain's `create_agent` gives a minimal tool-calling loop, Deep Agents provides a ready-made autonomous agent that can plan tasks, read and write files, run commands, and spawn sub-agents the moment it is pointed at a model.[2][3][5]

The design goal is durability over long horizons. A shallow agent calls a tool, reads the result, and calls the next tool in a tight loop, which works for short tasks but tends to lose the thread on work that spans hundreds of steps.[6] Deep Agents adds planning, delegation, and an external workspace so an agent can keep working on a problem that is far too large to fit in a single context window.[1][6] It works with any model that supports tool calling, including frontier APIs from Anthropic, OpenAI, and Google as well as open-weight models, and it has first-class support for the [Model Context Protocol](/wiki/model_context_protocol) for connecting to databases, APIs, and external tools.[2][7]

## Background and the "deep agent" concept

LangChain introduced the "deep agent" idea in a blog post published on July 30, 2025, alongside the first release of the open-source `deepagents` package.[6] The post grew out of an observation about [Claude Code](/wiki/claude_code), Anthropic's coding agent: people were using it for tasks well beyond writing code, and its generality seemed to come from the harness around the model rather than the model alone.[6] Looking across Claude Code and other systems that could "dive deep" on a problem, notably OpenAI's and Google's Deep Research features and the autonomous agent Manus, LangChain argued that they converged on the same four ingredients: a detailed system prompt with worked examples, a planning tool, sub-agents, and access to a file system.[6][8]

The planning tool is the most counterintuitive of the four. In its simplest form it is a to-do list that the agent writes and rewrites as it goes; the list does not execute anything, but keeping the plan in context acts as a steering mechanism that stops a long-running agent from drifting off task.[6] Sub-agents let the main agent hand an independent piece of work to a fresh agent with its own clean context, so the parent's context stays uncluttered.[6] The filesystem serves as shared memory and a scratchpad, letting the agent offload intermediate results to disk instead of holding everything in the prompt.[6][8] Deep Agents packages these four patterns as configurable, swappable components.[2][6]

By early 2026 the project had grown from a demonstration package into a general-purpose framework, and it was widely covered in the developer press in March 2026 as a mature, standalone agent runtime.[8] LangChain then built out a deployment story around it (see below) and shipped a substantial v0.6 update in June 2026.[9][10]

## Architecture and primitives

Deep Agents is organized around a small set of built-in primitives, most of which are implemented as LangGraph middleware that can be extended, overridden, or removed.[2][3]

### Planning

Agents decompose an objective and track progress through a built-in `write_todos` tool, which maintains a structured task list with per-item status.[3][8] This gives long tasks a recoverable state: the plan is visible in context, and the agent updates it as it learns.[8][11]

### Sub-agents

A `task` tool spawns sub-agents for independent subtasks.[3][8] Each sub-agent runs with isolated context and returns a compressed result to the parent, which keeps the main thread's context small and lets independent work proceed without cross-contamination.[3] Both synchronous and asynchronous sub-agents are supported, the latter aimed at parallel or distributed execution.[11]

### Virtual filesystem

Deep Agents exposes a filesystem through tools such as `ls`, `read_file`, `write_file`, `edit_file`, `glob`, `grep`, and `execute`.[3] The backend is pluggable: files can live in in-memory graph state, on local disk, or in a LangGraph store, and the same agent code runs against any of them.[3] The filesystem persists system prompts, skills, and long-term memory, and supports multimodal content and declarative read/write permission rules.[3]

### Context-management middleware

A stack of middleware manages what actually reaches the model. It compresses (summarizes) long conversation histories, offloads large tool outputs to the filesystem instead of leaving them in the prompt, isolates context by routing work to sub-agents, and applies prompt caching on providers that support it (Anthropic and Amazon Bedrock) to cut latency and cost.[1][3] Because Deep Agents runs on LangGraph, it inherits durable execution, checkpointing, streaming, and human-in-the-loop interrupts; sensitive tool calls can be gated for approval through an `interrupt_on` parameter.[3][8]

### Skills and memory

"Skills" are reusable agent behaviors defined in `SKILL.md` files that the agent can load on demand through progressive disclosure, an approach modeled on the skills pattern popularized by Claude Code.[3][12] Persistent preferences and long-term memory are stored in `AGENTS.md` files and pluggable memory backends, so context an agent builds up in one session can carry into the next.[3]

The public entry point is a single constructor. In Python, `create_deep_agent(model=..., tools=[...], system_prompt=...)` returns a compiled LangGraph graph that can be invoked, streamed, checkpointed, and deployed like any other LangGraph application.[3][8]

## Relationship to LangChain, LangGraph, and create_agent

Deep Agents sits at the top of a three-layer stack.[2][3] LangGraph is the low-level runtime: a graph engine that provides durable execution, state, streaming, and human-in-the-loop control. LangChain's `create_agent` is the minimal harness, a standard tool-calling agent loop. Deep Agents is "a more opinionated harness on top of `create_agent`," adding the filesystem, sub-agents, context management, and skills as tuned defaults.[2] Because `create_deep_agent` compiles down to a LangGraph `CompiledStateGraph`, everything in the LangGraph ecosystem, including checkpointers, the LangSmith tracing and observability platform, and LangGraph deployment, works unchanged.[3][8] This layering is the practical difference from building on LangGraph directly: developers get a working [agentic](/wiki/agentic_ai) system immediately, then peel back layers only where they need custom behavior.[2][5]

## Deep Agents Deploy and Managed Deep Agents

LangChain built two related paths for taking a deep agent to production, and they are distinct products.

Deep Agents Deploy, introduced in April 2026 and positioned as "an open alternative to Claude Managed Agents," turns an agent configuration into a LangSmith Deployment: a horizontally scalable server exposing more than 30 endpoints, including endpoints for the Model Context Protocol, agent-to-agent (A2A) communication, the Agent Protocol for UI integration, human-in-the-loop approvals, and memory.[13][14] Its selling point is the absence of vendor lock-in: the underlying `deepagents` harness is MIT-licensed and available in Python and TypeScript, and it works with OpenAI, Google, Anthropic, Azure, Bedrock, Fireworks, Baseten, OpenRouter, and Ollama, so teams can pick the best model for each task and own their agent memory.[13][14]

Managed Deep Agents, announced on May 13, 2026, is a separate, hosted offering: an API-first runtime for creating, running, and operating deep agents, with durable threads, streaming runs, checkpointing, hosted context, sandbox-backed workflows, and LangSmith tracing behind a `/v1/deepagents` API surface.[15] The intended workflow keeps the agent definition in the developer's own repository while the managed service handles the runtime; at launch it was in private beta.[15]

## Adoption and use cases

LangChain positions Deep Agents for three broad categories of work: research, coding, and go-to-market or business-process automation.[1] Documented uses include human-in-the-loop design-iteration systems and go-to-market workflow automation, in addition to autonomous research assistants.[1]

The most prominent adopter is LangChain's own Open SWE, an open-source asynchronous coding agent.[16] Open SWE was first launched in August 2025 and was later rebuilt on Deep Agents and LangGraph; a March 17, 2026 post reframed it as a framework for building internal coding agents.[16][17][18] It runs each task in an isolated cloud sandbox (with support for providers such as Daytona, Modal, and Runloop), can be triggered from Slack, Linear, or GitHub, delegates subtasks to sub-agents through the `task` tool, and finishes by committing changes and opening a pull request through a `commit_and_open_pr` tool, with middleware as a backstop that opens the PR if the agent forgets.[16][17] LangChain says the design captures patterns it observed in production coding agents at companies including Stripe, Ramp, and Coinbase.[16] Deep Agents also ships a pre-built terminal coding agent, comparable in shape to Claude Code, that can be driven by any model.[2][19]

## The Nemotron 3 Ultra harness-tuning example

A concrete illustration of the harness's value arrived in July 2026, when LangChain and NVIDIA collaborated on tuning Deep Agents to run NVIDIA's open-weight [Nemotron 3 Ultra](/wiki/nemotron_3) model well. In a July 2026 playbook titled "Tuning the harness, not the model: a Nemotron 3 Ultra playbook," LangChain kept the model weights fixed and changed only the harness (the system prompt, the tool descriptions, and the middleware around model and tool calls), leaving generation settings at NVIDIA's recommended defaults.[20] LangChain reported that this harness-only tuning brought Nemotron 3 Ultra to a best run of 0.86 on its internal Deep Agents evaluation suite, close to the 0.87 best that LangChain measured for [Claude Opus 4.8](/wiki/claude_opus_4_8), at roughly $4.48 per run against about $43.48 for the closest closed model (approximately 10x cheaper), with latency at parity.[20][21] These figures are LangChain's own benchmark results and had not been independently reproduced at the time of writing.[20][21]

The mechanism is the "harness profile" introduced in v0.6: a named, versionable bundle of per-model overrides (prompts, tool descriptions, and middleware) so that tuning done for one model carries forward across versions.[9][22] NVIDIA's engineering write-up gave a worked example: adding a small middleware called `ReadFileContinuationNoticeMiddleware`, which tells the model when a file read has been truncated, moved a file-reading eval from 94 out of 127 to 96 out of 127 and eliminated the three failing read-file tests, without touching the model.[22] As LangChain frames it, the point of harness engineering is to make the calls from the agent to the model look more like what the model saw in training; the technique has a ceiling, because it fixes failures that come from the scaffolding but cannot add capability that is not already in the weights.[20] The tuned profile shipped as part of a joint LangChain and NVIDIA release called the NemoClaw Deep Agents Blueprint on July 8, 2026, which pairs LangChain's Deep Agents Code, Nemotron 3 Ultra, and an NVIDIA runtime for enterprise agent deployments.[23][24]

Deep Agents v0.6, released in June 2026, generalized this direction. Alongside harness profiles it added a lightweight code interpreter, a v3 streaming event API with typed projections and front-end integrations, a `DeltaChannel` checkpoint format that LangChain says shrank a 200-turn coding session's stored state from 5.27 GB to 129 MB, and a `ContextHubBackend` that stores skills, policies, and memories in a versioned home backed by LangSmith Context Hub.[9] LangChain pitches these features as making open-weight models, including [Kimi K2.6](/wiki/kimi_k2_6), [Qwen](/wiki/qwen3), and [DeepSeek](/wiki/deepseek), usable in production at what it describes as more than 20x lower cost than closed frontier models.[9]

## How it compares with other agent frameworks

The agent-framework space in 2026 is crowded, and the frameworks differ mainly in how opinionated they are and how tightly they bind to a single model provider.

- **Anthropic's Claude Agent SDK** (formerly the Claude Code SDK, renamed in 2026) exposes the same agent loop that powers Claude Code as a programmable Python and TypeScript library.[25][26] It is the closest analogue in spirit, and Deep Agents was explicitly inspired by Claude Code, but the Claude Agent SDK runs on Anthropic's [Claude](/wiki/claude) models, whereas Deep Agents is model-agnostic across Anthropic, OpenAI, Google, and 100-plus other providers.[26] LangChain's own comparison also stresses deployment differences: Deep Agents can run an agent inside a sandbox or treat the sandbox as a tool, and ships built-in multi-tenancy and an agent server, while the Claude Agent SDK leaves API-wrapping and serving to the developer.[26]
- **OpenAI Agents SDK** is OpenAI's lightweight framework built around explicit handoffs between agents. It is centered on OpenAI models but can reach other LLMs through the Chat Completions interface. It is less "batteries-included" than Deep Agents, favoring a small, unopinionated core.
- **CrewAI** is an independent (non-LangChain) framework organized around role-based "crews," where multiple agents with defined roles collaborate through configurable process types. It is model-agnostic and known for a low-friction, role-oriented API.
- **Microsoft AutoGen** pioneered multi-agent conversation ("GroupChat") orchestration. In 2026 Microsoft merged AutoGen with Semantic Kernel into the Microsoft Agent Framework and moved active development there, leaving the original AutoGen codebase in maintenance mode.

A recurring theme in third-party reviews is that Deep Agents trades some single-model polish for model and infrastructure flexibility.[11][27] According to one independent review, Deep Agents scored about 42.65 percent on TerminalBench 2.0 using Claude Sonnet 4.5, roughly on par with Claude Code at the same model tier.[11]

## Limitations and criticisms

Deep Agents is a young project, and reviewers have flagged several caveats. The plugin and community ecosystem is still small relative to its age, and asynchronous sub-agents require remote infrastructure rather than being plug-and-play.[11] The bundled command-line tool reads more as a developer utility than a polished daily driver, and performance can vary significantly when cheaper or open models are swapped in for frontier ones, which is precisely the gap that harness profiles try to close.[11] Building on LangChain and LangGraph also adds framework weight and a learning curve for teams that only need a simple agent; for a single agent that calls one or two tools, a lighter vendor SDK is often the faster path.[11][27]

More broadly, harness engineering itself has limits that LangChain is candid about: tuning the scaffolding cannot substitute for capability that is not in the model, tuning without a solid set of evaluations is guesswork that overfits to whatever was examined last, and vendor benchmark numbers (including the Nemotron figures above) should be read as the vendor's own results until reproduced independently.[20] As with any autonomous agent that can execute shell commands and edit files, running Deep Agents on real systems carries the usual risks of unintended actions, which is why the framework includes human-in-the-loop approval gates and sandboxing.[3][8]

## Plain-language explanation (ELI5)

Imagine you hand a very capable but forgetful assistant a big, messy project. If you make them keep every detail in their head, they get overwhelmed and lose track. Deep Agents is a set of habits that keeps the assistant organized. First, it writes a to-do list and checks things off, so it always knows what is left. Second, when a part of the job is self-contained, it hands that part to a helper who works on it separately and reports back, so the main worker's desk stays clear. Third, it uses a filing cabinet (a filesystem) to stash notes and results instead of trying to remember everything at once. Fourth, it quietly tidies up its own memory as the conversation gets long. The clever twist is that the assistant (the AI model) can be almost any brand: LangChain built the desk, the filing cabinet, and the habits, and you plug in whichever "brain" you like, expensive or cheap. Getting a cheaper brain to do good work is mostly about arranging the desk to suit it, which LangChain calls "tuning the harness, not the model."[6][20]

## See also

- [LangChain](/wiki/langchain)
- [LangGraph](/wiki/langgraph)
- [AI agent](/wiki/ai_agent)
- [Agentic AI](/wiki/agentic_ai)
- [Claude Code](/wiki/claude_code)
- [Model Context Protocol](/wiki/model_context_protocol)
- [Nemotron 3](/wiki/nemotron_3)
- [Large language model](/wiki/large_language_model)

## References

1. LangChain, "Deep Agents: Build Agents for Complex, Multi-Step Tasks" (product page). https://www.langchain.com/deep-agents
2. langchain-ai/deepagents, "The batteries-included agent harness" (GitHub repository). https://github.com/langchain-ai/deepagents
3. LangChain Docs, "Deep Agents overview." https://docs.langchain.com/oss/python/deepagents/overview
4. deepagents (PyPI package page). https://pypi.org/project/deepagents/
5. LangChain Reference, "deepagents." https://reference.langchain.com/python/deepagents
6. LangChain, "Deep Agents" (original concept blog post), July 30, 2025. https://www.langchain.com/blog/deep-agents
7. DataCamp, "LangChain's Deep Agents: A Guide With Demo Project." https://www.datacamp.com/tutorial/deep-agents
8. MarkTechPost, "LangChain Releases Deep Agents: A Structured Runtime for Planning, Memory, and Context Isolation in Multi-Step AI Agents," March 15, 2026. https://www.marktechpost.com/2026/03/15/langchain-releases-deep-agents-a-structured-runtime-for-planning-memory-and-context-isolation-in-multi-step-ai-agents/
9. LangChain, "New in Deep Agents v0.6," June 2026. https://www.langchain.com/blog/deep-agents-0-6
10. langchain-ai/deepagents, Releases. https://github.com/langchain-ai/deepagents/releases
11. andrew.ooo, "LangChain Deep Agents Review: Open-Source Agent Harness," April 17, 2026. https://andrew.ooo/posts/langchain-deep-agents-review-open-source-coding-agent/
12. A B Vijay Kumar, "Building Deep Agents + SKILL.md with LangChain" (Medium). https://abvijaykumar.medium.com/building-deep-agents-skill-md-with-langchain-074176c66dec
13. LangChain, "Deep Agents Deploy: an open alternative to Claude Managed Agents," April 2026. https://www.langchain.com/blog/deep-agents-deploy-an-open-alternative-to-claude-managed-agents
14. LangChain Docs, "Deploy with the CLI." https://docs.langchain.com/oss/python/deepagents/deploy
15. LangChain, "Managed Deep Agents: the fastest way to ship a production deep agent," May 13, 2026. https://www.langchain.com/blog/introducing-managed-deep-agents
16. LangChain, "Open SWE: An Open-Source Framework for Internal Coding Agents," March 17, 2026. https://www.langchain.com/blog/open-swe-an-open-source-framework-for-internal-coding-agents
17. langchain-ai/open-swe (GitHub repository). https://github.com/langchain-ai/open-swe
18. InfoQ, "LangChain Launches Open SWE, an Open-Source Asynchronous Coding Agent," August 2025. https://www.infoq.com/news/2025/08/langchain-open-swe/
19. langchain-ai/deepagentsjs, "The batteries-included agent harness" (JS/TS repository). https://github.com/langchain-ai/deepagentsjs
20. LangChain, "Tuning the harness, not the model: a Nemotron 3 Ultra playbook," July 2026. https://www.langchain.com/blog/tuning-the-harness-not-the-model-a-nemotron-3-ultra-playbook
21. NVIDIA Blog, "NVIDIA Nemotron Achieves Benchmark-Leading Performance With LangChain Deep Agents Harness," July 8, 2026. https://blogs.nvidia.com/blog/nemotron-langchain-agents-open-stack/
22. NVIDIA Technical Blog, "Create a LangChain Deep Agents Harness Profile for NVIDIA Nemotron 3 Ultra to Improve Performance," July 8, 2026. https://developer.nvidia.com/blog/create-a-langchain-deep-agents-harness-profile-for-nvidia-nemotron-3-ultra-to-improve-performance/
23. LangChain, "LangChain and NVIDIA Launch the NemoClaw Deep Agents Blueprint," July 8, 2026. https://www.langchain.com/blog/langchain-and-nvidia-launch-the-nemoclaw-deep-agents-blueprint
24. PR Newswire, "LangChain and NVIDIA Launch NemoClaw Deep Agents Blueprint for Enterprise Agents," July 8, 2026. https://www.prnewswire.com/news-releases/langchain-and-nvidia-launch-nemoclaw-deep-agents-blueprint-for-enterprise-agents-302820446.html
25. anthropics/claude-agent-sdk-python (GitHub repository). https://github.com/anthropics/claude-agent-sdk-python
26. LangChain Docs, "Comparison with Claude Agent SDK." https://docs.langchain.com/oss/python/deepagents/comparison
27. Nebius, "LangChain tunes Deep Agents for NVIDIA Nemotron 3 Ultra: top open-model accuracy at 10x lower cost," July 2026. https://nebius.com/blog/posts/langchain-tunes-deep-agents-for-nemotron-3-ultra