managed-deepagents 0.4.0.dev68

Managed Deep Agents — the define_deep_agent authoring interface plus the CLI that compiles and deploys a code-first Deep Agent repository to a managed LangGraph runtime.

Python authoring package and CLI launcher for Managed Deep Agents.

[!IMPORTANT] Active development / private beta. Managed Deep Agents is in active development and currently in private beta. The PyPI package API and managed runtime contract may change. Join the waitlist for access and updates.

managed-deepagents is the PyPI package for authoring Managed Deep Agents in Python. It includes:

• define_deep_agent, the Python authoring contract for managed agents.
• define_schedule, the Python contract for managed cron schedules.
• mda, the CLI used to build and deploy your agent to LangSmith.
• managed_deepagents.runtime, the runtime helper used by generated managed entry modules.

Install

uv tool install managed-deepagents

[!NOTE] Private beta: dev releases only. We currently publish only PEP 440 pre-release (dev) versions and no stable version yet. uv skips pre-releases by default unless they are allowed explicitly:

uv tool install --prerelease allow managed-deepagents

This package requires Python 3.9 or newer. Each platform wheel bundles the prebuilt mda binary for its OS and CPU architecture and exposes it through the mda console script. This PyPI-installed CLI scaffolds and compiles Python projects only and vendors the Python runtime bundled with this wheel.

To start a new project:

mda init my-agent
cd my-agent
uv sync

Define an Agent

Create an agent.py that defines an agent:

from managed_deepagents import define_deep_agent

# The system prompt comes from instructions.md next to this file.
agent = define_deep_agent(
    model="openai:gpt-5.5",
    tools=[query_db],
)

define_deep_agent accepts the create_deep_agent keyword surface minus the managed keys: backend, store, checkpointer, memory, skills, and system_prompt. Those are provided by the managed runtime when your agent is deployed. Write the system prompt in instructions.md next to agent.py; the CLI embeds it at deploy time.

On deploy, Context Hub stores durable agent memory under memories/**. Hot memory (memories/AGENTS.md) is always injected into the prompt; other files under memories/** are cold artefacts the agent can create and read on demand. Deploy never overwrites Hub memories.

Project Shape

my-agent/
  agent.py              # named `agent` variable
  instructions.md       # managed system prompt
  pyproject.toml
  .env                  # local deploy secrets, never committed
  schedules/            # optional managed cron schedules
  tools/                # optional custom tools
  middleware/           # optional middleware
  skills/               # optional skills synced to Context Hub
  sandbox/              # LangSmith sandbox (`mda init` includes this; delete to opt out)
  connectors/mcp.py     # optional MCP server declaration

The CLI copies your project files into the managed build and generates the entry module that connects your definition to the hosted runtime.

The agent entry must live at the project root as agent.py.

Define a Schedule

Create one file per schedule under schedules/ and define a named schedule:

# schedules/daily_digest.py
from managed_deepagents import define_schedule

schedule = define_schedule(
    cron="0 8 * * 1-5",
    timezone="America/Los_Angeles",
    prompt="Write the daily digest.",
)

mda deploy reconciles schedules as LangSmith cron jobs after the deployment is live. Declarations must be statically serializable literals or top-level constants; prompt schedules become user-message input, and stateless runs clean up their temporary thread after completion.

Sandbox

mda init scaffolds sandbox/__init__.py with a LangSmith sandbox. MDA only enables the sandbox when that declaration is present — delete sandbox/ to opt out:

from deepagents.backends import LangSmithSandbox
from managed_deepagents import define_sandbox

sandbox = define_sandbox(
    LangSmithSandbox,
    scope="thread",
    idle_ttl_seconds=600,
)

If sandbox/setup.sh exists, MDA embeds it and runs it once when the sandbox is first provisioned. MDA owns sandbox naming, image/snapshot selection, reuse, and lifecycle.

MCP Connectors

Add connectors/mcp.py to attach MCP servers. The file must define a named mcp declaration. By default, MDA exposes every tool loaded from each declared server:

from managed_deepagents.connectors import define_mcp_servers

mcp = define_mcp_servers(
    mcp_servers={
        "langchainDocs": {
            "transport": "http",
            "url": "https://docs.langchain.com/mcp",
            "include_tools": ["search", "fetch"],
        },
    },
)

Use include_tools or exclude_tools inside a server config to select a subset. Tool names are raw MCP tool names before the managed {server}__ prefix is applied, so "include_tools": ["search"] on server langchainDocs exposes langchainDocs__search when prefixing is enabled.

CLI

Create a new project:

mda init my-agent

Build locally:

mda build ./my-agent

Run on the local LangGraph dev server:

mda dev ./my-agent

mda dev requires uv on PATH, but it resolves the local LangGraph dev server automatically; you do not need to install a global langgraph command.

Deploy to LangSmith:

mda deploy ./my-agent

The generated build is written to <root>/.mda/build by default.

Common deploy options:

mda deploy ./my-agent --name my-agent-dev --deployment-type dev
mda deploy ./my-agent --tenant-id "$LANGSMITH_TENANT_ID"
mda deploy ./my-agent --no-wait

Before deploying, make sure LANGSMITH_API_KEY and your model provider key such as OPENAI_API_KEY or ANTHROPIC_API_KEY are available in the project .env, the process environment, or LangSmith workspace secrets. Use LANGSMITH_TENANT_ID or --tenant-id when your LangSmith API key requires a workspace/tenant selection.