If you’ve been following the AI agent space, you know the tooling gap has been painful. Building agents is one thing. Running them in production—with observability, governance, and the ability to actually fix what breaks—has been another story entirely. LangChain just dropped a massive slate of announcements at Interrupt 2026 that directly addresses this gap, and it’s worth unpacking.
This isn’t incremental feature polish. They shipped infrastructure that would take most teams quarters to build internally, along with some genuinely novel approaches to the agent development lifecycle. Let’s break down what matters.
LangSmith Engine: Autonomous Agent Improvement
Here’s the pitch: instead of manually reading traces, hunting for failure patterns, writing evals, and crafting fixes, LangSmith Engine does that loop for you. It watches production traces, clusters failures into named issues, diagnoses root causes against your actual code, and proposes fixes.
For each issue it surfaces, Engine can open a PR with a targeted code or prompt fix, create a custom online evaluator scoped to that exact problem (so regressions get caught automatically), and add failing traces to your offline eval suite as ground truth examples.
This is significant because the manual loop of “read traces, find patterns, write evals, fix code” is exactly where agent development stalls. Teams ship an agent, it hits production, edge cases emerge, and then someone has to spend hours triaging. Engine automates the triage-to-fix pipeline.
Whether the autonomous fixes are good enough to merge without heavy review remains to be seen in practice. But even as a triage and proposal system, this cuts significant time from the improvement cycle.
SmithDB: A Database Built for Agent Traces
Agent observability has a data problem. Traces have exploded in volume and complexity—deeply nested spans, long-running operations, events arriving in pieces over hours. Traditional databases weren’t designed for these query patterns: random access, interactive filtering, full-text search, JSON filtering, tree-aware queries, thread reconstruction, and aggregations all at once.
SmithDB is LangChain’s answer—a Rust-based database built on Apache DataFusion and Vortex, with object storage for durable trace data. The architecture is stateless for ingestion, query, and compaction services, which makes it portable and easier to scale.
The performance claims are notable: up to 15x faster on core LangSmith experiences, with P50 trace tree loads at 92ms and P50 single run loads at 71ms. More importantly for enterprise adoption, the object-storage-backed, stateless design makes it far easier to run in self-hosted and multi-cloud environments than traditional database clusters.
This is infrastructure work that most companies wouldn’t undertake—building a purpose-specific database is a multi-year commitment. Having it available as part of the LangSmith stack removes a major scaling concern.
Managed Deep Agents: Hosted Runtime for Complex Agents
Deep Agents is LangChain’s open-source harness for agents that plan, use tools, delegate to subagents, write files, and work over longer timelines. Managed Deep Agents gives developers an API-first hosted runtime for creating, running, and operating these agents in LangSmith.
Key features include durable threads, streaming runs, checkpointing, and human-in-the-loop workflows for long-running tasks. There’s support for agent context files (AGENTS.md, skills/, subagents/, tools.json), sandbox-backed execution for code and shell commands, and a Context Hub for retaining memory and preferences across runs.
This matters because standing up your own agent server—with durable execution, persistent context, tool access, and sandboxed code execution—is a significant infrastructure lift. Most teams end up building bespoke solutions or running agents in ways that don’t survive failures gracefully. A managed runtime with these features out of the box changes the build-vs-buy calculation considerably.
Sandboxes Generally Available: Secure Code Execution at Scale
LangSmith Sandboxes are now generally available, providing secure code execution environments for agents. Each sandbox runs in a hardware-virtualized microVM, isolated from your services and from other sandboxes—critical for agents running model-generated code, external dependencies, or user-provided scripts.
The GA release includes several practical features. Snapshots and cheap forks let you capture a sandbox state or build from a Docker image, then fork parallel sandboxes using copy-on-write. Blueprints define refreshable base environments so new sandboxes start with fresh dependencies and warmed caches. Idle sandboxes pause automatically to avoid paying for unused resources.
The Auth Proxy feature is particularly interesting for security-conscious deployments: it injects credentials at the network layer so secrets don’t enter the runtime, with support for custom secret resolution, audit hooks, and domain allowlists.
For anyone who’s tried to build secure, isolated code execution for agents, this addresses a non-trivial security surface. Having it integrated with the rest of the LangSmith stack, with proper audit logging and credential isolation, is a meaningful step forward.
Context Hub: Managing What Shapes Agent Behavior
Context Hub provides a central place to manage the files that shape agent behavior—AGENTS.md files, skills, policies, examples, and other context bundles agents read and follow.
The insight here is that context is managed differently than harness code. It changes quickly as teams refine instructions, update examples, and learn what works. It’s also shaped by people across the organization: designers, marketers, support leads, product managers, compliance teams. Forcing all of this through GitHub doesn’t fit the workflow.
Context Hub brings versioning, tags (for dev/staging/prod environments), and comments for collaboration directly into LangSmith. This lets teams treat context as a first-class part of their agent system without requiring everyone who touches it to use git.
LLM Gateway: Runtime Governance for Agents
LangSmith LLM Gateway sits between your agents and LLM providers, enforcing spend limits and detecting sensitive data before requests leave your environment. Policy events flow directly into LangSmith alongside the traces that triggered them—no separate dashboards or audit pipelines to stand up.
The beta includes hard spend caps at the organization, workspace, user, and API key level (returning a 402 when hit), real-time spend visibility, PII and secrets detection with redaction on both requests and responses, and full audit logging.
Setup is a base_url swap—point your agents at the gateway endpoint with your LangSmith API key, configure policies in the UI, and you’re done. This is the kind of governance layer that enterprises need before deploying agents at scale, and having it integrated rather than bolted on addresses a real adoption blocker.
Fleet Expansions: Prebuilt Agents and Free Model Usage
LangSmith Fleet got several upgrades. Sandbox access is now in public beta, giving Fleet agents a secure place to write and run code—data analysis, file generation, coding tasks, and more.
The prebuilt agent templates expanded to five: a coding agent built on Open SWE, a GTM agent for sales and marketing, an X content manager, an executive assistant, and a competitive researcher. Each includes an onboarding flow that customizes the agent to your context.
Perhaps most significantly, Developer and Plus plans now include free model usage with inference powered by Fireworks. Lowering the barrier to actually try these agents should accelerate adoption and feedback.
Deep Agents 0.6: Performance at Scale
The v0.6 release adds a lightweight code interpreter for programmatic tool calling (REPL), typed streaming for agent UIs, and DeltaChannel for more efficient checkpoint storage.
The code interpreter lets agents compose tools, manage intermediate state, and decide what returns to model context—reducing avoidable model round trips. DeltaChannel stores diffs instead of full state snapshots, keeping long-running agents more efficient.
Frontend streaming support now includes integrations for React, Vue, Svelte, and Angular, making it easier to build responsive agent UIs.
LangChain Labs: Continual Learning Research
LangChain Labs is an applied research effort focused on continual learning for agents, with partners including Harvey, NVIDIA, Prime Intellect, Fireworks, and Baseten.
The research agenda includes mining large-scale agent data for eval generation and harness engineering, finding efficient agent configurations across cost/latency/performance tradeoffs, building evaluation and simulation environments, and reducing the manual work required to move agents between model families.
This is longer-term work, but it signals LangChain’s commitment to solving the harder problems in agent development—not just building tools, but understanding how to systematically improve agents from their own operational data.
What This Means for Teams Building Agents
Taken together, these announcements represent a maturing of the agent infrastructure stack. The theme is reducing the gap between “I built an agent that works in my notebook” and “I’m running agents in production with confidence.”
LangSmith Engine automates the improvement loop. SmithDB handles observability at scale. Managed Deep Agents and Sandboxes provide production-ready runtimes. LLM Gateway adds governance. Context Hub enables cross-functional collaboration on agent behavior.
For teams evaluating whether to build or buy agent infrastructure, this changes the math. The scope of what LangChain now offers would take years to build internally. Whether that translates to adoption depends on pricing, reliability, and how well these pieces integrate in practice—but the capability gap between rolling your own and using LangSmith just widened significantly.
If you’re building agents for production use, this stack is worth evaluating seriously.