deepagents 0.0.5rc4__tar.gz → 0.0.6rc2__tar.gz

{deepagents-0.0.5rc4 → deepagents-0.0.6rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepagents
-Version: 0.0.5rc4
+Version: 0.0.6rc2
 Summary: General purpose 'deep agent' with sub-agent spawning, todo list capabilities, and mock file system. Built on LangGraph.
 License: MIT
 Requires-Python: <4.0,>=3.11
@@ -115,15 +115,26 @@ class SubAgent(TypedDict):
     prompt: str
     tools: NotRequired[list[str]]
     model_settings: NotRequired[dict[str, Any]]
+
+class CustomSubAgent(TypedDict):
+    name: str
+    description: str
+    graph: Runnable
 ```
 
+**SubAgent fields:**
 - **name**: This is the name of the subagent, and how the main agent will call the subagent
 - **description**: This is the description of the subagent that is shown to the main agent
 - **prompt**: This is the prompt used for the subagent
 - **tools**: This is the list of tools that the subagent has access to. By default will have access to all tools passed in, as well as all built-in tools.
 - **model_settings**: Optional dictionary for per-subagent model configuration (inherits the main model when omitted).
 
-To use it looks like:
+**CustomSubAgent fields:**
+- **name**: This is the name of the subagent, and how the main agent will call the subagent
+- **description**: This is the description of the subagent that is shown to the main agent  
+- **graph**: A pre-built LangGraph graph/agent that will be used as the subagent
+
+#### Using SubAgent
 
 ```python
 research_subagent = {
@@ -139,6 +150,35 @@ agent = create_deep_agent(
 )
 ```
 
+#### Using CustomSubAgent
+
+For more complex use cases, you can provide your own pre-built LangGraph graph as a subagent:
+
+```python
+from langgraph.prebuilt import create_react_agent
+
+# Create a custom agent graph
+custom_graph = create_react_agent(
+    model=your_model,
+    tools=specialized_tools,
+    prompt="You are a specialized agent for data analysis..."
+)
+
+# Use it as a custom subagent
+custom_subagent = {
+    "name": "data-analyzer",
+    "description": "Specialized agent for complex data analysis tasks",
+    "graph": custom_graph
+}
+
+subagents = [custom_subagent]
+agent = create_deep_agent(
+    tools,
+    prompt,
+    subagents=subagents
+)
+```
+
 ### `model` (Optional)
 
 By default, `deepagents` uses `"claude-sonnet-4-20250514"`. You can customize this by passing any [LangChain model object](https://python.langchain.com/docs/integrations/chat/).

{deepagents-0.0.5rc4 → deepagents-0.0.6rc2}/README.md

@@ -102,15 +102,26 @@ class SubAgent(TypedDict):
     prompt: str
     tools: NotRequired[list[str]]
     model_settings: NotRequired[dict[str, Any]]
+
+class CustomSubAgent(TypedDict):
+    name: str
+    description: str
+    graph: Runnable
 ```
 
+**SubAgent fields:**
 - **name**: This is the name of the subagent, and how the main agent will call the subagent
 - **description**: This is the description of the subagent that is shown to the main agent
 - **prompt**: This is the prompt used for the subagent
 - **tools**: This is the list of tools that the subagent has access to. By default will have access to all tools passed in, as well as all built-in tools.
 - **model_settings**: Optional dictionary for per-subagent model configuration (inherits the main model when omitted).
 
-To use it looks like:
+**CustomSubAgent fields:**
+- **name**: This is the name of the subagent, and how the main agent will call the subagent
+- **description**: This is the description of the subagent that is shown to the main agent  
+- **graph**: A pre-built LangGraph graph/agent that will be used as the subagent
+
+#### Using SubAgent
 
 ```python
 research_subagent = {
@@ -126,6 +137,35 @@ agent = create_deep_agent(
 )
 ```
 
+#### Using CustomSubAgent
+
+For more complex use cases, you can provide your own pre-built LangGraph graph as a subagent:
+
+```python
+from langgraph.prebuilt import create_react_agent
+
+# Create a custom agent graph
+custom_graph = create_react_agent(
+    model=your_model,
+    tools=specialized_tools,
+    prompt="You are a specialized agent for data analysis..."
+)
+
+# Use it as a custom subagent
+custom_subagent = {
+    "name": "data-analyzer",
+    "description": "Specialized agent for complex data analysis tasks",
+    "graph": custom_graph
+}
+
+subagents = [custom_subagent]
+agent = create_deep_agent(
+    tools,
+    prompt,
+    subagents=subagents
+)
+```
+
 ### `model` (Optional)
 
 By default, `deepagents` uses `"claude-sonnet-4-20250514"`. You can customize this by passing any [LangChain model object](https://python.langchain.com/docs/integrations/chat/).

{deepagents-0.0.5rc4 → deepagents-0.0.6rc2}/deepagents.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepagents
-Version: 0.0.5rc4
+Version: 0.0.6rc2
 Summary: General purpose 'deep agent' with sub-agent spawning, todo list capabilities, and mock file system. Built on LangGraph.
 License: MIT
 Requires-Python: <4.0,>=3.11
@@ -115,15 +115,26 @@ class SubAgent(TypedDict):
     prompt: str
     tools: NotRequired[list[str]]
     model_settings: NotRequired[dict[str, Any]]
+
+class CustomSubAgent(TypedDict):
+    name: str
+    description: str
+    graph: Runnable
 ```
 
+**SubAgent fields:**
 - **name**: This is the name of the subagent, and how the main agent will call the subagent
 - **description**: This is the description of the subagent that is shown to the main agent
 - **prompt**: This is the prompt used for the subagent
 - **tools**: This is the list of tools that the subagent has access to. By default will have access to all tools passed in, as well as all built-in tools.
 - **model_settings**: Optional dictionary for per-subagent model configuration (inherits the main model when omitted).
 
-To use it looks like:
+**CustomSubAgent fields:**
+- **name**: This is the name of the subagent, and how the main agent will call the subagent
+- **description**: This is the description of the subagent that is shown to the main agent  
+- **graph**: A pre-built LangGraph graph/agent that will be used as the subagent
+
+#### Using SubAgent
 
 ```python
 research_subagent = {
@@ -139,6 +150,35 @@ agent = create_deep_agent(
 )
 ```
 
+#### Using CustomSubAgent
+
+For more complex use cases, you can provide your own pre-built LangGraph graph as a subagent:
+
+```python
+from langgraph.prebuilt import create_react_agent
+
+# Create a custom agent graph
+custom_graph = create_react_agent(
+    model=your_model,
+    tools=specialized_tools,
+    prompt="You are a specialized agent for data analysis..."
+)
+
+# Use it as a custom subagent
+custom_subagent = {
+    "name": "data-analyzer",
+    "description": "Specialized agent for complex data analysis tasks",
+    "graph": custom_graph
+}
+
+subagents = [custom_subagent]
+agent = create_deep_agent(
+    tools,
+    prompt,
+    subagents=subagents
+)
+```
+
 ### `model` (Optional)
 
 By default, `deepagents` uses `"claude-sonnet-4-20250514"`. You can customize this by passing any [LangChain model object](https://python.langchain.com/docs/integrations/chat/).

{deepagents-0.0.5rc4 → deepagents-0.0.6rc2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "deepagents"
-version = "0.0.5rc4"
+version = "0.0.6rc2"
 description = "General purpose 'deep agent' with sub-agent spawning, todo list capabilities, and mock file system. Built on LangGraph."
 readme = "README.md"
 license = { text = "MIT" }

{deepagents-0.0.5rc4 → deepagents-0.0.6rc2}/src/deepagents/graph.py

@@ -1,4 +1,9 @@
-from deepagents.sub_agent import _create_task_tool, _create_sync_task_tool, SubAgent
+from deepagents.sub_agent import (
+    _create_task_tool,
+    _create_sync_task_tool,
+    SubAgent,
+    CustomSubAgent,
+)
 from deepagents.model import get_default_model
 from deepagents.tools import write_todos, write_file, read_file, ls, edit_file
 from deepagents.state import DeepAgentState
@@ -8,37 +13,27 @@ from langchain_core.language_models import LanguageModelLike
 from deepagents.interrupt import create_interrupt_hook, ToolInterruptConfig
 from langgraph.types import Checkpointer
 from langgraph.prebuilt import create_react_agent
+from deepagents.prompts import BASE_AGENT_PROMPT
 
 StateSchema = TypeVar("StateSchema", bound=DeepAgentState)
 StateSchemaType = Type[StateSchema]
 
-base_prompt = """You have access to a number of standard tools
-
-## `write_todos`
-
-You have access to the `write_todos` tools to help you manage and plan tasks. Use these tools VERY frequently to ensure that you are tracking your tasks and giving the user visibility into your progress.
-These tools are also EXTREMELY helpful for planning tasks, and for breaking down larger complex tasks into smaller steps. If you do not use this tool when planning, you may forget to do important tasks - and that is unacceptable.
-
-It is critical that you mark todos as completed as soon as you are done with a task. Do not batch up multiple tasks before marking them as completed.
-## `task`
-
-- When doing web search, prefer to use the `task` tool in order to reduce context usage."""
-
 
 def _agent_builder(
     tools: Sequence[Union[BaseTool, Callable, dict[str, Any]]],
     instructions: str,
     model: Optional[Union[str, LanguageModelLike]] = None,
-    subagents: list[SubAgent] = None,
+    subagents: list[SubAgent | CustomSubAgent] = None,
     state_schema: Optional[StateSchemaType] = None,
     builtin_tools: Optional[list[str]] = None,
     interrupt_config: Optional[ToolInterruptConfig] = None,
     config_schema: Optional[Type[Any]] = None,
     checkpointer: Optional[Checkpointer] = None,
     post_model_hook: Optional[Callable] = None,
+    main_agent_tools: Optional[list[str]] = None,
     is_async: bool = False,
 ):
-    prompt = instructions + base_prompt
+    prompt = instructions + BASE_AGENT_PROMPT
 
     all_builtin_tools = [write_todos, write_file, read_file, ls, edit_file]
 
@@ -56,7 +51,7 @@ def _agent_builder(
     if model is None:
         model = get_default_model()
     state_schema = state_schema or DeepAgentState
-    
+
     # Should never be the case that both are specified
     if post_model_hook and interrupt_config:
         raise ValueError(
@@ -69,7 +64,7 @@ def _agent_builder(
         selected_post_model_hook = create_interrupt_hook(interrupt_config)
     else:
         selected_post_model_hook = None
-    
+
     if not is_async:
         task_tool = _create_sync_task_tool(
             list(tools) + built_in_tools,
@@ -88,7 +83,16 @@ def _agent_builder(
             state_schema,
             selected_post_model_hook,
         )
-    all_tools = built_in_tools + list(tools) + [task_tool]
+    if main_agent_tools is not None:
+        passed_in_tools = []
+        for tool_ in tools:
+            if not isinstance(tool_, BaseTool):
+                tool_ = tool(tool_)
+            if tool_.name in main_agent_tools:
+                passed_in_tools.append(tool_)
+    else:
+        passed_in_tools = list(tools)
+    all_tools = built_in_tools + passed_in_tools + [task_tool]
 
     return create_react_agent(
         model,
@@ -105,13 +109,14 @@ def create_deep_agent(
     tools: Sequence[Union[BaseTool, Callable, dict[str, Any]]],
     instructions: str,
     model: Optional[Union[str, LanguageModelLike]] = None,
-    subagents: list[SubAgent] = None,
+    subagents: list[SubAgent | CustomSubAgent] = None,
     state_schema: Optional[StateSchemaType] = None,
     builtin_tools: Optional[list[str]] = None,
     interrupt_config: Optional[ToolInterruptConfig] = None,
     config_schema: Optional[Type[Any]] = None,
     checkpointer: Optional[Checkpointer] = None,
     post_model_hook: Optional[Callable] = None,
+    main_agent_tools: Optional[list[str]] = None,
 ):
     """Create a deep agent.
 
@@ -137,6 +142,9 @@ def create_deep_agent(
         config_schema: The schema of the deep agent.
         post_model_hook: Custom post model hook
         checkpointer: Optional checkpointer for persisting agent state between runs.
+        main_agent_tools: Optional list of tool names that the main agent should have. If not provided,
+            will have access to all tools. Note that built-in tools (for filesystem and todo and subagents) are
+            always included - this filtering only applies to passed in tools.
     """
     return _agent_builder(
         tools=tools,
@@ -149,6 +157,7 @@ def create_deep_agent(
         config_schema=config_schema,
         checkpointer=checkpointer,
         post_model_hook=post_model_hook,
+        main_agent_tools=main_agent_tools,
         is_async=False,
     )
 
@@ -157,13 +166,14 @@ def async_create_deep_agent(
     tools: Sequence[Union[BaseTool, Callable, dict[str, Any]]],
     instructions: str,
     model: Optional[Union[str, LanguageModelLike]] = None,
-    subagents: list[SubAgent] = None,
+    subagents: list[SubAgent | CustomSubAgent] = None,
     state_schema: Optional[StateSchemaType] = None,
     builtin_tools: Optional[list[str]] = None,
     interrupt_config: Optional[ToolInterruptConfig] = None,
     config_schema: Optional[Type[Any]] = None,
     checkpointer: Optional[Checkpointer] = None,
     post_model_hook: Optional[Callable] = None,
+    main_agent_tools: Optional[list[str]] = None,
 ):
     """Create a deep agent.
 
@@ -189,6 +199,9 @@ def async_create_deep_agent(
         config_schema: The schema of the deep agent.
         post_model_hook: Custom post model hook
         checkpointer: Optional checkpointer for persisting agent state between runs.
+        main_agent_tools: Optional list of tool names that the main agent should have. If not provided,
+            will have access to all tools. Note that built-in tools (for filesystem and todo and subagents) are
+            always included - this filtering only applies to passed in tools.
     """
     return _agent_builder(
         tools=tools,
@@ -201,5 +214,6 @@ def async_create_deep_agent(
         config_schema=config_schema,
         checkpointer=checkpointer,
         post_model_hook=post_model_hook,
+        main_agent_tools=main_agent_tools,
         is_async=True,
     )

{deepagents-0.0.5rc4 → deepagents-0.0.6rc2}/src/deepagents/interrupt.py

@@ -19,7 +19,8 @@ def create_interrupt_hook(
     """Create a post model hook that handles interrupts using native LangGraph schemas.
 
     Args:
-        tool_configs: Dict mapping tool names to HumanInterruptConfig objects
+        tool_configs: Dict mapping tool names to HumanInterruptConfig objects or boolean values.
+                     If True, uses default HumanInterruptConfig. If False, no interrupt.
         message_prefix: Optional message prefix for interrupt descriptions
     """
     # Right now we don't properly handle `ignore`
@@ -47,7 +48,7 @@ def create_interrupt_hook(
 
         for tool_call in last_message.tool_calls:
             tool_name = tool_call["name"]
-            if tool_name in tool_configs:
+            if tool_name in tool_configs and tool_configs[tool_name]:
                 interrupt_tool_calls.append(tool_call)
             else:
                 auto_approved_tool_calls.append(tool_call)

{deepagents-0.0.5rc4 → deepagents-0.0.6rc2}/src/deepagents/prompts.py

@@ -1,27 +1,29 @@
-WRITE_TODOS_DESCRIPTION = """Use this tool to create and manage a structured task list for your current work session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
+WRITE_TODOS_TOOL_DESCRIPTION = """Use this tool to create and manage a structured task list for your current work session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
 It also helps the user understand the progress of the task and overall progress of their requests.
+Only use this tool if you think it will be helpful in staying organized. If the user's request is trivial and takes less than 3 steps, it is better to NOT use this tool and just do the taks directly.
 
 ## When to Use This Tool
-Use this tool proactively in these scenarios:
+Use this tool in these scenarios:
 
 1. Complex multi-step tasks - When a task requires 3 or more distinct steps or actions
 2. Non-trivial and complex tasks - Tasks that require careful planning or multiple operations
 3. User explicitly requests todo list - When the user directly asks you to use the todo list
 4. User provides multiple tasks - When users provide a list of things to be done (numbered or comma-separated)
-5. After receiving new instructions - Immediately capture user requirements as todos
-6. When you start working on a task - Mark it as in_progress BEFORE beginning work. Ideally you should only have one todo as in_progress at a time
-7. After completing a task - Mark it as completed and add any new follow-up tasks discovered during implementation
+5. The plan may need future revisions or updates based on results from the first few steps. Keeping track of this in a list is helpful.
 
-## When NOT to Use This Tool
+## How to Use This Tool
+1. When you start working on a task - Mark it as in_progress BEFORE beginning work.
+2. After completing a task - Mark it as completed and add any new follow-up tasks discovered during implementation.
+3. You can also update future tasks, such as deleting them if they are no longer necessary, or adding new tasks that are necessary. Don't change previously completed tasks.
+4. You can make several updates to the todo list at once. For example, when you complete a task, you can mark the next task you need to start as in_progress.
 
-Skip using this tool when:
+## When NOT to Use This Tool
+It is important to skip using this tool when:
 1. There is only a single, straightforward task
-2. The task is trivial and tracking it provides no organizational benefit
+2. The task is trivial and tracking it provides no benefit
 3. The task can be completed in less than 3 trivial steps
 4. The task is purely conversational or informational
 
-NOTE that you should not use this tool if there is only one trivial task to do. In this case you are better off just doing the task directly.
-
 ## Examples of When to Use the Todo List
 
 <example>
@@ -37,9 +39,9 @@ Assistant: I'll help add a dark mode toggle to your application settings. Let me
 
 <reasoning>
 The assistant used the todo list because:
-1. Adding dark mode is a multi-step feature requiring UI, state management, and styling changes
-2. The user explicitly requested tests and build be run afterward
-3. The assistant inferred that tests and build need to pass by adding "Ensure tests and build succeed" as the final task
+1. Adding dark mode in it of itself is a multi-step feature requiring UI, state management, and styling changes
+2. The assistant inferred that tests and build need to pass by adding "Ensure tests and build succeed" as the final task
+3. Both of the user's requests are complex and require multiple steps to complete.
 </reasoning>
 </example>
 
@@ -61,7 +63,6 @@ The assistant used the todo list because:
 1. Marketing campaign planning involves multiple distinct channels and activities
 2. Each component requires careful coordination and planning
 3. The systematic approach ensures all aspects of the launch are covered
-4. Progress tracking helps maintain timeline and deliverables
 </reasoning>
 </example>
 
@@ -74,10 +75,10 @@ Assistant: I've found 15 instances of 'getCwd' across 8 different files. Let me
 
 <reasoning>
 The assistant used the todo list because:
-1. First, the assistant searched to understand the scope of the task
-2. Upon finding multiple occurrences across different files, it determined this was a complex task with multiple steps
+1. The assistant searched to understand the scope of the task
+2. Upon finding multiple occurrences across different files, it determined this was a complex task with multiple steps (>3)
 3. The todo list helps ensure every instance is tracked and updated systematically
-4. This approach prevents missing any occurrences and maintains consistency
+4. This approach prevents missing any occurrences and maintains consistency.
 </reasoning>
 </example>
 
@@ -151,19 +152,45 @@ The assistant did not use the todo list because this is a single information loo
 </reasoning>
 </example>
 
+<example>
+User: I need to write a function that checks if a number is prime and then test it out.
+Assistant: I'll help you write a function that checks if a number is prime and then test it out.
+*Writes function that checks if a number is prime*
+*Tests the function*
+
+<reasoning>
+Even though this is a multi-step task, it is very straightforward and can be completed in two trivial steps (which is less than 3 steps!). Using the todo list here is overkill and wastes time and tokens.
+</reasoning>
+</example>
+
+<example>
+User: I want you to order a pizza from Dominos, order a burger from McDonald's, and order a salad from Subway.
+Assistant: I'll help you order a pizza from Dominos, order a burger from McDonald's, and order a salad from Subway.
+*Orders a pizza from Dominos*
+*Orders a burger from McDonald's*
+*Orders a salad from Subway*
+
+<reasoning>
+Even though this is a multi-step task, assuming the assistant has the ability to order from these restaurants, it is very straightforward and can be completed in three trivial tool calls. 
+Using the todo list here is overkill and wastes time and tokens. These three tool calls should be made in parallel, in fact.
+</reasoning>
+</example>
+
+
 ## Task States and Management
 
 1. **Task States**: Use these states to track progress:
    - pending: Task not yet started
-   - in_progress: Currently working on (limit to ONE task at a time)
+   - in_progress: Currently working on (you can have multiple tasks in_progress at a time if they are not related to each other and can be run in parallel)
    - completed: Task finished successfully
 
 2. **Task Management**:
    - Update task status in real-time as you work
    - Mark tasks complete IMMEDIATELY after finishing (don't batch completions)
-   - Only have ONE task in_progress at any time
    - Complete current tasks before starting new ones
    - Remove tasks that are no longer relevant from the list entirely
+   - IMPORTANT: When you write this todo list, you should mark your first task (or tasks) as in_progress immediately!.
+   - IMPORTANT: Unless all tasks are completed, you should always have at least one task in_progress to show the user that you are working on something.
 
 3. **Task Completion Requirements**:
    - ONLY mark a task as completed when you have FULLY accomplished it
@@ -181,36 +208,76 @@ The assistant did not use the todo list because this is a single information loo
    - Break complex tasks into smaller, manageable steps
    - Use clear, descriptive task names
 
-When in doubt, use this tool. Being proactive with task management demonstrates attentiveness and ensures you complete all requirements successfully."""
+Being proactive with task management demonstrates attentiveness and ensures you complete all requirements successfully
+Remember: If you only need to make a few tool calls to complete a task, and it is clear what you need to do, it is better to just do the task directly and NOT call this tool at all.
+"""
 
-TASK_DESCRIPTION_PREFIX = """Launch a new agent to handle complex, multi-step tasks autonomously. 
+TASK_TOOL_DESCRIPTION = """Launch an ephemeral subagent to handle complex, multi-step independent tasks with isolated context windows. 
 
 Available agent types and the tools they have access to:
-- general-purpose: General-purpose agent for researching complex questions, searching for files and content, and executing multi-step tasks. When you are searching for a keyword or file and are not confident that you will find the right match in the first few tries use this agent to perform the search for you. (Tools: *)
+- general-purpose: General-purpose agent for researching complex questions, searching for files and content, and executing multi-step tasks. When you are searching for a keyword or file and are not confident that you will find the right match in the first few tries use this agent to perform the search for you. This agent has access to all tools as the main agent.
 {other_agents}
-"""
-
-TASK_DESCRIPTION_SUFFIX = """When using the Task tool, you must specify a subagent_type parameter to select which agent type to use.
-
-When to use the Agent tool:
-- When you are instructed to execute custom slash commands. Use the Agent tool with the slash command invocation as the entire prompt. The slash command can take arguments. For example: Task(description="Check the file", prompt="/check-file path/to/file.py")
 
-When NOT to use the Agent tool:
-- If you want to read a specific file path, use the Read or Glob tool instead of the Agent tool, to find the match more quickly
-- If you are searching for a specific term or definition within a known location, use the Glob tool instead, to find the match more quickly
-- If you are searching for content within a specific file or set of 2-3 files, use the Read tool instead of the Agent tool, to find the match more quickly
-- Other tasks that are not related to the agent descriptions above
+When using the Task tool, you must specify a subagent_type parameter to select which agent type to use.
 
-
-Usage notes:
+## Usage notes:
 1. Launch multiple agents concurrently whenever possible, to maximize performance; to do that, use a single message with multiple tool uses
 2. When the agent is done, it will return a single message back to you. The result returned by the agent is not visible to the user. To show the user the result, you should send a text message back to the user with a concise summary of the result.
 3. Each agent invocation is stateless. You will not be able to send additional messages to the agent, nor will the agent be able to communicate with you outside of its final report. Therefore, your prompt should contain a highly detailed task description for the agent to perform autonomously and you should specify exactly what information the agent should return back to you in its final and only message to you.
 4. The agent's outputs should generally be trusted
 5. Clearly tell the agent whether you expect it to create content, perform analysis, or just do research (search, file reads, web fetches, etc.), since it is not aware of the user's intent
 6. If the agent description mentions that it should be used proactively, then you should try your best to use it without the user having to ask for it first. Use your judgement.
+7. When only the general-purpose agent is provided, you should use it for all tasks. It is great for isolating context and token usage, and completing specific, complex tasks, as it has all the same capabilities as the main agent.
 
-Example usage:
+### Example usage of the general-purpose agent:
+
+<example_agent_descriptions>
+"general-purpose": use this agent for general purpose tasks, it has access to all tools as the main agent.
+</example_agent_descriptions>
+
+<example>
+User: "I want to conduct research on the accomplishments of Lebron James, Michael Jordan, and Kobe Bryant, and then compare them."
+Assistant: *Uses the task tool in parallel to conduct isolated research on each of the three players*
+Assistant: *Synthesizes the results of the three isolated research tasks and responds to the User*
+<commentary>
+Research is a complex, multi-step task in it of itself.
+The research of each individual player is not dependent on the research of the other players.
+The assistant uses the task tool to break down the complex objective into three isolated tasks.
+Each research task only needs to worry about context and tokens about one player, then returns synthesized information about each player as the Tool Result.
+This means each research task can dive deep and spend tokens and context deeply researching each player, but the final result is synthesized information, and saves us tokens in the long run when comparing the players to each other.
+</commentary>
+</example>
+
+<example>
+User: "Analyze a single large code repository for security vulnerabilities and generate a report."
+Assistant: *Launches a single `task` subagent for the repository analysis*
+Assistant: *Receives report and integrates results into final summary*
+<commentary>
+Subagent is used to isolate a large, context-heavy task, even though there is only one. This prevents the main thread from being overloaded with details.
+If the user then asks followup questions, we have a concise report to reference instead of the entire history of analysis and tool calls, which is good and saves us time and money.
+</commentary>
+</example>
+
+<example>
+User: "Schedule two meetings for me and prepare agendas for each."
+Assistant: *Calls the task tool in parallel to launch two `task` subagents (one per meeting) to prepare agendas*
+Assistant: *Returns final schedules and agendas*
+<commentary>
+Tasks are simple individually, but subagents help silo agenda preparation.
+Each subagent only needs to worry about the agenda for one meeting.
+</commentary>
+</example>
+
+<example>
+User: "I want to order a pizza from Dominos, order a burger from McDonald's, and order a salad from Subway."
+Assistant: *Calls tools directly in parallel to order a pizza from Dominos, a burger from McDonald's, and a salad from Subway*
+<commentary>
+The assistant did not use the task tool because the objective is super simple and clear and only requires a few trivial tool calls.
+It is better to just complete the task directly and NOT use the `task`tool.
+</commentary>
+</example>
+
+### Example usage with custom agents:
 
 <example_agent_descriptions>
 "content-reviewer": use this agent after you are done creating significant content or documents
@@ -224,13 +291,13 @@ assistant: Sure let me write a function that checks if a number is prime
 assistant: First let me use the Write tool to write a function that checks if a number is prime
 assistant: I'm going to use the Write tool to write the following code:
 <code>
-function isPrime(n) {
+function isPrime(n) {{
   if (n <= 1) return false
-  for (let i = 2; i * i <= n; i++) {
+  for (let i = 2; i * i <= n; i++) {{
     if (n % i === 0) return false
-  }
+  }}
   return true
-}
+}}
 </code>
 <commentary>
 Since significant content was created and the task was completed, now use the content-reviewer agent to review the work
@@ -255,16 +322,15 @@ Since the user is greeting, use the greeting-responder agent to respond with a f
 </commentary>
 assistant: "I'm going to use the Task tool to launch with the greeting-responder agent"
 </example>"""
-EDIT_DESCRIPTION = """Performs exact string replacements in files. 
+
+LIST_FILES_TOOL_DESCRIPTION = """Lists all files in the local filesystem.
 
 Usage:
-- You must use your `Read` tool at least once in the conversation before editing. This tool will error if you attempt an edit without reading the file. 
-- When editing text from Read tool output, ensure you preserve the exact indentation (tabs/spaces) as it appears AFTER the line number prefix. The line number prefix format is: spaces + line number + tab. Everything after that tab is the actual file content to match. Never include any part of the line number prefix in the old_string or new_string.
-- ALWAYS prefer editing existing files. NEVER write new files unless explicitly required.
-- Only use emojis if the user explicitly requests it. Avoid adding emojis to files unless asked.
-- The edit will FAIL if `old_string` is not unique in the file. Either provide a larger string with more surrounding context to make it unique or use `replace_all` to change every instance of `old_string`. 
-- Use `replace_all` for replacing and renaming strings across the file. This parameter is useful if you want to rename a variable for instance."""
-TOOL_DESCRIPTION = """Reads a file from the local filesystem. You can access any file directly by using this tool.
+- The list_files tool will return a list of all files in the local filesystem.
+- This is very useful for exploring the file system and finding the right file to read or edit.
+- You should almost ALWAYS use this tool before using the Read or Edit tools."""
+
+READ_FILE_TOOL_DESCRIPTION = """Reads a file from the local filesystem. You can access any file directly by using this tool.
 Assume this tool is able to read all files on the machine. If the User provides a path to a file assume that path is valid. It is okay to read a file that does not exist; an error will be returned.
 
 Usage:
@@ -274,4 +340,76 @@ Usage:
 - Any lines longer than 2000 characters will be truncated
 - Results are returned using cat -n format, with line numbers starting at 1
 - You have the capability to call multiple tools in a single response. It is always better to speculatively read multiple files as a batch that are potentially useful. 
-- If you read a file that exists but has empty contents you will receive a system reminder warning in place of file contents."""
+- If you read a file that exists but has empty contents you will receive a system reminder warning in place of file contents.
+- You should ALWAYS make sure a file has been read before editing it."""
+
+EDIT_FILE_TOOL_DESCRIPTION = """Performs exact string replacements in files. 
+
+Usage:
+- You must use your `Read` tool at least once in the conversation before editing. This tool will error if you attempt an edit without reading the file. 
+- When editing text from Read tool output, ensure you preserve the exact indentation (tabs/spaces) as it appears AFTER the line number prefix. The line number prefix format is: spaces + line number + tab. Everything after that tab is the actual file content to match. Never include any part of the line number prefix in the old_string or new_string.
+- ALWAYS prefer editing existing files. NEVER write new files unless explicitly required.
+- Only use emojis if the user explicitly requests it. Avoid adding emojis to files unless asked.
+- The edit will FAIL if `old_string` is not unique in the file. Either provide a larger string with more surrounding context to make it unique or use `replace_all` to change every instance of `old_string`. 
+- Use `replace_all` for replacing and renaming strings across the file. This parameter is useful if you want to rename a variable for instance."""
+
+WRITE_FILE_TOOL_DESCRIPTION = """Writes to a file in the local filesystem.
+
+Usage:
+- The file_path parameter must be an absolute path, not a relative path
+- The content parameter must be a string
+- The write_file tool will create the a new file.
+- Prefer to edit existing files over creating new ones when possible."""
+
+
+BASE_AGENT_PROMPT = """In order to complete the objective that the user asks ofyou, you have access to a number of standard tools.
+
+## `write_todos`
+
+You have access to the `write_todos` tool to help you manage and plan complex objectives. 
+Use this tool for complex objectives to ensure that you are tracking each necessary step and giving the user visibility into your progress.
+This tool is very helpful for planning complex objectives, and for breaking down these larger complex objectives into smaller steps.
+
+It is critical that you mark todos as completed as soon as you are done with a step. Do not batch up multiple steps before marking them as completed.
+For simple objectives that only require a few steps, it is better to just complete the objective directly and NOT use this tool.
+Writing todos takes time and tokens, use it when it is helpful for managing complex many-step problems! But not for simple few-step requests.
+
+IMPORTANT: The `write_todos` tool should never be called multiple times in parallel.
+
+## `task` (subagent spawner)
+
+You have access to a `task` tool to launch short-lived subagents that handle isolated tasks. These agents are ephemeral — they live only for the duration of the task and return a single result.
+
+When to use the task tool:
+- When a task is complex and multi-step, and can be fully delegated in isolation
+- When a task is independent of other tasks and can run in parallel
+- When a task requires focused reasoning or heavy token/context usage that would bloat the orchestrator thread
+- When sandboxing improves reliability (e.g. code execution, structured searches, data formatting)
+- When you only care about the output of the subagent, and not the intermediate steps (ex. performing a lot of research and then returned a synthesized report, performing a series of computations or lookups to achieve a concise, relevant answer.)
+
+Subagent lifecycle:
+1. **Spawn** → Provide clear role, instructions, and expected output
+2. **Run** → The subagent completes the task autonomously
+3. **Return** → The subagent provides a single structured result
+4. **Reconcile** → Incorporate or synthesize the result into the main thread
+
+When NOT to use the task tool:
+- If you need to see the intermediate reasoning or steps after the subagent has completed (the task tool hides them)
+- If the task is trivial (a few tool calls or simple lookup)
+- If delegating does not reduce token usage, complexity, or context switching
+- If splitting would add latency without benefit
+
+## Filesystem Tools `ls`, `read_file`, `write_file`, `edit_file`
+
+You have access to a local, private filesystem which you can interact with using these tools.
+- ls: list all files in the local filesystem
+- read_file: read a file from the local filesystem
+- write_file: write to a file in the local filesystem
+- edit_file: edit a file in the local filesystem
+
+# Important Usage Notes to Remember
+- Don't be afraid to revise the To-Do list as you go. New information may reveal new tasks that need to be done, or old tasks that are irrelevant.
+- Whenever possible, parallelize the work that you do. This is true for both tool_calls, and for tasks. Whenever you have independent steps to complete - make tool_calls, or kick off tasks (subagents) in parallel to accomplish them faster. This saves time for the user, which is incredibly important.
+- Remember to use the `task` tool to silo independent tasks within a multi-part objective.
+- You should use the `task` tool whenever you have a complex task that will take multiple steps, and is independent from other tasks that the agent needs to complete. These agents are highly competent and efficient.
+"""

{deepagents-0.0.5rc4 → deepagents-0.0.6rc2}/src/deepagents/sub_agent.py

@@ -1,4 +1,4 @@
-from deepagents.prompts import TASK_DESCRIPTION_PREFIX, TASK_DESCRIPTION_SUFFIX
+from deepagents.prompts import TASK_TOOL_DESCRIPTION
 from deepagents.state import DeepAgentState
 from langgraph.prebuilt import create_react_agent
 from langchain_core.tools import BaseTool
@@ -9,6 +9,7 @@ from langchain_core.language_models import LanguageModelLike
 from langchain.chat_models import init_chat_model
 from typing import Annotated, NotRequired, Any, Union, Optional, Callable
 from langgraph.types import Command
+from langchain_core.runnables import Runnable
 
 from langgraph.prebuilt import InjectedState
 
@@ -22,10 +23,28 @@ class SubAgent(TypedDict):
     model: NotRequired[Union[LanguageModelLike, dict[str, Any]]]
 
 
-def _get_agents(tools, instructions, subagents: list[SubAgent], model, state_schema, post_model_hook: Optional[Callable] = None):
+class CustomSubAgent(TypedDict):
+    name: str
+    description: str
+    graph: Runnable
+
+
+def _get_agents(
+    tools,
+    instructions,
+    subagents: list[SubAgent | CustomSubAgent],
+    model,
+    state_schema,
+    post_model_hook: Optional[Callable] = None,
+):
     agents = {
         "general-purpose": create_react_agent(
-            model, prompt=instructions, tools=tools, checkpointer=False, post_model_hook=post_model_hook
+            model,
+            prompt=instructions,
+            tools=tools,
+            checkpointer=False,
+            post_model_hook=post_model_hook,
+            state_schema=state_schema,
         )
     }
     tools_by_name = {}
@@ -34,6 +53,9 @@ def _get_agents(tools, instructions, subagents: list[SubAgent], model, state_sch
             tool_ = tool(tool_)
         tools_by_name[tool_.name] = tool_
     for _agent in subagents:
+        if "graph" in _agent:
+            agents[_agent["name"]] = _agent["graph"]
+            continue
         if "tools" in _agent:
             _tools = [tools_by_name[t] for t in _agent["tools"]]
         else:
@@ -61,19 +83,25 @@ def _get_agents(tools, instructions, subagents: list[SubAgent], model, state_sch
     return agents
 
 
-def _get_subagent_description(subagents):
+def _get_subagent_description(subagents: list[SubAgent | CustomSubAgent]):
     return [f"- {_agent['name']}: {_agent['description']}" for _agent in subagents]
 
 
 def _create_task_tool(
-    tools, instructions, subagents: list[SubAgent], model, state_schema, post_model_hook: Optional[Callable] = None
+    tools,
+    instructions,
+    subagents: list[SubAgent | CustomSubAgent],
+    model,
+    state_schema,
+    post_model_hook: Optional[Callable] = None,
 ):
-    agents = _get_agents(tools, instructions, subagents, model, state_schema, post_model_hook)
+    agents = _get_agents(
+        tools, instructions, subagents, model, state_schema, post_model_hook
+    )
     other_agents_string = _get_subagent_description(subagents)
 
     @tool(
-        description=TASK_DESCRIPTION_PREFIX.format(other_agents=other_agents_string)
-        + TASK_DESCRIPTION_SUFFIX
+        description=TASK_TOOL_DESCRIPTION.format(other_agents=other_agents_string)
     )
     async def task(
         description: str,
@@ -101,14 +129,20 @@ def _create_task_tool(
 
 
 def _create_sync_task_tool(
-    tools, instructions, subagents: list[SubAgent], model, state_schema, post_model_hook: Optional[Callable] = None
+    tools,
+    instructions,
+    subagents: list[SubAgent | CustomSubAgent],
+    model,
+    state_schema,
+    post_model_hook: Optional[Callable] = None,
 ):
-    agents = _get_agents(tools, instructions, subagents, model, state_schema, post_model_hook)
+    agents = _get_agents(
+        tools, instructions, subagents, model, state_schema, post_model_hook
+    )
     other_agents_string = _get_subagent_description(subagents)
 
     @tool(
-        description=TASK_DESCRIPTION_PREFIX.format(other_agents=other_agents_string)
-        + TASK_DESCRIPTION_SUFFIX
+        description=TASK_TOOL_DESCRIPTION.format(other_agents=other_agents_string)
     )
     def task(
         description: str,

{deepagents-0.0.5rc4 → deepagents-0.0.6rc2}/src/deepagents/tools.py

@@ -5,14 +5,16 @@ from typing import Annotated, Union
 from langgraph.prebuilt import InjectedState
 
 from deepagents.prompts import (
-    WRITE_TODOS_DESCRIPTION,
-    EDIT_DESCRIPTION,
-    TOOL_DESCRIPTION,
+    WRITE_TODOS_TOOL_DESCRIPTION,
+    LIST_FILES_TOOL_DESCRIPTION,
+    READ_FILE_TOOL_DESCRIPTION,
+    WRITE_FILE_TOOL_DESCRIPTION,
+    EDIT_FILE_TOOL_DESCRIPTION,
 )
 from deepagents.state import Todo, DeepAgentState
 
 
-@tool(description=WRITE_TODOS_DESCRIPTION)
+@tool(description=WRITE_TODOS_TOOL_DESCRIPTION)
 def write_todos(
     todos: list[Todo], tool_call_id: Annotated[str, InjectedToolCallId]
 ) -> Command:
@@ -26,19 +28,19 @@ def write_todos(
     )
 
 
+@tool(description=LIST_FILES_TOOL_DESCRIPTION)
 def ls(state: Annotated[DeepAgentState, InjectedState]) -> list[str]:
     """List all files"""
     return list(state.get("files", {}).keys())
 
 
-@tool(description=TOOL_DESCRIPTION)
+@tool(description=READ_FILE_TOOL_DESCRIPTION)
 def read_file(
     file_path: str,
     state: Annotated[DeepAgentState, InjectedState],
     offset: int = 0,
     limit: int = 2000,
 ) -> str:
-    """Read file."""
     mock_filesystem = state.get("files", {})
     if file_path not in mock_filesystem:
         return f"Error: File '{file_path}' not found"
@@ -77,13 +79,13 @@ def read_file(
     return "\n".join(result_lines)
 
 
+@tool(description=WRITE_FILE_TOOL_DESCRIPTION)
 def write_file(
     file_path: str,
     content: str,
     state: Annotated[DeepAgentState, InjectedState],
     tool_call_id: Annotated[str, InjectedToolCallId],
 ) -> Command:
-    """Write to a file."""
     files = state.get("files", {})
     files[file_path] = content
     return Command(
@@ -96,7 +98,7 @@ def write_file(
     )
 
 
-@tool(description=EDIT_DESCRIPTION)
+@tool(description=EDIT_FILE_TOOL_DESCRIPTION)
 def edit_file(
     file_path: str,
     old_string: str,