AivexaNewsSearch
AI news for builders and product teamsChecked every hour

Managed Deep Agents: the fastest way to ship a production deep agent

Collected Nov 2, 2026

LangChain has moved Managed Deep Agents into public beta on LangSmith Cloud. The product runs the open-source Deep Agents harness on LangSmith's Agent Server, so developers describe what an agent does while the platform supplies the runtime around it. The company opened a private beta on May 13, 2026, and the current post describes the public beta as it works today.

The pitch is that shipping an agent to production, rather than building one, is the hard part. An agent that should be proactive or support multiple users has to be running in production, which means threads that survive restarts, a safe place to execute generated code, memory that persists between conversations, a record of what happened, and a scheduler for timed runs. Managed Deep Agents packages those as part of the deployment, with no servers for the developer to operate.

A Managed Deep Agent is an ordinary Python project. The one required file is agent.py, which calls define_deep_agent with a name, a model string such as openai:gpt-5.5, and a list of tools. The system prompt sits in instructions.md, folders under skills/ hold playbooks the agent loads when a task calls for them, and tools/ contains ordinary Python functions imported into agent.py; a tools/mcp.py file adds tools from remote MCP servers.

The workflow runs through a CLI. mda init scaffolds a project, mda dev starts a local Agent Server and opens the agent in LangSmith Studio for chatting and trace inspection, and mda deploy ships it to LangSmith and adds the model provider's key to the deployment. LangChain also offers a managed-deep-agents skill that walks a coding agent through the same setup.

Each production capability is expressed as a file or folder, and deployment provisions whatever it finds. Adding memory.py switches on cross-thread memory, either in a shared layer visible to every caller, a private per-user layer, or both. Files under schedules/ define cron runs, with a define_schedule call taking a cron expression, a timezone and a prompt. A channels/slack.py file lets people start runs from Slack and receive answers in the same thread, and any service that can send a webhook can start runs over HTTP. A sandbox/ folder gives the agent an isolated filesystem and shell for code it writes. identity.py authenticates callers so each person gets separate threads, memory and credentials, while Connections store API keys and run OAuth so end users authorize their own accounts. Subagents are declared in the agent definition, and async subagents run in the background while the agent continues its conversation. mda evals init -i sets up a Harbor eval workspace under evals/ and hands writing the tasks to a coding agent.

Some features need no file. Web search is built in and powered by Parallel with no separate account or API key, and the agent can operate a browser, handing control back to a person when a site requires login. Setting interrupt_on in the agent definition pauses for human approval before selected tool calls. Every deployment serves the Agent Server API for creating threads and streaming runs, and an MCP endpoint at /mcp lets MCP clients such as Claude Code call the agent as a tool.

LangChain says its own GTM Agent, Open SWE and Content Studio run on the platform, and that Content Studio's code shrank by roughly 80% after the move. Named beta patterns include incident triage from Slack alerts, with some teams having the agent open a pull request with a fix; engineering workflows kicked off by issue-tracker webhooks that loop through build and verify, sometimes testing fixes in preview environments with a browser; single-purpose Slack assistants for HR policy or finance; customer-facing agents behind a company's own frontend with per-user memory; long-running agents scoped to a project; and scheduled agents producing competitive reviews or marketing assets.

Instructions and skills are stored in LangSmith Context Hub, synced on each deploy and editable there so a quick change does not require redeploying. If the Hub copy has changed since the last deploy, the CLI asks which version to keep. Durable memory also lives in Context Hub and is written by the agent as it works. Runs are traced in LangSmith, and LangSmith Engine reads those traces to surface recurring issues, diagnose their cause and, when connected to the agent's Context Hub repository, propose fixes to instructions and skills.

The underlying harness is unchanged from open source: same agent loop, filesystem tools, subagents and skills. The API difference is who compiles the agent. create_deep_agent returns a compiled agent for which the developer owns the backend, store, checkpointer and server; define_deep_agent takes the same parameters minus runtime-managed ones and returns a definition that LangSmith compiles. Existing agents can be converted using the Move from Deep Agents guide, and teams wanting to host themselves can use the Deep Agents SDK on their own infrastructure.

My reading is that the main trade-off is control versus undifferentiated plumbing. Developers give up direct control of the store, checkpointer and server in exchange for durable threads and streaming without operating them, which is an easy trade for small teams and a harder one for companies with existing infrastructure standards or strict data residency needs. The file-as-capability convention is a practical design: capabilities are reviewable in version control and provisioned on deploy, though growth in the number of files raises questions about how conflicts between Hub edits and local deploys are resolved at scale. LangChain's roughly 80% code reduction figure is a self-reported datapoint from one internal product, so treat it as directional rather than a benchmark. Pricing for the public beta is not stated in the material.

Why it matters: Teams that want a production agent with persistence, sandboxing, scheduling and observability currently assemble that runtime themselves, and this offering competes directly with that work. Developers already on the Deep Agents SDK face a concrete choice between managed hosting and self-hosting the same harness, judging by the similar APIs. Product teams, by inference, should find it faster to iterate on agent behavior, since instructions and skills can be edited in Context Hub without redeploying, though the public beta status means production use should be evaluated against its own reliability and compliance requirements.

Read at LangChain

Based on reporting from the original publisher. Visit the source for full context and later updates.

Publisher excerpt

Run deep agents in production with durable execution, sandboxes, tool access, and LangSmith observability, without building the runtime yourself. Now in private beta