LangChain's Managed Deep Agents turns an AI agent into a folder you deploy with one command

What LangChain launched

LangChain has introduced Managed Deep Agents, a service that runs AI agents for you on its LangSmith platform. You write what the agent should do, pick the model, and LangSmith handles the machinery needed to keep it running in production. As langchain.com reported in its own announcement, there are no servers to operate and no infrastructure to wire together.

The post carries an update dated November 2, 2026, saying the product is now in public beta on LangSmith Cloud. It first ran on May 13, 2026, when it opened as a private beta. So the access limits you may have seen described earlier no longer apply in the way they once did.

It builds on Deep Agents, an open-source harness, meaning the framework that gives an agent a working loop, a filesystem, the ability to plan, and the ability to hand pieces of work to helper agents called subagents.

The gap it tries to close

LangChain's argument is that building a capable agent keeps getting easier, but running one in production is still heavy work. An agent needs conversations that survive a restart, a safe place to run code it writes, memory that lasts between chats, and a record of what it did. If you want it to act on a schedule, you also need something to trigger it.

Teams usually build and maintain all of that before a single user sees the agent. Managed Deep Agents takes that layer on. Each deployment runs on LangSmith Agent Server, which provides durable threads and streaming runs without you operating a server.

LangChain says it uses the product itself. Its GTM Agent, Open SWE and Content Studio all run on it, and Content Studio's code shrank by about 80% after the move. That is the company's own report, not an independent test.

An agent as a folder of files

A managed agent is an ordinary Python project. The only required file is agent.py, which names the agent, the model and its tools. Instructions go in a separate text file, and optional skills are playbooks the agent loads when a task needs them.

Two commands cover most of the journey. mda dev starts a local copy and opens the agent in LangSmith Studio, where you can chat with it and inspect its traces (step-by-step records of what it did). mda deploy sends the project to LangSmith.

The notable design choice is that each production feature is a file or folder you add, and deploy sets up whatever it finds:

• Memory: a memory file lets the agent keep knowledge across conversations, shared among everyone, private per user, or both.
• Schedules: a file defines a cron schedule, which is a timetable for automatic runs, such as a weekday morning digest.
• Channels: a Slack file lets people start runs and read answers in the same conversation. Anything that can send a webhook, an automatic web notification, can also start a run.
• Sandbox: an isolated filesystem and shell where the agent can run code it writes.
• Identity and connections: callers are authenticated, and end users authorize their own accounts rather than you handing out credentials.

The agent also gets built-in web search powered by Parallel, and you can require human approval before chosen tool calls.

What teams are building with it

LangChain lists several patterns from public-beta users. One is incident triage: an agent reads monitoring alerts in a Slack channel, investigates in its sandbox and reports back, and some teams have it open a pull request with a fix. Others deploy one assistant per job in Slack, such as an HR policy helper or a finance helper.

Some run customer-facing agents behind their own product, with separate memory per customer. Others schedule agents modeled on company functions like sales or product to produce competitive reviews and marketing assets without anyone prompting them.

Every deployment also exposes an API for your own app, plus an MCP endpoint. MCP is a common standard that lets AI tools call other tools, so a client like Claude Code can use your agent as one of its tools.

Improving it, and the trade-offs

The agent's instructions and skills sync to LangSmith Context Hub, where you can edit them for a quick change without redeploying. If someone edited the Hub copy since your last deploy, the command line tool asks which version to keep. Memory the agent writes also lives there. A separate tool, LangSmith Engine, studies traces to spot recurring problems and can propose fixes to instructions and skills.

The service runs the same open-source harness you could host yourself. In code, the difference is who assembles the agent: with the open-source route you own the storage, the checkpointing and the server, while the managed route has LangSmith do it. LangChain provides a guide for converting an existing agent, and says the Deep Agents SDK remains available if you want full control over hosting.

What the post does not cover is cost. It gives no pricing, and the speed advantage is LangChain's own claim. Anyone evaluating it should ask what a run costs, how easily you can see what the agent did, and how hard it would be to leave.