LangChain Pairs Agent Harness With LangSmith to Solve Production Gaps

Inside Managed Deep Agents: mda CLI, Context Hub, and Harbor Evals | Interrupt London — LangChain

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)

Reading summary

LangChain's Managed Deep Agents framework bridges the gap between local prototyping and reliable production by coupling an open agent execution harness with LangSmith's deployment infrastructure. According to Product Manager Victor Moreira, operationalizing deep agents requires unifying domain-specific business logic, a multi-capability harness, and managed infrastructure that governs context, authorization, and state. The Model Plus Harness Architecture (0:06) LangChain has transitioned from the standard ReAct (reason and action) loop toward a model plus harness paradigm. Moreira states that models are only as powerful as the context they receive, requiring a dedicated harness to deliver information at the correct moment. The Deep Agents harness rests on four structural pillars: an execution environment combining file system access with a code execution sandbox, context management that compacts histories and discloses skills progressively, task delegation to specialized subagents, and human-in-the-loop steering to pause execution for authorization. At pharmaceutical firm Madrigal, platform engineers codified researchers' specialized methodologies into discrete skills backed by structured evals. Moreira explains that successful deployments require coordinating three distinct layers: proprietary business logic, the harness runtime executing that expertise, and the underlying infrastructure managing concurrency, persistence, and multi-tenancy. Managed Infrastructure and CLI Standardization (4:33) Transitioning agents from local prototypes to production introduces distributed systems hurdles, including state persistence, token streaming, and task queue management under heavy concurrency. Managed Deep Agents relieves teams of this operational overhead by integrating the Deep Agents harness directly into LangSmith Deployment runtime. The managed environment delivers durable execution, Model Context Protocol (MCP) and agent-to-agent (A2A) orchestration, secure code sandboxes, and the LangSmith Context Hub for collaborative skill management. To standardize development across internal and customer teams, the framework uses the `mda` CLI. Developers scaffold projects with `mda init`, test locally via `mda dev` inside LangSmith Studio, and ship workloads using `mda deploy`. LangChain applies this pattern internally for its Go-To-Market (GTM) agent, organizing functionality into distinct files and directories for instructions, modular business playbooks, MCP tools, authorization settings, and memory configurations. Identity, Credentials, and Durable Execution (8:40) When an agent operates across platforms such as Slack, web portals, or APIs, Managed Deep Agents enforces identity boundaries via a centralized authorization handler. The service resolves whether the caller is an authenticated human or an autonomous agent identity, injecting that principal into the runtime context so tools and memory retrievals enforce user-scoped permissions without leaking credentials. Because the platform relies on the LangGraph runtime, it supports durable execution and state checkpointing. An agent can pause indefinitely when elevated permissions are required, message the user for authorization, and resume seamlessly days later. Memory is divided into user-level preferences and agent-level procedural knowledge. Deployment context dictates memory access: an agent in a private Slack direct message can tap personal user credentials, while the same agent in a shared channel restricts access to agent-scoped credentials to prevent data leakage. Context Collaboration, Harbor Evals, and Extensibility (11:34) To maintain reliability, teams use the LangSmith Context Hub to edit, version, and promote agent skills across workspaces. Integration with Harbor allows developers to initialize evaluation benchmarks via `mda evals init --interactive`, launching a coding agent that configures testing environments and performance checks. LangChain also introduced search capability through a partnership with Parallel, offering API-key-free web searches via LangSmith with zero data retention. Recent extensions to the platform reflect feedback from design partners such as Kyth and Consensus. These include HTTP channels for building custom communication interfaces beyond Slack or GitHub, autonomous agent-created recurring schedules, and per-run dynamic configurations that alter agent behavior at invocation time. Managed Deep Agents standardizes how organizations encapsulate proprietary human expertise into auditable, secure AI systems. As enterprise adoption scales across internal teams, long-term operational success depends on maintaining strict contextual boundaries between private user data and public collaboration environments.

Source quotes

[0:06] Victor Moreira: And we truly believe that models are only as powerful as the context that they're given. [10:39] Victor Moreira: 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. [3:05] Victor Moreira: 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.

Original transcript

[0:06] Alrighty. Hello, everyone. I'm Victor. [0:09] I'm a product manager here at LangChain. [0:12] And today we're going to be talking about deploying mission-critical agents [0:15] into production, and sort of everything that it takes to take a deep agent, for [0:20] example, and bring it into production with Managed Deep Agents. [0:24] So the first place that we like to start, and it's a question we often get, is: [0:27] what is an agent? Harrison talked about this a bit earlier today. [0:31] The first definition that we sort of had at LangChain was this idea of a [0:35] ReAct-style agent, or a reason and action style agent. [0:38] And this is sort of an agent that can essentially react, use a set of tools, [0:45] and reason and act over a particular task in order to accomplish that goal. [0:50] What has sort of happened as of late is that's evolved into this idea of [0:54] an agent harness. So we're now going into this model plus harness, and that's [0:58] sort of what defines an agent for us. [1:00] And this is everything that we put around our model itself, right? [1:04] So the skills, memory, system prompt, all of those things. [1:08] The question that we get a lot is: why do we go through the effort of this? [1:12] Why do we go through the task of building out an agent harness specific for [1:16] our use case? And it's really in order to get the model the correct set [1:20] of context at the correct time in order to do its particular task. [1:24] And we truly believe that models are only as powerful as the context that they're [1:28] given. And so when we start to build harnesses ourselves, we really wanted [1:34] to start focusing on building a customizable sort of base harness. [1:37] And that's what Deep Agents is. It's a great way to get started and build [1:41] out that domain-specific harness for your use case. [1:46] So what kind of goes into this Deep Agents harness? [1:49] So there's sort of four key areas. [1:51] The first being the execution environment, and this is really the backbone of [1:54] Deep Agents: the idea that you can have an agent use a file system. [1:58] So models are very, very good at using file systems now, writing code, things [2:02] of that nature, and we really want to take advantage of that when we're creating [2:04] our agents. So Deep Agents has first-class support for that, and we can also [2:09] pair it with a sandbox so that it can sort of execute that code in a safe [2:13] environment. The second core area is context management. [2:16] So context management is very important through progressive disclosure of [2:20] skills. We need to be able to manage memory and have the agent manage memory [2:24] itself. In some cases, we want to be able to summarize conversations, compact [2:28] them down, and offload context when needed. [2:31] So if a tool, for example, returns a really large output, we can sort [2:35] of store that in our file system and wait for the model to sort of reference [2:39] that context when it needs it. [2:41] The third key area is delegation. [2:43] So being able to decompose a task and delegate it to either specialized or [2:47] general-purpose subagents is very, very important. [2:50] And lastly is steering through human in the loop. [2:52] And that's something that is core to what we do here at LangChain. [2:55] And part of why this conference is named Interrupt is that function [2:59] to be able to encourage human in the loop and allow your agent to wait for [3:03] a human to approve an action. [3:05] So as we think about building out these domain-specific harnesses, one [3:09] of the companies that I'm excited to highlight, as I've worked with them [3:12] a decent amount, is Madrigal. [3:14] It's a pharmaceutical research company, and they were able to build a [3:18] domain-specific harness to help their PhDs, their researchers, really improve [3:23] and standardize how they're doing their research. [3:25] So they have a variety of different areas of work that they do research on [3:29] in the pharma industry, and they really wanted to codify this and make it really [3:33] valuable for the rest of the organization to come in and build agents for their [3:37] use case and build research agents for their particular domain. [3:40] And the way that they did this was they broke these down, and they broke [3:43] down their expertise into skills. [3:45] Their platform team and their engineers help them create evals and really start [3:49] to spin that flywheel that I'm sure you've heard a lot about today. [3:54] So when you think about building out an agent, something that Harrison sort [3:57] of touched on a bit earlier today is it really breaks down into three layers. [4:00] The first is the business logic, and this is what you bring, right? [4:03] This is your expertise. This is what you need to build agents for yourself. [4:07] The second is the harness. [4:08] So we need somewhere for that expertise to execute, right? [4:11] We need a system to execute it. [4:12] And that's sort of what this harness, or this Deep Agents base harness, provides. [4:17] And the third is going to be the infrastructure. [4:18] So this is all the stuff around bringing an agent, making it multi-tenant, [4:22] giving it a production runtime. [4:24] Each one of these layers, all three of these, sort of really need to work [4:28] together in a cohesive fashion in order to take an agent into production reliably. [4:33] So we talk about taking an agent into production. [4:35] The first step usually looks like this. [4:37] We're going to prototype it locally. [4:39] Getting it running locally is sort of a magical experience, right? [4:42] We can sort of prove that an agent can do a certain task for us. [4:44] And that's a very exciting moment. [4:46] It's a very valuable moment. [4:47] This is where we sort of prove, as developers, as agent engineers, that we [4:50] can build an agent to sort of do something that is domain-specific. [4:55] Then we start to go into production, and this is where things start to get a [4:58] little bit messy. We need to be able to handle multi-tenancy, we need to [5:02] be able to handle persistence, we need durable execution, we need to handle [5:06] streaming. All of these different things that go into taking an agent into [5:10] production start to become things that your team has to own if you're doing [5:13] this from scratch, right? And there's a lot of different layers to this [5:17] that can break down. So, for example, a task queue can be something that [5:21] can be tricky. You need to be able to prioritize which tasks are going to get [5:24] picked up by the agent, what priority that you're going to execute those. [5:28] That all becomes tricky as you scale to many, many, many users. [5:33] What we've done with Managed Deep Agents now, and why we're so excited about [5:36] it, is we've sort of taken that execution environment, the harness [5:39] itself, and we've tightly coupled it together with the infrastructure. [5:43] And this is a really important step in terms of making it really easy for you [5:47] and your developers to go and work on what actually makes the agent better, [5:51] which is the business logic. [5:55] When we talk about taking an agent into production with Managed Deep Agents, [5:58] this is sort of how it looks. [5:59] So all of those things, all those connections that you had to maintain as a [6:02] team before by managing the harness and the infrastructure, things like [6:06] durable execution, things like the task queue that I mentioned, these all come [6:10] out of the box with Managed Deep Agents, as it runs on LangSmith Deployment, [6:14] which is a proven production runtime that we have here. [6:17] You get MCP and A2A in terms of doing your sort of orchestration across [6:22] many agents. We have Context Hub as a great surface for you to interact [6:27] with business users on particular business logic and other things, such as [6:31] instructions and skills. You can sort of collaborate with them in that Context Hub. [6:35] We have LangSmith Sandboxes for safe code execution. [6:39] This is very important when you think about giving your agent access to [6:42] write and run code. You need to give it a safe environment to do so. [6:47] Then we have our layers of governance with LLM Gateway and our tracing [6:51] and evals, of course. [6:54] Now, since we're handling a lot of this infrastructure with the harness, we're [6:58] able to sort of scaffold this project into a very coherent project structure. [7:02] And this has actually paid dividends internally here at LangChain. [7:05] We have a lot of developers and agent engineers that work across different [7:07] agents internally. And having our agents defined in this project structure [7:11] has now been very valuable in terms of being able to jump into any agent project [7:15] and understand exactly how it works. [7:18] So the way that we scaffold it is through one simple command. [7:21] We can do mda init and give it a name like GTM agent, and that will go ahead [7:25] and scaffold this project structure for us. [7:27] Once we define our business logic, we can then run it locally with LangSmith Studio [7:31] using mda dev. And once we're ready to go into production, we can simply [7:36] run mda deploy and deploy it into production. [7:40] So, walking through what this actually looks like, I'd love to use the [7:44] example of a GTM agent that Harrison mentioned earlier today. [7:47] This is a very powerful agent. [7:48] Our sellers and our GTM team and people, including myself, absolutely [7:53] love using it. It really helps on the day-to-day, keeping track of everything [7:56] that can go on in the workplace. [7:58] But everything that goes into the deep agent now can be reflected for GTM [8:03] agent into this definition. [8:04] So the agent.ts or agent.py, you can do TypeScript or Python, will define your [8:09] actual agent loop. The instructions will define your agent logic, sort of that [8:14] core definition of how you want it to behave. [8:16] We can then give it sort of like playbooks. For GTM agent, for example, [8:20] we give it certain playbooks for different actions through skills, and then [8:24] we can also connect it to all the systems that we need to with tools, connecting [8:27] to MCP servers, things of that nature. And then the last two are pretty important [8:31] in terms of defining how we want to handle auth and handle identity, as well [8:36] as handle what it remembers and how it remembers. [8:40] So setting up this agent is an exciting part, and getting it all ready [8:45] to go. You start to think about this next layer, right? [8:49] And one of the hardest parts of building agents and putting them into production is [8:53] ensuring that it gets access to the right context and it has the right permissions [8:56] to get access to that context or these different tools. [8:59] So the first kind of key layer that we sort of start to see is we need to figure [9:03] out who can call the agent, right? [9:05] And the way that we do this in Managed Deep Agents is we have a centralized [9:08] sort of like auth handler service that, depending on the channel or where you're [9:12] calling this agent from, we will go ahead and make sure that we establish [9:16] who the principal is for that call, whether it's the agent itself or a particular [9:19] user, and we'll go ahead and pass that along into the runtime context. [9:24] So you're able to identify the user, and you're able to make sure that gets [9:27] passed into different tools or other connections. [9:31] As we start to go into... We have that user's context, and now as the run [9:36] is going through, we need to see, okay, what account should the user use, [9:39] or should the agent use, rather? In some cases, you might want to always ensure [9:43] that the agent is only using user-scoped credentials. As a developer, you can [9:47] define that very easily, as you see here. In other cases, you might want to have [9:52] a service account or an agent-scoped credential, and that's also very easy. [9:56] You can see there's just simply two types that you define as a developer [9:59] in order to define that when you're using tools or MCP servers, things [10:02] like that. [10:04] One thing that we're able to do as well, since Deep Agents [10:08] runs on the LangGraph runtime, we have that element of durable execution, [10:11] checkpointing, human in the loop, is we can also pause and wait indefinitely [10:14] for access to certain systems. [10:16] So, as a user, the first time that I use GTM agent in Slack, for example, if [10:20] I need to authenticate with it to use our CRM on my behalf, it'll ask me [10:25] to go ahead and authorize, will send me a message only I can see. [10:28] I can then come back three days later and say, "Oh yeah, I forgot I needed [10:31] to do that." Go ahead and hit authorize, and it'll continue the run exactly [10:34] from where it left off. So because we have that durable execution, it makes [10:38] it very easy to do things mid-task. [10:41] The next portion is memory. [10:42] So memory really helps us compound and learn over time. [10:45] And there's certain scenarios where you want an agent to be able to take [10:49] sort of like agent-level memory to improve its procedural memory, [10:52] or you want it to take user memory: personal preferences, how I like to write [10:55] emails, how I like to reach out to customers, things of that [10:59] nature. You're able to define that very easily in Managed Deep Agents [11:02] as well. [11:04] What's really nice, since we're managing this in code and we're able to define [11:07] this by the channel that it's calling it, as well as the particular [11:12] tool itself, I can control, based on where I call the agent, whether it's going [11:15] to use a set of personal memories, personal credentials, let's say in a Slack [11:20] DM, for example. And then if I want to use this agent also in a shared Slack [11:24] channel, we also don't want to leak any private information, of course. [11:27] So we can have our agent use agent-scoped credentials or service accounts in [11:31] those scenarios so that we know that it's safe. [11:34] As I mentioned before, we have a first-class integration with LangSmith's Context Hub, [11:38] and that allows us to collaborate with our business users on the different [11:43] context that your agent has access to. [11:45] This is really valuable in terms of having version control over this context [11:48] in a shared space that we can all sort of visualize it, interact with it, edit it. [11:52] And one of the nice things that we see is people often collaborate on skills. [11:56] They can promote skills to workspaces, things of that nature. [11:59] And once you start making these changes, one thing that we know is very [12:03] valuable in terms of working with a lot of customers, especially customers [12:06] that use LangSmith, is evals. [12:08] So evals are very, very easy in Managed Deep Agents. [12:12] We have a first-class integration with Harbor, which makes it really quite easy [12:17] to set up all of these sort of intricate details that Harbor allows for, in [12:22] a very managed process. So I can run mda evals init, and if I pass this interactive [12:26] flag, it'll actually run with a coding agent and help you set up the Harbor [12:30] environments, set up the checks, all these different things that go into building [12:34] really good evals. And then you can start to iterate and hill climb on those [12:37] particular set of eval [12:40] datasets and experiments. [12:43] Something we're really excited about is we launched a partnership with Parallel, [12:46] who you can find in the demo stations, and we are offering zero data retention, [12:52] and you can essentially use it directly through LangSmith without having to [12:54] go get your own Parallel search key. [12:57] We think that this is really important. [12:58] Having access to really good data through different search APIs is very valuable [13:02] for most agentic use cases. [13:04] You can really easily add it to your managed deep agent via MCP, as such, and [13:08] access it through LangChain itself or LangSmith. [13:12] We're really excited to highlight a few of our design partners that were with [13:16] us from the very beginning of working on this project. [13:18] So on the left side is Zahid, who worked with us from Kyth, and really [13:23] helped us define how we did user-scoped credentials, memories, things of that [13:27] nature. He was very opinionated as well, which is very helpful in a design [13:30] partner. The second would be Consensus, which Derek and his team had [13:35] a really cool use case of actually going around as a tiger team into different [13:39] parts of the org and building out these internal agents for different parts [13:42] of the organization. And that's something that we're seeing become more and [13:45] more popular as customers start to sort of expand the sort of breadth [13:50] of internal agents at their companies and providing that expertise [13:54] for other teams. [13:56] So what's new in Managed Deep Agents as of this past week is all of these wonderful [14:00] things. There's a few different ones that I'd like to highlight. [14:03] The very first one, HTTP channels allow you to define custom channels. [14:07] So we have a first-class integration with Slack, as well as GitHub and a [14:11] few others. But we also wanted to define a flexible spec for you as developers [14:15] to go ahead and implement your own channels and how you want to use your [14:20] agent. And then towards the bottom here, agent-created schedules are [14:24] really nice. You can sort of tell an agent, "Hey, every Monday at 9:00 a.m., [14:27] run this report for me, or go and find what customer meetings I have," [14:31] things of that nature, and it can go ahead and create its own schedules. [14:34] And then lastly, the per-run config allows for you to create dynamic agents. [14:38] So depending on the context of where I call the agent, I can insert some [14:42] runtime configuration and sort of dynamically create that agent on the fly. [14:46] And those are both very, very powerful. [14:50] Awesome. So we're excited to see you all try out Managed Deep Agents and [14:53] bring your domain expertise, and can't wait to see what you build. [14:57] Thank you.