## Introduction Deep Agents is a batteries-included AI agent harness built on LangChain and LangGraph, designed to eliminate the repetitive boilerplate of setting up prompts, tools, and context management for AI agents. With 13,100+ GitHub stars, 2,000+ forks, and an MIT license, the project has quickly gained traction as a production-ready framework for building sophisticated AI agents. The latest release (v0.4.11, March 13, 2026) continues to refine its planning, filesystem, and sub-agent capabilities. Building AI agents from scratch typically requires wiring together prompt templates, tool definitions, memory management, and execution loops. Deep Agents packages all of these into a cohesive harness that works out of the box while remaining fully customizable for advanced use cases. ## Architecture and Components Deep Agents provides six core modules that form the backbone of its agent architecture: | Component | Purpose | |-----------|--------| | Planning | Task breakdown and progress tracking via write_todos | | Filesystem | File reading, writing, editing, directory listing, search | | Shell Access | Command execution with sandboxing support | | Sub-agents | Task delegation with isolated context windows | | Context Management | Automatic summarization and output handling | | Smart Defaults | Pre-configured prompts teaching effective tool usage | **Planning** is handled through a structured todo system where agents break complex tasks into manageable steps and track their progress. This prevents the common problem of agents losing track of multi-step objectives. **Filesystem Operations** provide a full suite of file manipulation tools including reading, writing, editing specific sections, listing directories, and searching across codebases. These are essential for coding agents that need to navigate and modify project structures. **Sub-agent Spawning** enables task delegation with isolated context windows. When a task requires specialized focus, the main agent can spawn a sub-agent with its own context, preventing information overload in the parent agent's memory. **Context Management** automatically handles summarization and output truncation. As conversations grow long, the system compresses earlier context while preserving the most relevant information for the current task. ## Key Capabilities **Provider Agnostic**: Deep Agents works with any LLM that supports tool calling. Whether using OpenAI, Anthropic, Google, or open-source models through compatible APIs, the framework adapts without code changes. **CLI Tool**: Ships with a command-line interface featuring web search, remote sandboxes, persistent memory, and human-in-the-loop approval workflows. This makes it immediately usable for developer productivity tasks. **LangGraph Integration**: Returns a compiled LangGraph graph, enabling production deployments with streaming, checkpointing, and state persistence. This bridges the gap between prototype and production. **Remote Sandboxes**: Support for isolated execution environments where agents can run code safely without affecting the host system. **Persistent Memory**: Agents can maintain memory across sessions, building up knowledge over time rather than starting fresh with each interaction. ## Developer Integration Getting started requires minimal setup: ```python from deepagents import create_agent agent = create_agent(model="claude-sonnet-4") result = agent.invoke({"input": "Refactor this codebase to use async/await"}) ``` The framework also supports streaming for real-time feedback: ```python for chunk in agent.stream({"input": "Build a REST API for user management"}): print(chunk) ``` ## Limitations Deep Agents inherits the complexity of the LangChain and LangGraph ecosystem, which can be overwhelming for developers new to these frameworks. The abstraction layers, while convenient, can make debugging agent behavior more difficult when things go wrong. Sub-agent spawning adds latency as each sub-agent requires its own LLM calls. The smart defaults work well for coding tasks but may need significant customization for non-coding domains. Remote sandbox support requires additional infrastructure setup that is not trivial for small teams. ## Who Should Use This Deep Agents is ideal for teams already invested in the LangChain ecosystem who want a ready-to-deploy agent framework. Developers building coding assistants, automated refactoring tools, or code review agents will find the filesystem and shell tools particularly valuable. Organizations needing production-grade agent infrastructure with streaming and checkpointing benefit from the LangGraph integration. Teams wanting to experiment with multi-agent architectures can leverage the sub-agent spawning system without building coordination logic from scratch.