Skip to the yard
Waxsealai

Managed Deep Agents Brings File-Based Agent Projects to LangSmith Cloud

Shipped
Shipper
Christopher Williams
Readers
552

Managed Deep Agents runs the open-source Deep Agents harness on LangSmith, with memory, schedules, sandboxes and integrations configured in project files.

Managed Deep Agents Brings File-Based Agent Projects to LangSmith Cloud

Managed Deep Agents packages the work of running a production agent around a Python project: developers define its behavior and tools, then deploy it to LangSmith Cloud with mda deploy. The public beta combines the open-source Deep Agents harness with LangSmith’s managed runtime, including durable threads, streaming runs and optional production features declared in the project.

The practical shift is in what teams need to operate. A capable agent still needs durable state, isolated code execution, memory, and a way to run scheduled or user-triggered tasks. Managed Deep Agents supplies those runtime pieces, so teams can spend less time building the services around an agent. The tradeoff is that deployments run on LangSmith Cloud; teams that need to host the runtime themselves can use the open-source SDK.

A Python project becomes the deployment unit

A project can start with a single required file, agent.py. It defines the agent with define_deep_agent, including its name, model and tools. The example research assistant uses openai:gpt-5.5 and a web search tool. Instructions live in instructions.md; folders under skills/ contain playbooks the agent can load for relevant tasks.

Custom tools are Python functions in tools/, imported into the agent definition. A tools/mcp.py file can add tools from remote MCP servers. This layout keeps the agent’s behavior, instructions and integrations in a project developers can inspect and edit.

uvx --from managed-deepagents mda init research-assistant
cd research-assistant
uv sync
uv run mda dev
uv run mda deploy

mda dev starts a local Agent Server and opens the agent in LangSmith Studio, where developers can chat with it and inspect traces. mda deploy publishes the project to LangSmith and adds the model provider’s key to the deployment. A coding agent can follow the same setup using the managed-deep-agents skill.

Production features are added as needed

The runtime reads optional files and folders during deployment, so a minimal agent can gain capabilities as its requirements grow. By default, it retains context within the current thread. Adding memory.py enables knowledge that carries across threads, with shared memory for all callers, private memory per user, or both.

A module under schedules/ can define recurring work. For example, a schedule can run at 8 a.m. on weekdays in the America/Los_Angeles time zone and prompt the agent to write a daily digest. Deployment provisions the schedule once the agent is live.

For user interaction, channels/slack.py lets people start runs and receive replies in Slack. Other services can trigger runs over HTTP webhooks. An optional sandbox/ provides an isolated filesystem and shell where the agent can execute code it writes.

Identity and credentials have their own integration points. identity.py authenticates callers and supports private threads, memory and credentials for each person. Connections store API keys and support OAuth, allowing users to authorize their own accounts rather than requiring a team to provision credentials individually.

Agent definitions can also include subagents. An asynchronous subagent can work in the background while the main agent continues responding. For evaluation, mda evals init -i creates a Harbor evaluation workspace under evals/ and hands off to a coding agent to write tasks.

Some tools require no project file. Built-in web search is powered by Parallel, without a separate account or API key. Browser use can hand control to a person if a site requires login. Developers can pause selected tool calls for human approval by setting interrupt_on in the agent definition.

Applications can call agents through APIs and MCP

Each deployment exposes the Agent Server API. An application can use it to create threads and stream runs, or build a custom frontend around the agent. The deployment also offers an MCP endpoint at /mcp, enabling MCP clients such as Claude Code to invoke the agent as a tool.

These interfaces support several patterns described by teams in the public beta: Slack agents that investigate monitoring alerts in a sandbox; engineering agents triggered by issue tracker webhooks to build and verify changes; and internal assistants for functions such as HR or finance. Other deployments sit behind a company’s product interface, keep memory separate for each customer, or maintain context for long-running project work. Scheduled agents can also produce materials such as competitive reviews and marketing assets.

Traces and shared context support iteration

Instructions and skills are stored in LangSmith Context Hub. Each deployment syncs instructions.md and skills/ from the project. Teams can also edit those resources in Context Hub for a quick change without redeploying. If the Hub version has changed since the last deployment, the CLI asks which copy to retain.

Durable memory is stored in Context Hub as well, and the agent can update it while working. A support assistant, for instance, can retain its team’s escalation path for later conversations. LangSmith traces record tool calls and intermediate steps; LangSmith Engine can use those traces to find recurring issues and help diagnose them. When connected to the agent’s Context Hub repository, it can propose changes to instructions and skills.

Same open-source harness, managed runtime

Managed Deep Agents uses the same open-source harness, including its agent loop, filesystem tools, subagents and skills. The distinction is how the agent gets compiled and run. With create_deep_agent, developers receive a compiled agent and manage the backend, store, checkpointer and server. define_deep_agent accepts the corresponding agent settings, excluding runtime-managed options, and returns a definition that LangSmith compiles.

Teams with an existing create_deep_agent implementation can follow the migration guide. Those that want control over hosting can run the same harness on their own infrastructure with the Deep Agents SDK.

LangChain says it uses Managed Deep Agents for GTM Agent, Open SWE and Content Studio. It reports that Content Studio’s code shrank by about 80% after moving to the managed platform. That figure describes one internal migration; the article provides no broader benchmark of development time, operating cost or agent performance. For teams assessing adoption, the key question is whether the managed runtime’s defaults fit their deployment needs. The quickstart deploys a research assistant, while the tutorial adds a custom search tool, durable memory and a daily schedule.

Source: Christopher Williams · www.langchain.com

Same vesselRelated cargo