Managed Deep Agents

Managed Deep Agents (MDA) is the simplest way to build and deploy production agents. You focus on what your agent does. MDA runs it. There are no servers to run and no infrastructure to wire together. You write the agent’s intelligence: its instructions, the tools it can call, the skills it follows, and you select the model that drives it. MDA provides everything underneath:

The Deep Agents harness: The agent loop that plans, calls tools, manages a filesystem, and delegates to subagents. See Deep Agents.
A managed runtime: Every deployment runs on LangSmith Agent Server. You get the Agent Server API, threads, runs, streaming, and the MCP endpoint without operating the server yourself.

Example agent

A managed deep agent consists of a project folder that contains the business logic for its behavior:

agent.py

from managed_deepagents import define_deep_agent

from middleware.audit import log_tool_calls
from tools.search import internet_search

agent = define_deep_agent(
    name="research-assistant",
    model="openai:gpt-5.5",
    tools=[internet_search],
    middleware=[log_tool_calls],
)

instructions.md

# Assistant

You are a helpful assistant.

skills/research/SKILL.md

---
name: research
description: Gather and synthesize context before answering complex questions.
---

# Research

Use this skill when a task needs more than a direct answer.

1. Identify what information is missing.
2. Search LangChain docs when the question is about LangChain, LangGraph, or LangSmith.
3. Summarize findings before responding to the user.

tools/search.py

from langchain.tools import tool


@tool(parse_docstring=True)
def internet_search(query: str) -> str:
    """Search the internet for relevant sources.

    Args:
        query: The search query.
    """
    return f"Results for: {query}"

middleware/audit.py

from collections.abc import Awaitable, Callable

from langchain.agents.middleware import wrap_tool_call
from langchain.messages import ToolMessage
from langchain.tools.tool_node import ToolCallRequest
from langgraph.types import Command


@wrap_tool_call
async def log_tool_calls(
    request: ToolCallRequest,
    handler: Callable[[ToolCallRequest], Awaitable[ToolMessage | Command]],
) -> ToolMessage | Command:
    print(f"Calling tool: {request.tool_call['name']}")
    result = await handler(request)
    print(f"Finished tool: {request.tool_call['name']}")
    return result

connectors/mcp.py

from managed_deepagents import connectors

connector = connectors.mcp(
    mcp_servers={
        "langchainDocs": {
            "transport": "http",
            "url": "https://docs.langchain.com/mcp",
            "include_tools": ["search_docs_by_lang_chain"],
        },
    },
)

When you upload this folder with the mda CLI, it will automatically run on managed LangSmith infrastructure. You provide the business logic, and Managed Deep Agents provides the agent harness and production infrastructure. To get started, see the Managed Deep Agents quickstart.

Core capabilities

Each part of the agent maps to a file or directory. Add the ones your agent needs:

Capability	Path	Description
Model and configuration	`agent.py`	The model and core options. Required.
Instructions	`instructions.md`	The system prompt that defines how the agent behaves.
Skills	`skills/`	Task-specific playbooks the agent loads when they are relevant.
Tools	`tools/`	Functions the agent calls to run your application logic or reach external services.
MCP connectors	`connectors/`	Remote MCP servers that provide tools to the agent.
Middleware	`middleware/`	Custom logic that runs around model and tool calls.
Sandbox	`sandbox/`	An isolated filesystem and shell for running agent-written code.
Memory	`memory.py`	Preferences and knowledge that persist across threads.
Identity	`identity.py`	Per-caller private threads, memory, and credentials for multi-user deployments.
Channels	`channels/`	Connections to messaging services, such as Slack, that start runs and receive responses.
Schedules	`schedules/`	Managed cron schedules that run the agent on a recurring basis.
Evals	`evals/`	Harbor tasks that test the agent.

For the full layout, see Project structure.

Next steps

Quickstart

Create and deploy your first Managed Deep Agent with the mda CLI.

Tutorial

Add a custom search tool, durable memory, and a daily schedule.

Agent Server

Explore the runtime that hosts Managed Deep Agents deployments.

MCP endpoint

Call a deployed agent as a tool from Claude Code or another MCP client.

Connect these docs to Claude, VSCode, and more via MCP for real-time answers.

Edit this page on GitHub or file an issue.

Get started

Agent capabilities

Build and deploy

Example agent

Core capabilities

Next steps

Quickstart

Tutorial

Agent Server

MCP endpoint

​Example agent

​Core capabilities

​Next steps

Quickstart

Tutorial

Agent Server

MCP endpoint

Example agent

Core capabilities

Next steps