Looking for the JS/TS version? Check out Deep Agents.js.
To help you ship LangChain apps to production faster, check out LangSmith. LangSmith is a unified developer platform for building, testing, and monitoring LLM applications.
uv add deepagentsDeep Agents is an open source agent harness — an opinionated agent that runs out of the box. Extend, override, or replace any piece.
Principles:
Features include:
from deepagents import create_deep_agent
agent = create_deep_agent(
model="openai:gpt-5.5",
tools=[my_custom_tool],
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. For a full overview and quickstart of Deep Agents, the best resource is our docs.
Acknowledgements: This project was primarily inspired by Claude Code, and initially was largely an attempt to see what made Claude Code general purpose, and make it even more so.
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.
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.
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.
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.
See our Releases and Versioning policies.
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.
As an open-source project in a rapidly developing field, we are extremely open to contributions, whether it be in the form of a new feature, improved infrastructure, or better documentation.
For detailed information on how to contribute, see the Contributing Guide.
AgentState with DeltaChannel on messages to reduce checkpoint growth from O(N²) to O(N).
State schema for MemoryMiddleware.
State update for MemoryMiddleware.
Middleware for loading agent memory from AGENTS.md files.
Specification for an async subagent running on a remote Agent Protocol server.
A tracked async subagent task persisted in agent state.
State extension for async subagent task tracking.
Input schema for the start_async_task tool.
Input schema for the check_async_task tool.
Input schema for the update_async_task tool.
Input schema for the cancel_async_task tool.
Input schema for the list_async_tasks tool.
Middleware for async subagents running on remote Agent Protocol servers.
Metadata for a skill per Agent Skills specification (https://agentskills.io/specification).
State for the skills middleware.
State update for the skills middleware.
Middleware for loading and exposing agent skills to the system prompt.
Per-criterion grader verdict when the criterion passes.
Per-criterion grader verdict when the criterion fails.
One grader evaluation, appended to _rubric_evaluations each iteration.
State schema for RubricMiddleware.
Structured output the grader sub-agent must emit.
Middleware that drives self-evaluated iteration against a rubric.
Raised when PyAV cannot produce frames for the requested window.
Specification for an agent.
A pre-compiled agent spec.
Input schema for the task tool.
Middleware for providing subagents to an agent via a task tool.
Middleware to patch dangling tool calls in the messages history.
A single access rule for filesystem operations.
State for the filesystem middleware.
Input schema for the ls tool.
Input schema for the read_file tool.
Input schema for read_file when the optional video frame extraction is available.
Input schema for the write_file tool.
Input schema for the edit_file tool.
Input schema for the delete tool.
Input schema for the glob tool.
Input schema for the grep tool.
Input schema for the execute tool.
Middleware for providing filesystem and optional execution tools to an agent.
Input schema for the compact_conversation tool.
Represents a summarization event.
Dictionary-based summarization trigger with AND semantics.
Settings for truncating large tool-call arguments in older messages.
State for the summarization middleware.
Default settings computed from model profile.
Middleware that provides a compact_conversation tool for manual compaction.
Base sandbox implementation with execute() as the core abstract method.
Backend that stores files in a LangSmith Hub agent repo (persistent).
LangSmith sandbox implementation conforming to SandboxBackendProtocol.
Backend that stores files in LangGraph's BaseStore (persistent).
Backend that stores files in agent state (ephemeral).
Result of a single file download operation.
Result of a single file upload operation.
Structured file listing info.
A non-matching line surrounding a grep match, used for context_lines.
A single match from a grep search.
Data structure for storing file contents with metadata.
Result from backend read operations.
Result from backend write operations.
Result from backend edit operations.
Result from backend delete operations.
Result from backend ls operations.
Result from backend grep operations.
Result from backend glob operations.
Protocol for pluggable memory backends (single, unified).
Result of code execution.
Machine-readable metadata attached to an execute tool result.
Result of BaseSandbox.execute_with_offload.
Extension of BackendProtocol that adds shell command execution.
Routes file operations to different backends by path prefix.
Backend that reads and writes files directly from the filesystem.
Filesystem backend with unrestricted local shell command execution.
Declarative configuration for constructing a chat model.
Edits applied to the auto-added general-purpose subagent.
Declarative harness-profile config for YAML/JSON-backed profiles.
Runtime configuration for deep agent behavior.
Repair small Nemotron filesystem tool-call and tool-result quirks.
Append a continuation notice to exactly-at-limit read_file results.
Retry transient provider 429s around model calls.
Mirror standard LangChain tool-call fields into ChatNVIDIA payload metadata.
Remove preserved <think> blocks from normal assistant content.
Repair tool calls emitted as text content instead of structured calls.
Stop Ultra3-specific tool loops before they consume runaway context.
State schema for one-shot Nemotron policy nudges.
Inject lightweight policy nudges for common Ultra3 agent-control misses.
State schema for FollowupDisciplineMiddleware.
Send Ultra3 back once when it asks redundant follow-up questions.
State schema for EntityResolutionGuardMiddleware.
Send Ultra3 back once when it finalizes with unresolved or mis-bound IDs.
State schema for FinalAnswerGuardMiddleware.
Send Ultra3 back once when a final answer drops obvious required details.
Resolve a model string to a BaseChatModel.
Extract the provider-native model identifier from a chat model.
Extract the provider name from a chat model instance.
Check whether a model targets AWS Bedrock.
Check whether a model instance already matches a string model spec.
Create a deep agent.
Return fields annotated with PrivateStateAttr across state schemas.
Append text to a system message.
Append provider-specific prompt caching middleware.
Return whether the optional video dependencies appear to be installed.
Decode sampled frames from a video byte payload.
Create a runnable agent from a raw SubAgent spec.
Check if a backend supports command execution.
Compute default summarization settings based on model profile.
Create a Deep Agents SummarizationMiddleware with model-aware defaults.
Create a SummarizationToolMiddleware with model-aware defaults.
Compile a grep include-glob into a matcher with ripgrep-like semantics.
Alias for compile_grep_include_glob, named for the glob() call site.
Sanitize tool_call_id to prevent path traversal and separator issues.
Format file content with line numbers.
Check if content is empty and return warning message.
Convert current or legacy persisted file content to a string.
Create a FileData object with timestamps.
Update FileData with new content, preserving creation timestamp.
Floor a requested read window at a zero offset and zero lines.
Slice file data to the requested line range without formatting.
Perform string replacement with occurrence validation.
Truncate list or string result if it exceeds token limit (rough estimate: 4 chars/token).
Normalize backslash separators to forward slashes for PurePosixPath use.
Validate and normalize file path for security.
Return structured grep matches from an in-memory files mapping.
Group structured matches into the legacy dict form used by formatters.
Format structured grep matches using existing formatting logic.
Return a hint when a pattern looks like an (unsupported) regex.
Check whether a backend class's execute accepts a timeout kwarg.
Validate a profile registry key.
Register the built-in NVIDIA provider profile.
Raise if the installed langchain-openrouter is below the minimum.
Register the built-in OpenRouter provider profile.
Register a ProviderProfile for a provider or specific model.
Look up the ProviderProfile for a model spec.
Compose init_chat_model kwargs from the registered profile for spec.
Register the built-in OpenAI provider profile.
Register the built-in Claude Opus 4.7 harness profile.
Register the built-in Claude Haiku 4.5 harness profile.
Register a harness profile for a provider or specific model.
Register the built-in Claude Sonnet 4.6 harness profile.
Register the built-in Codex harness profile for each Codex spec.
Register the built-in Nemotron 3 Ultra harness profile.
Emit a deprecation warning with caller-controlled stack attribution.
Reset the @deprecated decorator's dedupe flag for testing.
Get the default model for Deep Agents.
Deep Agents package.
Primary graph assembly module for Deep Agents.
Middleware for the Deep Agents agent.
Middleware for loading agent memory/context from AGENTS.md files.
Middleware for async subagents running on remote Agent Protocol servers.
Backward-compatible re-export for filesystem permissions.
Skills middleware for loading and exposing agent skills to the system prompt.
Rubric middleware for self-evaluated agent iteration.
Middleware for providing subagents to an agent via a task tool.
Middleware to patch dangling tool calls in the messages history.
Middleware for providing filesystem tools to an agent.
Summarization middleware for automatic and tool-based conversation compaction.
Memory backends for pluggable file storage.
Base sandbox implementation.
Shared utility functions for memory backend implementations.
ContextHubBackend: Store files in a LangSmith Hub agent repo (persistent).
LangSmith sandbox backend implementation.
StoreBackend: Adapter for LangGraph's BaseStore (persistent, cross-thread).
StateBackend: Store files in LangGraph agent state (ephemeral).
Protocol definition for pluggable memory backends.
Composite backend that routes file operations by path prefix.
FilesystemBackend: Read and write files directly from the filesystem.
LocalShellBackend: Filesystem backend with unrestricted local shell execution.
Public beta APIs for model and harness profiles.
Provider profile package: ProviderProfile API and built-in providers.
Beta APIs for configuring model-construction behavior.
Harness profile package: HarnessProfile API and built-in registrations.
Beta APIs for configuring deep agent runtime behavior.
Adapter for langchain_core's private deprecation helpers.