LangChain
AI-assisted summary of The Agent Development Lifecycle: Build, Test, Deploy, Monitor | Interrupt 26 — original source. Check the original for full context.
Source published:
Key ideas
- LangChain introduced SmithDB, an in-house Rust database built on Apache DataFusion and Vortex to handle massive agent trace payloads that have surged from a 364 KB P99 to 12 MB, speeding up query workloads by 6x to 15x. (27:55)
- LangSmith Engine launched into public beta as an ambient background agent that clusters trace failures, generates GitHub pull requests, writes evaluation test cases, and updates prompts in Context Hub. (40:54)
- Deep Agents 0.6 brings native support for open-weights models like DeepSeek, Nemotron, and GLM-5, adds a QuickJS-powered CodeInterpreter runtime, and introduces standard client streaming protocols. (8:56)
- LangChain launched Managed Deep Agents in private preview, pairing the Deep Agents harness with hosted LangSmith Deployments, Context Hub memory, and LangSmith Sandboxes with sub-second cold starts. (21:33)
Detailed notes
## Background Published by LangChain on YouTube on May 19, 2026, this video features the opening keynote from Interrupt 26, LangChain's annual agent conference. In the presentation, co-founders Harrison Chase (CEO) and Ankush Gola (CTO) walk through the Agent Development Lifecycle (ADLC)—the operational framework teams use to build, test, deploy, and monitor production AI agents—while unveiling a suite of major product launches across the platform.
## TL;DR Chase and Gola argue that building agents requires abandoning traditional software development assumptions due to infinite input spaces and non-deterministic model behaviors. To address these demands across the Agent Development Lifecycle, LangChain introduces Deep Agents 0.6, QuickJS-powered CodeInterpreter, general availability for LangSmith Sandboxes, Context Hub, an LLM Gateway, and a private preview of Managed Deep Agents. On the data infrastructure side, Gola announces SmithDB, a purpose-built, Rust-based trace database engineered to handle massive multimodal trace volumes up to 15x faster. Finally, Chase reveals LangSmith Engine, an ambient background agent that autonomously clusters trace failures, generates regression test cases, and proposes pull requests to close the production iteration loop.
## Atmosphere & style The presentation balances high-energy conference keynote showmanship with rigorous, deep-dive systems engineering. Harrison Chase brings an affable, pragmatic presence to the stage—frequently cracking self-deprecating jokes about naming conventions and poking fun at the audience's selective applause—while Ankush Gola shifts the tempo into intense technical clarity with charts and systems diagrams illustrating real-world data bottlenecks. The arc progresses naturally from foundational software philosophy to concrete infrastructure reveals, leaving viewers with the urgent, invigorating sense that AI agent development is rapidly maturing from experimental hacking into robust enterprise engineering.
## Bulletin - [27:55](https://www.youtube.com/watch?v=jWy39wavbjY&t=1675s) LangChain introduced SmithDB, an in-house Rust database built on Apache DataFusion and Vortex to handle massive agent trace payloads that have surged from a 364 KB P99 to 12 MB, speeding up query workloads by 6x to 15x. - [40:54](https://www.youtube.com/watch?v=jWy39wavbjY&t=2454s) LangSmith Engine launched into public beta as an ambient background agent that clusters trace failures, generates GitHub pull requests, writes evaluation test cases, and updates prompts in Context Hub. - [08:56](https://www.youtube.com/watch?v=jWy39wavbjY&t=536s) Deep Agents 0.6 brings native support for open-weights models like DeepSeek, Nemotron, and GLM-5, adds a QuickJS-powered CodeInterpreter runtime, and introduces standard client streaming protocols. - [21:33](https://www.youtube.com/watch?v=jWy39wavbjY&t=1293s) LangChain launched Managed Deep Agents in private preview, pairing the Deep Agents harness with hosted LangSmith Deployments, Context Hub memory, and LangSmith Sandboxes with sub-second cold starts.
## Key takeaways - [02:00](https://www.youtube.com/watch?v=jWy39wavbjY&t=120s) Building agents differs fundamentally from traditional software engineering due to unbounded natural language input spaces and non-deterministic, prompt-sensitive model outputs. - [03:53](https://www.youtube.com/watch?v=jWy39wavbjY&t=233s) Teams successfully shipping production agents rely on the Agent Development Lifecycle (ADLC), shipping early to production and closing tight loops between evaluation, monitoring, and prompt iteration. - [06:34](https://www.youtube.com/watch?v=jWy39wavbjY&t=394s) Modern agent harnesses require foundational modules beyond basic tool-calling loops, including environment execution, context management, human steering, and multi-agent delegation. - [08:56](https://www.youtube.com/watch?v=jWy39wavbjY&t=536s) Deep Agents 0.6 adds a QuickJS-powered CodeInterpreter runtime to provide a safe, lightweight intermediate execution tier between full virtual sandboxes and mock file systems. - [12:40](https://www.youtube.com/watch?v=jWy39wavbjY&t=760s) Evaluating non-deterministic agents requires moving away from traditional unit tests toward dataset-driven hill-climbing benchmarks using LLM-as-a-judge rubrics and regression suites. - [13:37](https://www.youtube.com/watch?v=jWy39wavbjY&t=817s) LangSmith Sandboxes reached General Availability, providing sub-second cold starts, persistent state snapshots, and an external auth proxy that injects credentials to prevent secret exfiltration. - [16:07](https://www.youtube.com/watch?v=jWy39wavbjY&t=967s) LangSmith Context Hub establishes centralized versioning for markdown files, tool skills, and agent wikis, partnering with Redis, Elastic, MongoDB, and Pinecone to define an open memory standard. - [18:42](https://www.youtube.com/watch?v=jWy39wavbjY&t=1122s) The LangSmith LLM Gateway entered public beta to give enterprise fleets spend tracking, budget caps, PII scrubbing, and secret leak detection before routing requests to upstream model providers. - [21:33](https://www.youtube.com/watch?v=jWy39wavbjY&t=1293s) Managed Deep Agents provides a turnkey hosted API combining deep agent harnesses, model routing, sandbox isolation, and Context Hub memory without infrastructure management. - [23:36](https://www.youtube.com/watch?v=jWy39wavbjY&t=1416s) Traditional APM and logging infrastructure breaks down under agent workloads due to deeply nested execution trees, multimodal data, and payloads reaching up to 12 MB at the 99th percentile. - [29:38](https://www.youtube.com/watch?v=jWy39wavbjY&t=1778s) SmithDB leverages an object-storage-backed architecture separating compute and storage, utilizing sticky routing, PostgreSQL metadata catalogs, and compaction services for high-throughput scans. - [34:26](https://www.youtube.com/watch?v=jWy39wavbjY&t=2066s) SmithDB is implemented in Rust on top of Apache DataFusion and the Vortex columnar format, buffering leading-edge data in memory and SSD to deliver 6x to 15x query performance gains. - [34:26](https://www.youtube.com/watch?v=jWy39wavbjY&t=2066s) As agents increasingly act as automated consumers of tracing platforms to inspect their own execution history, latency in observability tooling becomes an Amdahl's law bottleneck. - [38:50](https://www.youtube.com/watch?v=jWy39wavbjY&t=2330s) Step-level trace observability has become table stakes, while triaging hundreds of execution steps and avoiding regression cycles remains the core bottleneck in agent development. - [40:54](https://www.youtube.com/watch?v=jWy39wavbjY&t=2454s) LangSmith Engine solves the triage bottleneck by acting as an ambient agent that monitors traces, identifies root failure causes, and automatically generates PRs and evaluation benchmarks.
## Detailed walkthrough ### [00:03](https://www.youtube.com/watch?v=jWy39wavbjY&t=3s) Opening Intro and Welcome to Interrupt 26
The conference opens with a cinematic video reflecting on the nature of artificial intelligence, questioning what intelligence even is if it lacks the capacity to act: “Intelligence. They call it intelligence. But if it can't act, what does it do?” The video traces how builders move intelligence from passive waiting into active execution by equipping it with tools, skills, and a harness with memory. In this formulation, memory provides context, context turns into plans, and plans lead to actions. Yet action alone remains incomplete without continuous improvement—demanding observation, measurement, rapid iteration, testing, evaluation, deployment, and fixing under pressure until an agentic system is truly running reliably in production.
Harrison Chase, co-founder and CEO of LangChain, takes the stage with a laugh, admitting he had not seen the dramatic intro video beforehand: “I did not know that video was going to be made, so yeah, it was great though.” He welcomes the audience to the second edition of Interrupt, noting that because of the overwhelming excitement and packed schedule, LangChain expanded the event into a two-day conference. Reflecting on the prior year's inaugural gathering, Chase recalls how the central theme had been the sheer difficulty of taking agents beyond initial prototypes into production environments. Over the intervening year, however, leading teams have navigated those roadblocks and found ways to ship production agents.
[02:00](https://www.youtube.com/watch?v=jWy39wavbjY&t=120s) Why Building Agents Is Fundamentally Different from Traditional Software
Chase explains that bringing agents into production remains inherently difficult because building agentic systems differs fundamentally from building traditional software. That divergence is precisely why developers cannot rely strictly on old paradigms and instead need new tools, new organizational skills, and fresh mental models. At the heart of this difference lie two massive, compounding challenges: an unbounded input space and a highly unstable output space.
The input side is vast because agents consume natural language, which is effectively infinite in dimensionality. Requests are no longer structured payloads; they arrive as open-ended text of arbitrary length and phrasing, and are increasingly accompanied by multimodal assets like images, video clips, and audio files. On the other end, the output space is equally challenging because large language models are inherently non-deterministic. Even when models appear deterministic, they remain extraordinarily sensitive to slight wording adjustments in a prompt. When an expansive input space collides with a non-robust, prompt-sensitive engine, predicting system performance prior to real-world deployment becomes nearly impossible.
As Chase highlights, successful organizations embrace this unpredictability by changing how they operate:
> “And the teams that have figured out how to build agents reliably, they ship early and then they iterate quickly.”
[03:53](https://www.youtube.com/watch?v=jWy39wavbjY&t=233s) The Agent Development Lifecycle (ADLC)
Through their rapid release cycles, production teams organically converge on a new operational framework: the Agent Development Lifecycle (ADLC). Running parallel to the traditional Software Development Lifecycle (SDLC), the ADLC is tailored specifically for the iterative, uncertain dynamics of agent systems, where evaluation and continuous feedback loops dictate success at every step. Chase stresses that mastering this lifecycle—whether an organization formally calls it by that name or not—is the defining trait of companies that successfully ship agents to production.
LangChain views its entire product strategy and ecosystem through the lens of supporting and accelerating every phase of this lifecycle. Chase notes that the company's objective is to understand what the next generation of agents will look like and build the infrastructure required to make them production-grade. The keynote is framed around breaking down this lifecycle step by step, beginning with the build phase and unveiling new tooling designed to compress development iteration cycles.
```mermaid flowchart TD accTitle: The Agent Development Lifecycle Iteration Loop accDescr: Flow diagram showing the contrast between traditional SDLC and the iterative Agent Development Lifecycle driven by open input spaces and non-deterministic LLM behavior.
subgraph Challenges["Core Agent Dynamics"] In["Infinite Input Space<br>(Natural language, audio, video)"] Out["Non-Deterministic Output<br>(Prompt sensitivity & variance)"] end
subgraph ADLC["Agent Development Lifecycle"] Build["1. Build<br>(Harness, tools, environment)"] Deploy["2. Ship Early<br>(Real user exposure)"] Monitor["3. Observe & Evaluate<br>(Traces, metrics, steering)"] Iterate["4. Fast Iteration<br>(Prompt tweaks, context updates)"] end
In --> Build Out --> Build Build --> Deploy Deploy --> Monitor Monitor --> Iterate Iterate --> Build ```
[04:57](https://www.youtube.com/watch?v=jWy39wavbjY&t=297s) The Evolution of LangChain: From AgentExecutor to Deep Agents
Tracing LangChain's roots, Chase looks back to the build stage where the project originated in late 2022, roughly a month before ChatGPT debuted. He shares a personal anecdote from the early days when he was naming early abstractions over the Thanksgiving holiday:
> “Fun fact, we had a class called Agent in LangChain before ChatGPT launched. I remember it. I was on, I think, I was in San Diego for Thanksgiving and was just trying to decide what to call it. And I ended up calling it agent-executor instead of agent. So, you know, we're not great at naming and that's maybe the first example of that.”
As developers moved beyond linear chains to build more sophisticated, cyclical applications, LangChain introduced LangGraph to manage complex stateful graphs. That progression continued through LangChain 1.0 and led to the launch of Deep Agents roughly nine months prior to Interrupt 26. Chase argues that while the underlying agent primitive has always been simple—an LLM running inside a loop calling tools until it decides the task is finished—Deep Agents represents the modern paradigm of an "agent harness," supercharging that core loop with production-ready capabilities.
[06:34](https://www.youtube.com/watch?v=jWy39wavbjY&t=394s) Anatomy of an Agent Harness
Chase defines Deep Agents as an all-inclusive agent harness that equips the core model-tool loop with the foundational infrastructure required for long-horizon execution. Rather than leaving developers to assemble ad-hoc infrastructure, the harness supplies pre-built modules for environment interaction, memory handling, human oversight, and subagent orchestration:
- **Execution Environment:** Agents require a concrete runtime. At one extreme, this means running in code sandboxes equipped with file systems and terminals to inspect files, edit code, and execute shell commands. At the other extreme, Deep Agents provides a virtual file system—a lightweight database exposed to the LLM as if it were a directory structure, playing to the model's natural aptitude for file manipulation. - **Context Management:** Built-in strategies prevent context windows from overflowing and optimize latency and cost. This includes automatic summarization for short-term conversation history, context offloading to handle massive tool call responses without blowing up context limits, and prompt caching to make repeated invocations faster and cheaper. - **Steering and Human-in-the-Loop:** Even though long-horizon deep agents can operate autonomously for extended periods, human intervention remains mandatory. Deep Agents includes native steering controls so human supervisors can inspect, pause, guide, or redirect agents mid-execution. - **Delegation and Subagents:** The harness provides structured mechanisms to coordinate hierarchies of specialized agents, whether delegating to an upfront planning agent or delegating subtasks to domain-specific worker agents and collecting their results.
Chase notes that LangChain invests heavily in applied AI research to optimize each harness capability—from identifying the most effective summarization routines to refining multi-agent delegation architectures.
[08:56](https://www.youtube.com/watch?v=jWy39wavbjY&t=536s) Introducing Deep Agents 0.6: Open Models and QuickJS CodeInterpreter
Chase announces the launch of Deep Agents 0.6, designed around three prevailing industry trends. The first trend is the rapid rise and viability of open source models alongside the escalating usage and financial costs of frontier proprietary models. Citing the recent launch of DeepSeek-V4, Chase highlights that open models are matching frontier capabilities on specific tasks. To make Deep Agents 0.6 the premiere framework for open source models, LangChain is introducing native support for GLM-5, DeepSeek, and Nemotron models, backed by tight integrations with inference partners including Fireworks AI, Baseten, and NVIDIA. Alongside this, LangChain is releasing Deep Agents Code, an open-source reference implementation of a complete coding agent powered by open weights.
The second trend centers on the execution environment spectrum. While sandboxes allow full code execution and virtual file systems offer lightweight mock storage, developers often need a balanced middle tier:
> “And then on the other extreme, we have a full-blown code sandbox where the agent can write and execute code, spin up a web server, any of that. And so this is a spectrum. But what sits in the middle? And so in Deep Agents 0.6, we're launching CodeInterpreter.”
The new CodeInterpreter is powered by QuickJS, an embedded JavaScript engine that provides agents with a lightweight, REPL-like runtime. While it deliberately restricts host-level capabilities like spinning up Docker containers, it gives agents a safe, fast, and programmable environment to invoke tools programmatically, transform complex data sets, and process files without the overhead of heavy sandbox virtualization.
[11:08](https://www.youtube.com/watch?v=jWy39wavbjY&t=668s) Lightweight Sandboxes and Deep Agents 0.6 Streaming Protocol
Harrison Chase explains that being able to read and write directly from the file system presents a compelling middle ground for agent architectures. Instead of spinning up an isolated virtual sandbox for every single agent run, developers get a lightweight, multi-tenant execution model that retains the core advantages of code-driven behavior without the heavy operational overhead.
Moving from execution to the user experience, Chase notes that building delightful user interfaces remains one of the hardest and most neglected challenges in productionizing agents. As agent architectures grow sophisticated, the variety of real-time events they emit expands exponentially: raw text tokens, discrete tool calls, multimodal image outputs, chain-of-thought reasoning steps, and delegated sub-agent invocations. To streamline connecting these complex event streams to front-end interfaces, LangChain is introducing advanced streaming support in Deep Agents 0.6. This release includes a dedicated streaming protocol, front-end SDKs across four core client languages, and pre-built integrations with modern UI frameworks such as CopilotKit, Assistant UI, and Vercel.
Chase makes an emphatic appeal for developers to adopt these emerging agent harnesses:
> “So if you haven't already tried out deep agents, please go try it out today. This is where we think the future is heading.”
[12:40](https://www.youtube.com/watch?v=jWy39wavbjY&t=760s) Testing and the Shift from Software QA to Evaluations
Transitioning from the build stage to the test stage, Chase outlines why evaluating non-deterministic agents requires fundamentally different infrastructure than traditional software testing. Rather than asserting fixed boolean checks, developers must construct comprehensive evaluation datasets containing reference inputs, golden reference outputs, and qualitative grading rubrics.
Teams must define tailored evaluation metrics—such as factual correctness, hallucinations, or domain-specific rubrics—and execute agents against these datasets to create benchmarked experiments. These experiments serve as continuous hill-climbing targets to iterate on prompts and architectures while ensuring safety against regressions. Chase highlights that LangSmith evaluations have been engineered over the past two years specifically to anchor this testing workflow, teasing additional evaluation announcements later in the keynote before shifting to the deploy stage.
[13:37](https://www.youtube.com/watch?v=jWy39wavbjY&t=817s) Deploying at Scale and the GA Launch of LangSmith Sandboxes
Moving an agent from local testing to high-scale production introduces critical infrastructural friction: managing per-user environment variables, isolating memory states, enforcing strict authentication boundaries, and handling durable execution when long-running runs encounter failures. Over the past year, LangSmith deployments addressed these challenges across more than 30 dedicated API endpoints designed for streaming, human-in-the-loop workflows, and auth, already powering over 100 million agent executions at enterprise companies including Workday, Cisco, Etsy, Podium, and ByteDance.
```mermaid flowchart LR accTitle: LangSmith Sandbox Auth Proxy Flow accDescr: An agent executes code in a sandbox through an external auth proxy that injects secrets before reaching external APIs.
subgraph UserEnv["User Execution Space"] Agent["Agent Harness"] Sandbox["LangSmith Sandbox<br/>(Snapshots, Forks, Ephemeral)"] end
subgraph SecurityLayer["Security Boundary"] AuthProxy["LangSmith Auth Proxy<br/>(External Secret Injection)"] end
ExternalAPI["External API / Service"]
Agent --> Sandbox Sandbox -->|"Outbound Request (No Secrets)"| AuthProxy AuthProxy -->|"Injected API Key / Token"| ExternalAPI ```
However, serving endpoints alone is insufficient; modern agents frequently need to generate code, analyze data tables, or execute shell commands inside secure execution sandboxes. Chase officially announces the General Availability (GA) of LangSmith Sandboxes, which provide:
- Sub-second cold starts for rapid agent spin-up. - Cross-interaction persistence with native snapshot and fork capabilities. - An external authentication proxy that intercepts outbound network traffic to inject sensitive API credentials, preventing prompt injection attacks from exfiltrating runtime secrets. - Complete framework independence via the LangSmith SDK, making it compatible with Deep Agents, third-party frameworks, reinforcement learning (RL) training loops, or raw production workloads (as demonstrated by Monday.com's AI assistant, Sidekick).
[16:07](https://www.youtube.com/watch?v=jWy39wavbjY&t=967s) LangSmith Context Hub and Open Standards for Memory
Context delivery has transformed alongside model capabilities. While developers once relied on LangSmith Prompt Hub to store version-controlled prompt strings, context architectures have graduated toward structured `agent.md` documentation files, external tool skills, and dynamic "LLM wikis"—a pattern popularized by Andrej Karpathy where LLMs continuously compress external knowledge into interconnected markdown archives.
Chase introduces the LangSmith Context Hub, providing central repository versioning, tagging, and commenting for files like `agent.md`, skill directories, and LLM wikis. Developers can pull these contextual assets straight to local terminals, inject them through virtual file systems into Deep Agents, or integrate them into custom frameworks. Framing context as the initial iteration of agent memory, Chase insists that memory must remain entirely open rather than proprietary:
> “We think memory should not be locked in to an LLM, to a framework, or to a platform.”
To prevent enterprise vendor lock-in, LangChain is actively collaborating with database and infrastructure providers—specifically Redis, Elastic, MongoDB, and Pinecone—to turn context definitions into an open, industry-wide agent memory specification.
[18:42](https://www.youtube.com/watch?v=jWy39wavbjY&t=1122s) Production Observability and the LangSmith LLM Gateway
Closing the development cycle is the monitor phase. LangSmith Observability provides step-level tracing of every model call, input, and output, supplemented by analytics dashboards to monitor latency and API token cost trajectories. It also supports continuous online evaluations—employing LLM-as-a-judge scorers or deterministic code assertions alongside direct end-user feedback loops.
Chase explains that while ad-hoc observability suffices when running a single prototype, scaling out to tens or hundreds of distinct agents across an enterprise requires strict governance around two acute failure modes: runaway API spend and unauthorized enterprise data exposure.
```mermaid flowchart TD accTitle: LangSmith LLM Gateway Architecture accDescr: Agents route LLM calls through the LangSmith LLM Gateway to enforce spend limits and guardrails before hitting upstream models.
subgraph AgentsFleet["Enterprise Agents Fleet"] A1["Agent 1"] A2["Agent 2"] AN["Agent N"] end
subgraph Gateway["LangSmith LLM Gateway (Beta)"] SpendCtrl["Spend Tracking & Hard Limits"] DataGuard["Data Exposure Guardrails"] end
subgraph LLMProviders["Upstream Providers"] OpenAI["OpenAI"] Anthropic["Anthropic"] CustomModel["Private Endpoints"] end
A1 --> Gateway A2 --> Gateway AN --> Gateway Gateway --> SpendCtrl SpendCtrl --> DataGuard DataGuard --> OpenAI DataGuard --> Anthropic DataGuard --> CustomModel ```
To solve this, Chase announces the public beta launch of the LangSmith LLM Gateway. When audience applause falters momentarily, Chase quips from the stage:
> “You guys can't just pick and choose which announcements you clap for. You've got to applaud for all of them. They're all great.”
Positioned as an inline proxy between executing agent applications and underlying foundation models, the gateway grants organizations centralized visibility over aggregate token usage, programmatic enforcement of per-user or per-agent budget limits to eliminate surprise billing, and dynamic guardrails to constrain sensitive enterprise data exposure.
[20:40](https://www.youtube.com/watch?v=jWy39wavbjY&t=1240s) The LLM Gateway and Completing the Agent Development Lifecycle
Building production-ready agents requires navigating a complex pipeline that touches model security, coding harnesses, model access, and tracing. Harrison Chase finishes detailing the newly announced LangSmith LLM Gateway, highlighting built-in protections against data leakage by helping with PII and secret detection. Because coding agents have emerged as the single most popular agent archetype—and represent where teams incur the vast majority of their compute and token bills—LangChain has prioritized native integrations between the gateway and widespread coding agent frameworks. The gateway connects to all LLM providers accessible through LangChain, automatically streaming every transaction as an execution trace into LangSmith.
Stepping back, Chase reflects on the overarching Agent Development Lifecycle (ADLC). Everything LangChain develops is intended to fit systematically into this lifecycle, yet taking an agent from prototype to a fully maintained production deployment still demands stitching together multiple disparate systems. “Taking an agent and going to production and going through this lifecycle involves a bunch of different pieces,” Chase explains. To eliminate that operational friction and bridge the underlying agent harness with deployment infrastructure, LangChain aims to package these tools into a unified, developer-friendly interface.
- **Security & Inspection:** LangSmith LLM Gateway integrates automated PII and secret detection out of the box. - **Ecosystem Compatibility:** Native integrations for external coding agents and any LLM provider accessible via LangChain. - **Automatic Tracing:** Transparent capture of inputs, outputs, latencies, and metadata directly into LangSmith.
---
[21:33](https://www.youtube.com/watch?v=jWy39wavbjY&t=1293s) Managed Deep Agents in Private Preview
To turn the disparate stages of building, running, and managing an agent into a single consumable endpoint, Harrison Chase announces Managed Deep Agents, entering private preview to enthusiastic applause. Managed Deep Agents wraps the deep agents agent harness into a turnkey API hosted on LangSmith Deployments. The service abstracts model selection, providing immediate access to proprietary frontier models from OpenAI and Anthropic, alongside high-performance open-source model providers like Fireworks and Base10.
Agent instructions, evolving system prompts, and working memory are stored and tracked centrally in LangSmith Context Hub. This architecture guarantees that whenever developers, end-users, or recursive agent loops update behavioral guidance, changes are versioned, inspectable, and auditable over time. Execution is strictly decoupled from tool computation: the agent engine runs on isolated deployment infrastructure, while code writing and execution take place within secure, independent LangSmith Sandboxes. Tools connect either via custom Model Context Protocol (MCP) servers or through ecosystem partners like Arcade. Everything streams back using LangChain's new standardized streaming protocol, allowing frontend teams to plug results cleanly into interfaces built with CopilotKit or Assistant UI.
```mermaid flowchart TD accTitle: Architecture of Managed Deep Agents accDescr: Diagram showing how Managed Deep Agents integrates models, memory, execution sandboxes, and client interfaces through a unified API.
subgraph Client["Client Tier"] UI["Frontend Applications<br/>(CopilotKit, Assistant UI)"] end
subgraph API["Managed Deep Agents API"] Harness["Deep Agents Harness<br/>(LangSmith Deployments)"] end
subgraph Context["Instructions & Memory"] CH["LangSmith Context Hub<br/>(Prompts, Memory, Versioning)"] end
subgraph Execution["Execution & Tools"] SB["LangSmith Sandboxes<br/>(Secure Code Execution)"] Tools["MCP Tool Servers<br/>(Direct or Arcade)"] end
subgraph Models["Model Routing"] LLMs["Proprietary & Open Source<br/>(OpenAI, Anthropic, Fireworks, Base10)"] end
UI <-->|"Streaming Protocol"| Harness Harness <--> CH Harness <--> LLMs Harness -->|"Write & Execute"| SB Harness <-->|"Tool Access"| Tools ```
- **Unified Surface:** A single API combining execution, memory, model access, and sandbox orchestration. - **Infrastructure Separation:** Agents run inside LangSmith Deployments while untrusted tool execution is isolated in LangSmith Sandboxes. - **Standardized Streaming:** Compatible with UI frameworks such as CopilotKit and Assistant UI for real-time frontend integration.
---
[23:36](https://www.youtube.com/watch?v=jWy39wavbjY&t=1416s) Ankush Gola on Why Agent Traces Break Traditional Infrastructure
Chase hands the stage over to LangChain co-founder and CTO Ankush Gola, noting that while the entire company obsesses over traces, Gola has spent the better part of a year analyzing how to build the ultimate trace platform. Walking out to upbeat music, Gola reiterates that traces are not just passive telemetry; they represent the structural backbone of the entire agent loop. “Each agent trace captures the unique behavioral record of what your agent actually did at a specific point in time,” Gola asserts. However, observing complex, autonomous agents introduces data infrastructure challenges that conventional logging systems cannot solve.
Traditional logging platforms assume shallow, discrete events with small string payloads. In contrast, modern agent executions are deeply nested, sprawling state trees containing thousands or tens of thousands of intermediate sub-steps. Payloads are effectively unbounded because autonomous agents run across longer time horizons while model context windows continue to expand dramatically. Additionally, agent execution has rapidly evolved beyond raw text into rich multimodal formats, with audio becoming especially dominant in production voice agents for customer support. Mining these multi-turn, multimodal traces for actionable debugging insights requires complex query patterns that push legacy databases past their architectural limits.
---
[25:58](https://www.youtube.com/watch?v=jWy39wavbjY&t=1558s) Exploding Trace Volumes and Massive Payloads
Illustrating the velocity of this data shift, Gola displays real-world telemetry from an enterprise LangSmith customer. In the early proof-of-concept and evaluation stages, trace volumes appear negligible. But once agents graduate into production—and companies spin up secondary, specialized fleets of autonomous workers—ingestion spikes vertically, surpassing 150 million weekly traces for a single organization.
The scale problem is intensified by the exploding size of individual payloads. In just two years, the median (P50) trace payload size delivered to LangSmith surged from 6 kilobytes to 37 kilobytes. The 99th percentile (P99) underwent a massive escalation, expanding from an already substantial 364 kilobytes to 12 megabytes per trace. Highlighting the extreme edge cases that LangChain's ingestion pipeline now absorbs, Gola reveals: “Earlier this year, we had a single customer send us 50 terabytes of trace data on a single day.”
To demonstrate what these traces look like in the real world, Gola presents a screen capture of a live LangSmith trace generated by an internal LangChain go-to-market agent built on Deep Agents. The visual interface shows a dense, deeply nested tree reflecting complex reasoning loops, tool interactions, and error corrections, culminating in an execution that encoded 8.1 million tokens in a single end-to-end trace. Gola emphasizes that running agent observability workloads on suboptimal, legacy data infrastructure leads directly to crushing query latencies, ingestion bottlenecks, and spiraling compute bills, paralyzing engineering teams who cannot afford sluggish iteration loops while debugging agent failures.
- **Customer Ingestion Scale:** Production customer volume exceeding 150,000,000 weekly traces. - **P50 Payload Growth:** Increased from 6 KB to 37 KB. - **P99 Payload Growth:** Ballooned from 364 KB to 12 MB. - **Peak Single-Day Customer Volume:** 50 TB of trace data ingested in 24 hours from one enterprise tenant. - **Internal GTM Agent Trace:** Encoded 8.1 million tokens within a single nested execution graph.
---
[27:55](https://www.youtube.com/watch?v=jWy39wavbjY&t=1675s) Announcing SmithDB: A Purpose-Built Observability Database
Recognizing that generic relational, column-oriented, or document databases fail when subjected to nested, multimodal, multi-megabyte traces, Gola announces the official launch of SmithDB. SmithDB is an in-house database engineered from scratch by LangChain specifically for agent observability workloads, built and refined over months of intense internal development and live production testing.
A product video underlines the core thesis behind the engine: agent traces represent thinking, decision-making, and intermediate tool execution across deep hierarchies, semantic meaning, and full-text context. Traditional infrastructure chokes on these payloads, degrading query speeds precisely when engineering teams need rapid feedback. “SmithDB is the database we purpose built for agent observability workloads,” Gola declares, noting that the database enables instant full-trace searching, semantic querying across complete conversational histories, and low-latency exploration of nested step hierarchies at immense scale.
---
[29:38](https://www.youtube.com/watch?v=jWy39wavbjY&t=1778s) The Architecture and Access Patterns of SmithDB
Gola dives into the underlying systems design of SmithDB, explaining why the team chose an object-storage-backed architecture. Relying on cloud object storage grants SmithDB three core architectural advantages: near-infinite, highly cost-effective storage capacity; a strict separation of compute and storage that allows services to scale up and down elastically without fragile data reshuffling or sharding; and a straightforward deployment footprint for enterprise self-hosted installations bound by strict data residency laws.
```mermaid flowchart TD accTitle: High-Level Architecture of SmithDB accDescr: End-to-end data lifecycle in SmithDB showing cluster management, ingestion, object storage persistence, metadata registration, caching, compaction, and query scanning.
subgraph Management["Routing Tier"] CM["Cluster Manager<br/>(Load Balancing & Sticky Routing)"] end
subgraph Ingestion["Ingestion Pipeline"] IS["Ingestion Service<br/>(Batching & Buffering)"] Postgres[("PostgreSQL Metastore<br/>(File Catalog)")] end
subgraph Storage["Storage Tier"] S3[("Object Storage<br/>(S3 / GCS / Blob)")] Compact["Compaction Service<br/>(File Layout Optimization)"] end
subgraph Query["Query Pipeline"] QS["Query Engine<br/>(File Pruning & Scanning)"] Cache["Fast SSD & Memory Cache"] end
CM -->|"Sticky Assignments"| IS CM -->|"Sticky Assignments"| QS IS -->|"Batch Write"| S3 IS -->|"Register Files"| Postgres Postgres -.->|"Lookup Files"| QS S3 <--> Compact S3 -->|"Fetch Files"| QS Cache <-->|"Minimize Round Trips"| QS ```
The flow of data through SmithDB follows a carefully coordinated pipeline: 1. **Cluster Management & Sticky Routing:** The cluster manager balances incoming requests across servers while maintaining sticky routing assignments, which preserves hot caches and aggregates incoming events for batching. 2. **Durable Ingestion:** Raw trace events hit the ingestion service, are assembled into optimized batches, and are written durably into object storage. 3. **Metastore Registration:** Newly written files are cataloged within a PostgreSQL-backed metastore. 4. **Continuous Compaction:** A background compaction service systematically merges and re-shapes files to ensure optimal layout for subsequent analytical scans. 5. **Query Engine & Caching:** When a query arrives, the engine queries the metastore to prune irrelevant data, identifies the precise files needed, downloads them, and executes parallel scans. High-throughput NVMe SSD caching and memory tiers minimize expensive round trips to object storage.
Gola maps this architecture against three indispensable agent observability access patterns: - **Snappy Random Access:** Debugging an agent requires jumping directly into specific, isolated execution runs and expanding deep intermediate tool steps. “Agent observability isn't just about asking what happened across millions of traces; it's also about asking what happened in this one particular agent execution,” Gola emphasizes. - **Fast Full-Text Search:** Traces contain tens of megabytes of raw prompt text, code snippets, tool inputs, and reasoning logs. To deliver interactive, sub-second keyword and phrase searches across these volumes, LangChain designed a specialized inverted index structure optimized specifically for object storage layouts. - **High-Speed Filtering and Range Scans:** Engineers frequently isolate narrow operational slices by applying multi-dimensional filters across metadata, names, custom tags, run status, and latency distributions over custom time horizons. SmithDB's scanning engine executes these selective analytical scans nearly instantaneously.
[33:40](https://www.youtube.com/watch?v=jWy39wavbjY&t=2020s) SmithDB Performance Gains and Early Adopter Validation
Ankush Gola emphasizes the raw speed improvements that SmithDB delivers across core LangSmith tracing and observability workloads. Compared to LangSmith’s legacy data infrastructure, query and tracing workloads now run anywhere from 6x to 15x faster. To show this is not merely an internal benchmark, Ankush highlights feedback from production teams at Clay and Vanta, two prominent early adopters whose developers rely heavily on tracing to debug complex automated workflows. Jeff from Clay and Andy from Vanta both reported that migrating to SmithDB fundamentally transformed their experience navigating and querying traces in the LangSmith UI.
- Tracing and observability workloads run between 6x and 15x faster on SmithDB compared to previous LangSmith storage engines. - Early adopters Clay (represented by Jeff) and Vanta (represented by Andy) validated these speedups on production trace data.
---
[34:26](https://www.youtube.com/watch?v=jWy39wavbjY&t=2066s) The Rust Architecture and Core Technical Challenges of SmithDB
Ankush dives into how SmithDB was built from the ground up as a purpose-built database tailored specifically for agent observability workloads. The entire engine is implemented in Rust on top of two key open-source technologies: Apache DataFusion, an extensible query engine, and Vortex, an extensible columnar file format that allows LangSmith to define custom encodings and chunking strategies per column. LangSmith layered heavy customizations on top of this foundation, including specialized indexing for full-text search, proprietary query planners, execution plans, and custom on-disk storage layouts.
```mermaid flowchart TD accTitle: Architecture and Ingestion Pipeline of SmithDB accDescr: Diagram illustrating SmithDB's query engine, ingestion buffering, and tiered storage model.
subgraph CoreEngine ["SmithDB Foundation (Rust)"] DF["Apache DataFusion (Query Engine)"] VTX["Vortex (Custom Column Encodings & Chunking)"] Custom["Custom Full-Text Indexing & Query Plans"] end
subgraph DataIngestion ["Ingestion & Leading-Edge Serving"] Ingest["Distributed Agent Spans"] --> Buffer["Ingestion Service Buffer (Memory & SSD)"] Buffer -->|"Durable Flush"| ObjStore[("Object Storage")] end
subgraph QueryExecution ["Query Resolution"] Query["Top-K / Time-Window Query"] Buffer -.->|"Immediate low-latency reads"| Query ObjStore -.->|"Pruned file scans"| Query end ```
Building a trace database specifically for agents introduced unique engineering hurdles that conventional time-series and APM databases do not handle cleanly. First, agent spans are inherently distributed and arrive in fragmented pieces because agents operate over long time horizons; a start event might be logged hours before an end event arrives, requiring efficient merging at both compaction and query time. Second, LangSmith UI workloads are heavily dominated by top-K queries featuring `ORDER BY` and `LIMIT` clauses. Running naive scans across raw files in object storage is prohibitively slow and expensive, so the team designed custom time-window execution plans. Third, observability demands near-instant access to the leading edge of data; SmithDB buffers incoming records in memory and local SSDs within the ingestion service even after durably flushing to object storage, preventing the query engine from having to fetch numerous tiny files from object storage.
Crucially, Ankush points out that performance is no longer just about satisfying human engineers waiting on a dashboard. “Increasingly, agents are not just the thing that are being observed by LangSmith, they are also the users of LangSmith,” Ankush explains. When automated agents query LangSmith to inspect their own tool histories or fetch context, sluggish infrastructure becomes an existential bottleneck. Ankush references Jeff Dean's observation that as agentic systems scale to operate orders of magnitude faster than humans, any latency in underlying tooling compounds into an Amdahl’s law bottleneck. As of Interrupt 26, SmithDB is actively serving production observability workloads across all US Cloud traffic on smith.langchain.com, with rollout to the remaining UI, self-hosted environments, and global cloud regions following shortly.
- Built on Rust, Apache DataFusion (query execution), and Vortex (extensible columnar file format). - Distributed span tracking handles agent runtimes where start and end events can be separated by hours. - Top-K queries (`ORDER BY... LIMIT`) bypass full object storage fan-outs via custom time-window execution planning. - Leading-edge queries read directly from memory and SSD buffers in the ingestion tier, eliminating object storage round trips for recent events. - Powers the tracing projects page across all US Cloud traffic on LangSmith today, with global cloud and self-hosted support upcoming.
---
[38:50](https://www.youtube.com/watch?v=jWy39wavbjY&t=2330s) The Hard Realities of the Agent Iteration Flywheel
Harrison Chase returns to the stage, praising Ankush and the systems team for doing the heavy infrastructure lifting while he gets the "fun and easy job" of presenting. Harrison argues that while tracing and database speed are foundational, passive observability has become table stakes. Being able to inspect individual steps of an agent execution is necessary, but it does not solve the hardest part of software engineering with LLMs: turning raw traces into reliable production improvements.
Harrison walks through the compounding friction points developers face every day when trying to iterate on agents. First, identifying problematic executions out of tens of thousands or millions of production traces is like searching for a needle in a haystack. Second, once an engineer locates a bad run, understanding the root failure is grueling because modern agent traces are hundreds of steps long, requiring painstaking review to spot where a tool call diverged or an LLM hallucinated. Third, resolving the issue is ambiguous—engineers must guess whether to tweak system prompts, modify deterministic control code, or rewrite tool schemas. Finally, avoiding regressions feels like an endless game of whack-a-mole: “You fix one thing, and then you change the prompt, and it reappears.”
- Observability and step-by-step trace visibility provide essential diagnostic data but are merely table stakes. - Finding specific failure modes across millions of long, branching traces is too slow for manual review. - Troubleshooting remains plagued by uncertainty over whether prompts, deterministic code, or tool definitions need revision. - Prompt adjustments frequently trigger unexpected regressions across previously working edge cases.
---
[40:54](https://www.youtube.com/watch?v=jWy39wavbjY&t=2454s) Launching LangSmith Engine: An Ambient Agent for the Tracing Flywheel
Harrison asks the audience what engineers naturally do when faced with repetitive, painful, and critical tasks they do not want to execute manually: “You build an agent to help you with them, of course.” To tackle the iteration bottleneck, LangChain is launching LangSmith Engine, an ambient, proactive, action-taking agent embedded directly within LangSmith.
LangSmith Engine runs persistently in the background on top of an organization's trace streams. It inspects trace traffic on a regular schedule, clusters anomalies, detects emerging failure modes, assigns severity priorities, and backs every insight with concrete trace evidence. Rather than merely alerting on errors, Engine proactively suggests actionable resolutions. Connected across the developer’s stack, it can propose GitHub pull requests for code changes, generate targeted test cases for LangSmith evaluation datasets, propose refined prompt updates in LangSmith Context Hub or Prompt Hub, and configure online evaluators to prevent recurring regressions. Harrison notes that pilot startups testing the system over recent weeks experienced massive drops in time-to-detection and time-to-triage. The keynote then plays a product video demonstrating Engine analyzing traces, summarizing root causes, and outputting ready-to-merge fixes.
- LangSmith Engine launches into public beta as an ambient, autonomous background agent. - Continuously parses trace data on a schedule to discover issues, prioritize severity, and cite specific trace IDs as proof. - Automatically generates suggested code modifications via GitHub repository integration. - Curates failing production inputs into regression datasets and generates new online evaluation rules. - Integrates directly with Prompt Hub and Context Hub to recommend targeted prompt adjustments.
---
[43:46](https://www.youtube.com/watch?v=jWy39wavbjY&t=2626s) Building the Complete Platform for the Agent Development Lifecycle
Harrison steps back to summarize LangChain's broader mission across the Agent Development Lifecycle (ADLC). Over the past several years, the company developed individual applications and infrastructure modules—from LangChain and LangGraph for building, to Prompt Hub and evaluation tools for testing, to sandboxes and deployment runtimes, to LangSmith for monitoring. With the dual launch of SmithDB as the foundational data layer and LangSmith Engine as the autonomous intelligence layer driving iteration, the pieces connect into a unified lifecycle platform.
Harrison closes the opening keynote by framing LangChain not just as an infrastructure vendor, but as a long-term partner to the developer community navigating this new paradigm of software development. He invites the audience to immediately open their laptops, log into LangSmith, and test the LangSmith Engine public beta. Harrison expresses his gratitude for the energy at Interrupt 26, encouraging attendees to use the two-day conference as an opportunity to pause their daily routines, connect with fellow builders, and exchange practical lessons across the rapidly maturing agent ecosystem.
## Notable quotes > [02:00](https://www.youtube.com/watch?v=jWy39wavbjY&t=120s) The teams that have figured out how to build agents reliably, they ship early and then they iterate quickly. — Harrison Chase
> [16:07](https://www.youtube.com/watch?v=jWy39wavbjY&t=967s) We think memory should not be locked in to an LLM, to a framework, or to a platform. — Harrison Chase
> [29:38](https://www.youtube.com/watch?v=jWy39wavbjY&t=1778s) Agent observability isn't just about asking what happened across millions of traces; it's also about asking what happened in this one particular agent execution — Ankush Gola
## Mentioned Harrison Chase, Ankush Gola, LangChain, LangGraph, Deep Agents, Deep Agents 0.6, Deep Agents Code, LangSmith, LangSmith Sandboxes, LangSmith Context Hub, LangSmith LLM Gateway, Managed Deep Agents, SmithDB, LangSmith Engine, Prompt Hub, QuickJS, DeepSeek, Nemotron, GLM-5, Fireworks AI, Baseten, NVIDIA, OpenAI, Anthropic, CopilotKit, Assistant UI, Vercel, Arcade, Model Context Protocol, Andrej Karpathy, Jeff Dean, Redis, Elastic, MongoDB, Pinecone, Clay, Vanta, Apache DataFusion, Vortex, PostgreSQL, Workday, Cisco, Etsy, Podium, ByteDance, Monday.com, Sidekick, Interrupt 26
## Video description At the opening keynote from Interrupt 26, LangChain's annual agent conference. Harrison Chase (CEO & co-founder) and Ankush Gola (CTO & co-founder) walk through the Agent Development Lifecycle: the framework top teams use to build, test, deploy, and monitor AI agents in production, as well as a wave of new LangChain launches across every stage of that lifecycle.
More resources - The Agent Development Lifecycle Explained: https://www.langchain.com/blog/the-agent-development-lifecycle - SmithDB: https://www.langchain.com/blog/introducing-smithdb - LangSmith Engine: https://www.langchain.com/blog/introducing-langsmith-engine - Try LangSmith: https://smith.langchain.com - Deep Agents 0.6: https://www.langchain.com/blog/deep-agents-0-6 - LangSmith Sandboxes: https://www.langchain.com/blog/introducing-langsmith-sandboxes-secure-code-execution-for-agents - LangSmith Context Hub: https://www.langchain.com/blog/introducing-context-hub - Managed Deep Agents: https://www.langchain.com/blog/introducing-managed-deep-agents
0:00 Intro 1:27 Welcome from Harrison Chase, CEO of LangChain 2:00 Why building agents is different from building software 3:53 The Agent Development Lifecycle overview 4:57 LangChain, LangGraph & Deep Agents 6:34 What is Deep Agents? The Agent Harness explained 8:56 New: Deep Agents 0.6 14:48 New: LangSmith Sandboxes 16:07 New: LangSmith Context Hub 19:20 What is the Agent Development Lifecycle? 20:09 New: LangSmith LLM Gateway 21:33 New: Managed Deep Agents 23:36 Ankush Gola, CTO of LangChain 25:58 The payloads of agent traces are getting larger 27:55 New: SmithDB 29:38 The architecture of SmithDB 34:00 How Clay & Vanta use SmithDB 38:50 New: LangSmith Engine 43:50 Building the platform for the entire ADLC
[Source](https://www.youtube.com/watch?v=jWy39wavbjY)