deepagents 1.0.0 → 1.1.0

package/LICENSE

@@ -1,6 +1,6 @@
-MIT License
+The MIT License
 
-Copyright (c) 2025 Oleksandr Shevtsov
+Copyright (c) LangChain, Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -9,13 +9,13 @@ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -1,151 +1,555 @@
-## This is an unofficial port of the [hwchase17/deepagents](https://github.com/hwchase17/deepagents) Python package to TypeScript
-
 # 🧠🤖Deep Agents
 
 Using an LLM to call tools in a loop is the simplest form of an agent.
-This architecture, however, can yield agents that are “shallow” and fail to plan and act over longer, more complex tasks.
-Applications like “Deep Research”, "Manus", and “Claude Code” have gotten around this limitation by implementing a combination of four things:
+This architecture, however, can yield agents that are "shallow" and fail to plan and act over longer, more complex tasks.
+
+Applications like "Deep Research", "Manus", and "Claude Code" have gotten around this limitation by implementing a combination of four things:
 a **planning tool**, **sub agents**, access to a **file system**, and a **detailed prompt**.
 
-<img src="deep_agents.png" alt="deep agent" width="600"/>
+> 💡 **Tip:** Looking for the Python version of this package? See [here: langchain-ai/deepagents](https://github.com/langchain-ai/deepagents)
+
+<!-- TODO: Add image here -->
 
-`deepagents` is a Typescript package that implements these in a general purpose way so that you can easily create a Deep Agent for your application.
+`deepagents` is a TypeScript package that implements these in a general purpose way so that you can easily create a Deep Agent for your application.
 
 **Acknowledgements: This project was primarily inspired by Claude Code, and initially was largely an attempt to see what made Claude Code general purpose, and make it even more so.**
 
 ## Installation
 
 ```bash
+# npm
 npm install deepagents
+
+# yarn
+yarn add deepagents
+
+# pnpm
+pnpm add deepagents
 ```
 
 ## Usage
 
-> NB! This part of documentation is not fully migrated
+(To run the example below, you will need to `npm install @langchain/tavily`).
 
-See [src/examples/research/agent.ts](src/examples/research/agent.ts) for a more complex example.
+Make sure to set `TAVILY_API_KEY` in your environment. You can generate one [here](https://www.tavily.com/).
+
+```typescript
+import { tool } from "langchain";
+import { TavilySearch } from "@langchain/tavily";
+import { createDeepAgent } from "deepagents";
+import { z } from "zod";
+
+// Web search tool
+const internetSearch = tool(
+  async ({
+    query,
+    maxResults = 5,
+    topic = "general",
+    includeRawContent = false,
+  }: {
+    query: string;
+    maxResults?: number;
+    topic?: "general" | "news" | "finance";
+    includeRawContent?: boolean;
+  }) => {
+    const tavilySearch = new TavilySearch({
+      maxResults,
+      tavilyApiKey: process.env.TAVILY_API_KEY,
+      includeRawContent,
+      topic,
+    });
+    return await tavilySearch._call({ query });
+  },
+  {
+    name: "internet_search",
+    description: "Run a web search",
+    schema: z.object({
+      query: z.string().describe("The search query"),
+      maxResults: z
+        .number()
+        .optional()
+        .default(5)
+        .describe("Maximum number of results to return"),
+      topic: z
+        .enum(["general", "news", "finance"])
+        .optional()
+        .default("general")
+        .describe("Search topic category"),
+      includeRawContent: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe("Whether to include raw content"),
+    }),
+  },
+);
+
+// System prompt to steer the agent to be an expert researcher
+const researchInstructions = `You are an expert researcher. Your job is to conduct thorough research, and then write a polished report.
+
+You have access to an internet search tool as your primary means of gathering information.
+
+## \`internet_search\`
+
+Use this to run an internet search for a given query. You can specify the max number of results to return, the topic, and whether raw content should be included.
+`;
+
+// Create the deep agent
+const agent = createDeepAgent({
+  tools: [internetSearch],
+  systemPrompt: researchInstructions,
+});
+
+// Invoke the agent
+const result = await agent.invoke({
+  messages: [{ role: "user", content: "What is langgraph?" }],
+});
+```
+
+See [examples/research/research-agent.ts](examples/research/research-agent.ts) for a more complex example.
 
 The agent created with `createDeepAgent` is just a LangGraph graph - so you can interact with it (streaming, human-in-the-loop, memory, studio)
 in the same way you would any LangGraph agent.
 
-## Creating a custom deep agent
+## Core Capabilities
 
-There is an option argument with three properties you can pass to `createDeepAgent` to create your own custom deep agent.
+**Planning & Task Decomposition**
 
-### `tools` (Required)
+Deep Agents include a built-in `write_todos` tool that enables agents to break down complex tasks into discrete steps, track progress, and adapt plans as new information emerges.
 
-This should be a list of functions or LangChain `@tool` objects.
-The agent (and any subagents) will have access to these tools.
+**Context Management**
 
-### `instructions` (Required)
+File system tools (`ls`, `read_file`, `write_file`, `edit_file`, `glob`, `grep`) allow agents to offload large context to memory, preventing context window overflow and enabling work with variable-length tool results.
 
-This will serve as part of the prompt of the deep agent.
-Note that there is a [built in system prompt](#built-in-prompt) as well, so this is not the _entire_ prompt the agent will see.
+**Subagent Spawning**
 
-### `subagents` (Optional)
+A built-in `task` tool enables agents to spawn specialized subagents for context isolation. This keeps the main agent's context clean while still going deep on specific subtasks.
 
-This can be used to specify any custom subagents this deep agent will have access to.
-You can read more about why you would want to use subagents [here](#sub-agents)
-`subagents` should be a list of dictionaries, where each dictionary follow this schema:
+**Long-term Memory**
 
-```js
-export interface SubAgent {
-    name: string;
-    description: string;
-    prompt: string;
-    tools?: string[];
-}
+Extend agents with persistent memory across threads using LangGraph's Store. Agents can save and retrieve information from previous conversations.
+
+## Customizing Deep Agents
+
+There are several parameters you can pass to `createDeepAgent` to create your own custom deep agent.
+
+### `model`
+
+By default, `deepagents` uses `"claude-sonnet-4-5-20250929"`. You can customize this by passing any [LangChain model object](https://js.langchain.com/docs/integrations/chat/).
+
+```typescript
+import { ChatAnthropic } from "@langchain/anthropic";
+import { ChatOpenAI } from "@langchain/openai";
+import { createDeepAgent } from "deepagents";
+
+// Using Anthropic
+const agent = createDeepAgent({
+  model: new ChatAnthropic({
+    model: "claude-sonnet-4-20250514",
+    temperature: 0,
+  }),
+});
+
+// Using OpenAI
+const agent2 = createDeepAgent({
+  model: new ChatOpenAI({
+    model: "gpt-5",
+    temperature: 0,
+  }),
+});
 ```
 
--   **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.
+### `systemPrompt`
 
-To use it looks like:
+Deep Agents come with a built-in system prompt. This is relatively detailed prompt that is heavily based on and inspired by [attempts](https://github.com/kn1026/cc/blob/main/claudecode.md) to [replicate](https://github.com/asgeirtj/system_prompts_leaks/blob/main/Anthropic/claude-code.md)
+Claude Code's system prompt. It was made more general purpose than Claude Code's system prompt. The default prompt contains detailed instructions for how to use the built-in planning tool, file system tools, and sub agents.
 
-```js
-import { createDeepAgent, SubAgent } from "deepagents";
+Each deep agent tailored to a use case should include a custom system prompt specific to that use case as well. The importance of prompting for creating a successful deep agent cannot be overstated.
+
+```typescript
+import { createDeepAgent } from "deepagents";
+
+const researchInstructions = `You are an expert researcher. Your job is to conduct thorough research, and then write a polished report.`;
+
+const agent = createDeepAgent({
+  systemPrompt: researchInstructions,
+});
+```
+
+### `tools`
+
+Just like with tool-calling agents, you can provide a deep agent with a set of tools that it has access to.
+
+```typescript
+import { tool } from "langchain";
+import { TavilySearch } from "@langchain/tavily";
+import { createDeepAgent } from "deepagents";
+import { z } from "zod";
+
+const internetSearch = tool(
+  async ({
+    query,
+    maxResults = 5,
+    topic = "general",
+    includeRawContent = false,
+  }: {
+    query: string;
+    maxResults?: number;
+    topic?: "general" | "news" | "finance";
+    includeRawContent?: boolean;
+  }) => {
+    const tavilySearch = new TavilySearch({
+      maxResults,
+      tavilyApiKey: process.env.TAVILY_API_KEY,
+      includeRawContent,
+      topic,
+    });
+    return await tavilySearch._call({ query });
+  },
+  {
+    name: "internet_search",
+    description: "Run a web search",
+    schema: z.object({
+      query: z.string().describe("The search query"),
+      maxResults: z.number().optional().default(5),
+      topic: z
+        .enum(["general", "news", "finance"])
+        .optional()
+        .default("general"),
+      includeRawContent: z.boolean().optional().default(false),
+    }),
+  },
+);
 
-const researchSubAgent: SubAgent = {
-    name: "research-agent",
-    description: "Used to research more in depth questions...",
-    prompt: subResearchPrompt,
-    tools: ["internet_search"],
-};
 const agent = createDeepAgent({
-    instructions: researchInstructions,
-    subagents: [researchSubAgent],
-    tools: [internetSearch],
+  tools: [internetSearch],
 });
 ```
 
-### `model` (Optional)
+### `middleware`
 
-By default, `deepagents` will use local LM Studio. If you want to use a different model,
-you can pass a [LangChain model object](https://js.langchain.com/docs/integrations/chat/).
+`createDeepAgent` is implemented with middleware that can be customized. You can provide additional middleware to extend functionality, add tools, or implement custom hooks.
 
-## Deep Agent Details
+```typescript
+import { tool } from "langchain";
+import { createDeepAgent } from "deepagents";
+import type { AgentMiddleware } from "langchain";
+import { z } from "zod";
+
+const getWeather = tool(
+  async ({ city }: { city: string }) => {
+    return `The weather in ${city} is sunny.`;
+  },
+  {
+    name: "get_weather",
+    description: "Get the weather in a city.",
+    schema: z.object({
+      city: z.string().describe("The city to get weather for"),
+    }),
+  },
+);
+
+const getTemperature = tool(
+  async ({ city }: { city: string }) => {
+    return `The temperature in ${city} is 70 degrees Fahrenheit.`;
+  },
+  {
+    name: "get_temperature",
+    description: "Get the temperature in a city.",
+    schema: z.object({
+      city: z.string().describe("The city to get temperature for"),
+    }),
+  },
+);
+
+class WeatherMiddleware implements AgentMiddleware {
+  tools = [getWeather, getTemperature];
+}
 
-The below components are built into `deepagents` and helps make it work for deep tasks off-the-shelf.
+const agent = createDeepAgent({
+  model: "claude-sonnet-4-20250514",
+  middleware: [new WeatherMiddleware()],
+});
+```
 
-### System Prompt
+### `subagents`
 
-`deepagents` comes with a [built-in system prompt](src/prompts.ts). This is relatively detailed prompt that is heavily based on and inspired by [attempts](https://github.com/kn1026/cc/blob/main/claudecode.md) to [replicate](https://github.com/asgeirtj/system_prompts_leaks/blob/main/Anthropic/claude-code.md)
-Claude Code's system prompt. It was made more general purpose than Claude Code's system prompt.
-This contains detailed instructions for how to use the built-in planning tool, file system tools, and sub agents.
-Note that part of this system prompt [can be customized](#promptprefix--required-)
+A main feature of Deep Agents is their ability to spawn subagents. You can specify custom subagents that your agent can hand off work to in the subagents parameter. Sub agents are useful for context quarantine (to help not pollute the overall context of the main agent) as well as custom instructions.
 
-Without this default system prompt - the agent would not be nearly as successful at going as it is.
-The importance of prompting for creating a "deep" agent cannot be understated.
+`subagents` should be a list of objects that follow the `SubAgent` interface:
 
-### Planing Tool
+```typescript
+interface SubAgent {
+  name: string;
+  description: string;
+  systemPrompt: string;
+  tools?: StructuredTool[];
+  model?: LanguageModelLike | string;
+  middleware?: AgentMiddleware[];
+  interruptOn?: Record<string, boolean | InterruptOnConfig>;
+}
+```
 
-`deepagents` comes with a built-in planning tool. This planning tool is very simple and is based on ClaudeCode's TodoWrite tool.
-This tool doesn't actually do anything - it is just a way for the agent to come up with a plan, and then have that in the context to help keep it on track.
+**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
+- **systemPrompt**: This is the prompt used for the subagent
+- **tools**: This is the list of tools that the subagent has access to.
+- **model**: Optional model name or model instance.
+- **middleware**: Additional middleware to attach to the subagent. See [here](https://docs.langchain.com/oss/typescript/langchain/middleware) for an introduction into middleware and how it works with createAgent.
+- **interruptOn**: A custom interrupt config that specifies human-in-the-loop interactions for your tools.
+
+#### Using SubAgent
+
+```typescript
+import { tool } from "langchain";
+import { TavilySearch } from "@langchain/tavily";
+import { createDeepAgent, type SubAgent } from "deepagents";
+import { z } from "zod";
+
+const internetSearch = tool(
+  async ({
+    query,
+    maxResults = 5,
+    topic = "general",
+    includeRawContent = false,
+  }: {
+    query: string;
+    maxResults?: number;
+    topic?: "general" | "news" | "finance";
+    includeRawContent?: boolean;
+  }) => {
+    const tavilySearch = new TavilySearch({
+      maxResults,
+      tavilyApiKey: process.env.TAVILY_API_KEY,
+      includeRawContent,
+      topic,
+    });
+    return await tavilySearch._call({ query });
+  },
+  {
+    name: "internet_search",
+    description: "Run a web search",
+    schema: z.object({
+      query: z.string(),
+      maxResults: z.number().optional().default(5),
+      topic: z
+        .enum(["general", "news", "finance"])
+        .optional()
+        .default("general"),
+      includeRawContent: z.boolean().optional().default(false),
+    }),
+  },
+);
+
+const researchSubagent: SubAgent = {
+  name: "research-agent",
+  description: "Used to research more in depth questions",
+  systemPrompt: "You are a great researcher",
+  tools: [internetSearch],
+  model: "gpt-4o", // Optional override, defaults to main agent model
+};
 
-### File System Tools
+const subagents = [researchSubagent];
 
-`deepagents` comes with four built-in file system tools: `ls`, `edit_file`, `read_file`, `write_file`.
-These do not actually use a file system - rather, they mock out a file system using LangGraph's State object.
-This means you can easily run many of these agents on the same machine without worrying that they will edit the same underlying files.
+const agent = createDeepAgent({
+  model: "claude-sonnet-4-20250514",
+  subagents: subagents,
+});
+```
+
+### `interruptOn`
 
-Right now the "file system" will only be one level deep (no sub directories).
+A common reality for agents is that some tool operations may be sensitive and require human approval before execution. Deep Agents supports human-in-the-loop workflows through LangGraph's interrupt capabilities. You can configure which tools require approval using a checkpointer.
 
-These files can be passed in (and also retrieved) by using the `files` key in the LangGraph State object.
+These tool configs are passed to our prebuilt [HITL middleware](https://docs.langchain.com/oss/typescript/langchain/middleware#human-in-the-loop) so that the agent pauses execution and waits for feedback from the user before executing configured tools.
 
-```js
+```typescript
+import { tool } from "langchain";
 import { createDeepAgent } from "deepagents";
+import { z } from "zod";
+
+const getWeather = tool(
+  async ({ city }: { city: string }) => {
+    return `The weather in ${city} is sunny.`;
+  },
+  {
+    name: "get_weather",
+    description: "Get the weather in a city.",
+    schema: z.object({
+      city: z.string(),
+    }),
+  },
+);
 
 const agent = createDeepAgent({
-    instructions: researchInstructions,
-    subagents: [critiqueSubAgent, researchSubAgent],
-    tools: [internetSearch],
+  model: "claude-sonnet-4-20250514",
+  tools: [getWeather],
+  interruptOn: {
+    get_weather: {
+      allowedDecisions: ["approve", "edit", "reject"],
+    },
+  },
 });
+```
 
-const result = await agent.invoke({
-    messages: [new HumanMessage("what is langchain?")],
-    files: [{"README.md": "# Deep Agents\n\nThis is a README file for the deep agents example."}],
+### `backend`
+
+Deep Agents use backends to manage file system operations and memory storage. You can configure different backends depending on your needs:
+
+```typescript
+import {
+  createDeepAgent,
+  StateBackend,
+  StoreBackend,
+  FilesystemBackend,
+  CompositeBackend,
+} from "deepagents";
+import { MemorySaver } from "@langchain/langgraph";
+import { InMemoryStore } from "@langchain/langgraph-checkpoint";
+
+// Default: StateBackend (in-memory, ephemeral)
+const agent1 = createDeepAgent({
+  // No backend specified - uses StateBackend by default
+});
+
+// StoreBackend: Persistent storage using LangGraph Store
+const agent2 = createDeepAgent({
+  backend: (config) => new StoreBackend(config),
+  store: new InMemoryStore(), // Provide a store
+  checkpointer: new MemorySaver(), // Optional: for conversation persistence
 });
 
-# Access any files afterwards like this
-result.files
+// FilesystemBackend: Store files on actual filesystem
+const agent3 = createDeepAgent({
+  backend: (config) => new FilesystemBackend({ rootDir: "./agent-workspace" }),
+});
+
+// CompositeBackend: Combine multiple backends
+const agent4 = createDeepAgent({
+  backend: (config) =>
+    new CompositeBackend({
+      state: new StateBackend(config),
+      store: config.store ? new StoreBackend(config) : undefined,
+    }),
+  store: new InMemoryStore(),
+  checkpointer: new MemorySaver(),
+});
 ```
 
-### Sub Agents
+See [examples/backends/](examples/backends/) for detailed examples of each backend type.
+
+## Deep Agents Middleware
+
+Deep Agents are built with a modular middleware architecture. As a reminder, Deep Agents have access to:
 
-`deepagents` comes with the built-in ability to call sub agents (based on Claude Code).
-It has access to a `general-purpose` subagent at all times - this is a subagent with the same instructions as the main agent and all the tools that is has access to.
-You can also specify [custom sub agents](#subagents--optional-) with their own instructions and tools.
+- A planning tool
+- A filesystem for storing context and long-term memories
+- The ability to spawn subagents
 
-Sub agents are useful for ["context quarantine"](https://www.dbreunig.com/2025/06/26/how-to-fix-your-context.html#context-quarantine) (to help not pollute the overall context of the main agent)
-as well as custom instructions.
+Each of these features is implemented as separate middleware. When you create a deep agent with `createDeepAgent`, we automatically attach **todoListMiddleware**, **FilesystemMiddleware** and **SubAgentMiddleware** to your agent.
 
-## Roadmap
+Middleware is a composable concept, and you can choose to add as many or as few middleware to an agent depending on your use case. That means that you can also use any of the aforementioned middleware independently!
 
--   [ ] Allow users to customize full system prompt
--   [ ] Code cleanliness (type hinting, docstrings, formating)
--   [ ] Allow for more of a robust virtual filesystem
--   [ ] Create an example of a deep coding agent built on top of this
--   [ ] Benchmark the example of [deep research agent](src/examples/research/agent.ts)
--   [ ] Add human-in-the-loop support for tools
+### TodoListMiddleware
+
+Planning is integral to solving complex problems. If you've used claude code recently, you'll notice how it writes out a To-Do list before tackling complex, multi-part tasks. You'll also notice how it can adapt and update this To-Do list on the fly as more information comes in.
+
+**todoListMiddleware** provides your agent with a tool specifically for updating this To-Do list. Before, and while it executes a multi-part task, the agent is prompted to use the write_todos tool to keep track of what its doing, and what still needs to be done.
+
+```typescript
+import { createAgent, todoListMiddleware } from "langchain";
+
+// todoListMiddleware is included by default in createDeepAgent
+// You can customize it if building a custom agent
+const agent = createAgent({
+  model: "claude-sonnet-4-20250514",
+  middleware: [
+    todoListMiddleware({
+      // Optional: Custom addition to the system prompt
+      systemPrompt: "Use the write_todos tool to...",
+    }),
+  ],
+});
+```
+
+### FilesystemMiddleware
+
+Context engineering is one of the main challenges in building effective agents. This can be particularly hard when using tools that can return variable length results (ex. web_search, rag), as long ToolResults can quickly fill up your context window.
+
+**FilesystemMiddleware** provides tools to your agent to interact with both short-term and long-term memory:
+
+- **ls**: List the files in your filesystem
+- **read_file**: Read an entire file, or a certain number of lines from a file
+- **write_file**: Write a new file to your filesystem
+- **edit_file**: Edit an existing file in your filesystem
+- **glob**: Find files matching a pattern
+- **grep**: Search for text within files
+
+```typescript
+import { createAgent } from "langchain";
+import { createFilesystemMiddleware } from "deepagents";
+
+// FilesystemMiddleware is included by default in createDeepAgent
+// You can customize it if building a custom agent
+const agent = createAgent({
+  model: "claude-sonnet-4-20250514",
+  middleware: [
+    createFilesystemMiddleware({
+      backend: ..., // Optional: customize storage backend
+      systemPrompt: "Write to the filesystem when...", // Optional custom system prompt override
+      customToolDescriptions: {
+        ls: "Use the ls tool when...",
+        read_file: "Use the read_file tool to...",
+      }, // Optional: Custom descriptions for filesystem tools
+    }),
+  ],
+});
+```
+
+### SubAgentMiddleware
+
+Handing off tasks to subagents is a great way to isolate context, keeping the context window of the main (supervisor) agent clean while still going deep on a task. The subagents middleware allows you supply subagents through a task tool.
+
+A subagent is defined with a name, description, system prompt, and tools. You can also provide a subagent with a custom model, or with additional middleware. This can be particularly useful when you want to give the subagent an additional state key to share with the main agent.
+
+```typescript
+import { tool } from "langchain";
+import { createAgent } from "langchain";
+import { createSubAgentMiddleware, type SubAgent } from "deepagents";
+import { z } from "zod";
+
+const getWeather = tool(
+  async ({ city }: { city: string }) => {
+    return `The weather in ${city} is sunny.`;
+  },
+  {
+    name: "get_weather",
+    description: "Get the weather in a city.",
+    schema: z.object({
+      city: z.string(),
+    }),
+  },
+);
+
+const weatherSubagent: SubAgent = {
+  name: "weather",
+  description: "This subagent can get weather in cities.",
+  systemPrompt: "Use the get_weather tool to get the weather in a city.",
+  tools: [getWeather],
+  model: "gpt-4o",
+  middleware: [],
+};
+
+const agent = createAgent({
+  model: "claude-sonnet-4-20250514",
+  middleware: [
+    createSubAgentMiddleware({
+      defaultModel: "claude-sonnet-4-20250514",
+      defaultTools: [],
+      subagents: [weatherSubagent],
+    }),
+  ],
+});
+```