LangChain moved its Deep Agents framework into hosted production on August 7, 2026, launching Managed Deep Agents in public beta. The pitch is simple: you write an agent in Python or TypeScript, test it locally, and deploy it with a single CLI command, while LangChain runs the durable execution, sandboxes, memory, and channel integrations that teams normally rebuild from scratch. The beta is US region only and CLI first, with no pricing disclosed yet. For anyone building agents rather than infrastructure, this is the part of the stack that has been missing.
What LangChain Just Shipped
Managed Deep Agents is a hosted service layered on LangChain's LangSmith Deployment infrastructure. It takes the open source Deep Agents harness, an opinionated agent that ships with a planning tool, sub-agents, a virtual file system, shell access, and persistent memory, and removes the operational work of running it in production. Deep Agents is model agnostic and works with any LLM that supports tool calling, and it is built on the LangGraph runtime, so the same graph you test on your laptop is the one that runs in the cloud.
The managed layer adds durable execution that survives restarts, integrated sandboxes for code execution and file work, memory that persists across conversations, channel integrations for Slack and GitHub, a Harbor based evaluation framework, identity and authentication support, streaming progress updates, and Context Hub synchronization so your prompts and skills stay in sync. In short, it is the difference between a working prototype and something a team can put in front of real users.
How Managed Deep Agents Compares
The agent tooling space now spans do it yourself SDKs and fully hosted platforms. The table below generalizes where Managed Deep Agents sits against common alternatives. Every option can build a capable agent; the real difference is how much production plumbing you own.
| Approach | Infrastructure you manage | Built-in persistence and memory | Best fit |
|---|---|---|---|
| Managed Deep Agents (public beta) | None, fully hosted | Durable execution, memory, sandboxes included | Teams shipping Deep Agents fast |
| Self-hosted LangGraph on LangSmith Deployment | You run and scale it | Configurable, you wire it | Teams that need full control |
| OpenAI Agents SDK | Your own hosting | You add state and storage | OpenAI centric stacks |
| Vercel AI SDK | Your own hosting or serverless | You add state and storage | Web and edge app builders |
The takeaway is not that one wins outright. If you already run LangGraph and want control, self hosting stays available. Managed Deep Agents is for the team that would rather spend its time on agent behavior than on queues, retries, and sandbox security.
From Local Script to Production Agent in Five Steps
Here is the practical path the beta enables, based on LangChain's documentation.
- Install the harness. Add Deep Agents to a Python project with
uv add deepagents, or usedeepagents.jsfor TypeScript. - Define the agent. Give it a detailed system prompt, the tools it needs, and any sub-agents for delegating focused tasks. The planning tool and virtual file system come built in.
- Test locally. Run the graph on your machine, inspect intermediate steps, and iterate on the prompt and tool set until behavior is reliable.
- Deploy by CLI. Push the agent to Managed Deep Agents with a single command. Durable execution, sandboxes, and memory are provisioned for you.
- Wire channels and watch it run. Connect Slack or GitHub, stream progress updates, and use the evaluation framework plus LangSmith tracing to catch regressions before users do.
What This Enables for Creators and Builders
For solo builders and small teams, the win is time. The hard parts of a production agent, keeping state across restarts, sandboxing untrusted code, retrying failed steps, and remembering context between sessions, are exactly the parts that take weeks to build and are easy to get wrong. Offloading them means a content workflow agent, a research assistant, or a code review bot can go from weekend prototype to something teammates rely on without a dedicated platform team. Because Deep Agents is open source and model agnostic, you are not locked into a single provider, and you can move the same agent between local, self hosted, and managed setups as your needs change. Start with one narrow, high value agent, get it durable and observable, then expand once the loop is proven.
Frequently Asked Questions
What is Managed Deep Agents?
It is a hosted service from LangChain, launched in public beta on August 7, 2026, that deploys agents built with the open source Deep Agents framework to production without you managing the underlying infrastructure.
Do I have to use a specific model?
No. Deep Agents is model agnostic and works with any LLM that supports tool calling, so you can choose your provider.
What languages are supported?
Python and TypeScript. Python installs with uv add deepagents, and TypeScript uses the deepagents.js package.
How is this different from self-hosting LangGraph?
Deep Agents is built on LangGraph, so you can self host for full control. The managed service adds durable execution, sandboxes, memory, channel integrations, and evaluation so you do not run that infrastructure yourself.
Is it available to everyone right now?
It is a public beta limited to the US region and is CLI first. LangChain has not disclosed pricing yet.
Can I still export or move my agent later?
Yes. Because the Deep Agents harness is open source and runs on LangGraph, the same agent can move between local development, self hosted deployment, and the managed service.
What to Do Next
Pick one agent you already run as a script and rebuild it on the Deep Agents harness locally first. Get its planning, tools, and memory working, then request beta access and deploy it by CLI to see how much operational work disappears. If you want full control instead, the self hosted path on LangGraph remains open. Read LangChain's public beta announcement for the current feature list and regional availability.
