Deep Agents

Why it's ranked here

This is a well-organized project, not just a wrapper script: a documented three-layer architecture separates the runtime, the agent abstraction, and the harness, and the monorepo splits cleanly into an SDK, a terminal coding agent, an editor integration, and a dedicated evaluation suite with its own command-line tool. MIT licensing and model-agnostic design, including self-hosted models, make it easy to adopt. The catch: the project states its security model plainly as trusting the model to behave, and pushes sandboxing entirely onto whoever wires up the tools.

What's good

The model-agnostic design is real, not marketing: it runs against frontier APIs, open-weight models hosted by other providers, and fully local models through common self-hosting tools, with no code changes beyond swapping the model string. Work can be delegated to helper agents that get their own context window instead of polluting the main thread, and a human approval step can intercept a tool call before it runs rather than only reviewing after the fact. Storage is pluggable too, so files an agent writes can live on local disk, in a sandbox, or on a remote backend depending on how much isolation a deployment needs.

Tradeoffs

There is no built-in sandbox: the project says outright that the agent can do anything its tools allow, so safety has to be enforced by whoever configures the backend and tools, not by the framework itself. It is also tightly coupled to LangChain's ecosystem for its runtime, tracing, and evaluation pipeline, so adopting it means signing up for that stack rather than a standalone library. The JavaScript version lives in a separate repository, so teams outside Python get a smaller, differently maintained slice of the same idea.

How to use it well

Reach for this when you want a full agent harness out of the box: planning, delegation, memory, and approval steps already wired together, so you configure rather than assemble from scratch. Try it first through the terminal coding agent to see the pieces working before writing any code. Skip it if you only need a thin agent loop with no bundled middleware, since a lighter harness one layer down already covers that, or if you need a custom orchestration shape the standard agent loop cannot express.

Observed

License

MIT

Language

Python for the core SDK, terminal coding agent, ACP integration, and evals suite; a separate JavaScript/TypeScript package exists outside this repository

Packaging

Installable from PyPI as the deepagents package; the terminal coding agent is a separate deepagents-code package installed via a shell script or pip

Interfaces

Python library (create_deep_agent), a terminal CLI (dcode), an Agent Client Protocol server for editor integration, and a separate deepagents-evals command-line tool

Repository structure

Monorepo with six independently versioned packages: a core SDK, a terminal coding agent, an ACP integration, an evaluation suite, an experimental runtime host, and provider partner integrations

Model support

Works with any tool-calling model: frontier APIs, open-weight models hosted by third-party providers, and self-hosted models via Ollama, vLLM, or llama.cpp

Dependency

Built on LangGraph and LangChain's create_agent rather than a custom runtime

Security model

States it follows a 'trust the LLM' model and relies on tool- and sandbox-level enforcement rather than built-in guardrails

Documentation

Includes a generated internal documentation index alongside a hand-written architecture guide