LangChain Launches Managed Deep Agents to Automate Production DevOps

Managed Deep Agents | Deploying mission critical agents to production — LangChain

LangChain

Packaging the Deep Agents harness directly with managed infrastructure eliminates the distributed systems, cross-surface identity, and memory hurdles that stall enterprise AI deployments.

AI-assisted summary of Managed Deep Agents | Deploying mission critical agents to production — original source. Check the original for full context.

Source published:

Key ideas

  • LangChain launched Managed Deep Agents in public beta, packaging the Deep Agents harness with managed LangSmith infrastructure to deploy agents defined as directories of instructions, skills, and tools via the mda CLI. (5:32)
  • The framework solves mid-task authentication bottlenecks using LangGraph interrupts, allowing agents to pause execution, prompt users for missing on-behalf-of OAuth tokens, and resume seamlessly from checkpointed state. (9:14)
  • Biotech firm Madrigal reduced the development cycle for specialized pharmaceutical research agents from several weeks to mere hours using Deep Agents on LangSmith. (3:15)
  • The 0.8 release introduces HTTP channels for arbitrary webhooks, direct sandbox file download APIs, Slack file transfers, channel-aware memory permissions, and zero-config Parallel web search. (14:18)

Detailed notes

## Background Published on YouTube by LangChain on October 9, 2026, this conference session features Product Manager Victor Moreira introducing Managed Deep Agents in public beta at Interrupt New York City. According to the page description, the talk explains how bundling the Deep Agents harness with managed LangSmith infrastructure enables developers to build, test, and deploy production-ready agents as simple folders using the mda CLI, addressing enterprise challenges like caller identity, mid-task authentication pauses, channel-scoped memory, and Harbor evaluations.

## TL;DR Victor Moreira breaks down the core architecture of Deep Agents, illustrating how a specialized harness manages context, virtual file systems, subagent delegation, and human-in-the-loop interrupts on top of the LangGraph runtime. He contrasts effortless local prototyping with the distributed systems bottlenecks of production—such as streaming connections, queuing, and cross-platform identity reconciliation. Managed Deep Agents solves these problems by bundling the harness with managed LangSmith infrastructure, allowing developers to scaffold, test, and deploy agents through three straightforward CLI commands. Real-world case studies from LangChain's internal GTM agent, Madrigal, and Consensus demonstrate how the platform safely handles on-behalf-of credentials, channel-aware memory boundaries, versioned Context Hub repos, and Harbor evaluations.

## Atmosphere & style The presentation carries the polished, pragmatic tone of an engineering-focused keynote delivered to an audience of active practitioners. Moreira speaks with measured clarity and product-minded realism, candidly acknowledging that production infrastructure is often seen as 'boring' yet represents the hardest part of delivering reliable agents. The talk maintains an empowering, solutions-oriented cadence that makes complex distributed systems concepts—like mid-task checkpointed authentication and channel-based memory gating—feel approachable, structured, and immediately actionable.

## Bulletin - [05:32](https://www.youtube.com/watch?v=XcsspzECTKA&t=332s) LangChain launched Managed Deep Agents in public beta, packaging the Deep Agents harness with managed LangSmith infrastructure to deploy agents defined as directories of instructions, skills, and tools via the mda CLI. - [09:14](https://www.youtube.com/watch?v=XcsspzECTKA&t=554s) The framework solves mid-task authentication bottlenecks using LangGraph interrupts, allowing agents to pause execution, prompt users for missing on-behalf-of OAuth tokens, and resume seamlessly from checkpointed state. - [03:15](https://www.youtube.com/watch?v=XcsspzECTKA&t=195s) Biotech firm Madrigal reduced the development cycle for specialized pharmaceutical research agents from several weeks to mere hours using Deep Agents on LangSmith. - [14:18](https://www.youtube.com/watch?v=XcsspzECTKA&t=858s) The 0.8 release introduces HTTP channels for arbitrary webhooks, direct sandbox file download APIs, Slack file transfers, channel-aware memory permissions, and zero-config Parallel web search.

## Key takeaways - [00:05](https://www.youtube.com/watch?v=XcsspzECTKA&t=5s) An agent harness encompasses everything built around a foundation model—including domain skills, external tools, context ingestion, and subagents—to ensure the model receives the right context at the right time. - [01:26](https://www.youtube.com/watch?v=XcsspzECTKA&t=86s) Deep Agents structures agent architecture across four core pillars: a virtual file system execution environment, sophisticated context management, subagent delegation, and human-in-the-loop interrupts. - [03:15](https://www.youtube.com/watch?v=XcsspzECTKA&t=195s) Madrigal demonstrated the power of deep agent harnesses by collapsing the setup time of literature-synthesizing research agents from weeks to hours. - [03:59](https://www.youtube.com/watch?v=XcsspzECTKA&t=239s) Transitioning from local prototypes to production introduces complex distributed systems challenges, including multi-surface routing, request queuing, streaming, and persistent checkpointing. - [05:32](https://www.youtube.com/watch?v=XcsspzECTKA&t=332s) Managed Deep Agents bundles Deep Agents with LangSmith Deployment, Sandboxes, Context Hub, and tracing, abstracting infrastructure maintenance away from developer teams. - [06:37](https://www.youtube.com/watch?v=XcsspzECTKA&t=397s) The development workflow is standardized around an agent folder structure in Python or TypeScript, managed via three core CLI commands: mda init, mda dev, and mda deploy. - [08:34](https://www.youtube.com/watch?v=XcsspzECTKA&t=514s) Production deployments require distinct handling for caller identity and data ownership, separating agent-scoped service credentials from user-scoped on-behalf-of permissions. - [09:14](https://www.youtube.com/watch?v=XcsspzECTKA&t=554s) When an agent encounters a missing user token mid-task, LangGraph state checkpointing pauses execution and presents an authentication prompt, resuming without data loss once verified. - [10:42](https://www.youtube.com/watch?v=XcsspzECTKA&t=642s) Channel-aware access controls prevent data leaks by suppressing private user memories and credentials when an agent is invoked in public team channels rather than private direct messages. - [11:40](https://www.youtube.com/watch?v=XcsspzECTKA&t=700s) Integration with Context Hub provides Git-like version control, diff reviews, and safe production promotion workflows for agent prompts, instructions, and skills. - [12:05](https://www.youtube.com/watch?v=XcsspzECTKA&t=725s) Running mda eval init provisions a local Harbor evaluation suite piped into LangSmith experiments, allowing developers to catch behavioral regressions before deploying changes. - [13:15](https://www.youtube.com/watch?v=XcsspzECTKA&t=795s) Consensus operates a centralized internal developer team that acts as agent consultants, deploying domain-tailored deep agents across multiple corporate departments on shared infrastructure. - [14:18](https://www.youtube.com/watch?v=XcsspzECTKA&t=858s) The 0.8 release expands connectivity beyond Slack with HTTP channels, sandbox file extraction APIs, and integrated zero-config Parallel search.

## Detailed walkthrough ### [00:05](https://www.youtube.com/watch?v=XcsspzECTKA&t=5s) What is an Agent Harness, and Why Does Context Matter?

Victor Moreira, a Product Manager at LangChain specializing in runtime products, introduces the core philosophy behind building and deploying mission-critical agents into production. He begins with a grounding refresher on what an agent actually is. At its fundamental level, an agent is simply a model utilizing tools to complete a given task. This architecture stems directly from the ReAct-style pattern (reasoning and action) that gained massive traction over a year earlier, where models iteratively reason over data and execute tool calls to achieve user goals.

Building on that premise, Moreira tackles a question his team frequently hears: what is an agent harness? In LangChain's framework, the harness encompasses "basically everything else that we bake in to create the agent"—from explicit domain skills and external tools to dynamic context ingestion and delegated subagents. The entire point of investing engineering effort into constructing a harness is context control. As Moreira explains, the underlying model is fundamentally constrained by what it sees:

> “So a lot of times when we're building an agent, we know that the model is only as powerful as the context that we give it.”

Therefore, the ultimate objective of an agent harness is ensuring the model receives precisely the right context at the right time.

[01:26](https://www.youtube.com/watch?v=XcsspzECTKA&t=86s) The Four Core Areas of a Deep Agent

Deep Agents represents a customizable base harness designed for arbitrary domain-specific tasks. LangChain developed it by distilling practical learnings from coding agents and real-world harness implementations into an adaptable architecture composed of four core technical areas:

1. **Virtual File System (Execution Environment):** Deep Agents introduces an abstraction layer between the model and the files it touches. Developers define a virtual boundary, meaning the backing storage can live anywhere—such as Amazon S3, a secure sandbox environment where agents can write and execute code, or lighter-weight computational cousins like a code interpreter or a REPL. 2. **Context Management:** Operating on top of this file system enables sophisticated context operations: - *Progressive disclosure of skills:* Revealing tool definitions or domain instructions only as needed. - *Cross-thread memory:* Persisting agent and user knowledge across distinct conversational threads. - *Summarization:* Compactly summarizing and storing conversation histories into the file system as conversational context windows expand. - *Context offloading:* Dumping massive tool payloads or large retrieval outputs directly into the file system rather than polluting the LLM's primary prompt window. 3. **Delegation:** The model can systematically create high-level plans, reason over execution steps, and spawn specialized subagents to carry out discrete tasks. 4. **Human-in-the-Loop:** Built directly on top of the LangGraph runtime, Deep Agents natively integrates LangGraph's signature `interrupt` primitive—after which LangChain's Interrupt conference itself is named—allowing agents to pause mid-execution for authorization, feedback, or review.

```mermaid flowchart TD accTitle: Anatomy of a Deep Agent accDescr: The four core architectural pillars of the Deep Agents harness built on LangGraph.

subgraph DeepAgent["Deep Agent Harness (LangGraph Runtime)"] VFS["Virtual File System\n(S3 / Code Sandbox / REPL)"] CM["Context Management\n(Progressive Skills, Offloading, Memory)"] DEL["Delegation & Planning\n(Reasoning & Subagents)"] HIL["Human-in-the-Loop\n(LangGraph interrupt)"] end

VFS <--> CM CM --> DEL DEL --> HIL ```

[03:15](https://www.youtube.com/watch?v=XcsspzECTKA&t=195s) Real-World Case Study: Madrigal's Research Agent

To illustrate how Deep Agents functions in a high-stakes setting, Moreira highlights LangChain customer Madrigal, a biotechnology firm. Madrigal needed a specialized pharmaceutical research agent capable of supporting domain researchers.

The workflow requires loading domain-specific knowledge bases tailored to an individual scientist's focus area, reasoning over dense scientific literature, synthesizing complex experimental findings, and compiling structured, cohesive research reports complete with formal citations. Prior to adopting the framework, building an agent for an individual researcher's domain was a heavy engineering lift taking several weeks. Using the customizable Deep Agents harness deployed directly onto LangSmith, Madrigal collapsed that development lifecycle from weeks down to a matter of hours.

[03:59](https://www.youtube.com/watch?v=XcsspzECTKA&t=239s) From Local Prototype to Production Reality

Transitioning an agent from an experimental local script to enterprise-grade production introduces significant architectural friction. Moreira breaks down agent development into three distinct tiers:

- **Business Logic:** The core expertise, custom instructions, and domain-specific skills that developers and teams bring to the table. Moreira emphasizes this as the highest-value work. - **The Harness:** Deep Agents provides the underlying framework for virtual file interactions, tool routing, subagent delegation, and context management. - **Infrastructure:** Often viewed as the "boring" layer, robust infrastructure is the hardest and most critical requirement for letting external users interact with an agent reliably.

When developers build locally, they easily validate the agent's core capability:

> “This is where we can kind of prove the magic of the agent, right? That the agent can actually do what we're designing it for.”

However, moving to production forces teams to resolve a barrage of distributed systems problems: supporting multiple front-end user surfaces, reconciling where incoming traffic connects into the runtime, implementing queuing mechanisms to manage bursty run volumes, maintaining stable streaming connections, and setting up persistent checkpointing.

```mermaid flowchart LR accTitle: Local Prototyping vs Production Infrastructure accDescr: Contrast between running an agent locally and handling the distributed systems requirements of production.

subgraph Local["Local Prototyping"] Proto["Single Machine Prototyping\n(Validate Logic & Magic)"] end

subgraph Prod["Production Infrastructure Requirements"] Surfaces["Multi-surface Channels\n(Slack, Web, APIs)"] Queue["Run Queuing & Checkpointing"] Stream["Real-time Streaming Engine"] Auth["Auth & Identity Handlers"] end

Proto -->|"Deploy to Prod"| Surfaces Surfaces --> Queue Queue --> Stream Stream --> Auth ```

[05:32](https://www.youtube.com/watch?v=XcsspzECTKA&t=332s) Managed Deep Agents: Bundling the Harness and Infrastructure

Managed Deep Agents eliminates infrastructure overhead by packaging the customizable Deep Agents harness directly with managed LangSmith infrastructure. This architecture liberates engineering teams from maintaining backend plumbing so they can focus on prompt engineering, tracing, evaluations, and refining business logic.

The managed architecture unifies several platform components: - **LangSmith Deployment:** Powers production streaming, state checkpointing, and authentication handlers. - **LangSmith Sandboxes:** Provides isolated compute environments for executing agent-generated code safely. - **LangSmith Context Hub:** Acts as a centralized repository where developers and business stakeholders collaborate on, version, and iterate upon agent instructions and skills. - **LLM Gateway & Tracing:** Out-of-the-box observability, routing, and experiment tracking. - **Unified Agent Interface:** Normalizes diverse caller interfaces on the front end into a single execution runtime.

[06:37](https://www.youtube.com/watch?v=XcsspzECTKA&t=397s) Project Structure and the `mda` CLI Workflow

Managed Deep Agents formalizes an agent as a clean directory structure rather than monolithic application code, supporting both TypeScript (`agent.ts`) and Python (`agent.py`). Key primitives—such as system prompts, modular skills, external tool definitions, and user authentication—map cleanly to designated folders and configuration files.

The development lifecycle is driven entirely through three simple commands using the `mda` CLI:

- `mda init <agent-name>`: Scaffolds a new project directory containing the standard file layout for skills, tools, instructions, and agent definitions. - `mda dev`: Boots a local Agent Server identical to the server backing LangSmith Deployment in production, enabling developers to test edge cases locally with complete environment parity. - `mda deploy`: Deploys the agent directory directly onto LangSmith's managed cloud infrastructure with zero custom DevOps setup.

[07:43](https://www.youtube.com/watch?v=XcsspzECTKA&t=463s) Internal Example: LangChain's Go-to-Market Agent

To demonstrate how file mapping translates to business value, Moreira shares LangChain’s internal Go-to-Market (GTM) agent, a tool accessible to anyone across the company for sales and revenue workflows. A typical request sent to the agent looks like: *"Prep me for a certain meeting and draft an email for me to review."*

This workflow maps across the standard project structure: - **Instructions & Skills folders:** Store the GTM playbooks detailing how the agent should structure meeting briefings or format email drafts. - **Tools folder:** Contains integrations connecting into internal SaaS platforms such as Salesforce and Gong. - **Identity & Memory configurations:** Manage user authentication credentials and govern cross-conversation memory persistence.

[08:34](https://www.youtube.com/watch?v=XcsspzECTKA&t=514s) Production Challenges: Identity, Data Ownership, and Permissions

Deploying enterprise agents into shared organizational environments surfaces four distinct security and operational challenges: 1. *Caller Identity:* Identifying precisely who is making the request across different entry points. 2. *Data Ownership:* Determining whose credentials, scopes, and data access permissions the agent must inherit. 3. *Memory Permissions:* Deciding which cross-thread memories the agent can safely read or update without leaking sensitive context. 4. *Access Gaps:* Managing workflows gracefully when an agent encounters missing authentication or permission walls during an active run.

Managed Deep Agents addresses caller reconciliation out of the box by providing first-class abstractions for communication channels. Whether an employee invokes the GTM agent via a dedicated Slack application or accesses it from an internal web surface, the runtime maps the caller back to a consistent enterprise identity to enforce authorization and credential boundaries.

[09:14](https://www.youtube.com/watch?v=XcsspzECTKA&t=554s) User Reconciliation and the Connections Primitive

When moving an agent out of a sandbox and into real-world production environments, developer teams immediately run into identity hurdles. A user might interact with the agent through Slack one minute, and through an internal web application or proprietary platform the next. Forcing that user to constantly re-authenticate and re-permission tools across every individual surface area destroys the user experience. To solve this, Managed Deep Agents introduces a dedicated authentication handler that reconciles user identities across various touchpoints and passes that unified identity directly into the runtime.

```mermaid flowchart TD accTitle: Mid-Task On-Behalf-Of Authentication Flow accDescr: An illustration of how Managed Deep Agents handles missing user credentials during task execution using LangGraph interrupts. subgraph RequestPhase ["Task Execution"] A["User Task Request"] --> B{"Requires On-Behalf-Of Tool?"} B -->|"No"| C["Execute with Service Account"] B -->|"Yes"| D{"User Token Exists?"} end

subgraph AuthPhase ["Human-in-the-Loop Interruption"] D -->|"No"| E["Pause & Checkpoint State in LangGraph"] E --> F["Send Auth Link to User"] F --> G["User Authenticates"] end

subgraph ResumePhase ["Execution Resumption"] G --> H["Resume Checkpointed Task"] D -->|"Yes"| H H --> I["Access Tool e.g., Salesforce CRM"] end ```

Once identity is resolved, the next critical architectural question is deciding whose credentials the agent should execute against. Developers can configure specific tools to operate strictly on behalf of the caller or use dedicated service accounts. For instance, if an employee sends a direct message asking, "Prep me for this meeting," the agent needs to invoke tools like Salesforce using that specific caller’s Salesforce permissions rather than an all-powerful admin account. In other scenarios, an agent-scoped credential or shared service token is more appropriate. Managed Deep Agents standardizes this through its connections primitive, allowing developers to define credentials and token-handling behavior cleanly.

Crucially, Managed Deep Agents addresses what happens when an on-behalf-of token is missing mid-task without crashing the workflow. Leveraging the built-in human-in-the-loop capabilities of Deep Agents and the LangGraph runtime, the agent can gracefully suspend execution. As Victor Moreira explains: “So since we have built-in human in the loop in Deep Agents and in the LangGraph runtime, what happens is when you make a request and the agent doesn't have a particular token for a particular user and it's an on-behalf-of token, it's actually able to really easily pause, ask the user to go ahead and authenticate.” Because interrupts are checkpointed in state, the workflow can safely pause indefinitely until the user clicks the verification link and completes authentication, after which execution seamlessly resumes.

- **Unified Auth Handler**: Reconciles user identities across Slack, custom web applications, and internal platforms without repeated permission prompts. - **Caller-Scoped vs. Agent-Scoped Credentials**: Configure tools (such as CRM lookups) to run on behalf of the individual user or via system-level service accounts. - **Checkpointed Mid-Task Interrupts**: If a required token is missing, LangGraph checkpoints state, triggers an authentication prompt, and resumes without losing progress.

[10:42](https://www.youtube.com/watch?v=XcsspzECTKA&t=642s) Channel-Aware Memory and Context Hub Versioning

Memory in production agents requires nuanced boundaries rather than a single monolithic vector store. Managed Deep Agents separates memory into two distinct conventions: agent-level procedural memory (which captures operational workflows and organizational rules over time) and user-level memory (which tracks individual preferences and personal facts). Storing these memories is only half the battle; the real engineering challenge lies in enforcing strict access control depending on where the conversation takes place.

To prevent sensitive leaks, Managed Deep Agents allows developers to define access control primitives tied directly to the source channel. In a private one-on-one Slack direct message, the agent is permitted to draw upon and record personal user memories and private credentials. However, if that same user summons the agent inside a shared public channel alongside teammates, the system suppresses those private memories so the agent does not inadvertently expose confidential information.

Beyond runtime memory, managing the agent's instructions and skills demands proper engineering rigor. Managed Deep Agents integrates natively with Context Hub, giving teams Git-like version control over prompts, operational guidelines, skills, and memory repositories. As Victor Moreira notes: “Another really nice part of Managed Deep Agents is we get version control for our agent context with Context Hub.” This integration enables multi-disciplinary teams to collaborate directly inside the LangSmith interface, iterate on system prompts, review diffs, and safely promote tested instructions to production.

- **Dual Memory Conventions**: Separates procedural agent-level knowledge from individual user preferences. - **Channel-Based Access Control**: Prevents personal user data from being exposed when an agent is invoked in shared team channels versus private DMs. - **Context Hub Integration**: Treats instructions, tools, and skills as versioned context repos inside LangSmith, streamlining team collaboration and production promotions.

[12:05](https://www.youtube.com/watch?v=XcsspzECTKA&t=725s) Harbor Evals and Built-In Search with Parallel

Pushing behavioral changes to production agents can be daunting because subtle prompt or skill tweaks can introduce silent regressions across complex workflows. As Victor Moreira puts it: “Promoting it to production, though, can be scary.” To provide confidence, Managed Deep Agents bakes in deep integration with Harbor, an evaluation framework tailored for complex agent workflows. Recognizing that customers often struggle with the initial setup curve of comprehensive evals, LangChain streamlined the entire onboarding flow into a single command-line call: running `mda eval init`.

This CLI initialization automatically provisions a local Harbor evaluation environment complete with baseline evaluation tasks and validation checks. Every evaluation run is piped into LangSmith, populating the experiments tab with comprehensive execution traces. This telemetry allows engineers to rerun identical benchmark suites, isolate regressions, and hill-climb agent performance locally on their own machines before deploying updates to production users.

Alongside evaluation tooling, the release introduces a native integration with web search provider Parallel. Built directly into the Managed Deep Agents runtime, the Parallel search tool requires zero setup friction—developers can equip their agents with web search without needing to register for an external account, provision API keys, or configure custom environment variables. The integration is provided completely free of charge throughout the public beta period.

- **Frictionless Evals**: The `mda eval init` command automates the scaffolding of tasks and assertion checks using the Harbor eval framework. - **LangSmith Experiments**: Evaluation runs log directly to LangSmith trace trees, enabling side-by-side comparisons across iterations. - **Zero-Config Web Search**: Built-in Parallel search integration functions out of the box without requiring external API keys during the public beta.

[13:15](https://www.youtube.com/watch?v=XcsspzECTKA&t=795s) Customer Stories: Consensus and Kyth

The architecture behind Managed Deep Agents was shaped through extensive internal usage alongside early design partners. Internally, LangChain relies on the harness to run its own mission-critical workloads, such as its internal go-to-market agent and Open SWE—an internal software factory agent that automates software engineering workflows. These internal environments served as a proving ground for stress-testing credential handling, state checkpoints, and contextual memory under daily operational load.

External customer collaborations provided vital insights into real-world organizational dynamics. Zahid from Kyth worked closely with the LangChain team to refine how non-technical business stakeholders and no-code contributors collaborate on agent definitions, while directly informing how the connections and memory primitives were architected.

At Consensus, a centralized developer team led by Derek demonstrated the intended scaling model for Managed Deep Agents across an enterprise. Rather than building one-off, fragile infrastructure for every department, Derek’s team acts as internal agent consultants, fanning out across different business units to rapidly stand up deep agents tailored to specific departmental needs. Victor Moreira observes: “And because Managed Deep Agents handles all of the infrastructure, they're able to really easily kind of go and deploy these agents.” By offloading orchestration, state persistence, and authentication scaffolding to the managed runtime, Consensus dramatically expanded the volume of production agents operating across its organization.

- **Internal LangChain Workloads**: In-house deployments include the Go-To-Market sales agent and Open SWE, an automated software engineering agent. - **Kyth (Zahid)**: Informed the design of connection management, memory ergonomics, and collaboration workflows for non-technical business users. - **Consensus (Derek)**: Scaled deployment by deploying an internal development team that builds domain-specific agents for distinct corporate departments on top of shared managed infrastructure.

[14:18](https://www.youtube.com/watch?v=XcsspzECTKA&t=858s) What's New in the Managed Deep Agents 0.8 Release

The presentation closes with a summary of the capabilities landing in the 0.8 public beta release of Managed Deep Agents. While native Slack connectivity has been a core showcase, the new release introduces HTTP channels, a flexible primitive enabling developers to wire deep agents into arbitrary bespoke surfaces. Developers can configure custom event listeners, define how the agent responds to external webhooks, and deliver agent outputs to custom web frontends, internal portals, or third-party enterprise tools.

```mermaid flowchart LR accTitle: Managed Deep Agents 0.8 Release Features accDescr: Overview of core capabilities introduced in the 0.8 public beta of Managed Deep Agents. subgraph MDA08 ["Managed Deep Agents 0.8"] direction TB C1["HTTP Channels"] C2["Sandbox File APIs"] C3["User-Scoped Memory"] C4["Connections Primitive"] C5["Slack File Transfers"] C6["Built-In Parallel Search"] end ```

The release also upgrades filesystem capabilities within the agent execution sandboxes. In addition to the agent inspecting and manipulating its workspace files, developers now have structured APIs allowing their client applications and front ends to directly access and download artifacts generated inside the sandbox. In workplace environments like Slack, this enables first-class file collaboration: an agent can generate formatted deliverables, such as PowerPoint decks or PDF summaries, and upload them directly into the Slack conversation for immediate human review and iteration.

Rounding out the release are user-scoped memory, the standardized connections primitive for user- and agent-level authentication, and zero-configuration Parallel search. Moreira concludes by inviting attendees to build production-grade, domain-specific agents on the new release: “We're really excited to announce Managed Deep Agents in our 0.8 release, and we can't wait to see what you build with it and build your domain-specific agents.”

- **HTTP Channels**: Custom event and webhook routing to deploy deep agents to any client surface beyond Slack. - **Sandbox Filesystem APIs**: Front-end applications can programmatically read and extract artifacts generated inside execution sandboxes. - **Slack File Transfers**: First-class generation and sharing of rich documents (PDFs, presentations) directly within Slack conversation threads. - **Connections & Memory Primitives**: Full availability of user-scoped memories alongside fine-grained user and service-level tool authentication. - **Built-in Parallel Search**: Pre-wired internet search enabled across all managed agents without credential configuration.

## Notable quotes > [00:05](https://www.youtube.com/watch?v=XcsspzECTKA&t=5s) So a lot of times when we're building an agent, we know that the model is only as powerful as the context that we give it. — Victor Moreira

## Mentioned Victor Moreira, LangChain, Managed Deep Agents, Deep Agents, LangSmith, LangGraph, LangSmith Sandboxes, LangSmith Context Hub, LangSmith Deployment, Harbor, Parallel, Madrigal, Consensus, Kyth, Zahid, Derek, Open SWE, Salesforce, Gong, Slack, Amazon S3, mda CLI, Interrupt NYC

## Video description Victor Moreira, Product Manager at LangChain, introduces Managed Deep Agents, now in public beta, which bundles the Deep Agents harness with managed LangSmith infrastructure so you can define an agent as a folder of instructions, skills, and tools, test it locally, and deploy it with the mda CLI. Using LangChain's internal go-to-market agent as the example, he walks through the questions that come up in production and how Managed Deep Agents answers them: caller identity across Slack and web surfaces, user and agent-scoped credentials that can pause mid-task for a user to authenticate, memory with access control by channel, versioned context in Context Hub, and Harbor evals traced to LangSmith experiments. He also shares how Madrigal built a pharmaceutical research agent with Deep Agents on LangSmith and how the team at Consensus builds agents for different parts of its organization, and closes with what is new in the 0.8 release, including HTTP channels, user-scoped memory, Slack file transfers, and built-in search powered by Parallel.

This session was captured at Interrupt New York City, the agent conference by LangChain.

LangChain products in this talk: Managed Deep Agents, Deep Agents, LangGraph, LangSmith, LangSmith Deployment, LangSmith Sandboxes, LangSmith Context Hub

Speakers: Victor Moreira, Product Manager, LangChain

Chapters: 0:00 What is an agent harness, and why does context matter? 1:26 The four core areas that make up a deep agent 3:15 Madrigal spins up research agents in hours instead of weeks 3:59 What changes when a local agent goes to production? 5:32 How Managed Deep Agents bundles harness and infrastructure 6:37 An agent as a folder, shipped with three mda commands 7:43 How LangChain's GTM agent maps onto files 8:34 Who is asking, and whose account should the agent use? 10:42 Which memories can the agent use in a DM or shared channel? 11:40 Versioned context in Context Hub and evals with Harbor 13:15 How Consensus builds agents for different parts of its org 14:18 What's new in the Managed Deep Agents 0.8 release

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: https://www.langchain.com/langsmith → Interrupt, the agent conference by LangChain: https://interrupt.langchain.com

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

Reading summary

LangChain Product Manager Victor Moreira argues that moving AI agents from prototypes to production requires solving context delivery, distributed infrastructure, and identity management by bundling a customizable harness with managed cloud runtimes. The Four Pillars of Deep Agent Architecture (1:26) An agent operates on a ReAct-style pattern of iterative reasoning and tool execution, but its capabilities remain fundamentally limited by the information it sees. Moreira defines an agent harness as the entire scaffolding designed to ensure the model receives the correct context at the right time. The Deep Agents harness structures this through four core areas: an abstract virtual file system backed by sandboxes or storage buckets, advanced context management (including progressive tool disclosure and payload offloading), multi-step subagent delegation, and human-in-the-loop pauses powered by LangGraph interrupts. This architectural separation allows domain-specific customization without re-engineering base mechanics. For instance, biotechnology company Madrigal used the harness on LangSmith to create pharmaceutical research agents that synthesize complex literature, collapsing domain-specific development timelines from several weeks down to hours. Bridging Local Logic with Managed Infrastructure (3:59) Moreira segments agent development into business logic, the harness, and infrastructure. While local scripts easily validate an agent's reasoning, deploying to external users introduces distributed systems hurdles, including multi-surface routing, burst traffic queuing, real-time streaming, and persistent checkpointing. Managed Deep Agents packages the harness directly with LangSmith deployment infrastructure, sandboxes, and observability gateways. Development is standardized through the mda CLI: developers scaffold projects with `mda init`, test locally with parity using `mda dev`, and deploy to production cloud runtimes using `mda deploy`, eliminating manual infrastructure maintenance. Identity Reconciliation and Mid-Task Authentication (9:14) Deploying agents across multiple communication surfaces, such as Slack and internal web portals, creates operational hurdles around caller identity and data permissions. Managed Deep Agents introduces an authentication handler that maps diverse entry points to a unified organizational identity, while its connections primitive lets developers designate whether a tool executes via a shared service account or caller-specific credentials. To handle missing user permissions without failing the run, the runtime combines human-in-the-loop interrupts with LangGraph checkpointing. If an agent requires an on-behalf-of token mid-task, it safely halts execution, sends an authentication link to the caller, and resumes automatically from its checkpointed state once credentials are provided. Channel-Aware Memory and Rigorous Evaluation (10:42) Enterprise memory requires strict contextual boundaries. Managed Deep Agents divides memory into procedural agent-level knowledge and user-level preferences, enforcing channel-based access rules. In a private direct message, the agent can record and leverage private user context, but it suppresses these personal memories when summoned in shared team channels to prevent information leakage. System instructions and skills are versioned through Context Hub, bringing Git-like iteration to prompt engineering. To prevent behavioral regressions when updating production agents, the runtime integrates Harbor evaluations through the `mda eval init` command. This automatically provisions local benchmark suites and pipes experiment traces into LangSmith, enabling developers to compare iterations side by side before deployment. The 0.8 public beta introduces HTTP channels for custom webhooks, sandbox APIs for client-side artifact extraction, native Slack document generation, and zero-configuration Parallel search. While internal deployments like LangChain's Open SWE and centralized enterprise teams like Consensus demonstrate the model's operational viability, teams must still carefully govern user-level credential boundaries across varied front-end surfaces.

Source quotes

[0:05] Victor Moreira: So a lot of times when we're building an agent, we know that the model is only as powerful as the context that we give it.

Original transcript

[0:05] Hi everyone, I'm Victor. I'm a product manager here at LangChain. [0:09] I primarily focus on our runtime products, and today we're going to talk about [0:13] deploying mission-critical agents into production. [0:16] We're going to start first with like a little refresher on what Deep Agents [0:19] are, and then we'll talk about Managed Deep Agents and why we're so excited [0:22] about them. So the first place we always love to start with this is: what is [0:26] an agent? It's a question we get a lot, and the core idea of an agent is [0:31] it's a model using tools in order to complete a task, and this is based on [0:36] the ReAct-style agents that have become popular over a year ago, and that's [0:41] based on like reason and action. [0:42] So they're going to use tools, they're going to reason over it to accomplish [0:45] a task for you. [0:47] The next question we often get is: what is a harness? [0:50] So a harness is basically everything else that we bake in to create the agent. [0:54] So that can be skills, it can be tools, context, subagents, really all of these [0:59] different things that we put into an agent in order for it to accomplish [1:03] a task. [1:05] Why do we do this? Like, why do we go through all the effort of building [1:08] a harness, building an agent, and going through all this development? [1:12] And that's to get the model the right context at the right time. [1:15] So a lot of times when we're building an agent, we know that the model is [1:19] only as powerful as the context that we give it. [1:21] And we need to always be able to get it the right context at the right time. [1:26] Deep Agents is a customizable harness that we can build for any domain-specific [1:30] task. So we took a lot of the learnings of coding agents and different harnesses [1:34] that are out there in the wild, and we've really put it into this very customizable [1:37] base harness that you can use for virtually any use case. [1:41] The anatomy of a deep agent is really comprised of four core areas. [1:46] The first being the execution environment. [1:48] And this is really core to the philosophy of Deep Agents, is we sort of [1:52] abstract away the file system for the agent. [1:54] So us as developers, we can define sort of this wall between your model and [1:58] the files it interacts with through a virtual file system. [2:02] That file system can actually live anywhere. [2:04] It could be S3 files. It could even be a sandbox where your agent can write [2:07] and execute code, or its lighter-weight cousin, a code interpreter or a REPL. [2:12] What's really cool about this too is this helps with context management. [2:15] So things like progressive disclosure of skills, doing things like [2:19] cross-thread memory. So you want to remember things about agents or about users [2:23] across threads, you can do that with the file system. [2:25] We can do things like summarization. [2:27] So as our context grows and grows, we're able to summarize that previous conversation, [2:34] compact it down, and store it in the file system. [2:36] And then we can also offload context. [2:38] So let's say we retrieve like a very large tool response, we can actually offload [2:42] that into the file system rather than directly loading that into our [2:47] model's context window. [2:48] The third kind of key area is delegation. [2:51] So delegation is the ability for the model to plan, reason over that plan, and [2:55] then kick off subagents to execute things. [2:58] And then lastly is human in the loop. [2:59] Human in the loop is very core to everything that we do here at LangChain. [3:03] This conference is actually named after the interrupt function, which [3:06] is a function of LangGraph. [3:07] Deep Agents is built on top of that LangGraph runtime. [3:10] So you have that ability to interrupt and pause for execution. [3:15] So a good example of taking a deep agent into production is a customer of ours, [3:18] which is Madrigal. Madrigal has a ton of different use cases, but primarily [3:23] focuses on a pharmaceutical research agent. [3:25] And this is for their pharmaceutical researchers to be able to load in [3:30] a domain-specific harness that is able to reason over a certain knowledge base [3:35] for that particular researcher's domain, synthesize all of those results, and [3:39] respond back with a cohesive report with cited sources and all of that. [3:43] They were able to build all of this with Deep Agents, and a task that used to [3:46] take them weeks, to spin up a new agent for a researcher, now just takes a few [3:50] hours by putting this all into the Deep Agents harness and deploying it onto [3:54] LangSmith. [3:59] Cool. So, let's talk about like what it takes to take an agent from something [4:02] that works locally and actually put it into production. [4:05] So, there's kind of like three core areas of building an agent. [4:08] The first is the business logic, and this is what we think is the most important [4:11] thing for developers and for teams to bring, is this core idea of like their [4:16] expertise and the different instructions and skills that your agent might use. [4:20] The second is the harness itself, which we talked about, as Deep Agents gives [4:24] our agent the ability to use files and do context management and all these [4:28] wonderful things. And the third area is going to be infrastructure. [4:31] So infrastructure is probably the more boring area, but the most important [4:34] area when you talk about actually taking an agent and putting into production [4:38] in a way that others can use it. [4:41] Cool. So one of the first things that we do when we're building an agent, [4:44] right, is we're prototyping it locally. [4:46] We get it running locally on our machine and it works great, and we're really [4:49] excited, and then we want to go and actually share this with everyone else. [4:52] This is actually a very, very valuable stage. [4:54] This is where we can kind of prove the magic of the agent, right? [4:57] That the agent can actually do what we're designing it for. [5:00] What happens then is we try to go into production, and now we need to think [5:04] about a lot of different things, right? [5:05] We need to think about where people are going to use this agent, the different [5:08] surfaces you might want your agent to be used from, [5:11] how you're going to reconcile where those different surfaces [5:13] are entering into your actual runtime. [5:16] You need to be able to queue up the runs so that your agent can kind of serve [5:19] them reasonably. You need to be able to establish streaming. [5:22] You need to do all these different things in order to have this agent run reliably [5:25] in production. And it requires kind of different things that your team has [5:29] to consider from an infrastructure standpoint. [5:32] With Managed Deep Agents, we wanted to make this process very, very easy. [5:36] So what we've done is we've sort of bundled together the harness and the infrastructure [5:40] to make it really, really easy for your teams to work on primarily the business [5:44] logic and actually improving your agents with evals, with traces, with Engine, [5:48] and iterating on your actual agent logic rather than focusing on the infrastructure [5:52] and the harness-level stuff. [5:54] So this is kind of what it looks like. That previous graph of all these [5:57] different boxes that you had to manage yourself now becomes very easy with [6:00] Managed Deep Agents. It runs on our proven LangSmith Deployment for things [6:04] like streaming, checkpointing, auth handlers, things of that nature. [6:08] It integrates directly with LangSmith Sandboxes for all of that sandbox control [6:13] when you need agents to run and execute code. [6:15] It also uses Context Hub, which we'll talk about a little bit later, but allows [6:19] us to kind of coordinate on instructions and skills with business users and [6:23] iterate on things. And then of course, it plugs into our LLM Gateway and traces [6:27] as well. And what's really nice is, on the left side you'll see this agent interface, [6:30] is we do a really good job of allowing you to use your agent [6:34] from different interfaces and reconcile those. [6:37] So since we're handling all of this infrastructure, we now can make it really [6:41] easy for you as a developer to define the agent. [6:43] So rather than kind of defining it in your own logic, we can go ahead and [6:47] give you this folder structure in order to define things. [6:49] So your agent will live in like the agent.ts or agent.py. [6:53] So this works for Python or TypeScript. [6:55] Your instructions, skills, tools, identity, all of these different primitives [6:59] that you need to add to the agent itself will live in different folders or [7:02] different files in your directory. [7:04] Getting started is really easy. [7:06] So, all we're going to do is run mda init and give our agent a name. [7:09] That'll scaffold this project directory for us. [7:12] After we add in all of that logic, we can then go ahead and run mda dev. [7:16] And that's going to start up a local Agent Server for us, which is the same [7:19] server that powers LangSmith Deployment. [7:21] So you're able to test everything out locally and make sure that it's working [7:24] as intended. And then once you're ready to actually go into production, all [7:28] you need to do is run mda deploy. [7:30] And that's going to go ahead and deploy it onto LangSmith's managed infrastructure. [7:33] This makes it really, really easy to go from an idea to a prototype, something [7:37] that works locally, and then into production. [7:43] Cool. So let's take a look at an actual example of an agent that you might [7:47] want to build, something that people in your organization might [7:50] use. This is sort of an example that we use a lot internally here at LangChain, [7:54] which is our go-to-market agent, and it's something that anyone in our organization [7:57] can interact with in order to do anything related to go-to-market. [8:00] So, we're going to ask it to prep me for a certain meeting and draft an email [8:04] for me to review, and that kind of gets sent into this GTM agent. [8:08] The way that this looks and the way that we can design this agent is really [8:11] quite easy. This now all maps to different files. [8:14] So again, our agent definitions at the beginning, the sort of playbook for how [8:17] we wanted to do different things, can live in both the instructions and the [8:20] skills, and then all of the connections to different business systems like Salesforce, [8:25] Gong, all these other sort of platforms, lives in tools, and then we can define [8:28] how users authenticate and how we remember things about users in the other [8:31] two files. [8:34] So, one of the core things that, when we talk about building agents with customers, [8:38] there's kind of four scary things that then get brought up when you bring it [8:40] into production, is how do we identify who's asking this agent to do what, [8:45] prep for the email or prep for the meeting? [8:47] Whose data is it going to use? [8:49] Which memory is it going to be able to reference or edit? [8:51] And then lastly, what happens if it is actually missing access when that run [8:55] gets initiated? [8:57] So jumping into the first one, this is something that we thought about a lot [9:00] with Managed Deep Agents, is being able to reconcile the callers between different [9:03] surface areas. So we have first-class support for different channels in [9:07] Managed Deep Agents. You can really easily just create a Slack application, [9:11] go ahead and use this agent, but you also might want to expose this agent in [9:14] your web UI or your web application or your own platform. [9:17] And you don't want to have to have a user always like re-authenticate and [9:20] re-go through the permissioning over and over again. [9:22] So what we did is built a very nice auth handler that will help you reconcile [9:25] those users, and you can have them reconcile across these different surface [9:28] areas, and that all gets passed into the runtime for the managed deep agent quite [9:32] easily. [9:34] The second is: whose account should it use? [9:36] So as a developer, we might want to define certain connections, certain tools [9:40] that your agent can use, and connect them in a certain way. [9:43] So we might want to say, okay, when it uses our CRM tool, for example, we always [9:47] want it to use the user's credentials. [9:49] So we want to have it operate on behalf of the caller. [9:52] So, if I'm in a DM with this agent and I say, "Prep me for this meeting," it's [9:55] then going to be able to use my Salesforce credentials and go and access that. [9:59] There's other scenarios where you might want your agent to have its own [10:02] agent-scoped credentials or be able to have service account credentials. [10:04] We make this really easy in Managed Deep Agents with this connections primitive. [10:08] So, all you need to do is define these connections, upload tokens. If they're [10:12] user-based, we'll actually handle that for you. [10:15] And how we handle that is really easily mid-task. [10:18] So since we have built-in human in the loop in Deep Agents and in the LangGraph [10:21] runtime, what happens is when you make a request and the agent doesn't have [10:25] a particular token for a particular user and it's an on-behalf-of token, it's [10:29] actually able to really easily pause, ask the user to go ahead and authenticate. [10:34] They'll click the link, everything proceeds as normal, and this will happen [10:38] indefinitely, since we have the interrupts checkpointed. [10:42] The second, or the third kind of core area that becomes interesting is memory. [10:45] There's a lot of different approaches to memory, and we wanted to have [10:49] really good defaults for this. [10:50] So the first kind of convention is agent-level memory, or procedural memory. [10:54] We have a really great way for your agent to be able to take and remember certain [10:57] procedural things about users in Managed Deep Agents. [11:00] The second is user-level memory. [11:02] So personal preferences that I tell the agent about myself. [11:05] And it's really important that your agent is able to kind of take these [11:08] different types of memory. [11:11] And this is where control starts to come into place. [11:13] So, one thing that we've built into Managed Deep Agents is allowing you to define [11:17] the access control based on the channel that it's calling from. [11:20] So, if I'm in a Slack DM, for example, it can use my personal memories. [11:23] It can use my personal credentials. [11:24] It can take personal memories about me, and that's totally fine. [11:27] But if I'm talking in a shared channel with my other co-workers, I probably [11:31] don't want it to be able to unveil certain information about me. [11:33] So, as a developer, I can define those sort of primitives if I need [11:37] to. [11:40] Another really nice part of Managed Deep Agents is we get version control for [11:44] our agent context with Context Hub. [11:46] So we're able to store all of our instructions, skills, and memory inside of [11:50] a Context Hub repo. And that will allow us to collaborate in the surface [11:55] within LangSmith, which is really great for kind of iterating on different things [11:59] like instructions, having version control over it, promoting it to production, [12:03] things of that nature. [12:05] Promoting it to production, though, can be scary. [12:07] So, one thing that we built into Managed Deep Agents that we've really spent [12:12] a lot of time on was its integration with Harbor as an eval framework. [12:16] So, I know we've talked about Harbor today, but we really think it's a great [12:19] way for running evals. [12:21] But what we found from customers is that it can be a bit difficult to get [12:24] started with. So, we wanted to make it really easy for Managed Deep Agents. [12:28] If you run this mda eval init, it'll go ahead and initialize a Harbor environment [12:33] for you. Help you set up the tasks, help you set up the checks. [12:36] All of that will get traced into LangSmith and show up in your LangSmith experiments [12:39] tab, and you're able to kind of improve your agent over time. [12:43] You can rerun the same tasks and you can actually hill-climb your agent right [12:47] in your own machine. [12:50] One of the things that we're announcing today is our integration with Parallel. [12:53] So, we're really excited to announce this integration. [12:55] It's going to be free during our public beta. [12:57] So, please feel free to go ahead and use it. [12:59] But the way that it works is essentially you can just go ahead and add [13:03] this tool to your managed deep agent. [13:04] You don't have to add any Parallel API keys, anything like that. [13:07] It'll all kind of work just out of the box. [13:09] So, we're really excited about partnering with Parallel on this for Managed [13:12] Deep Agents. [13:15] So something that we've really, really enjoyed was working not only internally [13:19] with our own agent use cases, like our go-to-market agent, Open SWE, which [13:23] is like a software factory type agent, and iterating on that for Managed Deep [13:26] Agents, but also working with a lot of our customers. [13:29] And we wanted to highlight two customers in particular. [13:32] Zahid from Kyth was instrumental in really helping us getting started with [13:36] some of the primitives of collaborating with no-code users, with business users. [13:40] Also setting up how connections and memory will work. [13:43] So, it's been really great working with Zahid, and we value him as a partner. [13:47] Additionally, Derek from Consensus has been really, really great to see how [13:51] he's actually used Managed Deep Agents in a way that we really intended [13:56] it to be used. So, him and his team of developers kind of go around the org [13:59] there at Consensus, and they build out different deep agent use cases for [14:03] different parts of the org. [14:04] And because Managed Deep Agents handles all of the infrastructure, they're able [14:08] to really easily kind of go and deploy these agents. [14:10] And they've been able to really rapidly increase the amount of agents that [14:14] are being used across Consensus, which is really exciting. [14:18] So what's new as of today in Managed Deep Agents? [14:21] The first is HTTP channels. [14:23] And the primitive here allows you to basically define your own custom channels. [14:28] So we have great pre-built integrations for Slack, for example, but we know [14:31] that you might want to use your agents in a variety of different ways across [14:34] a variety of different surfaces. [14:36] So we make it very easy for you now to define how your agent responds to certain [14:40] events, where it then responds to those events for you. [14:42] So it's very, very easy now with the new HTTP channels. [14:46] We also added much better APIs for accessing your sandbox's file system. [14:51] So not only can the agent access the file system, but you as a user can now [14:55] access it from your front ends in different places. [14:57] The third is user-scoped memories. [14:59] So as I mentioned, we thought a lot about user-scoped memories and how to [15:02] do it reliably and safely, and that's now available in Managed Deep Agents. [15:06] And then of course connections, which is how we're going to actually authenticate [15:09] and define that as developers, is now available. [15:12] The second to last is file transfers in Slack. [15:16] So very commonly you're going to want to collaborate on files. [15:18] You maybe want an agent to create a PowerPoint for you, create a PDF. [15:21] You want to be able to iterate on it right within Slack, and that is now [15:24] first-class in Managed Deep Agents. [15:26] And lastly, the built-in search with Parallel that I just mentioned. [15:30] Awesome. Thank you all for joining today. [15:33] We're really excited to announce Managed Deep Agents in our 0.8 release, [15:37] and we can't wait to see what you build with it and build your domain-specific [15:40] agents. Thank you.