LangChain
Enterprise AI agent development will shift from software engineers to frontline domain specialists as managed execution harnesses and evaluation-driven feedback loops eliminate manual coding.
AI-assisted summary of The Future of AI Agents: What Will Interrupt 2027 Look Like? | Interrupt 26 — original source. Check the original for full context.
Source published:
Key ideas
- LangChain launched LangSmith Fleet, a managed natural language agent builder that allows non-technical domain specialists to create, govern, and deploy autonomous workflows directly into channels like Slack. (13:42)
- The company announced LangChain Labs, a dedicated internal research group focused on continuous agent learning across model, harness, and context layers using execution traces and evaluation suites as optimization gradients. (9:34)
- LangChain's internal Go-to-Market agent built in Fleet increased lead-to-qualified conversions by 240% while saving sales representatives an average of 40 hours per month. (17:45)
- Fleet launched with support for over 200 native integrations, an Arcade partnership unlocking 7,500 additional connections, and a free open-source model tier hosted in partnership with Fireworks AI. (14:42)
Detailed notes
## Background Published on YouTube by LangChain on May 21, 2026, this video captures the Day 2 opening keynote of the Interrupt 26 conference. Presenters Harrison Chase, Brace Sproul, and Caroline di Vittorio explore where autonomous AI agents are headed over the next year, announce the formation of LangChain Labs, and showcase new product updates and live demos for LangSmith Fleet.
## TL;DR Harrison Chase opens by imagining the agent landscape at Interrupt 2027, predicting a structural divergence between long-horizon and low-latency customer experience agents while examining sandboxes, open-source model parity, agent authentication, and continual learning across the context, harness, and model tiers. To formalize using evaluation suites and execution traces as optimization gradients, Chase announces LangChain Labs, a dedicated research team focused on trace-driven agent refinement. The keynote then shifts to workforce dynamics, arguing that non-technical domain practitioners are best positioned to author production agents. Brace Sproul and Caroline di Vittorio demonstrate LangSmith Fleet, revealing how internal LangChain employees built and deployed automated go-to-market and software engineering agents directly into Slack with built-in human-in-the-loop controls, before launching Fleet publicly with free open-source model support via Fireworks AI.
## Atmosphere & style The presentation strikes an engaging balance between visionary tech forecasting and grounded, self-deprecating realism. Harrison Chase sets a relaxed, communal tone with playful jokes about bad conference predictions and sunburns before shifting into rapid-fire, highly technical architectural breakdowns. Smooth handoffs between Chase, Sproul, and di Vittorio sustain an energetic rhythm, culminating in an enthusiastic live Slack demo that grounds theoretical agent ideas in concrete, everyday office workflows.
## Bulletin - [13:42](https://www.youtube.com/watch?v=R9K2574YEAg&t=822s) LangChain launched LangSmith Fleet, a managed natural language agent builder that allows non-technical domain specialists to create, govern, and deploy autonomous workflows directly into channels like Slack. - [09:34](https://www.youtube.com/watch?v=R9K2574YEAg&t=574s) The company announced LangChain Labs, a dedicated internal research group focused on continuous agent learning across model, harness, and context layers using execution traces and evaluation suites as optimization gradients. - [17:45](https://www.youtube.com/watch?v=R9K2574YEAg&t=1065s) LangChain's internal Go-to-Market agent built in Fleet increased lead-to-qualified conversions by 240% while saving sales representatives an average of 40 hours per month. - [14:42](https://www.youtube.com/watch?v=R9K2574YEAg&t=882s) Fleet launched with support for over 200 native integrations, an Arcade partnership unlocking 7,500 additional connections, and a free open-source model tier hosted in partnership with Fireworks AI.
## Key takeaways - [01:22](https://www.youtube.com/watch?v=R9K2574YEAg&t=82s) The AI agent landscape is splitting into two distinct categories: long-horizon agents focused on complex multi-step reasoning and customer experience agents constrained by low latency. - [02:42](https://www.youtube.com/watch?v=R9K2574YEAg&t=162s) Voice systems are shifting from modular speech-to-text and text-to-speech sandwich pipelines toward native speech-to-speech models, though control and steerability remain key production hurdles. - [03:58](https://www.youtube.com/watch?v=R9K2574YEAg&t=238s) Code execution sandboxes are becoming mandatory infrastructure for agents to perform deep research, data analysis, and ad-hoc task automation. - [04:47](https://www.youtube.com/watch?v=R9K2574YEAg&t=287s) Open-source and open-weights models are closing the performance gap with closed frontier models, offering cost sustainability for high token burn and enabling domain-specific fine-tuning on execution traces. - [06:01](https://www.youtube.com/watch?v=R9K2574YEAg&t=361s) Agent identity is bifurcating into two coexistence models: acting on behalf of an authenticated user via inherited permissions versus acting under a dedicated service account identity. - [07:26](https://www.youtube.com/watch?v=R9K2574YEAg&t=446s) Continual learning for agents operates across three distinct structural tiers: the base model layer, the execution harness layer, and the context layer. - [09:34](https://www.youtube.com/watch?v=R9K2574YEAg&t=574s) Evaluation suites and benchmarks serve as the functional equivalent of training gradients for refining agent harnesses and contexts without altering underlying model weights. - [11:18](https://www.youtube.com/watch?v=R9K2574YEAg&t=678s) Enterprises are transitioning from technical intermediaries to empowering non-technical domain practitioners to build and maintain their own production agents. - [12:39](https://www.youtube.com/watch?v=R9K2574YEAg&t=759s) LangChain's internal operational agents across recruiting, sales, marketing, and engineering were built entirely without code by the employees who use them. - [14:42](https://www.youtube.com/watch?v=R9K2574YEAg&t=882s) LangSmith Fleet provides modular agent building with built-in memory, human-in-the-loop approval gates, cost controls, and native Slack, email, and API deployment surfaces. - [20:26](https://www.youtube.com/watch?v=R9K2574YEAg&t=1226s) Pre-built agents in Fleet, such as Go-to-Market and Software Engineering agents, execute tasks asynchronously within isolated sandboxes and produce standard deliverables like pull requests. - [21:28](https://www.youtube.com/watch?v=R9K2574YEAg&t=1288s) Fleet is powered out of the box with an open-source model hosted by Fireworks AI, aligning product capabilities with the rise of open-source model infrastructure.
## Detailed walkthrough ### [00:06](https://www.youtube.com/watch?v=R9K2574YEAg&t=6s) Welcome & Shoutouts
Opening Day 2 of Interrupt 26, Harrison Chase welcomes the crowd, joking that it is the coolest tech conference he has ever attended while pointing out with self-deprecating humor that he had nothing to do with organizing it. Before diving into the presentation, he asks the audience for a round of applause to recognize the team working behind the scenes—specifically shouting out Jess, Julia, Jacob, and Brianna for making the event run smoothly.
[00:29](https://www.youtube.com/watch?v=R9K2574YEAg&t=29s) Setting the Stage: Imagining Interrupt 2027
Reflecting on the conference’s first day, Chase notes that Day 1 concentrated heavily on how production teams are successfully building and shipping agents right now. For Day 2, he shifts the focus from current best practices to the horizon ahead. Figuring out what future agents will look like is embedded directly in LangChain's mission and vision statement. To explore these questions, Chase frames the keynote around a thought experiment: imagining that everyone is sitting in the room one year later at Interrupt 2027, looking back at which speculative bets actually materialized.
Chase readily acknowledges the risk of forecasting emerging technology, cautioning: “And I'm going to be wrong in a lot of these. This is going to look really silly and really stupid.” Nevertheless, he emphasizes that walking through these predictions offers the clearest window into how LangChain perceives the underlying trajectories and structural shifts across the AI industry.
[01:22](https://www.youtube.com/watch?v=R9K2574YEAg&t=82s) Two Types of Agents: Long-Horizon vs. Customer Experience
Chase predicts that the architectural landscape is splitting as agents diverge into two fundamentally distinct classes with starkly different technical requirements. On one side are long-horizon agents designed to tackle complex knowledge work over minutes, hours, or even days. These systems lean heavily on code execution, multi-step planning, subagents, multi-agent coordination, and modular skills, using high-level goals and desired outcomes to expand the boundaries of how long they can run autonomously without human intervention.
On the other side of the spectrum are customer experience agents, where low latency is the defining constraint. These systems handle end-user interactions like customer support and sales, where preserving brand identity, tone, and real-time responsiveness is paramount. For these conversational agents, modalities like voice—and eventually video—take center stage. Chase highlights that while both archetypes share a common underlying infrastructure stack, their day-to-day requirements diverge significantly. A central engineering challenge over the coming year will be determining just how unified that shared foundation can remain versus how much specialized tooling each agent category will require.
[02:42](https://www.youtube.com/watch?v=R9K2574YEAg&t=162s) The Future of Voice Agents
Voice is slated to become a primary modality for customer-facing agents, prompting LangChain to ramp up its investments in voice infrastructure. Chase diagrams the conventional voice architecture used across production today, which he characterizes as a sandwich pattern: a user speaks, their audio passes into a speech-to-text (STT) model to create a text transcript, an agent processes and reasons over the text to generate an output, and that response is converted back into speech via a text-to-speech (TTS) engine.
```mermaid flowchart LR accTitle: Traditional Voice Pipeline Sandwich accDescr: Pipeline showing speech converted to text, passed to an agent, and converted back into speech. A["User Audio"] -->|"Speech-to-Text (STT)"| B["Transcript (Text)"] B --> C["Agent Reasoning (Text Space)"] C -->|"Text-to-Speech (TTS)"| D["Audio Output"] ```
While this sandwich pipeline remains the standard, Chase observes the rapid emergence of native speech-to-speech models, pointing out that OpenAI had released V2 of their native voice model roughly two weeks prior. However, when building mission-critical enterprise systems, teams still run into reliability limits with end-to-end audio models. Chase observes: “And while I would say the consensus today seems to be for applications where you really care about having control, they're not quite steerable enough yet, we do expect that to change.” Consequently, the major debate over the coming year will center on whether developers stick with modular pipelines, migrate to native voice-to-voice architectures, or build hybrid combinations of both.
[03:58](https://www.youtube.com/watch?v=R9K2574YEAg&t=238s) Why Every Agent Needs a Sandbox
Chase argues that every agent—especially those designed for long-horizon planning—will inevitably require a secure sandbox execution environment. In modern agentic architectures, coding extends far beyond traditional software engineering; it serves as a core engine for deep research, ad-hoc data analysis, web browsing automation, and programmatic image generation.
To illustrate why giving agents an execution environment is so transformative, Chase shares an insight from an attendee he spoke with on Day 1:
> “I was talking to someone yesterday who said that when they think about building agents for their marketing team, one of the ways that they think about it is they think about giving that marketing team a software engineer. What would that software engineer build? What apps would it build to make the marketing team's job easier? That's what giving an agent the ability to write and execute code is.”
Because executing arbitrary code is so central to expanding what agents can accomplish, LangChain officially launched its own sandbox product the day prior. Chase emphasizes that both agents and sandboxes remain in their earliest infancy, predicting that sandbox tooling and execution environments will become a dominant discussion topic across the industry over the next year.
[04:47](https://www.youtube.com/watch?v=R9K2574YEAg&t=287s) The Rise of Open-Source Models
Over the next twelve months, open-source and open-weights models are poised to see a massive surge in enterprise adoption. Benchmarking conducted by LangChain on complex agent frameworks shows that raw base open models—even prior to task-specific post-training—are already rapidly closing the capability gap with closed frontier models.
```mermaid flowchart TD accTitle: Drivers of Open Model Adoption accDescr: Three core forces driving the adoption of open models for AI agents. subgraph Drivers["Adoption Drivers for Open Models"] D1["Performance Parity<br/>(Approaching frontier closed models)"] D2["Cost Efficiency<br/>(Combating extreme token burn in coding agents)"] D3["Domain Post-Training<br/>(Fine-tuning on proprietary agent traces)"] end Drivers --> OpenAdoption["Surge in Enterprise Open Model Adoption"] ```
Chase identifies three primary drivers propelling this transition: - **Frontier parity:** Base open models perform near top closed models out of the box on agent benchmarks, making them viable replacements for complex agentic workflows. - **Cost reduction for heavy token usage:** Long-horizon and coding agents burn through millions of tokens at breakneck speed; open models provide a dramatically cheaper and sustainable economic alternative. - **Custom post-training on traces:** Organizations are accumulating massive repositories of agent run traces, and open models allow teams to use those execution logs for domain-specific fine-tuning and distillation.
[06:01](https://www.youtube.com/watch?v=R9K2574YEAg&t=361s) Agent Identity & Auth Patterns
As agents move beyond static Q&A systems to taking concrete real-world actions, determining agent identity and permissioning becomes a critical architectural challenge. Chase explains that two distinct authentication patterns have begun to take shape across the ecosystem:
| Identity Pattern | Mechanism & Credential Scope | Behavioral Impact | |:--- |:--- |:--- | | **Acting on Behalf of a User** | The agent inherits the individual user's OAuth/Slack credentials dynamically at runtime. | Two different colleagues (e.g., Chase vs. Julia) asking the exact same question will receive different answers based entirely on their personal internal access permissions. | | **Fixed Service Account Identity** | The agent operates under a permanent, dedicated credential set or service account independent of the caller. | Every user receives identical output visibility regardless of who triggers the run. Several SaaS vendors have even started allowing agents to register their own standalone software accounts. |
Chase anticipates that both authentication models will persist alongside each other rather than one wiping out the other. The real challenge for developers over the next year will be establishing crisp precision over which authentication pattern to employ for specific business tasks and ensuring end users clearly understand which identity context an agent is operating under when taking real-world actions.
[07:26](https://www.youtube.com/watch?v=R9K2574YEAg&t=446s) Continual Learning: Model, Harness & Context Layers
Chase identifies continual learning as one of the areas LangChain is most enthusiastic about exploring. Rather than looking solely at weights, he views continual learning as the systematic improvement of the broader agentic system over time, which operates across three distinct structural tiers:
```mermaid flowchart TD accTitle: The Three Layers of an Agentic System accDescr: Three structural layers—Model, Harness, and Context—that can be continuously improved over time. subgraph System["Three Layers of Continual Agent Learning"] L1["Context Layer<br/>(agent.md, skills, task guidelines)"] L2["Harness Layer<br/>(Execution code connecting model to environment: Deep Agents, Claude Code)"] L3["Model Layer<br/>(Base weights: Sonnet, GLM-4, GPT-4, Qwen 3.5)"] end L1 --> L2 L2 --> L3 ```
- **The Model Layer:** The underlying foundation model weights, such as Claude 3.5 Sonnet, GLM-4, GPT-4, or Qwen 3.5. - **The Harness Layer:** The deterministic scaffolding and execution code that surrounds the model and interfaces with the runtime environment (including Deep Agents, Claude Code, or Pi). - **The Context Layer:** The runtime guidance provided directly into the harness to steer behavior without editing system code, such as `agent.md` files, prompt instructions, and modular skills. As Chase points out, developers cannot modify Claude Code's internal code directly, but they can easily drop in an `agent.md` or provide dynamic skills to tune its behavior for specific tasks.
To demonstrate continual learning at the model layer, Chase cites recent research published by Ramp and Prime Intellect. By fine-tuning an open-source Qwen 3.5 model specifically for querying and analyzing Ramp sheets, they achieved exceptionally high task accuracy paired with ultra-low latency.
Continuous optimization is equally powerful at the harness layer. Chase points to the *MetaHarness* paper from researchers at MIT and Stanford, where an autonomous agent was tasked with recursively optimizing a coding harness evaluated against Terminal Bench 2. By leveraging environment execution feedback to let an agent rewrite and refine the scaffolding code—all while leaving the underlying model completely untouched—the automatically evolved harness ended up outperforming human-written harness baselines. Drawing on his own professional background in classical machine learning, Chase observes that the loops for harnessing execution traces, training data, and environment feedback to refine software systems mirror the fundamental feedback principles that have guided predictive ML for years.
[09:34](https://www.youtube.com/watch?v=R9K2574YEAg&t=574s) Evals as Gradients and the Launch of LangChain Labs
While model training relies on gradient descent to directly modify weights, Harrison Chase explains that refining agents at the harness or context level operates on a different, yet analogous mechanism. In these higher layers, rigorous evaluations serve as the essential forcing function. Running an agent through benchmarks like TerminalBench 2 produces structured feedback and execution traces that are routed back into the agentic system to guide iterative adjustments. In this paradigm, evaluation suites provide the functional equivalent of a training gradient, making traces and evals the primary bedrock of agent optimization.
LangChain tested this approach internally on TerminalBench 2. Without altering the underlying model's weights, the team modified only the agent harness, catapulting their system from outside the top thirty into the top five on the public leaderboard. Although leaderboards shift rapidly, the benchmark confirmed that continuous optimization at the harness level yields massive performance leaps. Convinced that organizations across the industry will need to operationalize continual learning across the model, harness, and context tiers, Harrison Chase announces the launch of LangChain Labs—a dedicated internal research group created to explore continual learning by leveraging the massive stores of execution traces and user feedback natively captured inside LangSmith.
```mermaid flowchart TD accTitle: Continual Learning Architecture in Agentic Systems accDescr: Feedback from evaluations acts as a synthetic gradient driving updates across the context, harness, and model layers.
subgraph EvaluationLoop ["Evaluation Feedback Loop"] Agent["Agent Run"] --> Evals["Evaluations & Benchmarks<br>(e.g., TerminalBench 2)"] Evals --> Feedback["Traces & Feedback Engine<br>(LangSmith)"] end
subgraph OptimizationLayers ["Optimization Layers"] Feedback -->|"Context Updates"| L1["Context Layer<br>(Memory & Prompts)"] Feedback -->|"Harness Refactoring"| L2["Harness Layer<br>(Scaffolding & Routing)"] Feedback -->|"Fine-Tuning / Gradients"| L3["Model Layer<br>(Weights)"] end
L1 -.-> Agent L2 -.-> Agent L3 -.-> Agent ```
- When discussing the mechanics of harness tuning, Harrison Chase noted: “When you're updating the agent in general, depending on the layer you're at, if you're working at the harness or context layer, it's not exactly gradient descents, but the evals that you write act as a forcing function.” - Reflecting on industry adoption, Harrison Chase asserted: “And so we think that more and more companies will be doing this type of continual learning, whether it's at the model layer, the harness layer, or the context layer, for their particular use cases.”
[11:18](https://www.youtube.com/watch?v=R9K2574YEAg&t=678s) Shifting from Feedback Providers to Agent Builders
Turning to workforce dynamics, Harrison Chase outlines a fundamental shift in how agents are authored and maintained inside modern enterprises. Today, improving an agent requires cross-functional participation: user experience researchers, domain specialists, customer support staff, product managers, and software engineers constantly provide feedback, refine prompts, and troubleshoot behaviors in company Slack channels. Domain specialists often possess the sharpest intuition about how an agent should behave, yet traditionally they have had to pass their critiques downstream to technical teams for implementation.
Harrison envisions an imminent future where subject-matter experts cut out the engineering intermediary and build production agents themselves. Rather than merely supplying critiques or fine-tuning instructions on behalf of developers, non-technical specialists will design, iterate, and deploy their own automated agents. LangChain has spent recent months treating its own staff as an experimental testbed for this model, empowering employees across varied operational departments to author autonomous workflows tailored to their daily duties.
- Emphasizing the operational transition for domain experts, Harrison Chase stated: “They're not just going to be giving feedback on them and handing that off to a separate team, they're actually going to be involved in building these agents.”
[12:39](https://www.youtube.com/watch?v=R9K2574YEAg&t=759s) Internal Agents and Three Lessons from Three Years of Building
Taking the stage with a quick joke asking if anyone else got sunburned the day before, Brace Sproul details how LangChain has already embedded autonomous agents across its internal business operations. The company's talent acquisition team sources candidates via an automated sourcing agent; sales reps leverage a go-to-market agent for outbound messaging and account research; marketing monitors industry developments through an "Intel bot"; and engineering teams triage and resolve software incidents using OpenSuite. These systems continuously operate behind the scenes, monitoring key data streams and piping operational updates straight into Slack.
Remarkably, every single one of these internal agents was conceptualized, built, and maintained by the specific LangChain employees who rely on them—without those employees writing a single line of code. They achieved this using LangSmith Fleet, LangChain's managed agent builder that enables natural language agent authoring. Drawing from three years of developing agentic systems, Brace distills their hard-earned operational insights down to three foundational maxims:
- Summarizing LangChain's core architectural philosophy, Brace Sproul argued: “Over the last three years of building agents, we've learned three main things.” - Expanding on the primary takeaway, Brace Sproul declared: “One, the best people to build the agents are the ones who actually do the job.” - The remaining two takeaways emphasize environment and scale: agents must live inside existing communication channels and software systems, and enterprise governance rapidly becomes a major bottleneck if not engineered from day one.
[14:42](https://www.youtube.com/watch?v=R9K2574YEAg&t=882s) LangSmith Fleet: Tools, Integrations, and Enterprise Governance
To enable non-technical operators to build effective tools, Fleet treats agents as modular assemblies of natural language instructions, distinct skills, integrated tools, and built-in memory that compounds in utility the more an agent is used. To bridge agents into existing enterprise workflows, Fleet provides over 200 native integrations alongside a flagship partnership with Arcade that unlocks an additional 7,500 integrations out of the box. For bespoke systems and proprietary datasets, Fleet fully supports the open Model Context Protocol (MCP). Agents deploy natively into day-to-day work surfaces such as Slack, Gmail, and Outlook, alongside a dedicated visual management UI and exposed Fleet APIs for developers embedding agents into production apps.
As adoption expands across an organization, governance tools become crucial. Fleet addresses credential and authentication friction by managing service connections per user and per agent, while native cost tracking and usage controls allow administrators to inspect expenditure and impose strict budget limits. To ensure safe execution with high-leverage tools, Human-in-the-Loop approval checkpoints are built directly into the core platform, with full execution observability flowing back into LangSmith traces. Furthermore, Fleet remains model-agnostic, built atop the open-source Deep Agents harness, and allows teams to download raw agent configurations directly into code at any time.
- Underscoring the importance of safety controls around powerful integrations, Brace Sproul explained: “Human in the Loop is also a first class feature in Fleet.” - On why domain practitioners are ideally suited to author agents, Brace Sproul pointed out: “And who best to codify that than the people actually doing the jobs?”
[17:45](https://www.youtube.com/watch?v=R9K2574YEAg&t=1065s) Live Demo: The Go-to-Market Agent in Action
Brace welcomes Caroline di Vittorio to conduct a live demonstration of LangChain’s internal Go-to-Market (GTM) agent built inside Fleet. Connected directly to Salesforce, BigQuery, Slack, and Gmail, the agent combines dedicated research subagents with a library of procedural skills designed to reliably analyze accounts, parse call recordings, and draft outbound correspondence. Instead of forcing reps into a standalone dashboard, the agent lives in Slack, activating whenever someone tags `@gtmagent`.
Caroline runs a live prompt asking for a status update and recommended next steps on the fictional "Pied Piper" account. The agent reviews past records, identifies the account as at-risk due to customer pushback around pricing, and suggests re-engaging account lead Jared via email. When Caroline instructs it to draft the message, Fleet's Human-in-the-Loop safeguard interrupts the workflow, displaying the draft for approval rather than sending it autonomously. Caroline reviews the copy, adjusts the capitalization of "LangGraph," and confirms the email is ready for dispatch.
- Highlighting the dramatic shift in team ownership, Caroline di Vittorio noted: “Originally, an engineer had built this agent directly in code.” - Demonstrating the long-term impact on revenue operations, Caroline di Vittorio added: “The go-to-market team, 84% of the go-to-market team uses it weekly.” - Internal deployment metrics demonstrate an increase in lead-to-qualified conversions of 240%, while saving sales reps an average of 40 hours per rep every month.
[20:26](https://www.youtube.com/watch?v=R9K2574YEAg&t=1226s) Pre-Built Fleet Agents: From GTM to Software Engineering
Following the live demonstration of the Go-to-Market agent, Caroline di Vittorio pauses as the audience breaks into applause, remarking on the reception before highlighting how LangChain makes these systems accessible to everyone. Rather than forcing teams to design complex autonomous architectures from scratch, many of the internal tools the LangChain team relies on every day are directly accessible as pre-packaged, pre-built agents inside LangSmith Fleet. In addition to the Go-to-Market agent featured in the keynote demo, Caroline spotlights their internal software engineering agent, designed to give engineering organizations full ownership over an autonomous teammate that plugs straight into their existing developer workflows.
Caroline explains that developers can interact with the software engineer agent directly where they already collaborate by tagging it in Slack. Once invoked, the agent carries out code modifications inside an isolated execution sandbox and automatically files a pull request ready for a human engineer to inspect and merge. Setting up these pre-built agents is intentionally lightweight: teams simply instantiate the agent, link it to their organization’s internal tools and services, and walk through a brief onboarding flow to supply the background context it needs to understand company-specific conventions. Caroline summarizes the streamlined setup process: “All you have to do to use it is create the agent, connect it to the tools that your organization uses, and then go through a short onboarding flow so it gets to know your company, and then you're good to go.”
```mermaid flowchart LR accTitle: Pre-Built Software Engineer Agent Workflow accDescr: Step-by-step flow showing how the Fleet software engineering agent is configured, triggered in Slack, executes in a sandbox, and submits a pull request. subgraph Setup["Setup & Configuration"] A["Create Agent in Fleet"] --> B["Connect Org Tools & Sandbox"] B --> C["Complete Onboarding Flow"] end subgraph Action["Execution & Delivery"] C --> D["Tag Agent in Slack"] D --> E["Write Code in Sandbox"] E --> F["Submit PR for Human Merge"] end ```
- **Pre-Built Agent Catalog**: Includes both the Go-to-Market agent demonstrated on stage and the internal Software Engineer agent used daily across LangChain. - **Developer Experience**: Engineers tag the agent directly inside Slack channels, allowing it to perform tasks asynchronously without leaving team communication channels. - **Safe Sandboxing & Review**: Code changes are developed and tested within dedicated sandboxes before outputting a standard Git pull request for human sign-off. - **Three-Step Deployment**: Creating the agent, authenticating organization-specific tool integrations, and completing a quick contextual onboarding profile.
---
[21:28](https://www.youtube.com/watch?v=R9K2574YEAg&t=1288s) Launching Fleet with Open-Source Models and Closing the Keynote
Harrison Chase steps back to the podium amidst warm applause to officially invite the Interrupt 26 audience to start using LangSmith Fleet immediately. Sharing his personal experience with the product, Harrison notes that he uses Fleet himself on a daily basis across an assortment of administrative and technical tasks. To lower the barrier to entry and encourage immediate experimentation across the community, he reveals that LangChain has integrated a free model into Fleet available for a limited promotional window.
Connecting this product release back to the keynote's earlier thematic focus on the rise of open weights and open architectures, Harrison highlights that this free model tier is an open-source model hosted and powered in partnership with Fireworks AI. Emphasizing the company's commitment to supporting the broader open ecosystem, Harrison states: “So we try to live what we preach in terms of open source models and also trying to have the best partners here.” He urges attendees to explore the expo hall to meet the diverse partner ecosystem showcasing their technologies at the conference booths before officially bringing the Day 2 opening keynote to a close.
- **Immediate Fleet Availability**: LangSmith Fleet is live and ready for general use, with Harrison Chase actively utilizing it for everyday internal workloads. - **Limited-Time Free Tier**: Users can explore Fleet's capabilities at no cost via an included free model tier. - **Powered by Fireworks AI**: The complimentary offering runs on an open-source foundation model hosted by infrastructure partner Fireworks AI, putting LangChain's advocacy for open-source AI directly into practice. - **Partner Ecosystem**: Keynote wraps with an invitation for conference attendees to visit the partner booths and engage directly with exhibitors across the Interrupt 26 floor.
## Notable quotes > [12:39](https://www.youtube.com/watch?v=R9K2574YEAg&t=759s) the best people to build the agents are the ones who actually do the job. — Brace Sproul
## Mentioned Harrison Chase, Brace Sproul, Caroline di Vittorio, Jess, Julia, Jacob, Brianna, LangChain, LangSmith, LangSmith Fleet, LangChain Labs, Interrupt 26, Interrupt 2027, OpenAI, Ramp, Prime Intellect, MIT, Stanford, TerminalBench 2, Claude Code, Claude 3.5 Sonnet, GLM-4, GPT-4, Qwen 3.5, Pi, Deep Agents, OpenSuite, Arcade, Model Context Protocol, Slack, Gmail, Outlook, Salesforce, BigQuery, Fireworks AI, LangGraph
## Video description Harrison Chase, Brace Sproul, and Caroline di Vittorio kicked off Day 2 of Interrupt 26 with an inside look at where AI agents are headed, the unveiling of LangChain Labs, as well as the latest features in LangSmith Fleet.
0:00 Welcome & Shoutouts 0:29 Setting the Stage: Imagining Interrupt 2027 1:22 Two Types of Agents: Long-Horizon vs. Customer Experience 2:42 The Future of Voice Agents 3:58 Why Every Agent Needs a Sandbox 4:47 The Rise of Open-Source Models 6:01 Agent Identity & Auth Patterns 7:26 Continual Learning: Model, Harness & Context Layers 10:42 Announcing LangChain Labs 11:00 Updates to LangSmith Fleet 12:39 How LangChain Builds Agents Internally 13:40 Fleet Demo: Go-to-Market Agent 19:05 Fleet Features: Tools, Channels, Governance 21:28 Closing
Extra resources: • Everything we shipped at Interrupt: https://www.langchain.com/blog/interrupt-2026-overview • Meet LangSmith Engine: https://www.langchain.com/blog/introducing-langsmith-engine • About LangChain: https://www.langchain.com/
[Source](https://www.youtube.com/watch?v=R9K2574YEAg)