LangChain · Published 2026-08-07

Managed Deep Agents explained in 20 minutes

privateReview: unreviewedConfidence: high
managed deep agentslangsmithContext Hubmda clisandboxesMCPmanaged-deep-agentscontext-hubmda-cliHarnessdurable-executionagent-deployment
Open on YouTube ↗

Summary

Overview

  • Speaker: Harrison Chase
  • Channel: LangChain
  • Main topic: Managed Deep Agents: Building, Running, and Deploying Agents in Production
  • Purpose: To provide a comprehensive overview and quick start guide for Managed Deep Agents, detailing their architecture, deployment hurdles, and practical implementation. Harrison Chase explains Managed Deep Agents, a new offering by LangChain designed to simplify building, running, and deploying agents in production. The video covers agent architecture across three layers—business logic (prompts, skills, tools, sub-agents provided by the developer), harness (deep agents framework handling context management and filesystem access), and infrastructure (runtimes, sandboxes, channels, connectors provided by LangChain). He contrasts the difficulties of deploying agents from scratch with local development (using uv and LangSmith Studio) and cloud deployment (using mda deploy, context hubs, schedules, and custom tools like Tavily).

Topic Map

Introduction to Managed Deep Agents

  • Explanation: Introduction of Managed Deep Agents as the best way to build, run, and deploy agents in production, solving major infrastructure and context management challenges.
  • Key claims:
    • Makes it far easier to build powerful agents and run them at scale.
  • Examples:
    • Launching managed deep agents in LangChain ecosystem.
  • Terminology:
    • Managed Deep Agents
    • production agents
  • Why it matters: Lowers the barrier to entry for robust agent deployment.

Anatomy of an Agent: Three Layers

  • Explanation: Breaking down an agent into Business Logic (provided by you), Harness (Deep Agents framework), and Infrastructure (runtime, sandbox, connectors).
  • Key claims:
    • Business logic like prompts and tools must be provided by the developer.
    • Harness handles context management and filesystem access.
    • Infrastructure manages production runtime, sandboxes, and scaling.
  • Examples:
    • Business Logic vs Deep Agents harness vs infrastructure.
  • Terminology:
    • Business Logic
    • Harness
    • Infrastructure
    • Deep Agents
  • Why it matters: Establishes a clear separation of concerns in agent architecture.

Challenges in Deploying Agents

  • Explanation: Outlining what makes deploying agents hard: runtime durability, sandboxes for untrusted code, context management, evaluations, authentication, user experience, and memory.
  • Key claims:
    • Running untrusted code requires secure sandboxes.
    • Evaluations are difficult to build, write, and maintain.
    • Context management requires accessible storage for non-developers.
  • Examples:
    • Listing runtime, sandboxes, evals, auth, UX, memory challenges.
  • Terminology:
    • durable execution
    • sandboxes
    • evals
    • Context Hub
    • MCP
  • Why it matters: Identifies the core pain points that Managed Deep Agents solve.

Managed Deep Agents Architecture & Components

  • Explanation: Detailed architecture of how Managed Deep Agents bundle business logic with LangSmith deployments, Context Hub, sandboxes, schedules, connectors (MCP), auth, channels (Slack), and Harbour evals.
  • Key claims:
    • Context Hub stores instructions, skills, and memory in a UI for non-developers.
    • Schedules allow agents to run proactively as cron jobs.
    • Connectors use MCP to integrate with Slack, Notion, Linear, etc.
  • Examples:
    • LangSmith Deployments
    • Context Hub
    • MCP connectors
    • Harbour evals
  • Terminology:
    • LangSmith
    • Context Hub
    • MCP
    • Harbour
    • Schedules
  • Why it matters: Shows how infrastructure components integrate seamlessly.

Quick Start Tutorial (Python)

  • Explanation: Step-by-step walkthrough of installing managed-deepagents via uv tool install, initializing a project with mda init, defining agent.py, identity.py, instructions.md, sandbox configuration, adding Tavily search tool, running locally with mda dev, and deploying with mda deploy.
  • Key claims:
    • Managed deep agents are structured as a file system project.
    • mda dev runs a local agent server with LangSmith Studio.
    • mda deploy syncs context hub and provisions serverless deployments.
  • Examples:
    • Initializing research-assistant project, adding tavily-python, modifying instructions to Italian in Context Hub.
  • Terminology:
    • uv
    • mda CLI
    • LangSmith Studio
    • Context Hub
  • Why it matters: Provides practical, actionable steps for developers to build and deploy agents.

Key Points

Three-layer agent architecture

  • Explanation: Agents are split into developer-provided business logic, harness (Deep Agents), and infrastructure (LangSmith).
  • Evidence: Layered diagram showing Business Logic, Deep Agents harness, and Infrastructure.
  • Practical implication: Developers focus purely on prompts and tools while infrastructure is handled.

Context Hub decouples context from code

  • Explanation: Instructions, skills, and memory live in a UI called Context Hub so non-developers can edit them without redeploying code.
  • Evidence: Editing instructions.md in Context Hub and seeing agent behavior change instantly in Italian.
  • Practical implication: Enables non-technical team members to tune agent behavior safely.

Seamless local development and production deployment

  • Explanation: Using mda CLI tools allows instant local testing via LangSmith Studio and one-command cloud deployment via mda deploy.
  • Evidence: Demo running 'mda dev' and opening Studio, then running 'mda deploy'.
  • Practical implication: Drastically reduces time-to-market for agent applications.

Frameworks, Models & Processes

Managed Deep Agents Architecture

  • How it works: Combines developer business logic with a model-agnostic harness and managed cloud infrastructure.
  • Components:
    • Business Logic (prompts, skills, tools, sub-agents)
    • Harness (filesystem access, context management)
    • Infrastructure (runtime, sandbox, channels, connectors)
  • When to use: When building and scaling production AI agents.

Examples & Case Studies

Created a research assistant agent using 'mda init research-assistant', added Tavily search tool, ran locally with 'mda dev', and deployed with 'mda deploy'.

  • Illustrates: The full lifecycle of building, testing, and deploying a managed deep agent.
  • Lesson: Development and deployment can be streamlined into simple CLI commands and file structures.

Modified agent instructions in the LangSmith Context Hub UI to respond in Italian and re-tested in Studio without redeploying code.

  • Illustrates: Dynamic context management via Context Hub.
  • Lesson: Prompt and instruction updates do not require software redeployments.

Actionable Takeaways

  • Immediate:
    • Install managed-deepagents using uv tool install.
    • Initialize projects with mda init.
    • Test agents locally using mda dev and LangSmith Studio.
  • Strategic:
    • Separate business logic from infrastructure to scale agent deployments.
    • Leverage Context Hub for collaborative agent prompt engineering with non-developers.
  • Questions to investigate:

Claims Worth Verifying

  • Managed Deep Agents package the harness and runtime as a hosted deployment on LangSmith Agent Server. (architectural claim)
  • Context Hub updates instructions and memory immediately without requiring code redeploys. (functional claim)

Notable Quotes

"Today we're launching managed deep agents, the best way to build, run and deploy your agents in production." "Managed deep agents is a file system. So this is one of the cool parts about it."

Compressed Summary

  • Managed Deep Agents streamline building, running, and deploying production AI agents.
  • Architecture consists of Business Logic (you provide), Harness (Deep Agents), and Infrastructure (LangSmith).
  • Features include Context Hub for non-developer editing, secure sandboxes, MCP connectors, schedules, and Harbour evals.
  • Simple CLI workflow: mda init, mda dev for local testing, and mda deploy for production.
  • Keywords: managed deep agents, langsmith, context hub, mda cli, sandboxes, mcp
  • Core insight: Managed Deep Agents bundle business logic, harness, and infrastructure into a seamless file-system-based workflow with cloud deployment and dynamic Context Hub editing.

Core insights

6
Architecturehigh noveltystrong evidence

Context (instructions, skills, memory) is stored and edited in a separate UI (Context Hub) rather than in source control, so behavior changes take effect without redeploying code.

Why it matters

Splits the agent's mutable behavior surface from its immutable code surface, allowing rapid prompt/instruction iteration and non-developer participation without a build/deploy cycle — a different abstraction boundary than 'prompts live in the repo'.

Generalization

Any agent system can be decomposed into a code artifact (tools, graph, identity) and a context artifact (instructions, skills, memory) with independent release cadences.

Context Hub stores instructions, skills, and memory in a UI for non-developers.
Open source video
Prompt and instruction updates do not require software redeployments.
Open source video
Editing instructions.md in Context Hub and seeing agent behavior change instantly in Italian.
Open source video
Mental Modelmedium noveltystrong evidence

The agent is split into three explicit layers — developer-authored business logic, a model-agnostic harness (context management and filesystem access), and managed infrastructure (runtime, sandboxes, channels, connectors) — with each layer owned by a different party.

Why it matters

Gives a concrete ownership boundary: developers ship prompts/skills/tools/sub-agents only, while durable execution, sandboxing, and connectivity are treated as infrastructure concerns rather than application code.

Generalization

Agent engineering is converging on a 'business logic vs harness vs infra' split analogous to app code vs framework vs cloud runtime.

Business logic like prompts and tools must be provided by the developer.
Open source video
Harness handles context management and filesystem access.
Open source video
Combines developer business logic with a model-agnostic harness and managed cloud infrastructure.
Open source video
Mechanismmedium noveltymoderate evidence

Deployment is a two-artifact operation: mda deploy simultaneously syncs the Context Hub and provisions serverless deployments, coupling a context release to a code release at deploy time.

Why it matters

Reveals the actual release semantics of the managed platform — context is not purely hot-swappable in all paths; the CLI establishes a synchronization contract between Hub state and deployed code.

Generalization

Context-as-configuration architectures must define a sync/promotion protocol between the context store and deployed runtimes, otherwise drift becomes inevitable.

mda deploy syncs context hub and provisions serverless deployments.
Open source video
Architecturemedium noveltymoderate evidence

Agents can be run proactively on schedules (cron-like) rather than only reactively per user request.

Why it matters

Shifts the agent runtime from request-response to scheduled/proactive execution, which changes requirements around idempotency, state, and notification channels.

Generalization

Production agent runtimes need both interactive (channel/chat) and non-interactive (scheduled) invocation surfaces over the same agent definition.

Schedules allow agents to run proactively as cron jobs.
Open source video
Architecturemedium noveltymoderate evidence

Standardizing tool/integration access on MCP turns connectors (Slack, Notion, Linear) into infrastructure-provided, agent-agnostic wiring rather than per-agent code.

Why it matters

Connectors become a shared platform capability, reducing per-agent integration code and centralizing auth/credentials handling at the infrastructure layer.

Generalization

Tool connectivity is moving from library-level SDKs to protocol-level (MCP) infrastructure endpoints shared across agents.

Connectors use MCP to integrate with Slack, Notion, Linear, etc.
Open source video
Failure Modemedium noveltystrong evidence

Secure sandboxes and durable execution are framed as infrastructure problems to be absorbed by the platform, arising specifically because agents execute untrusted, model-generated code.

Why it matters

Identifies code-executing agents as a distinct security/isolation problem class, not a generic 'agent reliability' concern, and locates the fix below the application layer.

Generalization

Any agent with a filesystem or code-execution tool inherits a sandboxing requirement that must be supplied by the runtime, not the agent author.

Running untrusted code requires secure sandboxes.
Open source video
Listing runtime, sandboxes, evals, auth, UX, memory challenges.
Open source video
Runtime durability
Open source video

Deep dives

5

Context release engineering: versioning, promotion, and drift detection between Context Hub and deployed code

Research question

What minimal protocol (versioned context artifacts, staged promotion, diff-based review, deploy-time drift checks) prevents behavior drift when instructions/skills/memory live outside source control and sync at deploy?

Why

Without a sync contract, context edits can bypass review and diverge from the code artifact they were tested with, making production behavior non-reproducible and hard to audit.

Context Hub stores instructions, skills, and memory in a UI for non-developers.
Open source video
Context management requires accessible storage for non-developers.
Open source video
Detailed architecture of how Managed Deep Agents bundle business logic with LangSmith deployments, Context Hub, sandboxes, schedules, connectors (MCP), auth, channels (Slack), and Harbour evals.
Open source video
Source video

Eval-gated context deployment

Research question

Can eval runs be automatically triggered on Context Hub commits and used as promotion gates with automatic rollback when quality scores regress?

Why

Context Hub enables instant behavior changes without redeploy, so evals must attach to context changes rather than code releases to prevent silent regressions.

Evaluations are difficult to build, write, and maintain.
Open source video
Context Hub stores instructions, skills, and memory in a UI for non-developers.
Open source video
Detailed architecture of how Managed Deep Agents bundle business logic with LangSmith deployments, Context Hub, sandboxes, schedules, connectors (MCP), auth, channels (Slack), and Harbour evals.
Open source video
Source video

Isolation guarantees of managed sandboxes for model-generated code

Research question

Which isolation primitives (containers, microVMs, seccomp, network policy) back the managed sandbox, and what are measured escape, egress, and persistence properties when agents execute untrusted code?

Why

Agents with filesystem/code execution inherit a sandboxing requirement that is asserted as infrastructure but not verifiable from the developer side, making security a trust boundary.

Running untrusted code requires secure sandboxes.
Open source video
Outlining what makes deploying agents hard: runtime durability, sandboxes for untrusted code, context management, evaluations, authentication, user experience, and memory.
Open source video
Infrastructure manages production runtime, sandboxes, and scaling.
Open source video
Source video

Durable execution semantics for long-running agents

Research question

What is checkpointed in durable agent execution, and how are mid-run failures, replay, and duplicate side effects handled for tool calls and sandbox actions?

Why

Without knowing checkpoint granularity, teams cannot design idempotent tools or reason about recovery from partial failures.

Outlining what makes deploying agents hard: runtime durability, sandboxes for untrusted code, context management, evaluations, authentication, user experience, and memory.
Open source video
The video covers agent architecture across three layers—business logic (prompts, skills, tools, sub-agents provided by the developer), harness (deep agents framework handling context management and filesystem access), and infrastructure (runtimes, sandboxes, channels, connectors provided by LangChain).
Open source video
Source video

Proactive scheduled agents vs interactive invocation

Research question

What state, concurrency, and cost controls are required when the same agent definition is run by cron-like schedules and by interactive channels?

Why

Scheduled runs shift idempotency, notification, and budget requirements, but the platform exposes schedules without describing overlap or deduplication semantics.

Schedules allow agents to run proactively as cron jobs.
Open source video
Detailed architecture of how Managed Deep Agents bundle business logic with LangSmith deployments, Context Hub, sandboxes, schedules, connectors (MCP), auth, channels (Slack), and Harbour evals.
Open source video
Source video

Article ideas

4

Context Is the New Deployment Artifact

The most important release in an agent system is no longer the code deploy; it is the context commit. Once instructions, skills, and memory live in a UI-backed store and sync at deploy time, teams need context CI/CD—versioning, review, promotion, and drift detection—or they lose reproducibility and auditability.

Angle

Reframe agent release engineering around two independent artifacts and show what breaks when only code is versioned.

Source video

Your Agent Framework Is Quietly Becoming a Cloud Runtime

The three-layer split—developer business logic, model-agnostic harness, managed infrastructure—mirrors app/framework/cloud, which means the strategic decision is no longer model choice but where you accept platform ownership of sandboxing, durability, connectors, and auth.

Angle

Argue that harness/runtime boundaries, not prompts, define portability and lock-in for production agents.

Source video

Sandboxes Are the Real Agent Security Boundary

Prompt-injection filters and guardrail prompts do not secure code-executing agents; the isolation guarantees of the sandbox do. Treating sandboxing as infrastructure is correct, but it moves the burden of proof to the platform and makes adversarial sandbox benchmarks a first-class requirement.

Angle

Shift security investment from prompt-level controls to runtime isolation verification.

Source video

Scheduled Agents Will Break Your Observability and Cost Model

Moving agents from reactive chat to cron-like proactive runs changes idempotency, deduplication, notification, and budget semantics. Teams that reuse the same agent definition for scheduled and interactive entry points without concurrency and cost controls will ship duplicate side effects and surprise bills.

Angle

Focus on operational failure modes of proactive agents rather than capabilities.

Source video

Project ideas

4

Context Drift Sentinel

gatehouse

If context is synced from a UI store at deploy time, then automated snapshots, diff-based review gates, and deploy-time drift checks will reduce unintended production behavior changes compared with unversioned context edits.

Proof of concept

A CLI wrapper around mda deploy that exports Context Hub instructions/skills/memory into versioned artifacts, computes a semantic diff, requires approval for changes, and blocks deployment when live Hub state diverges from the approved snapshot.

Measurement

Number of unintended behavior changes per 100 deploys, mean time to rollback, and count of code/context drift incidents before vs after.

Source video

Eval-Gated Context Commit

beyond-evals

Automatically re-running evals on Context Hub edits and blocking promotion when scores regress will catch context-induced quality drops without increasing edit-to-safe-deploy time beyond a threshold.

Proof of concept

A Context Hub watcher that triggers Harbour evals on each instruction/skill/memory change, compares scores to a baseline, and either auto-promotes or opens a rollback/block signal.

Measurement

Regression catch rate, false-positive gate rate, median time from context edit to safe deployment, and number of post-deploy eval regressions.

Source video

Sandbox Escape Range

gatehouse

Managed sandboxes for model-generated code have measurable escape, egress, and persistence surfaces that can be quantified by adversarial payload benchmarks, and unverified assumptions about isolation understate agent security risk.

Proof of concept

A test harness that executes adversarial model-generated code payloads inside the managed sandbox, probing network egress, filesystem persistence across runs, resource exhaustion, and cross-tenant metadata access.

Measurement

Number of successful policy violations per 100 payloads, egress attempts blocked/allowed, persistence across runs, and resource-limit breach thresholds.

Source video

Scheduled Agent Chaos Harness

new

Running the same agent definition on schedules and interactive channels without concurrency/idempotency controls produces duplicate side effects and cost spikes, and adding a deduplication/overlap guard reduces duplicate actions.

Proof of concept

A chaos test that triggers cron schedules overlapping with interactive Slack runs, injects mid-run failures, and records duplicate tool calls, state conflicts, and token/cost per outcome with and without an idempotency and lock layer.

Measurement

Duplicate side-effect rate, overlap conflict count, cost per scheduled run vs interactive run, and recovery success rate under injected failures.

Source video

Architectural implications

3

Context (instructions/skills/memory) is separated from the deployed code artifact and editable by non-developers.

Before

Prompt and instruction changes require editing source, reviewing, and redeploying the agent application.

After

Context lives in a UI-backed store; edits propagate to the running agent without redeployment.

Consequence

Context becomes an independently versioned and mutable surface, raising new needs for review, rollback, and drift detection between Hub state and code.

Source video

Sandboxing, durable execution, auth, scheduling, and connectors are supplied by managed infrastructure rather than implemented per-agent.

Before

Teams build their own runtime durability, sandboxing, auth, and integration plumbing alongside agent logic.

After

Developers contribute only business logic (prompts, skills, tools, sub-agents) on top of a managed harness and runtime.

Consequence

Agent teams shrink to prompt/tool authors, increasing platform lock-in and making the harness/runtime boundary the key architectural decision point.

Source video

The same agent definition is invoked both interactively (channels like Slack) and non-interactively (schedules).

Before

Agents are typically assumed to be request-triggered, chat-shaped services.

After

Agent definitions are invoked by schedulers and channels through infrastructure-managed adapters.

Consequence

Design must account for idempotency, delivery/notification targets, and cost control for unmonitored recurring runs.

Source video

Tradeoffs and failure modes

3

Context decoupled from code deployment

Benefit

Non-technical team members can tune agent behavior and see instant effect without redeploying code.

Cost or risk

Behavior can change without engineering review or a code diff, creating auditability, approval-gating, and code/context drift risk.

Enables non-technical team members to tune agent behavior safely.
Open source video
Source video

Platform-managed harness and runtime

Benefit

mda dev plus mda deploy collapse local test and cloud provisioning into single CLI commands, drastically reducing time-to-market.

Cost or risk

Harness, sandbox, and connector behavior are owned by the platform, so debugging depth and portability outside LangSmith are constrained.

Drastically reduces time-to-market for agent applications.
Open source video
Source video

Model-agnostic harness with infrastructure-supplied connectors and sandboxes

Benefit

Business logic stays portable and integration/auth plumbing is centralized.

Cost or risk

Correctness of sandbox isolation and connector semantics is inherited and unverifiable from the developer's side.

Infrastructure manages production runtime, sandboxes, and scaling.
Open source video
Source video

Open questions

5

How is Context Hub state versioned, promoted, and rolled back across environments, and how is drift between context and code detected?

Why unresolved

The summary shows instant context edits and deploy-time syncing but describes no versioning, review, or promotion mechanism.

Research direction

Prototype a context CI/CD pipeline: versioned context artifacts, staged promotion, diff-based review, and deploy-time drift checks.

Source video

How do evaluations interact with context changes — are evals re-run automatically when instructions/skills change in the Hub?

Why unresolved

Harbour evals and Context Hub are both mentioned, but no linkage or gating between context edits and eval runs is described.

Research direction

Build eval-triggered on context commit, with regression gates and automatic rollback when scores drop.

Source video

What are the concrete isolation guarantees and failure modes of the sandbox for model-generated, untrusted code?

Why unresolved

Sandboxing is asserted as a requirement but no isolation mechanism, limits, or escape/leak analysis is provided.

Research direction

Adversarial benchmarking of agent code-execution sandboxes: resource exhaustion, network egress, filesystem persistence between runs.

Source video

What does 'durable execution' mean operationally here — which steps are checkpointed and what happens on mid-run failure?

Why unresolved

Runtime durability is listed as a deployment challenge with no detail on checkpoint granularity or recovery semantics.

Research direction

Fault-injection testing of long-running agent runs to map checkpoint boundaries and replay/duplicate side-effect behavior.

Source video

How do scheduled (proactive) agent runs interact with memory, channels, and cost controls compared to interactive runs?

Why unresolved

Schedules are introduced as cron jobs without discussing delivery, deduplication, or budget caps.

Research direction

Measure cost and duplicate-action rates of scheduled runs versus user-triggered runs on the same agent definition.

Source video

Key claims

8
factualVerification needed

Context Hub stores instructions, skills, and memory in a UI accessible to non-developers.

Evidence

Context Hub stores instructions, skills, and memory in a UI for non-developers.

Question

Does editing instructions in Context Hub actually change live agent behavior without any redeploy?

Source video
factualVerification needed

Managed Deep Agents package the harness and runtime as a hosted deployment on LangSmith Agent Server.

Evidence

Managed Deep Agents package the harness and runtime as a hosted deployment on LangSmith Agent Server.

Question

Is the harness runtime exclusively hosted, or can the same harness be self-hosted?

Source video
factualVerification needed

Schedules allow agents to run proactively as cron jobs.

Evidence

Schedules allow agents to run proactively as cron jobs.

Question

What state and concurrency guarantees apply when a scheduled run overlaps with an interactive run of the same agent?

Source video
factualVerification needed

Connectors use MCP to integrate with Slack, Notion, Linear and similar services.

Evidence

Connectors use MCP to integrate with Slack, Notion, Linear, etc.

Question

Are MCP connectors first-party hosted endpoints with managed auth, or locally spawned MCP servers?

Source video
factualVerification needed

mda dev runs a local agent server with LangSmith Studio, and mda deploy syncs context hub while provisioning serverless deployments.

Evidence

mda deploy syncs context hub and provisions serverless deployments.

Question

What exactly is uploaded by mda deploy, and can context sync be decoupled from code deploy?

Source video
causalVerification needed

Running untrusted (model-generated) code requires secure sandboxes, making durability, sandboxing, evals, auth, UX, and memory the core deployment pain points.

Evidence

Running untrusted code requires secure sandboxes.

Question

Which isolation primitives (containers, microVMs, seccomp) back the managed sandbox, and what are their measured escape properties?

Source video
factualVerification needed

Harness handles context management and filesystem access, while infrastructure manages production runtime, sandboxes, and scaling.

Evidence

Harness handles context management and filesystem access.

Question

Is the harness model-agnostic in practice, and does swapping models require any harness-level changes?

Source video
comparativeVerification needed

Development and deployment are streamlined into simple CLI commands and file structures, drastically reducing time-to-market.

Evidence

Drastically reduces time-to-market for agent applications.

Question

What is the measured time from mda init to a deployed agent versus a hand-rolled LangGraph deployment?

Source video

Connections

5