Managed Deep Agents is now in Public Beta

Today, Managed Deep Agents is available in public beta. Go from prototype to production scale without managing the underlying infrastructure yourself. You can author a Deep Agent in Python or TypeScript, test it locally, and deploy it to a managed runtime with one command.

You control the model, instructions, tools, middleware, subagents, and more. LangSmith handles the runtime, including persistence, memory mounts, skill loading, sandbox lifecycle, and deployment.

Get started with the commands below:

# Install from the ecosystem you use to author the agent
uv tool install managed-deepagents      # Python
# or: npm install -g managed-deepagents # TypeScript

mda init research-assistant
cd research-assistant
uv sync                                 # Python
# or: npm install                       # TypeScript

mda dev        # run locally in LangSmith Studio
mda deploy     # deploy to LangSmith

Deep Agents is an open source agent harness you can own

We built Deep Agents around a pattern we kept seeing in useful agents. Agents often need to:

• Call tools
• Have somewhere to keep working files
• Manage growing context over long runs
• Needs to delegate work to subagents
• Load domain-specific skills
• Pause for human approval before taking sensitive actions.

You can build all of that yourself on top of a lower-level framework, but the pattern is common enough that it should be available as a reusable harness that companies can own and control. Deep Agents is that harness. It's open source and model agnostic, allowing you to bring your model, your instructions, your tools, and your business logic.

Managed Deep Agents helps you take the harness to production

Deep Agents makes it easier to build capable agents. Managed Deep Agents makes it easier to run those agents in production.

It handles the production infrastructure that’s costly to build and maintain, while keeping the parts that make your agent unique in your control. That means you can spend your time on the agent's behavior, including prompts, tools, middleware, identity rules, evals, and domain logic instead of rebuilding the same infra that every agent requires:

• Durable execution so long-running agents can pause, retry, and resume without losing work
• Streaming so users can see progress while the agent is working
• Persistence so thread state survives across turns, restarts, and failures
• Sandboxes so agents can work with files, run code, and use CLIs in isolated environments
• Evals so teams can test behavior, tool use, and state changes before and after deployment
• Channels so agents can meet users in tools like Slack
• Memory so agents can carry durable context and preferences across conversations
• Identity so agents can act with the right user context and access boundaries

A Managed Deep Agent is a code-first project in your repo. It allows you to easily organize all your agent’s primitives into a simple directory:

my-agent/
  agent.py | agent.ts | agent.tsx
  pyproject.toml | package.json    # project dependencies
  instructions.md                  # prompt synced to Context Hub
  identity.py | identity.ts        # auth, thread scoping, memory scoping
  memory.py | memory.ts            # define your agent's memory
  tools/                           # custom tools
  channels/                        # entry points like Slack and GitHub
  middleware/                      # custom middleware
  schedules/                       # managed cron schedules
  connectors/                      # managed cron schedules
  skills/                          # skills synced to Context Hub
  sandbox/                         # sandbox configuration
  evals/                           # agent evals

Once you author your project and run mda deploy , Managed Deep Agents compiles the project, syncs deploy-owned context to LangSmith Context Hub, uploads the build, and creates a hosted LangSmith deployment.

Built on top of LangSmith Deployment

Most production infrastructure assumes short-lived, stateless requests. Agents often break both assumptions. Agents often run for minutes, hours, and even days. It may need to pause for approval, resume after a user replies, stream progress while it works, and recover from infrastructure restarts without losing state. It may need durable threads, persistent memory, cancellation, retry behavior, and traceability across model calls, tool calls, files, errors, and runtime state.

Building this infrastructure from scratch can take months or even quarters, and it has to be maintained. Durable execution, streaming, human approval, auth, scheduling, and conversation state all introduce edge cases around persistence, retries, timeouts, and reliability that directly impact user experience and agent usefulness.

Managed Deep Agents is built on the same LangSmith Deployment Agent Server that teams already use to run agents in production. It packages the operational patterns required for product agents into a more opinionated runtime for Deep Agents.

Sandboxes for code execution and filesystem work

Many useful agents need an isolated working environment to inspect files, write outputs, run tests, install dependencies, call CLIs, or execute code securely.

Deep Agents supports sandbox backends for this kind of work. We have built first class support for LangSmith Sandboxes for Managed Deep Agents.

You configure a sandbox in just a few lines of code:

from managed_deepagents import define_sandbox

sandbox = define_sandbox(
    provider="langsmith",
    scope="thread",
)

By default, each durable thread gets its own sandbox. That works well for agents that need an isolated workspace per user conversation or task, such as a coding agent. You can also set the scope to agent when the agent process should share one sandbox across threads.

Harbor evals without the setup work

Verifying agent behavior requires more than evaluating just a prompt and expected answer. You need to check what actions the agent took along the way to get to the final answer. That's where evals come in.

Managed Deep Agents uses Harbor for this workflow. Harbor tasks give the agent an instruction, run it in an isolated environment, and grade the resulting files or state with a verifier.

The hard part is usually packaging your agent so Harbor can run it. Managed Deep Agents handles this packaging for you, in just a few short terminal commands:

mda evals init
mda evals compile

mda evals init creates checked-in Harbor tasks under evals/. mda evals compile builds a Harbor handoff under .mda/evals/, including the compiled agent artifact, the adapter Harbor uses to run the agent, and an example Harbor job config.

Channels bring agents into the tools where work happens

Channels are how you expose your agent to users. Managed Deep Agents has first class support for channels, making it straightforward to define how your agent connects to different channels, such as Slack. Add a file under channels/, and the runtime mounts the provider event endpoint, verifies provider signatures, invokes your agent with identity stamps, and can reply in the originating conversation.

For Slack, that can be as simple as defining a channel file:

from managed_deepagents import channels

channel = channels.slack(
    on=["app_mention", "direct_message"],
    auto_reply=True,
)

Memory that persists across threads

Thread state helps an agent manage a single conversation, but agents often need context that lasts longer than one thread. Memory gives them durable preferences and context they can carry across conversations.

Managed Deep Agents gives every deployment agent-scoped memory to start. You define memory behavior in memory.py or memory.ts, and the runtime backs memory with Context Hub. At runtime, the agent reads and writes memory files under /memories/.

Identity and auth for multi-user agents

Managed Deep Agents includes a basic identity model today, and we will keep adding more advanced auth and credential flows going forward.

Today, your agent can run with a fixed set of credentials. If you define an OIDC provider in identity.py or identity.ts, Managed Deep Agents scopes threads per end user id from your OIDC provider.

How teams are using Managed Deep Agents today

Managed Deep Agents was amazing to work with. Highly recommend for teams exploring agent infrastructure who want a more cohesive offering, while avoiding model or lab lock-in. - Chip Lay, Director of Product, Fullstory

Managed Deep Agents lets us scale our agentic workforce: an agent goes from idea to production in hours, not weeks. Our teacher agent wakes up every morning to review the runs of our entire fleet and drives improvements based on observability and live evals. We focus on the business logic; Managed Deep Agents handles the operational complexity, from persistent memory and the runtime to Slack and GitHub integration. - Mathieu Mailhos, Staff Engineer, AI Runtime & Infrastructure, stealth-mode startup

When to use Managed Deep Agents

Managed Deep Agents is useful when you want a code-first Deep Agent with LangSmith owning persistence, execution, deployment, and the common production scaffolding around the harness.

Use it when you want to:

• Build on the open source Deep Agents harness
• Keep control over your model, prompts, tools, middleware, and business logic
• Deploy without rebuilding agent infrastructure from scratch
• Give the agent durable threads, memory, sandboxes, channels, schedules, evals, and traces
• Move quickly from local development to a hosted LangSmith deployment

Get started

Follow the quickstart to deploy your first Managed Deep Agent. The tutorial adds identity, memory, tools, and evals step by step.

If you want the open source harness first, start with the Deep Agents overview. When you are ready to productionize that harness, use Managed Deep Agents to deploy it to LangSmith.