LangChain
Deploying reliable AI agents requires separating proprietary domain skills from the underlying execution layer to prevent operational failures around credentials, memory leakage, and task persistence.
AI-assisted summary of Inside Managed Deep Agents: mda CLI, Context Hub, and Harbor Evals | Interrupt London — original source. Check the original for full context.
Source published:
Key ideas
- LangChain's Managed Deep Agents (MDA) has entered public beta, providing an integrated harness that couples the Deep Agents execution model with LangSmith's production infrastructure. (0:06)
- The platform introduces the `mda` CLI, a tool designed to standardize agent project structures, local development via LangSmith Studio, and deployment workflows. (6:54)
- Security and privacy are managed through context-aware authorization that distinguishes between personal user-scoped credentials and service-based agent credentials based on the channel. (10:43)
- Developers can now utilize Harbor-based evaluation suites, with a new capability to use a coding agent to automatically scaffold and set up evaluation checks. (11:34)
Detailed notes
## Background This session was published by the LangChain YouTube channel on October 26, 2026. As captured at the Interrupt London conference, Victor Moreira, Product Manager at LangChain, discusses moving agents from local prototypes to production using Managed Deep Agents, covering the integration of the Deep Agents harness with LangSmith infrastructure.
## TL;DR Victor Moreira introduces Managed Deep Agents as a solution to the operational challenges of deploying agents, offering a standardized scaffolding tool for consistent project architecture. The presentation details how the system handles critical production requirements like durable execution, user-versus-agent credential scoping, and collaborative context management. He also highlights how teams can leverage built-in features like Harbor evaluations, Parallel search, and new capabilities such as HTTP channels and dynamic, agent-created scheduling to streamline their agent lifecycles.
## Atmosphere & style The presentation is professional, authoritative, and deeply technical, reflecting the atmosphere of a developer-focused industry conference. Victor Moreira adopts the role of an expert guide, pacing his delivery to balance high-level architectural philosophy with granular, practical demonstrations of the CLI tools. The mood is one of forward-looking pragmatism, designed to leave the audience feeling confident that the complex 'chasm' between local prototyping and enterprise-ready deployment can be bridged through LangChain’s managed infrastructure.
## Bulletin - [00:06](https://www.youtube.com/watch?v=Wb3hQaG_xf0&t=6s) LangChain's Managed Deep Agents (MDA) has entered public beta, providing an integrated harness that couples the Deep Agents execution model with LangSmith's production infrastructure. - [06:54](https://www.youtube.com/watch?v=Wb3hQaG_xf0&t=414s) The platform introduces the `mda` CLI, a tool designed to standardize agent project structures, local development via LangSmith Studio, and deployment workflows. - [10:43](https://www.youtube.com/watch?v=Wb3hQaG_xf0&t=643s) Security and privacy are managed through context-aware authorization that distinguishes between personal user-scoped credentials and service-based agent credentials based on the channel. - [11:34](https://www.youtube.com/watch?v=Wb3hQaG_xf0&t=694s) Developers can now utilize Harbor-based evaluation suites, with a new capability to use a coding agent to automatically scaffold and set up evaluation checks.
## Key takeaways - [00:06](https://www.youtube.com/watch?v=Wb3hQaG_xf0&t=6s) The 'model plus harness' architecture is now the standard for production agents, shifting the focus from simple ReAct loops to managing system prompts, memory, and skills. - [00:06](https://www.youtube.com/watch?v=Wb3hQaG_xf0&t=6s) The four core pillars of the Deep Agents harness include execution environments, context management, delegation to subagents, and human-in-the-loop steering. - [03:05](https://www.youtube.com/watch?v=Wb3hQaG_xf0&t=185s) Organizations like Madrigal have successfully operationalized domain expertise by breaking down complex research methodologies into discrete, testable agent skills. - [04:33](https://www.youtube.com/watch?v=Wb3hQaG_xf0&t=273s) Successful production-grade agents require a three-layer alignment: internal business logic, the harness runtime, and the underlying infrastructure for scaling and multi-tenancy. - [05:26](https://www.youtube.com/watch?v=Wb3hQaG_xf0&t=326s) Managed Deep Agents reduces operational friction by automating durable execution, task queuing, and sandboxed code execution, which are typically difficult to maintain manually. - [06:54](https://www.youtube.com/watch?v=Wb3hQaG_xf0&t=414s) The `mda init` command enforces a standardized directory structure, ensuring consistency in instructions, skills, and tools across large engineering teams. - [08:40](https://www.youtube.com/watch?v=Wb3hQaG_xf0&t=520s) Managed Deep Agents use an internal authorization service to identify the caller and inject the appropriate principal into the execution loop for policy enforcement. - [10:01](https://www.youtube.com/watch?v=Wb3hQaG_xf0&t=601s) Durable execution and checkpointing allow long-running agent tasks to pause and wait for human authorization, resuming exactly where they left off even days later. - [10:43](https://www.youtube.com/watch?v=Wb3hQaG_xf0&t=643s) Access to personal memory and credentials is dynamically restricted in shared Slack channels, ensuring private user data does not leak into collaborative environments. - [11:34](https://www.youtube.com/watch?v=Wb3hQaG_xf0&t=694s) LangSmith's Context Hub acts as a collaborative, version-controlled repository for managing and sharing business context and agent skills across an organization. - [12:45](https://www.youtube.com/watch?v=Wb3hQaG_xf0&t=765s) A new partnership with Parallel enables agents to perform web searches without developers needing to manage or provide their own API keys. - [13:56](https://www.youtube.com/watch?v=Wb3hQaG_xf0&t=836s) The platform now supports HTTP channels for custom integrations, agent-created schedules for recurring tasks, and per-run configuration for dynamic behavior adjustments.
## Detailed walkthrough ### [00:06](https://www.youtube.com/watch?v=Wb3hQaG_xf0&t=6s) The Evolution from ReAct to Agent Harnesses
Victor Moreira, Product Manager at LangChain, introduces the reality of taking mission-critical deep agents into production using Managed Deep Agents. When discussing what an agent is, LangChain’s initial paradigm was centered on the ReAct (reason and action) pattern—a loop where an agent uses tools, reasons about a problem, and acts iteratively toward a goal. However, that concept has evolved into a "model plus harness" architecture. The harness encompasses everything surrounding the model: its skills, its system prompts, its memory mechanisms, and its execution tooling.
The core justification for engineering custom harnesses boils down to context delivery. As Victor Moreira emphasizes: “And we truly believe that models are only as powerful as the context that they're given.” The Deep Agents harness is designed as an open, customizable foundation that supplies the model with the exact information it needs at the exact right moment.
The Deep Agents harness is built across four fundamental pillars: - **Execution Environment:** Serves as the backbone, giving the agent native access to a file system to write code and manipulate files, paired with a sandbox for safe code execution. - **Context Management:** Enables progressive disclosure of skills, manages long-term memory, compacts or summarizes conversation histories, and offloads massive tool outputs directly to the file system until needed. - **Delegation:** Decomposes complex user queries and delegates tasks out to specialized or general-purpose subagents. - **Steering through Human-in-the-Loop:** Incorporates real-time interruption and review, allowing an agent to pause execution and wait for human authorization.
```mermaid flowchart TD accTitle: Deep Agents Core Harness Pillars accDescr: The four core pillars of the Deep Agents harness supporting the model.
subgraph Harness["Deep Agents Harness"] EE["Execution Environment<br/>(File system & sandboxed code)"] CM["Context Management<br/>(Progressive skills & compaction)"] DEL["Delegation<br/>(Specialized & general subagents)"] HITL["Steering via Human-in-the-Loop<br/>(Pause & human approval)"] end
Harness --> Model["LLM / Reasoning Model"] ```
---
[03:05](https://www.youtube.com/watch?v=Wb3hQaG_xf0&t=185s) Domain Expertise as Skills: The Madrigal Case Study
To illustrate how organizations tailor domain-specific harnesses, Victor points to Madrigal, a pharmaceutical research company. Madrigal needed a mechanism to codify and standardize the specialized methodologies of their research PhDs across distinct medical focus areas. Rather than leaving research techniques siloed, their platform engineers and scientists teamed up to translate their proprietary scientific approaches into discrete agent skills. By packaging researcher workflows into skills and pairing them with structured evals, they activated an internal engineering flywheel that empowered any team across the company to spin up tailored research agents.
Building agents successfully requires aligning three distinct architectural layers: 1. **Business Logic:** The proprietary domain expertise, prompts, and playbooks unique to the enterprise. 2. **The Harness:** The runtime execution system (like Deep Agents) where that domain expertise is enacted. 3. **The Infrastructure:** The underlying plumbing that manages multi-tenancy, durable execution, and production runtimes.
As Victor Moreira observes: “Each one of these layers, all three of these, sort of really need to work together in a cohesive fashion in order to take an agent into production reliably.”
---
[04:33](https://www.youtube.com/watch?v=Wb3hQaG_xf0&t=273s) The Prototype-to-Production Chasm and the Managed Deep Agents Solution
Local prototyping gives developers an immediate, almost magical proof of concept that an agent can execute a domain-specific workflow. Moving to production, however, introduces systemic distributed systems challenges: handling multi-tenancy, durable execution, state persistence, token streaming, and task queue prioritization under heavy concurrency. Building and maintaining this infrastructure alongside a bespoke harness creates immense operational overhead for engineering teams.
Managed Deep Agents eliminates that friction by tightly coupling the Deep Agents harness directly with LangSmith's production infrastructure. This offloads the operational burden so developers can concentrate entirely on refining business logic.
```mermaid flowchart LR accTitle: Managed Deep Agents Architecture accDescr: Mapping developer-owned business logic into the managed harness and LangSmith infrastructure.
subgraph Dev["Developer Layer"] BL["Business Logic & Playbooks"] end
subgraph Managed["Managed Deep Agents"] Harness["Deep Agents Harness<br/>(File System, Memory, Delegation)"] Runtime["LangSmith Deployment Runtime<br/>(Durable Execution & Task Queue)"] Tools["Ecosystem Tools<br/>(Sandboxes, Context Hub, Gateway)"] end
BL --> Harness Harness --> Runtime Runtime --> Tools ```
Managed Deep Agents ships with the following out-of-the-box infrastructure capabilities: - **LangSmith Deployment:** Provides durable execution, background task queuing, and multi-tenant scaling. - **Protocol Support:** Supports Model Context Protocol (MCP) and Agent-to-Agent (A2A) orchestration across fleet agents. - **LangSmith Context Hub:** A collaborative surface where engineers and business users can view, iterate on, and manage business logic, prompts, and skills. - **LangSmith Sandboxes:** Isolated, secure execution environments for agents writing and executing arbitrary code. - **Governance & Monitoring:** LLM Gateway routing, comprehensive tracing, and Harbor-based evaluation suites.
---
[06:54](https://www.youtube.com/watch?v=Wb3hQaG_xf0&t=414s) Scaffolding with the `mda` CLI and LangChain's Internal GTM Agent
To streamline development across large engineering teams, Managed Deep Agents enforces a standardized project structure using a dedicated command-line interface (`mda`). Victor shares that this consistency has paid major dividends inside LangChain, where developers frequently contribute to multiple internal agent repositories without needing to decipher custom scaffolding each time.
The development lifecycle operates through three CLI commands: - `mda init <agent-name>`: Scaffolds the standardized project directory (e.g., `mda init gtm-agent`). - `mda dev`: Launches the agent locally inside LangSmith Studio for live debugging and testing. - `mda deploy`: Packages and deploys the agent directly onto LangSmith Deployment infrastructure.
To demonstrate how these pieces assemble in practice, Victor highlights LangChain's internal Go-To-Market (GTM) agent. Used daily across LangChain's sales, product, and leadership teams, the GTM agent tracks complex internal workflows using a clear file-based layout: - `agent.ts` or `agent.py`: Houses the core agent execution loop. - `instructions/`: Defines the agent's baseline behavioral logic and system persona. - `skills/`: Contains modular playbooks and operational instructions for executing specific business tasks. - `tools/`: Manages external integrations and MCP server connections. - **Auth & Identity Configs:** Declares user vs. agent credential policies. - **Memory Configs:** Controls state persistence, compaction strategies, and memory scopes.
---
[08:40](https://www.youtube.com/watch?v=Wb3hQaG_xf0&t=520s) Establishing Identity, Context, and Caller Permissions
Once an agent is scaffolded and prepared for deployment, handling security, context boundaries, and identity permissions becomes paramount. An agent operating across diverse platforms (such as Slack channels, web interfaces, or direct API requests) must determine precisely who triggered it and what resources that caller can access.
Managed Deep Agents addresses this with a centralized authorization handler service. When an incoming call reaches the agent: 1. The auth handler inspects the incoming channel and origin to establish the principal (differentiating between an individual authenticated user and an autonomous agent identity). 2. The resolved identity is injected directly into the runtime context of the execution loop. 3. Downstream tools, memory retrieval routines, and external API connectors use this contextual principal to enforce proper user-scoped permissions and avoid credential leaks across runs.
### [09:39](https://www.youtube.com/watch?v=Wb3hQaG_xf0&t=579s) Configuring Credentials and Durable Execution Victor Moreira explains that developers have full control over credential management, specifically choosing between user-scoped credentials and service-based, agent-scoped credentials. This distinction allows the agent to interact with external systems—such as CRM tools via MCP servers—using the correct security context. Because Managed Deep Agents leverage the LangGraph runtime, they benefit from "durable execution" and checkpointing, which enables a "human-in-the-loop" pattern where an agent can pause a run indefinitely.
If a user initiates a task that requires authentication, the agent can pause, send a private message for authorization, and wait. Moreira highlights the resilience of this workflow: “I can then come back three days later and say, ‘Oh yeah, I forgot I needed to do that.’ Go ahead and hit authorize, and it'll continue the run exactly from where it left off.”
### [10:41](https://www.youtube.com/watch?v=Wb3hQaG_xf0&t=641s) Managing Memory and Data Privacy Memory is categorized into two types: agent-level memory, which refines procedural knowledge, and user-level memory, which captures personal preferences and communication styles. Moreira emphasizes that Managed Deep Agents allow developers to control memory access based on the deployment context.
For instance, an agent used in a Slack DM can safely access personal credentials and memories. However, if the same agent is used in a shared Slack channel, the system prevents the leakage of private information by enforcing agent-scoped credentials. This ensures that the agent remains functional in collaborative spaces without compromising sensitive user data.
### [11:34](https://www.youtube.com/watch?v=Wb3hQaG_xf0&t=694s) Context Hub, Harbor Evals, and Parallel Search The platform integrates with LangSmith’s Context Hub, providing a version-controlled, shared space for teams to edit, visualize, and collaborate on the context an agent accesses. This is particularly useful for teams that manage "skills" and promote them to different workspaces. To ensure these agents perform reliably, the system features a first-class integration with Harbor.
Moreira notes that initializing evaluations is straightforward: “I can run `mda evals init`, and if I pass this interactive flag, it'll actually run with a coding agent and help you set up the Harbor environments, set up the checks, all these different things that go into building really good evals.” This allows developers to iterate and "hill climb" on their performance metrics effectively. Additionally, a new partnership with Parallel enables users to perform search tasks without needing their own API keys, as the service is offered through LangSmith with zero data retention.
### [13:12](https://www.youtube.com/watch?v=Wb3hQaG_xf0&t=792s) Design Partners and Recent Feature Additions The development of Managed Deep Agents was heavily influenced by two design partners: Kyth and Consensus. Zahid from Kyth provided opinionated feedback on user-scoped credentials and memory, while the team at Consensus utilized a "tiger team" approach to deploy agents across different parts of their organization. Moreira identifies this expansion of internal agents as a growing trend among their customers.
The session concludes by detailing several new features added to the platform: * **HTTP Channels:** A flexible specification that allows developers to implement custom communication channels beyond built-in integrations like Slack or GitHub. * **Agent-Created Schedules:** Agents can now be tasked with creating their own recurring schedules, such as generating reports or checking meeting calendars every Monday. * **Per-run Config:** Enables the creation of dynamic agents that adjust their behavior based on the specific context or runtime configuration provided at the moment of invocation.
```mermaid flowchart TD A["User Call"] --> B{"Deployment Context"} B -->|Slack DM| C["Personal Memory & Credentials"] B -->|Shared Channel| D["Agent-Scoped Credentials"] C --> E["Durable Execution"] D --> E E --> F["Task Completion"]
accTitle: Managed Deep Agent Flow accDescr: A diagram illustrating how the agent manages different credentials and memory access based on whether the input comes from a private Slack DM or a shared channel, leading to a unified execution flow. ```
## Notable quotes > [00:06](https://www.youtube.com/watch?v=Wb3hQaG_xf0&t=6s) And we truly believe that models are only as powerful as the context that they're given. — Victor Moreira
> [10:39](https://www.youtube.com/watch?v=Wb3hQaG_xf0&t=639s) I can then come back three days later and say, ‘Oh yeah, I forgot I needed to do that.’ Go ahead and hit authorize, and it'll continue the run exactly from where it left off. — Victor Moreira
> [03:05](https://www.youtube.com/watch?v=Wb3hQaG_xf0&t=185s) Each one of these layers, all three of these, sort of really need to work together in a cohesive fashion in order to take an agent into production reliably. — Victor Moreira
## Mentioned Victor Moreira, LangChain, Managed Deep Agents, Deep Agents, LangSmith, LangSmith Studio, LangSmith Deployment, LangSmith Context Hub, mda CLI, Madrigal, Kyth, Consensus, Parallel, Harbor, Slack, GitHub, Model Context Protocol (MCP), LangGraph
## Video description Victor Moreira, Product Manager at LangChain, explains what it takes to move a deep agent from a local prototype into production, and how Managed Deep Agents, now in public beta, couples the Deep Agents harness with LangSmith infrastructure so your team can focus on the business logic. Using LangChain's internal GTM agent as the example, he shows how an agent is scaffolded into one project structure with the mda CLI, run locally in LangSmith Studio, and deployed on LangSmith Deployment, then covers who can call the agent, when it should use user or agent-scoped credentials, how a run can wait for a user to authorize access and pick up where it left off, which memories and credentials it can use in a Slack DM versus a shared channel, versioned context in LangSmith Context Hub, and Harbor evals that a coding agent helps you set up. He also shares how Madrigal built a domain-specific harness by breaking its researchers' expertise into skills, built-in web search through a partnership with Parallel, the design partners Kyth and Consensus, and recent additions including HTTP channels, agent-created schedules, and per-run config for dynamic agents.
This session was captured at Interrupt London, the agent conference by LangChain.
Chapters: 0:00 Why agents need a harness, and what Deep Agents puts in one 3:05 How Madrigal turned research expertise into skills 3:54 What it takes to get a local prototype into production 5:33 What Managed Deep Agents runs for you out of the box 6:54 Scaffolding a GTM agent with the mda CLI 8:40 Who can call your agent, and whose credentials does it use? 10:04 Pausing a run until the user authorizes access 10:41 Keeping personal memory out of shared Slack channels 11:34 Sharing context in Context Hub and hill climbing with Harbor 12:43 Using Parallel search without your own API key 13:12 How design partners helped shape Managed Deep Agents 13:56 What's new with HTTP channels, schedules, and dynamic agents
Resources: → Managed Deep Agents docs: https://docs.langchain.com/langsmith/python/managed-deep-agents-overview → Deep Agents: https://www.langchain.com/deep-agents → LangSmith Deployment: https://www.langchain.com/langsmith/deployment → LangSmith Context Hub: https://docs.langchain.com/langsmith/use-the-context-hub → Interrupt, the agent conference by LangChain: https://interrupt.langchain.com
[Source](https://www.youtube.com/watch?v=Wb3hQaG_xf0)