LangChain Debuts Managed Deep Agents to Halt Autonomous Run Crashes

Introducing Managed Deep Agents | Interrupt 26 — LangChain

LangChain

Autonomous agents inevitably fail in enterprise production unless supported by durable state checkpointing, filesystem context offloading, and isolated sandboxes that protect long-horizon execution from crashes.

AI-assisted summary of Introducing Managed Deep Agents | Interrupt 26 — original source. Check the original for full context.

Source published:

Key ideas

  • LangChain introduced Managed Deep Agents in private beta, offering an API-first hosted runtime built on LangSmith to create, update, manage, and run deep agents programmatically. (10:52)
  • The open-source Deep Agents harness provides a provider-agnostic framework built around four core capabilities: an execution environment with a file system, proactive context management, delegation with sub-agents, and first-class human-in-the-loop steering primitives. (2:14)
  • Durable execution powered by the LangGraph runtime checkpoints agent state after every step, allowing failed runs to retry from the exact point of failure and enabling indefinite pauses for human review. (12:23)
  • Managed Deep Agents integrates with Context Hub for versioning agent artifacts like agent.md and skills, and introduces LangSmith Sandboxes equipped with snapshot/restore capabilities and zero-exposure auth proxies. (15:07)

Detailed notes

## Background Published on YouTube by LangChain on May 29, 2026, this keynote from the Interrupt 26 conference introduces Managed Deep Agents in private beta. Presented by Sydney Runkle and Victor Moreira, the video details an API-first hosted runtime within LangSmith engineered for creating, running, and managing long-horizon deep agents programmatically.

## TL;DR Sydney Runkle begins by defining the agent harness and outlining the open-source Deep Agents framework across four core capabilities: an execution environment with a file system and sandboxes, context management via offloading and memory, structured delegation to sub-agents, and human-in-the-loop steering. Victor Moreira then introduces Managed Deep Agents, addressing the operational hurdles of running agents at scale through a durable, LangSmith-backed runtime featuring per-step checkpointing and horizontal auto-scaling. The platform integrates three-tier enterprise security, Agent-to-Agent (A2A) and remote graph interoperability, version-controlled Context Hub artifacts optimized by LangSmith Engine, and secure compute sandboxes with snapshot/restore and auth proxies.

## Atmosphere & style The talk delivers a crisp, confident keynote presentation that smoothly transitions from architectural first principles to practical infrastructure engineering. Sydney provides a clean, pedagogical walkthrough of what makes an agent harness function, setting up an engaging dynamic as Victor steps in with a pragmatic, battle-tested perspective on enterprise operations. The tone is refreshingly realistic rather than hype-driven, acknowledging that essentials like durable checkpointing can feel 'a little boring' and underscoring the tedious engineering required to solve UX edge cases like mid-flight cancellations and double-texting.

## Bulletin - [10:52](https://www.youtube.com/watch?v=LdQpoK2TzSo&t=652s) LangChain introduced Managed Deep Agents in private beta, offering an API-first hosted runtime built on LangSmith to create, update, manage, and run deep agents programmatically. - [02:14](https://www.youtube.com/watch?v=LdQpoK2TzSo&t=134s) The open-source Deep Agents harness provides a provider-agnostic framework built around four core capabilities: an execution environment with a file system, proactive context management, delegation with sub-agents, and first-class human-in-the-loop steering primitives. - [12:23](https://www.youtube.com/watch?v=LdQpoK2TzSo&t=743s) Durable execution powered by the LangGraph runtime checkpoints agent state after every step, allowing failed runs to retry from the exact point of failure and enabling indefinite pauses for human review. - [15:07](https://www.youtube.com/watch?v=LdQpoK2TzSo&t=907s) Managed Deep Agents integrates with Context Hub for versioning agent artifacts like agent.md and skills, and introduces LangSmith Sandboxes equipped with snapshot/restore capabilities and zero-exposure auth proxies.

## Key takeaways - [00:20](https://www.youtube.com/watch?v=LdQpoK2TzSo&t=20s) An agent is defined as a model coupled with a harness, where the harness supplies skills, memory, tools, and context to bridge the model to real-world tasks. - [01:26](https://www.youtube.com/watch?v=LdQpoK2TzSo&t=86s) Production-grade agents require solving five core challenges: an action-taking execution environment, domain data connectivity, context overflow regulation, parallelization, and human-in-the-loop steering. - [02:35](https://www.youtube.com/watch?v=LdQpoK2TzSo&t=155s) An execution environment anchored by a local file system and code interpreter is the foundational capability that enables agents to store scratch work, persist memories, and execute dynamic code. - [04:48](https://www.youtube.com/watch?v=LdQpoK2TzSo&t=288s) Context overflow is mitigated via automatic summarization and proactive offloading of verbose tool outputs, user messages, and files directly to the local file system. - [05:47](https://www.youtube.com/watch?v=LdQpoK2TzSo&t=347s) Skills are managed through progressive disclosure, injecting minimal manifests into initial prompts and loading full definitions dynamically only when relevant. - [06:43](https://www.youtube.com/watch?v=LdQpoK2TzSo&t=403s) Delegating tasks to specialized sub-agents isolates context windows, enables parallel execution, and allows heterogeneous routing across different foundation models. - [08:06](https://www.youtube.com/watch?v=LdQpoK2TzSo&t=486s) Human-in-the-loop steering relies on four core decision primitives: approve, edit, reject, and respond. - [09:03](https://www.youtube.com/watch?v=LdQpoK2TzSo&t=543s) Deep Agents avoids vendor lock-in through provider-neutral model swapping and a middleware hook system for injecting deterministic business logic, guardrails, and PII redaction. - [10:25](https://www.youtube.com/watch?v=LdQpoK2TzSo&t=625s) Transitioning agents from prototypes to production introduces severe hurdles around fault tolerance, user response delays, bursty traffic scaling, and complex security governance. - [11:38](https://www.youtube.com/watch?v=LdQpoK2TzSo&t=698s) The Managed Deep Agents runtime provides task queues, horizontal auto-scaling, and client SDKs integrated with UI frameworks like CopilotKit and Assistant UI. - [12:23](https://www.youtube.com/watch?v=LdQpoK2TzSo&t=743s) Step-by-step durable checkpointing in LangGraph allows long-running ambient agents to be replayed, forked, or paused indefinitely for human input without losing state. - [13:20](https://www.youtube.com/watch?v=LdQpoK2TzSo&t=800s) Enterprise security in Managed Deep Agents spans three layers: inbound caller identity, outbound user-scoped credentials for MCP and external tools, and RBAC/ABAC lifecycle management. - [14:03](https://www.youtube.com/watch?v=LdQpoK2TzSo&t=843s) Standardized interoperability is supported via the remote graph pattern for LangSmith and LangGraph deployments alongside native support for the Agent-to-Agent (A2A) protocol. - [15:07](https://www.youtube.com/watch?v=LdQpoK2TzSo&t=907s) LangChain's Context Hub acts as a version-controlled single source of truth for agent.md files and reusable procedural skills across staging and production. - [15:51](https://www.youtube.com/watch?v=LdQpoK2TzSo&t=951s) The LangSmith Engine forms a continuous optimization flywheel by analyzing production traces to iteratively refine prompts, agent guidelines, and skills. - [16:12](https://www.youtube.com/watch?v=LdQpoK2TzSo&t=972s) LangSmith Sandboxes provide safe execution environments for computational tasks with fast snapshot/restore and an auth proxy that prevents secret leakage to LLMs.

## Detailed walkthrough ### [00:07](https://www.youtube.com/watch?v=LdQpoK2TzSo&t=7s) Introduction and Defining the Agent Harness

Sydney Runkle, an open source engineer at LangChain, opens the talk alongside Victor Moreira, a product manager at LangChain, to introduce Managed Deep Agents. Before diving into the hosted offering, Sydney steps back to define foundational concepts: an agent at its simplest is merely a model coupled with a tool-calling loop, continuously invoking tools until a task finishes and returns a result. However, an effective agent requires more than just raw model inference.

Sydney defines an agent as a model plus a harness, explaining that “the harness is everything that connects the model to the real world.” It bundles skills, memory, base system prompts, tools, sub-agents, and supplementary context. Because a model’s real-world efficacy is entirely bottlenecked by what it sees, Sydney emphasizes: “A model is only as powerful as the context that it's given. And so, the harness exists to bridge this gap.”

Building production-ready agents demands solving five core requirements: - Operating within an action-taking execution environment, which establishes true agency. - Connecting directly to domain data to produce relevant actions. - Regulating context growth over long runs to prevent context overflow. - Parallelizing tasks to handle complex operations efficiently. - Engaging humans in the loop on high-stakes, sensitive workflows while iteratively improving over time.

[02:14](https://www.youtube.com/watch?v=LdQpoK2TzSo&t=134s) Deep Agents: The Four Core Harness Capabilities

To address these hurdles, LangChain designed Deep Agents: an open-source, customizable agent harness purpose-built for complex, real-world tasks over long horizons. Sydney outlines four primary architectural pillars that form the harness: an execution environment anchored by a file system, sophisticated context management utilities, structured delegation with sub-agents, and first-class human-in-the-loop steering primitives.

```mermaid flowchart TD accTitle: Deep Agents Core Architecture accDescr: The four core pillars comprising the Deep Agents harness and their foundational relationships.

subgraph Environment ["Execution Environment"] FS["File System"] Box["Sandbox / Code Interpreter"] FS --- Box end

subgraph Context ["Context Management"] Offload["Context Offloading & Eviction"] Summ["Periodic Summarization"] Mem["Short- & Long-Term Memory"] Cache["Prompt Caching"] Skill["Skills (Progressive Disclosure)"] end

subgraph Orchestration ["Orchestration & Control"] Delegation["Delegation (Sub-agents & Planning)"] HITL["Human-in-the-Loop Steering"] end

Environment --> Context Context --> Orchestration ```

[02:35](https://www.youtube.com/watch?v=LdQpoK2TzSo&t=155s) Capability 1: Execution Environment and File System

Sydney highlights the execution environment as the foundational backbone supporting the rest of the harness: “This capability powers all of the rest.” At its base sits the file system. Agents leverage this local environment to read and write scratch files while performing tasks, store and retrieve persistent memories directly in the hot execution path, and dynamically invoke specialized skills.

Because modern foundation models are trained extensively on code and command-line environments, they are naturally adept at file system operations. Augmenting the file system with an execution sandbox or code interpreter provides a secure space to write and execute code. This grants the agent substantial dynamic runtime behavior and unlocks creative problem-solving far beyond static API calls.

[04:48](https://www.youtube.com/watch?v=LdQpoK2TzSo&t=288s) Capability 2: Context Management

Context management is identified as perhaps the most vital operational discipline for production systems. To combat the context overflow that frequently plagues high-context, long-running agent loops, Deep Agents embeds automatic summarization alongside proactive context offloading. Large items—such as verbose tool call outputs, detailed human messages, and raw files—are routinely evicted from the active context window and offloaded onto the local file system. Whenever historical message depth threatens the model's token limits, summarization triggers automatically to compress prior interactions.

Beyond context offloading, the harness integrates native memory, prompt caching, and progressive skill loading: - **Memory Systems**: Ships with out-of-the-box short- and long-term memory support. As Sydney points out, “I would argue that memory is maybe the most important kind of context, because it's the context that changes from run to run, and allows your agent to improve over time.” - **Provider-Agnostic Prompt Caching**: Essential for preserving budget predictability and keeping token costs manageable during long-running tasks. - **Skills via Progressive Disclosure**: Rather than bloating the base system prompt with every skill definition, Deep Agents injects minimal skill manifests into the system prompt upfront. The agent then dynamically inspects and loads full skill resources into its scripts only when a task demands it.

[06:43](https://www.youtube.com/watch?v=LdQpoK2TzSo&t=403s) Capability 3: Delegation and Sub-Agents

As workflows expand in scope and duration, a monolithic agent struggling through every phase of a job quickly degrades. Deep Agents equips agents with built-in planning tools to map out milestones and delegate tasks to sub-agents, which can be general-purpose or deeply specialized. In a software engineering workflow, for example, a lead agent might spin up dedicated sub-agents for system architecture, security and code reviews, and automated test suite creation.

Sub-agents resolve three structural bottlenecks: - **Context Isolation**: When dispatched, a sub-agent receives isolated context tailored strictly to its scoped task. Once complete, it hands back a concise, streamlined result to the parent orchestrator without polluting the primary context window. - **Parallelization**: Multiple sub-agents run concurrently, significantly shortening end-to-end wall-clock execution time. - **Heterogeneous Model Routing**: Sub-agents can run on completely different foundation models or infrastructure providers, allowing developers to route simpler sub-tasks to lightweight, inexpensive models while reserving frontier reasoning models for complex planning.

[08:06](https://www.youtube.com/watch?v=LdQpoK2TzSo&t=486s) Capability 4: Human-in-the-Loop Steering

For sensitive workflows and edge cases where model confidence drops, Deep Agents provides first-class steering primitives. Human oversight serves two specific functions: vetting sensitive or irreversible operations, and giving users an avenue to clarify ambiguity and unblock progress.

| Decision Pattern | Mechanism | Example Use Case | |:--- |:--- |:--- | | **Approve** | Evaluates a planned action and yields explicit authorization before execution. | Reviewing and approving an email draft before it sends. | | **Edit** | Intercepts and modifies the model's generated payload prior to dispatch. | Tweaking the copy of a social media post or tweet before publishing. | | **Reject** | Halts execution or forces re-planning when an action violates constraints. | Blocking an unauthorized or erroneous financial transaction. | | **Respond** | Interrupts the agent loop to solicit targeted answers from the user. | Clarifying ambiguous prompt parameters to unblock execution. |

[09:03](https://www.youtube.com/watch?v=LdQpoK2TzSo&t=543s) Why Deep Agents: Provider Neutrality and Custom Middleware

Deep Agents is explicitly architected to avoid vendor lock-in. Developers can configure and swap model providers dynamically or assign different providers across the orchestration tree: - Commercial frontier providers including Anthropic, OpenAI, and Google. - Local model runtimes using Ollama. - Cost-effective, high-throughput open-source model inference via Fireworks, Nvidia, OpenRouter, and Baseten.

```mermaid flowchart LR accTitle: Deep Agents Middleware Architecture accDescr: Interception lifecycle where customizable middleware wraps the core agent reasoning and tool loop.

In(["Input Task"]) --> Pre["Pre-Step Middleware\n(Auth, Policy, PII)"] Pre --> Loop["Core Agent Loop\n(Model & Tool Calls)"] Loop --> Post["Post-Step Middleware\n(Output Guardrails, Logging)"] Post --> Out(["Result / Action"]) ```

Beyond model portability, Deep Agents introduces a hook system called **middleware** wrapped around the core model-and-tool loop. This middleware allows teams to inject deterministic business rules, enforce compliance policies (such as redacting PII before prompts leave the cluster), or implement dynamic runtime adjustments like swapping available tools and models on the fly based on current task constraints.

[10:25](https://www.youtube.com/watch?v=LdQpoK2TzSo&t=625s) Transitioning to Production: Managed Deep Agents

Sydney concludes her portion of the presentation by contrasting local prototyping with production engineering: “Even with a capable harness, going to production is really hard.” Moving an autonomous agent to enterprise production introduces severe operational challenges: - Maintaining persistent execution across long durations and gracefully recovering from sudden node or process crashes. - Managing interactive human-in-the-loop state suspends and resumes alongside erratic user response times. - Absorbing highly bursty customer traffic without hitting severe rate limits or dropping threads. - Maintaining an airtight security posture and continuously tracking shifting interoperability specifications.

Sydney passes the stage to Victor Moreira, who officially announces the launch of **Managed Deep Agents in private beta**. Victor notes that while observing teams deploy agents to real users, LangChain identified clear infrastructure hurdles that software teams face repeatedly. Managed Deep Agents is structured across four foundational pillars: 1. The open-source **Deep Agents harness** described by Sydney. 2. A scalable, durable **runtime** engineered directly for enterprise production loads. 3. Deep integrations with LangChain's **Context Hub** infrastructure. 4. Secure sandboxing and execution environments.

[11:39](https://www.youtube.com/watch?v=LdQpoK2TzSo&t=699s) Pillar 1: Production Runtime and Durable Execution

Victor Moreira details the foundational runtime of Managed Deep Agents, which is engineered directly on top of LangSmith deployment. Moving an agent from a prototype to production requires infrastructure capable of supporting high concurrency, real-time interactivity, and enterprise scalability. Managed Deep Agents exposes dedicated endpoints to create, update, manage, and invoke agents programmatically from any external service or internal developer portal. To withstand unpredictable traffic spikes—such as an infrastructure outage triggering thousands of customers to simultaneously flood a customer support bot—the runtime incorporates a purpose-built task queue paired with automated horizontal scaling. It also provides client SDKs and native integrations with UI frameworks like CopilotKit and Assistant UI, enabling generative user experiences without custom glue code.

Underpinning this infrastructure is durable execution powered by the LangGraph runtime. Victor acknowledges that state persistence is rarely flashy, remarking: “This is one of those things that is a little boring to think about, but it is very, very reliable in production.” Because the runtime checkpoints the agent’s execution graph after every individual step into durable storage, failures no longer discard completed progress. If an agent encounters a network timeout or runtime exception at step 49 out of a 50-step sequence, developers or automated recovery systems can simply resume and retry directly from step 49 rather than re-running the entire workflow from scratch. Furthermore, complete execution checkpointing allows teams to fork or replay an agent run from any historical state, inspect alternative decision trees, or pause execution indefinitely while waiting for human input—a core primitive for ambient, long-running agents.

```mermaid flowchart TD accTitle: Managed Deep Agents Durable Execution and Checkpointing Flow accDescr: An architecture diagram showing how agent requests move through task queues into LangGraph step execution, persisting state to durable checkpoints for replay or resumption.

subgraph ClientLayer ["Client & Ingress"] REQ["Application Request"] --> ENDP["Management Endpoints"] ENDP --> QUEUE["Task Queue & Auto-Scaling"] end

subgraph RuntimeLayer ["LangGraph Runtime"] QUEUE --> STEP1["Step 1 Execution"] STEP1 --> CK1[("Checkpoint 1")] CK1 --> STEPN["Step N Execution"] STEPN --> CKN[("Checkpoint N")] end

subgraph Resilience ["Durable State Operations"] CKN --> PAUSE["Indefinite Wait (Human-in-the-Loop)"] CKN --> RETRY["Resume / Retry from Failure"] CKN --> FORK["Fork / Replay Conversation"] end ```

- **Production-Ready Endpoints:** Programmatic APIs for creating, updating, inspecting, and invoking deep agents across environments. - **Traffic Spikeproofing:** Dedicated task queuing and elastic horizontal scaling to absorb sudden bursts in request volume. - **Durable Checkpointing:** Every state transition is written to disk, preventing costly re-runs when multi-step tasks fail near completion. - **Human-in-the-Loop Pausing:** State snapshots allow runs to halt indefinitely until a human review occurs, unlocking ambient agent workflows.

---

[13:20](https://www.youtube.com/watch?v=LdQpoK2TzSo&t=800s) Security, Auth Layers, and Agent Interoperability

Production deployments introduce severe authentication and authorization challenges that simple API wrappers cannot address. Victor outlines three non-negotiable security layers required for enterprise agents. The first layer handles inbound identity validation, verifying that the calling user or system has permission to invoke the requested agent. The second layer governs outbound access from within the agent itself to external enterprise APIs or Model Context Protocol (MCP) tools, guaranteeing that tool invocations assume the precise runtime permissions of the initiating user. The third layer provides governance over the agent lifecycle through role-based access control (RBAC) and attribute-based access control (ABAC), delineating whether an AI engineer, a service account, or an executive can modify prompt templates, update tool sets, or deploy code changes.

Interoperability is equally critical so teams do not end up with siloed agents. Managed Deep Agents brings the "remote graph" pattern from LangSmith deployments, enabling developers to invoke a managed deep agent inside a custom LangGraph application deployed elsewhere using just a single line of code. It also provides native out-of-the-box support for the Agent-to-Agent (A2A) protocol, facilitating standardized cross-agent communication. Recognizing that developers want their agents integrated where their work actually happens, the platform supports interfaces like Deep Agents Code and desktop tools like Claude Desktop. Victor points out that handling these integration surfaces cleanly involves complex UX edge cases: “Things like double texting, canceling a run mid-flight, are all things that actually take real engineering work and will take you weeks if not months to build.” Managed Deep Agents eliminates that toil by packaging those lifecycle states directly into the hosted platform.

- **Three Auth Boundaries:** Inbound app verification, outbound scoped credentials for MCP and custom tools, and internal RBAC/ABAC for agent management. - **Remote Graph Invocations:** Managed agents can be invoked as subgraphs inside separate LangGraph deployments with one line of code. - **Protocol Standardization:** Full compliance with the A2A protocol for structured multi-agent negotiation and delegation. - **Edge-Case Handling:** Pre-built handling for mid-flight run cancellations, user interruptions, and double-texting scenarios.

---

[15:07](https://www.youtube.com/watch?v=LdQpoK2TzSo&t=907s) Pillar 3: Context Hub and LangSmith Engine Integration

The third pillar of Managed Deep Agents is deep integration with Context Hub, LangChain's repository for managing, versioning, and deploying agent artifacts. Long-horizon deep agents rely on dynamic files such as `agent.md` system guidelines, procedural skills, and accumulated user memories. Context Hub acts as the single source of truth for these files, establishing a version-controlled release pipeline where teams can test and refine skills in staging before promoting them into production. This centralized mechanism prevents behavioral drift and democratizes reusable skills across different agents in an organization.

Context Hub also connects directly into the LangSmith Engine flywheel to drive autonomous, data-driven optimization. As agents handle real-world user interactions in production, LangSmith Engine analyzes trace logs, tool outputs, and evaluation metrics to identify recurring failures or suboptimal behaviors. The engine can then iteratively refine prompt templates, adjust `agent.md` behavioral rules, and tune domain skills to continuously improve agent reliability over time.

- **Artifact Versioning:** Centralized tracking and diffing for `agent.md` files, custom skills, and long-term user memories. - **Staging-to-Production Promotion:** Controlled promotion workflows that ensure agent skills are thoroughly validated before widespread rollout. - **LangSmith Engine Feedback Loop:** Production traces inform automated prompt engineering and skill refinements, creating self-improving agents.

---

[16:12](https://www.youtube.com/watch?v=LdQpoK2TzSo&t=972s) Pillar 4: LangSmith Sandboxes and Private Beta Launch

The final core capability of Managed Deep Agents addresses the reality that modern software agents must frequently execute untrusted code. Victor observes that code generation is no longer confined to dedicated programming assistants, noting: “Even a research agent use case, they might want to be able to crunch some quick stats and add them to a report.” To give agents safe, isolated compute environments without endangering host infrastructure, LangChain is introducing LangSmith Sandboxes, which integrate natively with Managed Deep Agents.

LangSmith Sandboxes provide two primary enterprise capabilities: an integrated auth proxy and robust snapshot/restore functionality. The auth proxy securely injects sensitive third-party credentials and API keys at runtime so that secret environment variables are never exposed directly to the sandbox filesystem or visible to the LLM. Meanwhile, the snapshot and restore engine allows an agent's execution environment—including installed dependencies, environment state, and working directories—to be instantly frozen, cached, and restored on demand. Victor highlights that an upcoming session with Mikhail will explore sandboxing deeply, and concludes the keynote by officially announcing the private beta for Managed Deep Agents and opening the waitlist to developers.

- **Integrated Compute Isolation:** Sandboxes allow research and operational agents to run computational scripts and format reports securely. - **Zero-Exposure Auth Proxy:** Secrets and tokens are injected into outbound calls on the fly, preventing code interpreters from leaking environment variables. - **Fast Snapshot and Restore:** Environments can be checkpointed and restored instantly to guarantee consistent execution state across sessions. - **Private Beta Availability:** Managed Deep Agents enters private beta immediately at Interrupt 26, with an open developer waitlist.

## Notable quotes > [04:48](https://www.youtube.com/watch?v=LdQpoK2TzSo&t=288s) I would argue that memory is maybe the most important kind of context, because it's the context that changes from run to run, and allows your agent to improve over time. — Sydney Runkle

> [00:07](https://www.youtube.com/watch?v=LdQpoK2TzSo&t=7s) A model is only as powerful as the context that it's given. And so, the harness exists to bridge this gap. — Sydney Runkle

> [13:20](https://www.youtube.com/watch?v=LdQpoK2TzSo&t=800s) Things like double texting, canceling a run mid-flight, are all things that actually take real engineering work and will take you weeks if not months to build. — Victor Moreira

## Mentioned Sydney Runkle, Victor Moreira, Mikhail, LangChain, Deep Agents, Managed Deep Agents, LangSmith, LangSmith Engine, LangSmith Sandboxes, LangGraph, Context Hub, Interrupt 26, Anthropic, OpenAI, Google, Ollama, Fireworks, Nvidia, OpenRouter, Baseten, CopilotKit, Assistant UI, Claude Desktop, Deep Agents Code, Model Context Protocol, Agent-to-Agent protocol

## Video description At LangChain's agent conference Interrupt, we announced Managed Deep Agents in private beta, an API-first hosted runtime for creating, running, and operating deep agents.

Deep Agents gives developers an open-source harness for building agents that can plan, use tools, delegate to subagents, write files, and work over long horizons. Managed Deep Agents gives those agents a durable home in LangSmith.

With the Managed Deep Agents API, you can create, update, manage, and run agents programmatically from your own application or internal platform workflow.

In this Interrupt 26 keynote, Sydney Runkle and Victor Moreira demonstrated what's new in LangChain for building and deploying Deep Agents in production.

Introducing Managed Deep Agents | Interrupt 26 00:00 Introduction: Sydney and Victor 00:20 What is an agent? Model + tool-calling loop 00:42 What is a harness? Defining the concept 01:07 The harness: skills, memory, tools, sub-agents 01:10 Job of a harness: right context at the right time 01:26 Why you need a harness: five agent requirements 02:14 What is Deep Agents? 02:26 The four capabilities of the Deep Agents harness 02:35 Capability 1: Execution environment and file system 03:53 Sandboxes and code interpreters 04:48 Capability 2: Context management 05:15 Summarization, context offloading, and memory 05:47 Prompt caching and skills (progressive disclosure) 06:43 Capability 3: Delegation and sub-agents 07:20 Why sub-agents matter: isolated context and parallelization 08:06 Capability 4: Human-in-the-loop steering 08:35 Four human-in-the-loop decision patterns 09:03 Why Deep Agents: provider-agnostic, customizable, middleware 10:25 Going to production is hard — handoff to Victor 10:52 Introducing Managed Deep Agents (private beta) 11:19 The four pillars of Managed Deep Agents 11:38 Pillar 1: Runtime — built on LangSmith deployment 12:23 Durable execution and checkpointing 13:13 Security and auth layers (RBAC, ABAC, MCP tools) 14:03 Agent interoperability: remote graph, Agent-to-Agent protocol 14:37 Bringing agents where you work 15:07 Pillar 3: Context Hub integration 15:51 LangSmith Engine integration 16:12 Pillar 4: LangSmith Sandboxes 16:53 Auth proxy and snapshot/restore 17:07 Wrapping up: private beta and waitlist

Extra resources: • Everything we shipped at Interrupt: https://www.langchain.com/blog/interrupt-2026-overview • Introducing Managed Deep Agents: https://www.langchain.com/blog/introducing-managed-deep-agents • About Deep Agents: https://www.langchain.com/deep-agents • About LangChain: https://www.langchain.com/

[Source](https://www.youtube.com/watch?v=LdQpoK2TzSo)

Reading summary

At Interrupt 26, LangChain's Sydney Runkle and Victor Moreira introduced Deep Agents and the private beta of Managed Deep Agents, arguing that autonomous systems require a specialized execution harness and durable production infrastructure rather than raw model inference alone. The Four Capabilities of the Deep Agents Harness (2:14) Sydney Runkle frames an agent as a model paired with an execution harness, arguing that real-world efficacy is bottlenecked by the context and tools provided to the model. To overcome challenges in long-horizon tasks, LangChain designed Deep Agents around four architectural capabilities. The foundation rests on a local file system and execution sandbox, allowing agents to inspect directories, maintain scratchpads, and run code. Layered above this is an active context management engine that prevents token overflow by offloading large tool outputs or human messages to disk, triggering periodic summarization, and progressively loading skill manifests only when required. To handle sprawling workflows without degrading context, the harness incorporates built-in planning that delegates isolated sub-tasks to specialized sub-agents. These sub-agents run concurrently and can route to heterogeneous foundation models—ranging from commercial frontier systems to local Ollama runtimes—returning concise outputs to the primary agent. Finally, human-in-the-loop steering primitives (approve, edit, reject, and respond) allow operators to intercept, modify, or guide actions during sensitive operations or edge cases. Middleware hooks wrap around this loop, enforcing deterministic business rules such as PII redaction and credential checks. Durable Execution and Runtime Infrastructure (11:39) Transitioning agents from prototype scripts to production environments introduces severe infrastructure hurdles, including handling bursty request volumes, sudden process failures, and long pauses while waiting for user steering. Victor Moreira explains that Managed Deep Agents addresses these hurdles by deploying on top of LangSmith infrastructure, incorporating programmatic agent-management endpoints, client SDKs, and elastic task queues paired with automatic horizontal scaling. Underpinning this hosted runtime is LangGraph's durable execution model, which writes the state of the agent's graph to disk after every single step. If a long-running process fails on step 49 of a 50-step run due to an exception or timeout, the system resumes and retries directly from step 49 rather than restarting the entire workflow. This continuous checkpointing also allows developers to pause runs indefinitely during human-in-the-loop reviews, fork execution paths to evaluate alternative decisions, and replay past interactions. Multi-Boundary Security and Ecosystem Interoperability (13:20) Enterprise deployments require security boundaries that simple API wrappers fail to supply. Moreira outlines three discrete authorization layers built into Managed Deep Agents: inbound authentication to verify client identity, outbound scoped credentials that pass a user's explicit permissions into Model Context Protocol (MCP) and custom enterprise tools, and administrative role- and attribute-based access controls (RBAC/ABAC) over agent templates and deployments. To prevent agent silos, Managed Deep Agents adopts standardized protocols and modular integration patterns. Developers can invoke a managed agent inside external LangGraph deployments using a single-line remote graph pattern, or connect it to multi-agent environments via the Agent-to-Agent (A2A) protocol. The runtime also natively resolves complex interaction edge cases—such as user interruptions, mid-flight run cancellations, and double-texting—without requiring custom glue code. Context Hub Artifacts and Secure Sandboxing (15:07) Long-horizon agents depend on mutable operational files, such as behavioral system instructions (agent.md), reusable skills, and accumulated long-term memories. Managed Deep Agents centralizes these assets within Context Hub, providing a version-controlled repository to test and promote skills from staging to production. This pipeline feeds into the LangSmith Engine, which analyzes production traces and evaluation metrics to automatically identify behavioral failures and iteratively refine prompts and tool definitions. To allow agents to execute arbitrary computational scripts and process reports safely, LangChain introduced LangSmith Sandboxes. These isolated compute environments feature an auth proxy that dynamically injects enterprise secrets into external tool requests without exposing environment variables or API keys to the model or sandbox filesystem. The sandboxes also provide snapshot and restore capabilities, enabling systems to freeze, cache, and rapidly resume dependencies and environment states across sessions. Managed Deep Agents has entered private beta with an open developer waitlist; its operational effectiveness hinges on how reliably its checkpointed runtime and sandboxed boundaries isolate untrusted code and coordinate complex, multi-agent workflows in live enterprise settings.

Source quotes

[4:48] Sydney Runkle: I would argue that memory is maybe the most important kind of context, because it's the context that changes from run to run, and allows your agent to improve over time. [0:07] Sydney Runkle: A model is only as powerful as the context that it's given. And so, the harness exists to bridge this gap. [13:20] Victor Moreira: Things like double texting, canceling a run mid-flight, are all things that actually take real engineering work and will take you weeks if not months to build.

Original transcript

[0:07] Hi folks. I'm Sydney and I am an open [0:10] source engineer at LangChain. [0:12] Hi, I'm Victor. I'm a product manager. [0:14] And today we're going to be walking [0:15] through managed deep agents. But before [0:18] we talk about that, Sydney's going to [0:19] walk us through deep agents as a [0:21] harness. [0:24] So, first off, what is an agent? [0:28] An agent is a simple model and tool [0:30] calling loop. A model calling tools in a [0:33] loop until it completes a task and [0:35] returns a final result. [0:39] What is a harness? [0:41] We can define a harness as [0:44] or we can define an agent as a model [0:46] plus a harness. [0:48] So, the harness is everything that [0:49] connects the model to the real world. [0:52] Everything around the model that helps [0:54] it complete tasks. [0:56] So, this is made up of skills, [0:58] memory, [1:00] the base system prompt, [1:02] tools, sub agents, and any additional [1:04] context. [1:07] What's the job of a harness? [1:10] So, the job of a harness is to get the [1:12] model the right context at the right [1:14] time for the given task. [1:17] A model is only as powerful as the [1:19] context that it's given. And so, the [1:21] harness exists to bridge this gap. [1:26] Why do you need a harness? Well, agents [1:29] have a lot of jobs. [1:30] Agents need to work in an environment [1:33] where they can take actions. [1:35] This action taking is what gives them [1:38] agency. That's what makes agents useful. [1:41] They need to connect to your data so [1:44] that their actions are relevant for your [1:46] use case. [1:48] They need to manage growing context over [1:50] long runs so that they can avoid context [1:53] overflow. [1:56] They need to be able to parallelize [1:57] tasks to complete complex tasks [2:00] efficiently. [2:02] They need to connect with a human in the [2:04] loop for sensitive workflows. [2:07] And finally, ideally, they improve over [2:09] time so that they remain relevant and [2:11] useful. [2:14] So, [2:15] what is Deep Agents? [2:17] Deep Agents is a customizable agent [2:19] harness [2:21] that's purpose-built for complex [2:23] real-world tasks. [2:26] First, I'm going to cover the four main [2:29] capabilities that are part of the Deep [2:31] Agents harness, and then we'll do kind [2:33] of a deep dive into each one. [2:35] So, first up, we have the execution [2:37] environment. This is the backbone of a [2:40] Deep Agent, and it all starts with the [2:42] file system. [2:45] Optionally, you can also augment this [2:47] with a sandbox or, similarly, a code [2:50] interpreter. [2:53] Next, we have, I think, the most [2:55] important capability, uh, which is [2:57] context management. So, there are lots [3:00] of utilities built into Deep Agents that [3:02] help with this tall order. [3:04] That includes skill support, [3:07] out-of-the-box support for short- and [3:09] long-term memory, [3:10] summarization capabilities, [3:13] context offloading, [3:15] and prompt caching. [3:18] The third capability is delegation. [3:20] As agents run for longer amounts of time [3:23] and take on complex workflows, they need [3:26] to be able to plan and organize tasks, [3:29] and then also use sub-agents to get [3:31] delegate work. [3:34] Finally, we build steering into the Deep [3:36] Agents harness with first-class [3:39] human-in-the-loop support. [3:43] So, now for our deep dive. [3:45] Starting with the execution environment, [3:46] which I mentioned is the backbone of a [3:48] Deep Agent, this capability powers all [3:51] of the rest. [3:53] So, we start with the file system. [3:56] An agent uses a file system to read and [3:58] write scratch files as it tackles work, [4:02] load and store persistent memories in [4:05] the hot path, [4:07] invoke skills when relevant for a given [4:09] task, and many more things. [4:12] Agents are excellent at using file [4:14] systems. They are trained in a an [4:18] environment to use file systems, and [4:21] also trained on lots of code. [4:24] And that's why giving an agent a [4:25] sandbox, or lighter weight cousin, the [4:28] code interpreter, [4:30] is very powerful. [4:32] When you give an agent these code [4:33] execution tools, [4:35] you give it a secure environment to [4:37] write and run code, [4:38] which makes an agent capable of much, [4:41] much more creative problem-solving, um [4:44] and kind of dynamic run-time behavior. [4:48] The second capability is context [4:51] management. [4:53] Deep Agent ships with built-in [4:55] summarization and context offloading. [4:58] You can see on the graph here, [5:00] periodically, Deep Agent will evict [5:03] large messages, so that can be human [5:05] messages, tool results, tool calls, to [5:09] the file system so that we don't build [5:11] up context in the window too quickly. [5:14] Additionally, summarization is triggered [5:17] less frequently, but every so often when [5:19] the history starts to approach the [5:21] model's context limit. [5:23] Both of these are in an effort to avoid [5:25] context overflow, which is a problem [5:27] that plagues long-running agents, or [5:29] high-context agents, or both. [5:32] Deep Agent also ships with built-in [5:35] memory support. [5:36] I would argue that memory is maybe the [5:38] most important kind of context, because [5:41] it's the context that changes from run [5:43] to run, and allows your agent to improve [5:45] over time. [5:48] It also ships with provider agnostic [5:50] prompt caching. [5:52] This is incredibly important for [5:54] long-running high context agents [5:57] that need to operate cost-effectively. [6:00] Finally, Deep Agent ships with skill [6:03] support out of the box. [6:05] Skills are part of the context [6:06] management system um because of a system [6:08] called progressive disclosure. [6:11] So, Deep Agent loads some minimalistic [6:13] information about what skills your agent [6:16] has available up front into the system [6:18] prompt. And then we give the agent the [6:20] power to dynamically pull in full skill [6:23] resources and invoke those skills in [6:25] their scripts when relevant for a given [6:27] task. [6:29] All of this [6:30] this umbrella of context management is [6:33] again [6:34] catering to that need for a harness to [6:36] get the model the right context at the [6:39] right time for the given task. [6:43] The third capability of the Deep Agent [6:45] harness is delegation. [6:48] So, the Deep Agent harness is equipped [6:50] with a planning tool that allows the [6:52] model to organize work [6:55] for challenging tasks. [6:57] It's also equipped with sub agent [6:58] support out of the box. [7:01] Sub agents can be general purpose [7:03] or specialized. [7:05] So, for example, if you were building a [7:07] coding agent, maybe you would want to [7:09] attach some specialized sub agents for [7:12] architecture design, for code review and [7:15] security review, and then test writing [7:18] and execution. [7:20] Why are so Why are sub agents so [7:22] important? [7:24] Well, first, they operate with isolated [7:26] context, and they actually help with [7:28] overall context management. [7:30] So, when you when the main agent invokes [7:32] a sub agent, it starts with fresh [7:35] context only relevant to its given task, [7:37] and then it returns just a streamlined [7:39] final result back to that main agent so [7:42] that it doesn't pollute the main context [7:44] window. [7:46] Secondly, they can be used to [7:47] parallelize work. [7:49] So you your agent can run tasks [7:52] end-to-end more efficiently with that [7:54] parallelization. [7:56] Finally, sub-agents can use any model [7:59] and any provider. [8:00] So you can match model capability with [8:03] task complexity. [8:06] The fourth and final capability of the [8:08] Deep Agent harness is support for [8:11] steering [8:12] via first-class human-in-the-loop [8:14] primitives. [8:15] So human-in-the-loop is really critical [8:17] for two things. [8:19] The first is getting real-time user [8:21] feedback on sensitive actions or tool [8:24] calls as we mentioned before. [8:26] And the second is getting real-time [8:28] feedback when feedback is needed from [8:30] the user to unblock the model. [8:34] So what does this look like? There's [8:36] four common decision patterns that we [8:38] build into Deep Agents. [8:40] The first is an approval flow. So maybe [8:42] you're approving an email before it's [8:43] sent. [8:45] Second is an edit. So maybe editing a [8:47] tweet before it's published. The third [8:49] is a reject decision, rejecting a [8:52] proposed financial transaction. [8:54] And the fourth is the respond pattern. [8:56] So that's when the agent interrupts and [8:58] asks the user for a question to unblock [9:00] its future progress. [9:03] So we've done a deep dive into the [9:05] capabilities of the Deep Agent harness. [9:07] Now let's talk about why Deep Agents. [9:11] Deep Agents is provider agnostic. You [9:13] can use any provider and any model, swap [9:17] it anytime, [9:18] and even mix and match. Your main agent [9:21] can use a different model than your [9:22] sub-agents. [9:23] You can use major providers like [9:25] Anthropic, OpenAI, Google. [9:28] You can use local models with Ollama. [9:31] Or you can use the increasingly [9:34] performant and much cheaper open-source [9:37] models like Fireworks [9:39] from providers like Fireworks, Nvidia, [9:42] Open Router, Base Ten. [9:45] Deep Agents is highly customizable. [9:48] Here's a quick recap of what that core [9:50] agent loop looks like. [9:52] And here's what the Deep Agents loop [9:54] looks like. [9:55] Deep Agents provides a set of hooks [9:57] around the core agent loop. We call this [10:00] system middleware. [10:02] And middleware enables [10:04] basically any custom logic that you want [10:06] to add to your agent. [10:08] That might look like bespoke business [10:10] logic, deterministic code at any point, [10:13] policy enforcement like PII reduction, [10:16] or dynamic agent control. For example, [10:18] changing the model and tools available [10:20] at runtime based on the task at hand. [10:25] Even with a capable harness, going to [10:27] production is really hard. [10:29] Your agent needs to run for long periods [10:32] of time and recover from unexpected [10:34] failures, [10:35] handle human in the loop and [10:37] unpredictable behavior, [10:39] support bursty traffic, [10:41] all while maintaining a secure posture, [10:44] and keeping up with ever-changing [10:46] interoperability standards. [10:48] And now, I'm going to hand it off to [10:49] Vic, who's going to cover how we make [10:51] this easy. [10:52] Awesome. Thank you, Sydney. [10:54] All right. [10:56] So, we just saw what a Deep Agent is. [10:58] Now, we're going to talk about what it [11:00] takes to actually take one of these Deep [11:01] Agents into production. I see a few [11:03] familiar faces in the crowd of people [11:05] that have actually taken these agents [11:07] and served them to customers in [11:08] production. Um so, we've kind of seen [11:10] this firsthand. [11:11] Today, we're going to talk about how [11:13] we're introducing managed Deep Agents in [11:14] private beta in order to make this [11:16] process as easy as possible. [11:19] So, there's kind of four core pillars to [11:21] what managed Deep Agents are. First is [11:23] the harness, which Sydney just walked [11:24] through. [11:25] The second is the runtime, which is how [11:27] we can actually use this agent in [11:28] production. [11:30] The third is going to be an integration [11:31] with context hub. And then lastly, the [11:34] way that we can execute safe code in a [11:36] sandbox. [11:39] So, let's first talk about this runtime. [11:41] So, managed deep agents is actually [11:43] built on top of LangSmith deployment, [11:45] which means we get a lot of primitives [11:47] to handle that real-time kind of [11:48] interaction and scalability that agents [11:50] will actually need in production. [11:52] This means we get endpoints for [11:53] creating, updating, even invoking our [11:55] agents wherever we need them. [11:57] We'll get a purpose-built task queue and [11:59] horizontal scaling in order to handle [12:01] kind of the bursty request loads that [12:03] your agents might experience. [12:04] You can imagine a use case of support [12:07] agent, your systems go down, and now [12:09] everyone's hitting that support agent [12:10] all at once. You need to be able to [12:11] handle that traffic well. [12:13] Lastly is SDKs in order to use these [12:16] agents wherever you need them, [12:17] integrations with Copilot Kit, Assistant [12:19] UI for Gen UI, the list goes on. [12:23] The second kind of core pillar of this [12:24] production runtime is durable execution. [12:27] This is one of those things that is a [12:28] little boring to think about, but it is [12:30] very, very reliable in production. So, [12:32] because we run deep agents on top of the [12:34] LangGraph runtime, we're able to [12:36] actually checkpoint each step that your [12:37] agent takes in production. [12:39] This means that these are all stored in [12:41] durable storage, and we can resume and [12:43] restart from any one of these [12:44] checkpoints. So, if your agent fails on [12:47] step 49 of 50, you don't have to restart [12:49] that whole run again, you can pick up [12:50] and retry from from step 49. [12:53] Lastly, we have the ability to replay [12:55] and fork our agent from any point in [12:57] time with that state. [12:58] This enables some advanced use cases [13:00] where we're close, so you know, [13:01] something like, "Oh, I want to I want to [13:02] fork this conversation from here." But [13:04] it also enables human approval through [13:06] human in the loop. [13:07] Since everything is checkpointed into [13:09] this database, we're able to await human [13:11] input indefinitely. This is what enables [13:14] ambient agent use cases such as [13:16] LangSmith engine, which you hear about [13:17] in the next session. [13:20] Security and auth are very, very [13:22] important to production agents. You need [13:24] multiple layers of auth in order to kind [13:26] of serve these production agent use [13:28] cases. The first is going to be inbound [13:30] from your actual application. How do you [13:32] authenticate that this user is who they [13:33] say they are and they're allowed to use [13:35] this agent? [13:36] The second is going to be outbound from [13:37] inside the agent to your external [13:39] services. You might have tools or MCP [13:41] tools that you need to be able to [13:42] reliably authenticate with and assume [13:44] the correct permissions at runtime. [13:46] The third is actually who has the [13:47] ability to create, update, and manage [13:49] these agents. Whether it is your AI [13:52] engineers internally or maybe your CTO [13:54] wants to get in there and make a quick [13:55] change, you need to have that level of R [13:57] back and A back to enable who actually [13:59] has permissions to make these changes. [14:02] >> [snorts] [14:02] >> Agent interoperability is becoming more [14:04] and more important as you want to use [14:06] your agents in a variety of different [14:07] use cases. [14:09] One thing that's core to LangSmith [14:10] deployment that we're bringing in to [14:11] manage deep agents is the ability to use [14:13] your agent via remote graph. That means [14:15] that you can call your agent that is [14:17] built on managed deep agents in a custom [14:19] LangGraph application that's deployed on [14:21] LangSmith elsewhere in just one line of [14:22] code. [14:23] Second is the ability to support A to A [14:25] protocol. So, a lot of agents are using [14:28] A to A today as a way to kind of handle [14:30] this agent to agent communication layer [14:32] and we support this out of the box in [14:33] both our standard LangSmith deployment [14:35] and also managed deep agent. [14:37] The third is being able to bring this [14:39] agent where you actually do work. We [14:41] have a lot of agents that we build [14:42] internally and deploy on LangSmith [14:43] deployment and we'd love to use them [14:45] where we're doing work. Whether it's [14:46] deep agents code or it's Cloud Desktop, [14:49] you want to be able to bring this agent [14:51] and use it where you need it. [14:53] We thought of all of these different [14:54] production use cases so that you don't [14:56] have to. Things like double texting, [14:58] canceling a run mid-flight, are all [15:00] things that actually take real [15:01] engineering work and will take you weeks [15:02] if not months to build. We have this all [15:04] out of the box for you. [15:07] The third kind of core pillar here is [15:10] the context of integration. [15:13] Oop. [15:13] So, Context Hub is [15:15] built into managed deep agents and it's [15:17] how we version and save every one of [15:19] these files that your agent actually [15:21] operates and runs on. So, things like [15:23] the agent MD and the skills that [15:24] Harrison mentioned during the keynote [15:25] are becoming more and more popular. [15:27] Memories that your agents is taking [15:28] about your users, these all get saved [15:30] and saved in version inside of Context [15:32] Hub so that your team is able to control [15:35] different different levels of promotion, [15:37] right? Like we can start in staging, go [15:38] to production for different skills, [15:40] things of that nature. And you can [15:41] really democratize these skills across [15:42] different agents. [15:46] The next kind of core feature that is [15:47] part of Context Hub in this managed deep [15:50] agents primitive is our integration with [15:52] LangSmith engine. You're going to hear [15:54] more about LangSmith engine in the next [15:55] session, but essentially what it'll be [15:57] able to do is take real production usage [15:59] of these deep agents, make some quality [16:02] improvements, some changes to your [16:03] prompts, your system or your skills, [16:05] things of that nature, and that'll lead [16:07] to better behavior over time as this [16:08] loop in this engine continues to build. [16:12] The fourth kind of key component of [16:14] managed deep agents is sandboxes. [16:17] So, as Sydney mentioned before, [16:18] increasingly nearly every agent is [16:20] becoming a coding agent. Even a research [16:22] agent use case, they might want to be [16:24] able to crunch some quick stats and add [16:26] them to a report. You want to enable [16:27] your agents to do these things in [16:28] production because it can lead to a lot [16:30] more creative results. That's why we're [16:32] launching LangSmith sandboxes and we're [16:33] integrating them directly with managed [16:35] deep agents. [16:36] There's a few core features to this kind [16:38] of LangSmith sandbox primitive. The [16:40] first being an off proxy in order to at [16:42] runtime inject in those credentials that [16:44] your sandbox is using securely so that [16:47] none of your important environment [16:48] variables are exposed the actual agent [16:51] or the actual sandbox itself. [16:53] And the second is the ability to [16:54] snapshot and restore so that your agent [16:57] always has the correct execution [16:58] environment. [16:59] We'll have a session on this for a [17:01] deeper dive tomorrow with Mikhail, but [17:03] they are very very excellent for most [17:04] agent use cases. [17:07] So, this is kind of everything that you [17:08] need all together in order to take an [17:11] idea or a working deep agent and take it [17:13] into production. [17:15] That's why we're launching managed deep [17:16] agents and we're starting the private [17:18] beta as of today. So we encourage you [17:20] all to jump on the wait list and thanks [17:23] for the time. [17:25] >> [applause]