Deep Agents overview

• Take actions in an environment: Take actions via tools, read and write files, execute code
• Connect to your data: Load memories, skills, and domain knowledge at the right moment
• Manage growing context: Summarize history and offload large results across long runs
• Parallelize tasks: Delegate to general or specialized subagents running in isolated context windows
• Stay in the loop: Pause for human approval at critical decision points
• Improve over time: Update memory, skills, and prompts based on real usage

​

Quickstart

import * as z from "zod";
// npm install deepagents langchain @langchain/core
import { createDeepAgent } from "deepagents";
import { tool } from "langchain";

const getWeather = tool(
  ({ city }) => `It's always sunny in ${city}!`,
  {
    name: "get_weather",
    description: "Get the weather for a given city",
    schema: z.object({
      city: z.string(),
    }),
  },
);

const agent = createDeepAgent({
  tools: [getWeather],
  systemPrompt: "You are a helpful assistant",
});

console.log(
  await agent.invoke({
    messages: [{ role: "user", content: "What's the weather in Tokyo?" }],
  })
);

​

Core capabilities

​

Execution environment

• Tools: custom functions, APIs, and databases the agent can call
• Virtual filesystem: file tools backed by pluggable backends
• Filesystem permissions: declarative access control over which paths agents can read or write
• Code execution: sandboxed shell execution and an in-process JavaScript interpreter

​

Tools and MCP

from deepagents import create_deep_agent

agent = create_deep_agent(
    model="anthropic:claude-sonnet-4-6",
    tools=[search, fetch_page, run_query],
)

​

Virtual filesystem access

from deepagents import HarnessProfile, register_harness_profile

register_harness_profile(
    "anthropic:claude-sonnet-4-6",
    HarnessProfile(
        excluded_tools=frozenset(
            {"ls", "read_file", "write_file", "edit_file", "glob", "grep"}
        ),
    ),
)

​

Filesystem permissions

• operations: "read" and/or "write"
• paths: Glob patterns for files or directories
• mode: "allow" or "deny"

​

Code execution

• Sandbox backends expose an execute tool for shell commands in an isolated environment.
• Interpreters add an eval tool that runs JavaScript in a scoped QuickJS runtime.

​

Streaming

​

Context management

• Skills—on-demand domain knowledge loaded progressively from skill files
• Memory—persistent instructions and preferences loaded at startup from AGENTS.md files
• Summarization and context offloading—automatic compression of conversation history and large tool results
• Prompt caching—static prompt sections are cache-eligible to speed up inference and reduce cost on supported models

​

Skills

​

Memory

​

Summarization and context offloading

• Input context: System prompt, memory, skills, and tool prompts define what the agent starts with.
• Compression: Built-in offloading and summarization compress conversation history and large intermediate results.
• Isolation: Subagents quarantine heavy subtasks and return only final results (see Delegation).
• Long-term memory: Persistent storage in the virtual filesystem carries information across threads.

​

Prompt caching

​

Delegation

• Task planning: a built-in write_todos tool for structured task tracking
• Subagents: ephemeral child agents that handle isolated subtasks

​

Task planning

​

Subagents

• Fresh context: Each invocation creates a new agent instance with its own context.
• Autonomous execution: The subagent runs independently until completion.
• Single handoff: It returns one final report to the main agent.
• Configurable strategy: Use the default general-purpose subagent (enabled by default) or define custom subagents.
• Stateless messaging: Subagents are stateless and cannot send multiple messages back.
• Context and token efficiency: Heavy subtask work stays isolated and is compressed into a compact result.

​

Steering

​

Human-in-the-loop

​

Get started