deepagents

Provides create_deep_agent() factory function that returns a fully-configured LangGraph compiled graph with planning, tool calling, and context management pre-wired. Eliminates manual prompt engineering and graph construction by bundling opinionated defaults for system prompts, tool schemas, and execution flow. Supports provider-agnostic LLM selection (Anthropic, OpenAI, Google, etc.) via LangChain's model registry.

Implements a composable middleware system that intercepts tool calls before execution, allowing custom logic injection for logging, validation, sandboxing, and result transformation. Middleware stack processes each tool invocation through registered handlers in sequence, with support for early termination and result eviction. Built on LangGraph's node-level hooks, enabling fine-grained control over tool execution without modifying core agent logic.

Supports deploying agents as remote services via the 'deepagents deploy' command, exposing agents over HTTP/gRPC for client-server execution. Clients can invoke remote agents via a standardized protocol, with support for streaming responses and long-running tasks. Integrates with container orchestration platforms (Docker, Kubernetes) for scalable deployment.

Integrates with remote sandbox providers (Daytona, RunLoop, Modal, QuickJS) to execute code and tools in isolated environments rather than the agent's local process. Supports multiple sandbox backends with a unified interface; agents can switch providers at runtime. Enables safe execution of untrusted code or resource-intensive operations without impacting the agent's process.

CLI agents can automatically discover and inject local files and directory context into the agent's system prompt, enabling agents to be aware of the current working directory and available files. Supports glob patterns for selective file inclusion and automatic content summarization for large files. Enables agents to understand the local environment without explicit file listing commands.

Integrates with the Harbor evaluation framework to benchmark agent performance on standardized tasks and datasets. Supports defining evaluation tasks, running agents against them, and collecting metrics (success rate, latency, cost, tool usage). Enables comparing different agent configurations, models, and strategies on the same benchmarks.

Implements support for the Agent Client Protocol (ACP), a standardized protocol for client-agent communication. Enables deepagents to interoperate with other ACP-compliant tools and frameworks, allowing agents to be invoked from different clients and integrated into larger systems. Handles protocol translation and ensures compatibility with ACP specifications.

Enables parent agents to spawn child agents (sub-agents) for specific subtasks, with automatic task decomposition and result aggregation. Sub-agents inherit parent's tools, memory, and configuration but execute in isolated contexts, allowing parallel or sequential delegation. Implemented via LangGraph's subgraph pattern, where each sub-agent is a compiled graph invoked as a node in the parent's execution flow.

Provides configurable memory backend (in-memory, file-based, or custom) that persists agent state across invocations and automatically summarizes long conversation histories to fit within LLM context windows. Uses token counting to estimate message sizes and evicts or compresses older messages when approaching limits. Supports both short-term (current conversation) and long-term (summarized history) memory with configurable retention policies.

Provides a suite of built-in tools for safe filesystem operations (read, write, list, delete) with automatic path validation to prevent directory traversal attacks. All filesystem operations are sandboxed to a configurable root directory; paths are validated against a whitelist/blacklist before execution. Implements secure file handling with proper error messages that don't leak sensitive path information.

Abstracts LLM provider differences (Anthropic, OpenAI, Google, Ollama, etc.) through LangChain's model registry, allowing agents to switch providers or models at runtime without code changes. Handles provider-specific tool calling conventions, token limits, and system prompt formats transparently. Configuration is provider-agnostic; same agent code works with any supported LLM.

Leverages LangGraph's native streaming support to emit agent execution events (tool calls, LLM responses, state updates) in real-time as the graph executes. Supports both token-level streaming (for LLM output) and event-level streaming (for tool calls and state changes). Enables building responsive UIs that show agent progress without waiting for full execution completion.

Implements a middleware-based approval system that pauses agent execution when certain tools are invoked, requiring human approval before proceeding. Integrates with the middleware pipeline to intercept tool calls, emit approval requests, and resume execution based on human decision. Supports custom approval policies (e.g., approve all read operations, require approval for write operations).

Provides a skills registry where custom tools can be bundled into reusable skill packages with automatic schema generation and documentation. Skills are composable; agents can load multiple skill packages and inherit their tools. Tool schemas are automatically generated from Python function signatures and docstrings, reducing boilerplate. Supports skill versioning and dependency management.

Provides a command-line interface (deepagents CLI) for running agents interactively with chat-like input/output, autocomplete, and session persistence. Interactive mode maintains conversation history, supports multi-turn interactions, and provides commands for configuration, model switching, and session management. Non-interactive mode allows running agents from scripts or CI/CD pipelines with input/output redirection.