# What are deep agents?

> A deep agent is an LLM tool-calling loop plus planning, subagents and a filesystem, so it can work on long tasks. What each part does and when you need it.

Source: https://www.honeyhive.ai/learn/deep-agents (updated 2026-11-11)

A deep agent is an AI agent that still runs a language model in a tool-calling loop, with extra structure around the loop so it can plan and work through long, multi-step tasks. Harrison Chase [used the label](https://www.langchain.com/blog/deep-agents) for agents that "dive deep" on a topic in July 2025, and he named four parts: a detailed system prompt, a planning tool, subagents and a file system.

The term names a pattern. Chase [cited](https://www.langchain.com/blog/deep-agents) Claude Code, OpenAI's Deep Research and Manus as examples. LangChain's Deep Agents library is one implementation of it.

## What makes an agent "deep"

The post [says](https://www.langchain.com/blog/deep-agents) a naive loop of tool calls produces "shallow" agents that struggle to plan over longer time horizons. Each of the four parts addresses a piece of that.

| Part | What it does | Related page |
|---|---|---|
| Detailed system prompt | [Detailed instructions](https://www.langchain.com/blog/deep-agents) on how to use tools, with examples of behavior | [System prompt](/learn/system-prompt) |
| Planning tool | A to-do list that is [mainly a way](https://www.langchain.com/blog/deep-agents) to keep the agent on track | [Agent planning](/learn/agent-planning) |
| Subagents | Focused tasks handed to [separate agents](https://www.langchain.com/blog/deep-agents), each going deeper on one thing | [Subagents](/learn/subagents) |
| File system | Notes, memory and a [shared workspace](https://www.langchain.com/blog/deep-agents) for agents and subagents | [Agent memory](/learn/agent-memory) |

## The same idea outside LangChain

Anthropic reached the same shape from the other direction. Justin Young [wrote](https://www.anthropic.com/engineering/effective-harnesses-for-long-running-agents) that "getting agents to make consistent progress across multiple context windows remains an open problem," because each session starts with no memory of the last. Anthropic's fix is files and git, not a bigger window: a first session sets up the environment and a progress log, a feature list starts with every item marked failing, and later sessions [make](https://www.anthropic.com/engineering/effective-harnesses-for-long-running-agents) incremental progress and leave structured updates. The post names the failures this prevents: trying to one-shot the app and running out of context mid-feature, and a later session declaring the job done too early.

For research tasks, Anthropic's multi-agent system has a lead agent that [saves its plan](https://www.anthropic.com/engineering/multi-agent-research-system) to memory so it survives truncation, then starts 3 to 5 subagents in parallel. Anthropic [reported](https://www.anthropic.com/engineering/multi-agent-research-system) in June 2025 that its lead-and-subagent setup (Claude Opus 4 leading Claude Sonnet 4 subagents) beat a single Opus 4 agent by 90.2% on an internal research eval, at a price: multi-agent systems use about 15 times more tokens than chat.

The common thread across these sources is state kept outside the context window (a to-do list, files, a progress log, a saved plan) plus delegation to workers that start clean. That is what [context engineering](/learn/context-engineering) looks like for long tasks, and it is why deep agents are often described as an [agent harness](/learn/agent-harness) rather than a model feature.

## How the LangChain library packages it

LangChain's docs [describe](https://docs.langchain.com/oss/python/deepagents/overview) Deep Agents as a harness on the same core tool-calling loop as other frameworks. It ships:

- A `write_todos` planning tool, which has been opt-in since v0.7.
- A configurable virtual filesystem with `ls`, `read_file`, `write_file`, `edit_file`, `delete`, `glob` and `grep`.
- A `task` tool that creates ephemeral subagents, each returning a single final report.
- Summarization, context offloading, prompt caching, and memory in `AGENTS.md` files.

It sits on top of LangChain and LangGraph, using the [LangGraph](/learn/langgraph-framework) runtime for durable execution, streaming and human-in-the-loop. See [LangChain](/learn/langchain-framework) for how the pieces relate.

## When a plain agent is enough

The docs [say](https://docs.langchain.com/oss/python/deepagents/overview) to reach for planning on long or complicated tasks, subagents when heavy subtasks should stay out of the main context, and a sandbox when the agent installs dependencies, runs tests or calls CLIs. For anything that does not need those, they [point](https://docs.langchain.com/oss/python/deepagents/overview) to `create_agent` or a custom LangGraph workflow. A single question answered in a few tool calls does not need a to-do list or subagents, and Anthropic's token figures above are the cost of adding them anyway.

See [how to build AI agents](/learn/how-to-build-ai-agents) and [multi-agent systems](/learn/multi-agent-systems) for the wider choices.

## Tracing a deep agent

A deep agent's run is a tree: the main agent, each subagent and every tool call under it. When one fails, you need to see which subagent was handed what and what it returned. HoneyHive's [Tree View](https://docs.honeyhive.ai/v2/tracing/tree-view.md) shows parent-child spans down to LLM and tool events, and its [Thread View](https://docs.honeyhive.ai/v2/tracing/thread-view.md) lists messages in order across sub-agents, tools and handoffs. For the practice, see [agent tracing](/learn/agent-tracing).

## FAQ

### What is a deep agent?

An agent that still runs an LLM in a tool-calling loop but adds structure around it for long tasks. Harrison Chase [named](https://www.langchain.com/blog/deep-agents) four parts: a detailed system prompt, a planning tool, subagents and a file system.

### What is the difference between a deep agent and a regular agent?

The loop is the same. Harrison Chase [wrote](https://www.langchain.com/blog/deep-agents) that a naive loop of tool calls gives "shallow" agents that struggle to plan over longer horizons. A deep agent adds planning, delegation and external state.

### Is a deep agent the same as Deep Agents from LangChain?

No. Deep Agents is one open source [harness](https://docs.langchain.com/oss/python/deepagents/overview) that implements the pattern. The same shape appears in Claude Code, OpenAI's Deep Research and Manus, which the original post cites as examples.

### Are deep agents multi-agent systems?

Partly. Subagents make them multi-agent, but in LangChain's library each one [returns](https://docs.langchain.com/oss/python/deepagents/overview) a single final report to the main agent. Anthropic's [research system](https://www.anthropic.com/engineering/multi-agent-research-system) uses the same lead and subagent layout.

### When should you not use a deep agent?

For short tasks that fit in one context window. LangChain's docs [point](https://docs.langchain.com/oss/python/deepagents/overview) to a plain `create_agent` or a custom LangGraph workflow when the built-in capabilities are not needed.