Product Announcements for 2026 — LangChain's Platform
At Interrupt 2026, LangChain shipped a connected stack designed to take a deep agent from local prototype to production without stitching the runtime layer together yourself. Seven launches anchored the keynote and the product talks; this page breaks each one down — what it is, the details that matter, why it matters, and who it's for. The single best umbrella reference is LangChain's own recap, "Everything we shipped at Interrupt".
Source note: written from in-person session transcripts (Whisper
large-v3) and cross-checked against LangChain's official blog and docs. Status labels reflect what was announced at the event.
| # | Launch | What it is | Status |
|---|---|---|---|
| 1 | Deep Agents 0.6 | The open-source agent harness (model + execution env + context mgmt + steering + subagents) | Open source |
| 2 | Managed Deep Agents | API-first hosted runtime to create/run/operate deep agents in LangSmith | Launched (hosted) |
| 3 | LangSmith Sandboxes | Secure, microVM-isolated execution of untrusted agent code | Generally Available |
| 4 | LangSmith Context Hub | Version-controlled, portable store for the instructions/skills/policies agents follow | Launched |
| 5 | LangSmith LLM Gateway | Runtime governance — spend caps + PII redaction in front of every model call | Beta |
| 6 | SmithDB | A database purpose-built for agent observability (Rust, object storage) | Backs LangSmith Cloud |
| 7 | LangSmith Engine | Ambient agent that clusters trace failures and opens fix PRs | Public beta |
1. Deep Agents 0.6
The open-source library that turns "a model in a loop" into an agent harness.
What it is. A deep agent is a model plus a harness that adds batteries to the core loop. The harness gives the model four things: an execution environment (a spectrum from a virtual file system to a full code sandbox), context management (skills, memory, summarization, context offloading, prompt caching), human-in-the-loop steering, and delegation to subagents.
Key details.
- A new Code Interpreter built on QuickJS — a lightweight, multi-tenant middle ground between the virtual file system and a full sandbox.
- Native support for open-source models (GLM, DeepSeek, Nemotron) and inference-partner integrations (Fireworks, Baseten, NVIDIA).
- A new streaming protocol with front-end SDKs (CopilotKit, assistant-ui), plus a
deepagents-codeCLI for coding agents. - A recurring principle: memory and context standards should stay open — not locked into one model, framework, or platform.
Why it matters. It standardizes the unit of agent engineering. Instead of re-implementing sandboxes, memory, and steering per project, you adopt a portable, open harness — and stay model-agnostic as the frontier churns.
Who it's for. Agent builders and OSS developers who want a portable foundation rather than framework lock-in.
Status. Open source. Learn more: Day 1 Keynote · New in Deep Agents v0.6
2. Managed Deep Agents
The fastest path from a Deep Agents project to a running production agent — without operating the runtime yourself.
What it is. An API-first hosted runtime for creating, running, and operating deep agents inside LangSmith. You define agents using the familiar Deep Agents project structure, manage them programmatically through the /v1/deepagents API, and inspect every run in LangSmith.
Key details.
- Built on durable execution: each step is checkpointed, so a failure on step 49 of 50 resumes from step 49 rather than restarting the whole run.
- Middleware wraps the agent loop — custom business logic, policy enforcement (e.g. PII redaction), dynamic agent control, fault tolerance, context management, and toolsets.
- First-class Context Hub integration and safe in-process code execution.
Why it matters. The hard part of shipping agents isn't the prototype — it's the production runtime (multi-tenancy, durable state, policy, observability). Managed Deep Agents provides that layer as a service.
Who it's for. Teams that want to ship and operate production agents without building deployment infrastructure.
Status. Launched as a hosted runtime in LangSmith. Learn more: Introducing Managed Deep Agents (talk) · Blog · Docs
3. LangSmith Sandboxes
Secure execution of untrusted, model-generated code — now generally available.
What it is. Sandboxes where agents can write and run real code safely. Each sandbox runs as a hardware-virtualized microVM, fully kernel-isolated from your services and from other sandboxes — security that containers alone can't guarantee against supply-chain attacks or kernel exploits.
Key details.
- Sub-second spin-up (~1s) and the ability to run thousands in parallel without managing dedicated compute.
- GA primitives: Snapshots and cheap copy-on-write forks, Blueprints (pre-warmed environments), Service URLs, a Sandbox CLI, and an Auth Proxy that injects credentials so API keys stay hidden from the agent (a prompt-injection defense).
- Durable pause/resume with no hard time limit; bring-your-own Docker images; one-line SDK; full LangSmith tracing. Works with agents like Cursor, Claude Code, and OpenSWE.
Why it matters. Agents increasingly write and execute real code. Running that code in plain containers is "dangerously insufficient" for production — microVM isolation makes it safe at scale.
Who it's for. Anyone running code-writing, data-analysis, or computer-use agents in production.
Status. Generally Available. Learn more: Run Untrusted Agent Code (talk — Mukil Loganathan) · Sandboxes are GA (blog) · Docs
4. LangSmith Context Hub
Version control for the instructions, skills, and policies that define how your agents behave.
What it is. A place to store, version, and collaborate on the files that shape agent behavior — AGENTS.md files, skills, policies, examples, and other file bundles. Context (instructions, skills, policies) has an outsized impact on agent performance, and Context Hub gives teams version-controlled, environment-aware management of it.
Key details.
- Every change creates an immutable, browsable commit — inspect previous versions and roll back when needed.
- Tag versions with environments like dev / staging / prod and promote a commit so downstream agents pull the right, stable context.
- Skills are versioned repos that package a reusable capability — a persistent "briefing doc" an agent attaches for a specific task or domain.
- Designed as an open, portable standard — usable from any harness, not locked to LangChain.
Why it matters. As soon as instructions/policies live in code with no history, agent behavior becomes un-auditable. Context Hub treats prompts and skills like software: versioned, promotable, and reviewable.
Who it's for. Teams managing agent instructions, skills, and policies across environments at scale.
Status. Launched. Learn more: Day 1 Keynote · Introducing Context Hub (blog) · Docs
5. LangSmith LLM Gateway
Runtime governance built into the agent lifecycle — spend limits and PII protection in front of every model call.
What it is. A gateway that sits between your agents and model providers, enforcing policy at request time rather than just logging problems after the fact.
Key details.
- Hard spend caps at the organization, workspace, user, or API-key level; when a cap is hit the agent gets a clean 402 response, with real-time cost rollups by workspace/user/key.
- PII and secret redaction from both requests and responses before they reach the model or get written to a trace — the agent keeps running, sensitive data doesn't propagate.
- Policy violations surface as traceable events inside LangSmith, so you go from a blocked request to the triggering trace to a fix without switching tools. Setup is mostly swapping your
base_urlto the Gateway endpoint.
Why it matters. Cost overruns and data leakage are the two scariest failure modes of autonomous agents. The Gateway addresses both at the choke point every request already passes through.
Who it's for. Enterprises and regulated teams that need cost control and data-protection guarantees across providers.
Status. Beta. Learn more: Day 1 Keynote · Introducing LLM Gateway (blog)
6. SmithDB
The data layer purpose-built for agent observability — because agent traces broke traditional databases.
What it is. A database, written in Rust on the Apache DataFusion query engine and the Vortex file format (heavily customized), purpose-built for the trace and evaluation workloads behind LangSmith. It now backs core LangSmith Cloud experiences.
Key details.
- Object storage for durable trace data, a small Postgres metastore, and stateless ingestion/query/compaction services — scale by adding compute, with no local disks to manage.
- Makes core LangSmith experiences up to ~12× faster (the keynote cited 6–15× across workloads): roughly P50 92ms trace-tree loads, 400ms full-text search, 82ms run filtering.
- Supports random access on individual runs, full-text search, JSON key-path filtering, and trajectory queries — kept fast as volume grows.
- Built for the new reality of trace scale: 150M+ traces/week, payloads up ~6× in two years (P50 6KB→37KB, P99 364KB→12MB), one customer sending 50TB in a day, and a single internal trace encoding 8.1M tokens.
Why it matters. Modern agent traces — hundreds of nested spans, multimodal content, spans open for hours — are a workload general-purpose databases were never designed for. SmithDB is the infrastructure that keeps observability fast (and mostly invisible) at that scale.
Who it's for. Effectively everyone on LangSmith Cloud — it's transparent infrastructure that makes the platform faster.
Status. Backs LangSmith Cloud. Learn more: How We Built It (talk) · We built SmithDB (blog)
7. LangSmith Engine
An ambient agent that improves your agents — it reads traces, clusters failures, and opens fix PRs.
What it is. A proactive, action-taking agent that watches your production traces on a schedule, clusters recurring failures into named issues, diagnoses root causes against your source code, and drafts pull requests and evaluators for your review — replacing the manual cycle of reading traces, spotting patterns, and writing fixes.
Key details.
- Runs on a schedule (e.g. a periodic CRON), dispatching a parallel fix run per code-rooted issue.
- Proposes the full range of fixes: code changes, dataset additions, prompt/context changes, and online evals to stop regressions from returning.
- Opens PRs directly from issues, using your code to generate higher-quality fixes.
- Early customer reactions: Harmonic's Austin Berke said it surfaces emerging failure modes and "proactively suggests evals and code changes"; campfire's Nancy Jin said it "dramatically reduced our time-to-detection and time-to-triage."
Why it matters. It closes the loop from observability to action — an agent that improves agents, turning passive traces into reviewed, shippable fixes.
Who it's for. Teams operating agents in production who spend too much time hunting through traces.
Status. Public beta. Learn more: How We Built It (talk) · Introducing LangSmith Engine (blog) · Docs
How the launches fit together
The pieces form one pipeline. You build an agent with Deep Agents 0.6; it runs untrusted code in Sandboxes and pulls versioned instructions/skills from Context Hub; Managed Deep Agents hosts and operates it; the LLM Gateway governs spend and redacts PII on every call; SmithDB stores the resulting traces fast enough to query; and LangSmith Engine reads those traces to propose fixes — feeding improvements back into the agent. Build → run → govern → observe → improve.
For the full story, see the Conference Recap and every session in the Presentation Directory. The closing talk's materials (slides, annotated notes, evals skills) are available from Hamel Husain & Shreya Shankar's Return of the Data Scientist resources (free, email-gated).
Conference: May 13–14, 2026 · San Francisco