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)