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

tools/mcp.py

from managed_deepagents import define_mcp

mcp = define_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	`tools/mcp.py`	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. Instructions, skills, and optional durable memory are stored in Context Hub.

Relationship to Deep Agents

Managed Deep Agents runs the open source Deep Agents harness rather than a second framework. The agent loop, filesystem tools, subagents, and skills are the same, so there is no second API to learn and an agent you already built keeps working. Managed Deep Agents adds the layer around the agent. The sandbox, durable memory, channels, and schedules above are declarations in a project file rather than services you build and operate. Connections run OAuth, so end users authorize their own accounts instead of you provisioning credentials for each one. LangSmith hosts the result on Agent Server. In the code, the difference is narrower: who compiles the agent.

create_deep_agent returns a compiled agent. You run it, and you own the backend, store, checkpointer, and server around it.
define_deep_agent returns a definition. The mda CLI hands it to the managed runtime, which supplies those pieces along with memory, skills, and the system prompt, then compiles the agent with create_deep_agent.

So define_deep_agent takes the same parameters minus the managed ones, plus a required static name. Every define_* function works this way: declare what the agent needs, and leave the lifecycle to the runtime. Stay on Deep Agents when you run the agent yourself or need a backend, store, or checkpointer of your own. For a side-by-side comparison of the two, and the steps to convert an agent you already built, see Move from Deep Agents.

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 your agent of choice 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

Relationship to Deep Agents

Next steps

Quickstart

Tutorial

Agent Server

MCP endpoint

​Example agent

​Core capabilities

​Relationship to Deep Agents

​Next steps

Quickstart

Tutorial

Agent Server

MCP endpoint

Example agent

Core capabilities

Relationship to Deep Agents

Next steps