Skip to main content
Deep Agents can call any tool you define, any LangChain tool, and tools from any MCP server. Pass them to create_deep_agent via the tools= parameter alongside the built-in harness tools for planning, file management, and subagent spawning. 
import { createDeepAgent } from "deepagents";

const agent = await createDeepAgent({
  model: "anthropic:claude-sonnet-4-6",
  tools: [search, fetchUrl, runQuery],
});

​
Custom tools

Pass any callable — plain functions, LangChain @tool-decorated functions, or tool dicts — directly to tools=. Deep Agents infers the tool schema from the function signature and docstring, so you don’t need to define a separate schema in most cases. 
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 agent = createDeepAgent({
  model: "google-genai:gemini-3.5-flash",
  tools: [internetSearch],
});
For full details on defining and using LangChain tools (tool dicts, StructuredTool, return types, error handling, and more), see Tools.

​
MCP tools

Deep Agents fully support Model Context Protocol (MCP) — the open standard for connecting agents to external services. Load tools from any MCP server and pass them directly to create_deep_agent.
MCP is an open protocol that lets agents connect to a growing ecosystem of servers — databases, APIs, file systems, browsers, and more — through a standard interface. Instead of writing custom integration code for each service, you point Deep Agents at an MCP server and it gets all the tools that server exposes. Install @langchain/mcp-adapters to connect to MCP servers: 
npm install @langchain/mcp-adapters

import { MultiServerMCPClient } from "@langchain/mcp-adapters";
import { createDeepAgent } from "deepagents";

const client = new MultiServerMCPClient({
  my_server: {
    transport: "http",
    url: "http://localhost:8000/mcp",
  },
});

const tools = await client.getTools();

const agent = await createDeepAgent({
  model: "openai:gpt-5.4",
  tools,
});

const result = await agent.invoke({
  messages: [{ role: "user", content: "Use the MCP server to help me." }],
});
For detailed configuration options — including stdio servers, OAuth authentication, tool filtering, and stateful sessions — see the full MCP guide.

​
Built-in harness tools

In addition to the tools you provide, every Deep Agent comes with a built-in set of tools from the harness:
ToolDescription
lsList files in a directory
read_fileRead file contents (with pagination and multimodal support)
write_fileCreate new files
edit_filePerform exact string replacements in files
globFind files matching a glob pattern
grepSearch file contents
executeRun shell commands (sandbox backends only)
taskSpawn a subagent to handle a delegated task
write_todosManage a structured todo list
For a full breakdown of what each built-in tool does, see Harness capabilities.
Connect these docs to Claude, VSCode, and more via MCP for real-time answers.
Edit this page on GitHub or file an issue.