What are Deep Agents?

Hey, this is Lance. I want to talk a bit about the deep agents package that we recently released. Now, the length of

recently released. Now, the length of tasks that an agent can take every seven months. And we see numerous examples of

months. And we see numerous examples of popular longrunning agents like Claude Code, Deep Research, Manis. The average

Manis, task,, for example,, can, be, up, to, 50 different tool calls. And so, it's increasingly clear that agents are needed to do what we might consider deeper work or more challenging tasks that take longer periods of time. Hence

this term deep. Now, one of the interesting things you can see when you look at agents like Manis or like Claude Code is that they don't actually use that many different tools. They focus on

a small number of atomic tools that do some very basic but powerful actions.

Notably, access to a file system in a computer with things like tools for file manipulation as well as a bash tool or a shell tool to execute scripts.

This is extremely useful for offloading context over the course of long agent trajectories and for performing actions through script execution as an example. Similarly

longrunning agents typically involve some kind of planning. Claude code has a planning tool. Manis also has the notion

planning tool. Manis also has the notion of planning. And both claude code as

of planning. And both claude code as well as manus use sub aents for context isolation. So if there's a specific

isolation. So if there's a specific task, we can spawn a sub agent with its own independent context window. It can

perform that task and return results back to the parent agent. This is

extremely useful way to preserve the context window of the parent. Now in all these cases of course, prompting is still extremely relevant. The cloud code system prompt

relevant. The cloud code system prompt for example,, is, publicly, available, and it's quite long and extensive. So a

small number of atomic tools that can do broad set of actions notably sub aent delegation for context isolation planning for longunning tasks access to a computer through file system

through a shell tool for offloading context for performing different actions via scripts are all extremely general and useful and guided by often fairly

detailed prompting. Now because these

detailed prompting. Now because these tools are so general we've rolled them into the deep agents package. It's fully

open source and this package can be used to build many different types of agents.

Now, how does this differ from lang chain and langraph? So, langraph

provides a core agent runtime. This

gives low-level infrastructure things like checkpointing, things like memory support for human the loop that's all built in the langraph framework itself.

Now lang chain provides some generally useful, abstractions, for example, for accessing chat models for defining tools and then deep agents is an opinion and agent harness built on top of these two

things that implements a specific set of tools as mentioned for planning for sub aent delegation for file system manipulation and bash and general code execution

and these are built into the harness with some opinionated prompting to govern how they should be used and you can see those differences laid out in the table here. Again, lang chain is just a framework with a set of common

abstractions for things like chat models for things like tools. Lang graph is the agent runtime supporting lower level infrastructure support durable execution things like streaming human and loop

persistence and deep ages of course is just a harness built on top of lang chain and langraph with a set of predefined tools prompts that could be easily adapted for many

different agent use cases. So lang graph is extremely low level.

It has very simple abstractions such as nodes and edges. It can be used to build different agents. It can be used to

different agents. It can be used to build many different types of workflows.

Lang chain has some general abstractions that can be used to build many different types of agents. And deep agent is just one particular agent harness which is opinionated which has a few specific

tools built into it. Now why think about this? Now it is clear that agents are

this? Now it is clear that agents are becoming autonomous quite quickly. As

mentioned the task length that agents can undertake is doubling roughly every seven months. So some principles for

seven months. So some principles for working with deep agents models are getting increasingly capable.

This small set of atomic tools is very general.

The ability to use a shell tool, the ability to manipulate files, the ability to delegate tasks and plan. So typically

it's beneficial to actually move a lot of the complexity of your application into the prompting itself. And so we're seeing increasingly narrow set of capable tools

and highly sophisticated instructions or prompting to use those basic tools. If

you look at cloud code, there's less than 20 tools but very extensive system prompt instructing how to use those very general tools in the best way. And the

second main idea is to really use the file system.

Not only can the file system be used to offload context from the LM's context window, for example, write a plan, pull it back in later. We see that with Manis, but also the file system can be

used to store scripts that the agent can use. We've

seen this more recently with the idea of clawed skills. So we can give the agent

clawed skills. So we can give the agent access to a file system with directories with different skills that gives it access to many different scripts that it can just call using its bash tool. So

with access to a computer effectively a file system and a bash tool an agent can perform a very large number of actions.

And of course sub aent delegation can be very useful. For example you see claude

very useful. For example you see claude call the task tool for certain things that are more tokenheavy that are best isolated in their own context window. So

we've launched the deep agents CLI which is just a deep agent running on your local machine much like cloud code with access to your local file system. We've

also launched deep agents 0.2. And this

release gives you pluggable backends. So

rather than just using a virtual file system which is just the Langar state object, you actually can use your local file system. DHES also has some useful

file system. DHES also has some useful middleware. You can think about

middleware. You can think about middleware really as hooks. So this is basic code that runs at specific points within the agent life cycle to do different things. One example is context

different things. One example is context compression. So once the messages list

compression. So once the messages list grows sufficiently long, you can apply compression to summarize it. We see this with cloud code. Middleware also serves

as a tool handlers for file system tools as well as for the sub agent tool. And

it supports things like prompt caching which is a very useful way to save latency and cost by caching input tokens that are not changing ac across

different agent invocations.

The CLI lets you run a custom deep agent directly from the terminal. It's a lot like cloud code and this is really giving deep agent access to your own file system with support for skills and

with support for memory. So overall deep agents is an opinionated agent harness built on top of lang chain and lang graph. It uses a few atomic tools that

graph. It uses a few atomic tools that we've seen very commonly with agents like manis and claude code access sub aents use of the file system use of a shell tool and use of planning. It bakes

all these into the harness for you but it can be easily customized by adding your own instructions or even adding your own tools with support for MCP. We've also

launched the deep agent CLI, deep agent that can run locally on your machine with access to your local file system much like cloud code.

And in addition to the core tools built into deep agent package, the CLI also ships with support for memory skills, a shell tool, web fetch tool, and a few other things that are particularly

useful when running locally on your own machine.

And again, all this is fully open source, and we strongly encourage contributions and welcome any feedback.

Thanks.