graph

Create a SummarizationMiddleware with model-aware defaults.

Computes trigger, keep, and truncation settings from the model's profile (or uses fixed-token fallbacks) and returns a configured middleware.

Get the default model for deep agents.

Resolve a model string to a BaseChatModel instance.

If model is already a BaseChatModel, returns it unchanged.

String models are resolved via init_chat_model, with OpenAI models defaulting to the Responses API. See the create_deep_agent docstring for details on how to customize this behavior.

Create a deep agent.

By default, this agent has access to the following tools:

• write_todos: manage a todo list
• ls, read_file, write_file, edit_file, glob, grep: file operations
• execute: run shell commands
• task: call subagents

The execute tool allows running shell commands if the backend implements SandboxBackendProtocol. For non-sandbox backends, the execute tool will return an error message.

Backend that stores files in agent state (ephemeral).

Uses LangGraph's state management and checkpointing. Files persist within a conversation thread but not across threads. State is automatically checkpointed after each agent step.

Special handling: Since LangGraph state must be updated via Command objects (not direct mutation), operations return Command objects instead of None. This is indicated by the uses_state=True flag.

Protocol for pluggable memory backends (single, unified).

Backends can store files in different locations (state, filesystem, database, etc.) and provide a uniform interface for file operations.

All file data is represented as dicts with the following structure: { "content": list[str], # Lines of text content "created_at": str, # ISO format timestamp "modified_at": str, # ISO format timestamp }

Middleware for providing filesystem and optional execution tools to an agent.

This middleware adds filesystem tools to the agent: ls, read_file, write_file, edit_file, glob, and grep.

Files can be stored using any backend that implements the BackendProtocol.

If the backend implements SandboxBackendProtocol, an execute tool is also added for running shell commands.

This middleware also automatically evicts large tool results to the file system when they exceed a token threshold, preventing context window saturation.

Middleware for loading agent memory from AGENTS.md files.

Loads memory content from configured sources and injects into the system prompt.

Supports multiple sources that are combined together.

Middleware to patch dangling tool calls in the messages history.

Middleware for loading and exposing agent skills to the system prompt.

Loads skills from backend sources and injects them into the system prompt using progressive disclosure (metadata first, full content on demand).

Skills are loaded in source order with later sources overriding earlier ones.

A pre-compiled agent spec.

When the subagent completes, the final message in the 'messages' list will be extracted and returned as a ToolMessage to the parent agent.

Specification for an agent.

When using create_deep_agent, subagents automatically receive a default middleware stack (TodoListMiddleware, FilesystemMiddleware, SummarizationMiddleware, etc.) before any custom middleware specified in this spec.

Middleware for providing subagents to an agent via a task tool.

This middleware adds a task tool to the agent that can be used to invoke subagents. Subagents are useful for handling complex tasks that require multiple steps, or tasks that require a lot of context to resolve.

A chief benefit of subagents is that they can handle multi-step tasks, and then return a clean, concise response to the main agent.

Subagents are also great for different domains of expertise that require a narrower subset of tools and focus.