TechPrufer
Get started
LangChain
LangChain logoLangChain · Feature trail

Deep Agents Harness

21 videos · Sep 2026 – Oct 2026

What this trail covers

Deep Agents is LangChain's open-source, model-neutral harness designed to enable complex, long-running AI agents. It provides essential components like context management, tool integration, memory, subagent orchestration, sandboxing for untrusted code, and human-in-the-loop controls for sensitive actions. A key architectural feature is its swappable filesystem, allowing agents to operate seamlessly across different environments (local, sandbox, cloud) without code modifications, thereby streamlining development and deployment. Managed Deep Agents extends this by bundling the Deep Agents harness with managed LangSmith infrastructure, enabling agents to be defined as a folder of instructions, skills, and tools, tested locally, and deployed via CLI. It addresses production concerns like caller identity, user/agent-scoped credentials with mid-task authentication pauses, channel-aware memory access control, versioned context in Context Hub, and Harbor evals traced to LangSmith experiments. New in 0.8 are HTTP channels, user-scoped memory, Slack file transfers, and built-in search powered by Parallel.

All LangChain trails
  1. What is a Skill?This post defines an AI 'skill' as a self-contained unit comprising instructions, scripts, and reference documentation for a specific task. It explains how agents leverage skills to manage their context window by loading only the relevant skill's name and description at startup, and then opening the full skill when needed. This approach conserves tokens and improves agent speed by keeping the active context small.
  2. Three Questions Every Agent Engineer Should Be Able To AnswerThis talk introduces a framework for agent engineers to "own their own intelligence" by answering three critical questions: where is the agent failing, how can failures be reliably reproduced, and what needs to be done to fix them. It details techniques for mining production traces using fine-tuned judges for scalable monitoring, creating "world specs" and tasks that mimic production environments (using LangChain's GTM agent as an example), and implementing fixes at both the harness and model layers. The emphasis is on leveraging application-specific insights from real-world usage to improve agent reliability, especially as models and user interactions evolve.
  3. Managed Deep Agents | Deploying mission critical agents to productionThis post introduces Managed Deep Agents, a production-ready deployment solution for Deep Agents. It bundles the Deep Agents harness with managed LangSmith infrastructure, allowing agents to be defined as a folder of instructions, skills, and tools. Key production-ready features highlighted include: caller identity management across Slack and web, user and agent-scoped credentials with pause-for-authentication capabilities, channel-aware memory access control, versioned context in Context Hub, and Harbor evals integrated with LangSmith experiments. The 0.8 release adds HTTP channels, user-scoped memory, Slack file transfers, and Parallel-powered search.
  4. What is an agent skill? How to protect your agent's context window.This post elaborates on the concept of 'skills' within LangChain's Deep Agents harness. Skills are introduced as a mechanism to manage agent complexity and protect the context window. Each skill is a self-contained folder with instructions, scripts, references, and assets for a specific task. At startup, only the skill's name and description are loaded, preventing the system prompt from becoming overly verbose. The agent dynamically selects and loads the appropriate skill only when a task requires it, and the context associated with that skill is discarded upon task completion. This approach aims to prevent agents from getting stuck due to excessive information crammed into the context window.
  5. Building Engine v2: How LangChain approaches agent improvementThis talk introduces Engine v2, an evolution of LangChain's agent engineering framework. Engine v2 introduces capabilities for detecting cross-trace metric trends and inefficient agent paths, moving beyond single-trace analysis. It also adds validated fixes, which reproduce bugs and test their resolutions, and red teaming for pre-release agent testing. The talk highlights the importance of per-task benchmarks for complex agents and discusses the trade-offs of using smaller models for simpler tasks. It also previews Engine v3 plans, including BYOIP support for self-hosted Engine and the ability to propose cheaper models based on evals.
  7. What is Deep Agents? An open source harness for long-running agents.This post introduces Deep Agents as LangChain's open-source harness for building complex, long-running AI agents. It highlights the harness's role in providing context management, tools, memory, subagents, sandboxes, and human-in-the-loop (HITL) controls. Specific features discussed include sandboxing for untrusted code execution, HITL and authorization checks for gating sensitive actions, and a swappable filesystem architecture that allows agents to run across diverse environments (laptop, sandbox, cloud) without code changes. The post emphasizes that the harness is critical for an agent's ability to complete long and complex tasks.
  8. How to Build a Model Router in the HarnessThis post details the implementation of a model router within LangChain's Open SWE coding agent harness. The router dynamically selects models based on task mix, identified through LangSmith traces, aiming to optimize cost-performance. The implementation involved mapping task types, selecting models along a Pareto frontier, building the router logic within the harness (including swapping a classifier to Jev for faster tier tasks), and tracking outcomes via evals or A/B tests. An A/B test demonstrated a 64% reduction in median cost per thread with no measurable quality degradation. Future work includes benchmarks, subagent integration, and mid-thread rerouting.
  9. Add Web Search to Managed Deep Agents for free with One MCP ConfigThis post demonstrates how to integrate web search capabilities into Managed Deep Agents using a single MCP configuration, leveraging LangSmith's built-in search powered by Parallel. It shows how to add the search server to an agent, test its functionality with a research question, deploy it to LangSmith, and inspect the tool calls within LangSmith Studio. The contribution also highlights the importance of guardrails for agents with web search access.
  10. How Zip Uses LangSmith and LangGraph to Ship New Features FasterThis post details how Zip's procurement platform leveraged LangGraph and LangSmith to significantly accelerate their AI feature development. Previously, their in-house LLM orchestration and tracing pipeline was slow and lacked necessary detail, taking weeks to add new features. By adopting LangGraph and LangSmith, Zip gained automatic, detailed tracing of node interactions and LLM calls without custom code. This led to faster iteration cycles, adoption by other teams, and the establishment of an evaluation setup to prevent regressions. The post highlights the benefits of using these tools over building custom solutions, emphasizing improved developer velocity and system robustness.
  11. Skills are just fancy prompts. Here's why that matters.This post clarifies that 'skills' in Deep Agents are essentially shareable, loadable prompts. It introduces the 'progressive disclosure' pattern, where agents fetch skills on demand rather than keeping them in constant context, thereby keeping the agent's prompt clean. This mechanism allows for more efficient management and utilization of agent capabilities.
  12. Interrupt NYC: Opening KeynoteThis talk announces Managed Deep Agents, an evolution of the Deep Agents harness, introducing authentication primitives, user-level memory, and integrated web search. It also details the LangSmith platform's enhancements: the LangSmith LLM Gateway for routing model calls through decision models like Jev, LangSmith Trajectories for faster agent debugging, LangSmith Fine-Tuning with the smithtune CLI for optimizing trajectories into models, and LangSmith Custom Apps for building UIs on LangSmith data. LangSmith Engine v2 is introduced with advanced red teaming capabilities and automated self-testing of fixes, building upon its extensive trace analysis.
  13. What Is Human in the Loop?This post explains the 'human in the loop' design pattern for AI agents, where an agent pauses to await human approval before executing its next action. It emphasizes that the best production agents use this pattern deliberately for high-stakes actions, allowing agents to handle routine work while humans oversee critical decisions. The core idea is to build systems where humans and agents intelligently divide labor, rather than aiming for full autonomy immediately.
  14. Build, Test, Deploy, Monitor: The Agent Development Lifecycle ExplainedThis post details the four phases of the agent development lifecycle: build, test, deploy, and monitor. It highlights how frameworks like Deep Agents facilitate the 'build' phase, while tools like LangSmith are crucial for 'test' (using real inputs and expected outputs), 'deploy' (into production), and 'monitor' (with tracing and evaluations). The contribution is a structured explanation of the end-to-end process for developing and improving AI agents.
  15. HTTP Channels for Managed Deep AgentsThis post details how to build a custom HTTP channel for a Managed Deep Agent, enabling it to receive inbound requests from external services like HubSpot, Salesforce, or texting providers. It demonstrates this with an expense-reporting agent (Reflex) that processes receipt photos received via iMessage through Photon. Key technical contributions include: implementing verify and parse functions for incoming data, managing thread IDs per user for stateful interactions, utilizing a post hook for sending replies, and integrating with LangSmith for trace checking and Context Hub for durable memory. The post also discusses hashing phone numbers into durable user IDs and provides guidance on when to opt for HTTP channels versus custom UIs on the LangGraph SDK.
  16. This Is Why Your Main Agent Shouldn't Read Every TraceThis post argues against a monolithic main agent processing all trace data. Instead, it proposes a hierarchical agentic approach where specialized sub-agents (screener and verifier) pre-process and filter trace information before it's presented to the main agent. This strategy aims to improve efficiency, reduce cognitive load on the main agent, and enable more focused investigation of agent behavior. The core technical contribution is the architectural pattern of delegating trace analysis to dedicated sub-agents within an agent harness.
  17. Evaluating Agents in Production: Traces, LLM-as-Judge, and Prompt Management at WonderThis post details how Wonder leverages LangSmith traces, LLM-as-judge evaluators, and automated prompt management to enhance their generative AI application's development and debugging lifecycle. Key contributions include: transitioning from manual log debugging to LangSmith traces for better visibility, implementing LLM-as-judge for evaluating agent responses, automating prompt management to reduce feedback loop times from hours to minutes, and enabling a full-stack bug-fixing workflow where a coding agent can read LangSmith traces, identify code issues, and resolve them autonomously. The post also highlights the empowerment of non-engineers in managing prompts.
  18. We Built a Slack-to-GitHub PR Agent in a Few Lines of CodeThis post demonstrates the ease of building a functional agent for creating GitHub Pull Requests from Slack messages using LangChain's Managed Deep Agents. It highlights the ability to integrate various tools (Slack, GitHub MCP, code sandbox) with minimal code, showcasing the power of the Deep Agents harness for rapid agent development and deployment. The agent performs actions like reading GitHub, running code in a sandbox, and opening PRs, all triggered by a single Slack command.
  19. What are Deep Agents? Explained fastThis post introduces Deep Agents as a LangChain harness for building complex agents. It highlights the harness's features for managing agent context, integrating file systems, skills, subagents, and summarization. It also details built-in security features like sandboxing for untrusted code, human-in-the-loop gating for sensitive actions, and authorization checks. The swappable architecture is emphasized as a core benefit, enabling consistent agent execution across diverse environments.
  20. How Lyft Increased Its Agent Resolution Rate by 16% with LangSmith and LangGraphThis post details how Lyft leveraged LangGraph and LangSmith to rebuild their customer support agent stack. They moved from brittle, single-call agents to a meta-agent architecture using LangGraph nodes. This allowed PMs and ops to deploy new agents via prompt and config changes, drastically reducing build time from six months to one to two weeks. LangSmith provided crucial observability through tracing and evaluations, transforming the agent system from a black box to a visible and improvable one, ultimately leading to a 16% increase in resolution rate.
  21. How Do I Get Started Building Agents?This post provides a practical starting point for building AI agents, highlighting two primary methods: Deep Agents for developers comfortable with code, and Agent Builder for a no-code approach. It emphasizes the integration of these agents into LangSmith for testing, deployment, and monitoring, regardless of the underlying framework or model used. The core contribution is guiding users on how to begin agent development and leverage LangSmith for operationalizing them.
  22. What is an agent harness? Explained fastThis post defines an agent harness as the component that enables a model to perceive, act, persist information, and enforce boundaries. It highlights four key pieces of a harness: a file system for offloading data, subagents for isolating and parallelizing work, and skills that models load on demand. The post emphasizes that without a harness, models can exceed context windows and lose track of their tasks. It introduces Deep Agents as LangChain's opinionated harness that includes file system, subagents, and memory integration, allowing for swappable backends and easy addition of new capabilities.