Introduction
Here’s a problem many business owners run into. You test an AI agent in a demo, it performs well, and it looks promising. But when you put it into a real business workflow, things can quickly fall apart. Without durable execution and persistent state, long-running agent tasks may lose their progress when an interruption occurs, making it harder to resume work, maintain context across multiple steps, or continue a task across sessions.
What are LangChain Managed Deep Agents? Managed Deep Agents is LangChain’s hosted runtime for running Deep Agents, LangChain’s open-source agent harness built on LangGraph in production. It’s delivered through LangSmith and is currently in public beta (LangSmith Cloud, US region), handling threads, checkpointing, streaming, persistent context, sandboxed execution, and human-in-the-loop approval.
LangChain introduced Managed Deep Agents to address the infrastructure challenges of running long-lived, tool-using agents reliably in production. This article explains what it is, what problems it solves, and where it can actually help your business in plain terms, no jargon.
What Are LangChain Managed Deep Agents?
Managed Deep Agents is LangChain’s hosted runtime for creating, running, and operating Deep Agents on long-running, tool-using tasks without requiring teams to build and manage their own agent runtime infrastructure.
Deep Agents is LangChain’s open-source agent harness, built on top of LangGraph (LangChain’s lower-level agent orchestration engine), for building agents that can plan and decompose complex tasks, use tools, manage files and context, and delegate work to specialized subagents.
Managed Deep Agents gives that open-source harness a hosted home inside LangSmith. Currently in public beta on LangSmith Cloud (US region), it handles the runtime layer threads, checkpointing, streaming, persistent context, sandbox-backed execution, and human-in-the-loop approval alongside tracing and observability.
The Core Capabilities Behind Managed Deep Agents
In practical terms, Managed Deep Agents provide durable execution, checkpointing, persistent context, and human-in-the-loop controls for agents that need to work across longer-running tasks.
To maintain context across long-running tasks, thread state is stored via checkpointing, system prompts are synced to LangSmith Context Hub, and long-term user preferences persist across threads via memory.py.
You describe what you want the agent to do, which tools it can use, and what skills it needs, typically through project files like instructions.md, prompt, Python tool definitions inside tools/, remote Model Context Protocol (MCP) integrations in connectors/, and skills inside skills/. LangChain explains in its post introducing Managed Deep Agents that this setup lets businesses focus on what the agent should do, not how to keep it running. Depending on the configuration, the managed runtime can checkpoint execution, preserve agent context across runs in a managed store, call LangChain Context Hub, pause tool calls for human approval, and provide sandbox-backed environments for code, shell commands, and file operations.
What Problems Do Managed Deep Agents Solve?
The problem: AI agents fall apart during long tasks. One major challenge is moving an agent from a successful prototype to a production system that can reliably handle long-running execution, interruptions, tool calls, context, and human approval.
Long tasks fail in ordinary, frustrating ways. Without checkpointing and durable execution, an interruption can leave a long-running task without the state it needs to continue from its previous point. A connection drops halfway through a job. Or the agent needs a person to approve something before it can continue, but there’s no clean way for it to pause and wait. Building all of those safety nets from scratch is a serious engineering lift, one most businesses don’t have the time, infrastructure, or dedicated team to take on. It’s the same pilot-to-production gap that stalls most enterprise AI initiatives. See our 5-step roadmap for scaling AI agents in the enterprise for a closer look at why it happens and how to close it.
How Managed Deep Agents solves it: it gives every agent three things it was missing before.
It remembers its place. Checkpointed execution allows a run to resume from a previously saved state after an interruption, rather than requiring the entire task to restart.
It can pause and wait for a person. If a task requires human sign-off, such as sending an email or approving a payment, the agent pauses cleanly rather than forcing an all-or-nothing decision.
It runs code safely. For workflows that require code, shell commands, or file operations, Managed Deep Agents can use sandbox-backed execution to isolate those workloads from the primary application environment.
The result: less time spent fixing broken agents and less risk of losing data or mishandling tasks that involve money or customers.
How Are Deep Agents Different From Managed Deep Agents?
In plain terms, Deep Agents is the open-source harness that gives an agent its abilities: planning, delegation, a filesystem, and skills. Managed Deep Agents is what runs and operates that harness for you, so you’re not standing up your own servers, checkpointing, sandboxes, and tracing from scratch.
Deep Agents vs. Managed Deep Agents
| Dimension | Deep Agents | Managed Deep Agents |
|---|---|---|
| What it is | Open-source agent harness | Hosted runtime built on that harness, delivered through LangSmith |
| SDK / package | free, open source, on GitHub | Not open source during the beta |
| Where it runs | Wherever you deploy it yourself | LangSmith Agent Server, managed by LangChain |
| Checkpointing & threads | Supported via the underlying LangGraph runtime; you operate the persistence layer | Durable threads and checkpointing are handled by the managed runtime |
| Context storage | Virtual filesystem with pluggable backends you choose (in-memory, disk, LangGraph store, custom) | Same filesystem model, backed automatically by Context Hub — instructions and skills sync on deploy, with optional durable memory via memory.py |
| Sandboxed code execution | Built into the harness, you provision where it runs | Sandbox-backed execution hosted and isolated by the managed runtime |
| Human-in-the-loop | Supported through middleware and interrupts you configure | Same interrupt model; pausing and approval handled by the managed runtime |
| Getting it running | pip install deepagents, write and host the code yourself | mda dev to test locally, mda deploy to ship — no server to stand up |
| Tracing | Optional — integrates with LangSmith if you wire it up | Automatic — every run is traced in LangSmith by default |
| Availability | Generally available, self-host anywhere | Public beta, LangSmith Cloud, US region only |
Dimension
What it is
Deep Agents
Open source agent harness
Managed Deep Agents
Hosted runtime built on that harness, delivered through LangSmith
Dimension
SDK / package
Deep Agents
Free, open source, on GitHub
Managed Deep Agents
Not open source during the beta
Dimension
Where it runs
Deep Agents
Wherever you deploy it yourself
Managed Deep Agents
LangSmith Agent Server, managed by LangChain
Dimension
Checkpointing & threads
Deep Agents
Supported via the underlying LangGraph runtime; you operate the persistence layer
Managed Deep Agents
Durable threads and checkpointing are handled by the managed runtime
Dimension
Context storage
Deep Agents
Virtual filesystem with pluggable backends you choose (in-memory, disk, LangGraph store, custom)
Managed Deep Agents
Same filesystem model, backed automatically by Context Hub – instructions and skills sync on deploy, with optional durable memory via memory.py
Dimension
Sandboxed code execution
Deep Agents
Built into the harness, you provision where it runs
Managed Deep Agents
Sandbox backed execution hosted and isolated by the managed runtime
Dimension
Human-in-the-loop
Deep Agents
Supported through middleware and interrupts you configure
Managed Deep Agents
Same interrupt model; pausing and approval handled by the managed runtime
Dimension
Getting it running
Deep Agents
pip install deepagents, write and host the code yourself
Managed Deep Agents
mda dev to test locally, mda deploy to ship – no server to stand up
Dimension
Tracing
Deep Agents
Optional – integrates with LangSmith if you wire it up
Managed Deep Agents
Automatic – every run is traced in LangSmith by default
Dimension
Availability
Deep Agents
Generally available, self host anywhere
Managed Deep Agents
Public beta, LangSmith Cloud, US region only
Selection Guidance
- Choose Deep Agents (Open Source): If you require self-hosted or air-gapped infrastructure, full control over persistence backends, custom execution runtimes, or non-US data residency.
- Choose Managed Deep Agents (Hosted): If you want zero server setup, automatic thread persistence, native Context Hub integration, built-in sandboxing, default tracing, and seamless CLI deployment (`mda deploy`).
Where Can Managed Deep Agents Be Used?
Managed Deep Agents are most useful for business workflows that involve multiple steps, tool calls, persistent context, file or code operations, delegation, or execution that needs to continue over longer periods. Here’s what that looks like in real business settings:
- Customer support – An agent can triage support requests, gather relevant information, maintain context across longer threads, and route sensitive actions through human approval when configured.
- Research – an agent gathers information from multiple sources across several steps, instead of one shallow search.
- Coding – an agent writes, tests, and fixes code, running each attempt safely in a sandbox.
- Data analysis – an agent runs reports overnight, with results ready by morning, and no one watching it work.
- Internal operations – an agent updates CRMs, tracks support tickets, or manages recurring internal tasks without manual input every time.
If you’ve been thinking about using AI agents like actual team members with real responsibilities, this is the kind of reliable foundation that makes that possible without things constantly breaking.
How Do Managed Deep Agents Work?
You define the agent’s instructions, tools, skills, subagents, and context; Managed Deep Agents provides the hosted runtime and operational infrastructure needed to run and observe it. Here’s what that actually looks like, step by step:
You define the agent. In your own codebase, you implement the agent logic in Python or TypeScript. You define core options in agent.py and the system prompt in instructions.md, custom tools in tools/ (or via connectors/ for MCP), and domain playbooks in skills/. (like a search tool, a database connection, or a code sandbox) and any specific skills it needs for the job.
You package and connect it via CLI and API. Developers test and package agents locally using the official mda CLI (mda dev for local LangSmith testing and mda deploy for publishing). Once deployed, your application interacts with the agent through an API-first model to create threads and stream runs without managing custom servers. This is the hand-off moment: from here, LangChain takes over the “keeping it alive” part.
The managed runtime supports checkpointing, allowing the execution state to be persisted during a run and used to resume work after interruptions. When execution is interrupted, a checkpointed state can support resuming the run rather than requiring the workflow to begin again from scratch.
It pauses when it hits a human-approval step. Human-in-the-loop controls can be configured on tools so that sensitive actions require human approval before the tool call proceeds. It doesn’t guess or force a decision on its own.
Code runs inside a sandbox. For workflows that require code, shell commands, or file I/O, Managed Deep Agents can use sandbox-backed execution environments designed to isolate those workloads, separate from your actual systems, so a bad script can’t touch real data or infrastructure.
You get a record of what happened. Managed Deep Agents automatically trace runs in LangSmith, allowing teams to inspect tool calls, intermediate activity, and execution behavior for debugging and observability, useful for debugging or for auditing sensitive tasks after the fact.
The upshot: your team writes the “what”; LangChain handles the “how”: the checkpointing, the safe execution, the pausing logic, so you’re not building that infrastructure from scratch.
Why Do Managed Deep Agents Make AI Easier to Scale?
Managed Deep Agents can reduce the engineering effort required to build and operate the runtime infrastructure around long-running agents.
Here’s the actual bottleneck most businesses hit. Getting an agent to work in a demo is the easy part. Getting it to survive a production environment, where servers restart, connections drop, and tasks need human sign-off, is a separate engineering problem entirely. Historically, that meant hiring engineers to build:
- A system to save and reload agent progress (so a crash doesn’t mean starting over)
- A safe sandbox to run any code the agent generates
- An approval workflow so a human can step in on sensitive steps
- Logging and monitoring to track what the agent actually did
Building these capabilities internally can introduce significant engineering, infrastructure, security, and maintenance requirements before an agent is ready for production. Most small and mid-sized businesses don’t have a team dedicated to building that kind of reliability layer, and even companies that do often decide it’s not worth diverting engineers away from their core product to solve it.
Managed Deep Agents moves much of this runtime and operational infrastructure into a managed service, allowing teams to focus more of their engineering effort on agent behavior, tools, context, and business logic. That changes the math for scaling: instead of building the entire runtime layer yourself, teams can use the managed infrastructure while focusing their engineering effort on configuring, testing, evaluating, securing, and integrating the agent.
The industry-wide shift toward task-specific AI agents is happening fast. In a Gartner press release on enterprise AI agent adoption, Senior Director Analyst Anushree Verma described AI agents progressing rapidly from the basic, embedded assistants found in most enterprise applications today to task-specific agents by 2026, and toward multiagent ecosystems by 2029. The businesses able to move quickest are the ones that don’t have to build the plumbing themselves first.
Conclusion
Managed deep agents automate execution, not strategy; they still require a clearly defined workflow and target objective. But Managed Deep Agents addresses several barriers between an agent prototype and production deployment by providing managed execution, checkpointing, context, human-in-the-loop workflows, sandbox-backed execution, and observability. For business owners, that means less time worrying about the technical side and more time deciding where AI can actually help your business grow.
Frequently Asked Questions
Do I need to be a tech expert to use Managed Deep Agents?
Managed Deep Agents is designed for developers and technical teams. You still need to define the agent, configure its tools and context, integrate it with your application, and manage permissions and business logic. The managed runtime reduces the need to build and operate the underlying agent infrastructure yourself.
Is it free or open source?
Deep Agents is an open-source agent harness, free to use and self-host. Managed Deep Agents is the hosted runtime built around it inside LangSmith. It launched in private beta in May 2026 and moved to public beta in August 2026, so teams can now follow LangChain’s quickstart to deploy a managed agent rather than needing design-partner access.
Which businesses should try this first?
Managed Deep Agents is particularly relevant for teams building support and triage agents, research agents, coding agents, data-analysis agents, and internal operations agents that need persistent context, tools, artifacts, or longer-running execution.
Is this only useful for large enterprises, or can smaller businesses use it too?
Both can use Managed Deep Agents. It is most relevant for teams of any size that need to run complex, long-running agents without building the underlying runtime infrastructure themselves.