The Deep Agent Pattern: Beyond Multi-Agent Systems
Meet the next-gen "Agent 2.0" pattern - and let's look at how it works.
The patterns behind Claude Code’s agent harness, Deep Research features from Perplexity and OpenAI, and Operator have consolidated into a common architecture that LangChain recently coined “Deep Agents.” Anthropic validated this by rebranding their “Claude Code SDK” to “Agent SDK”—recognizing that this pattern is both generalizable and enables applied “deep” agents for specific domains.
While Deep Agents are a “multi-agent” and “multi-tool” pattern, they have key attributes that distinguish them from standard tool-calling agents.
What Makes an Agent “Deep”?
1. A “deep” system prompt (detailed, long, extensive—think thousands of tokens)
Claude Code is not an anomaly. Most of the best coding or deep research agents have complex system prompts. Without these system prompts, the agents would not be nearly as deep. Prompting matters still. - LangChain
Deep agents use long, structured prompts that provide extensive guidance. Claude Code’s system prompt exceeds 2,000 tokens. This is dissimilar to ordinary system prompts since they extensively provide detailed, prioritized contextual guidance that goes into exceeding level of detail (high level role → tasks → dos & don’ts → edge cases).
2. Explicit planning via planning tool (write, read, & recall)
Deep agents are equipped with an explicit planning capability. In Claude, this appears as a special Todo list tool that the agent can call. Notably, LangChain’s deepagents uses a no-op planning tool—calling it doesn’t affect the environment, but it lets the agent print a “plan” into the conversation (which remains in context). This is clever “context engineering” since repeating the plan maintains attention on the next step.
3. Access to a dedicated filesystem for storing & managing context with dedicated tools
“That’s why we treat the file system as the ultimate context in Manus: unlimited in size, persistent by nature, and directly operable by the agent itself. The model learns to write to and read from files on demand—using the file system not just as storage, but as structured, externalized memory.” - Manus Blog
Deep agents maintain a form of continuously updated long-term memory or scratch space outside the transient LLM context. In practice, this often means a file system (virtual or local) where the agent can read/write files. The agent might write notes to notes.txt, save intermediate results, or read a knowledge base file when needed. This shared workspace allows information to persist between agent iterations and be shared across sub-agents AND HUMANS.
Agents have built-in tools: ls, read_file, write_file, edit_file, glob, grep. Agents can offload information to files instead of keeping everything in memory, which prevents context window overflow on large projects.
4. The ability to delegate & spawn to subagents
Task execution is accelerated and context is better managed by spinning up subagents. These subagents, with their own loops, have both 1) a stricter task-specific context, and 2) are able to run in parallel and decoupled to make sure tasks are completed faster rather than in sequence.
How Deep Agents Operate?
Deep agents operate in a continuous agentic loop rather than single-shot responses. Each iteration:
Receives your instruction or resumes from previous state
Plans the next steps (explicitly written out)
Takes actions (file operations, searches, code changes)
Observes results of those actions
Reasons about what to do next
Loops until task completion or user intervention
Aren’t “Deep Agents” Just “Agents”?
Deep Agents are a type of Agent. It’s a design pattern that allows depth of domain knowledge, planning, and execution. This depth is not possible to achieve using ordinary tool calling Agent design pattern. Instead, Deep Agents include the necessary primitives, techniques and specialization to enable 1) tackling complex, and ambiguous long-term tasks, and 2) learn and recover from failures.
Similar to how Deep Research is different than Web Search (the former is a system that plans, researches several topics, and responds with a comprehensive report), Deep Agents and Agents are also different. A few months ago, we would’ve referred to Deep Agents as “Multi-agent system” or an “Agentic system.” Turns out, simply being able to spawn sub-agents is not enough to achieve the “deep-ness” that systems like Claude Code and others have been able to achieve. It’s this design pattern that we now call Deep Agents.
Aren’t “Deep Agents” Just “Workflows”?
No. Deep Agents are more similar to a knowledge worker, than a pre-determined Standard Operating Procedure (SOP). In fact, a key benefit of using Deep Agents is the ability to handle ambiguous and “open ended” tasks that cannot be pre-determined up front. This means that Deep Agents can generate a workflow on the fly (in the form of an SOP).
What Makes Deep Agents Hard to Build?
Deep agents are more difficult to build and meet expectations due to significant level of effort required vs. normal agents. Several areas need innovation:
1. Context Engineering & Token Efficiency
Innovation is needed in Context Engineering and Token Efficiency. In normal usage, users end up using the main agent for most tasks due to higher quality. Sub-agents are not the complete answer.
Active AI-driven dynamic context parsing and elimination and replacement of unnecessary blocks with simple summary and “restore links” is needed. Agents should be able to decide to restore context blocks using a tool on the fly. This requires dynamic context management services for long running tasks and conversations, including:
Optimize and compact tools
Restore tools
Tool response management
File system organization and context mapping
2. Governance is Even More Complex
Governance is even more complex for Deep Agents since it needs to extend to non-deterministic spawned subagents. Traditional monitoring and control mechanisms weren’t designed for agents that spawn other agents unpredictably.
References & Further Reading
https://blog.langchain.com/introducing-deepagents-cli/
DeepAgent Github: https://github.com/langchain-ai/deepagents
Claude Agent SDK: https://docs.claude.com/en/api/agent-sdk/overview
https://www.philschmid.de/agents-2.0-deep-agents
https://blog.langchain.com/not-another-workflow-builder/
https://blog.langchain.com/doubling-down-on-deepagents/
https://blog.langchain.com/langsmith-agent-builder/