LangChain Launches Fleet and Labs in Bet Workers Will Build Own Agents

The Future of AI Agents: What Will Interrupt 2027 Look Like? | Interrupt 26 — LangChain

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)

Reading summary

LangChain co-founder Harrison Chase argues that the agent ecosystem is splitting into long-horizon problem solvers and low-latency customer interaction systems, underpinned by open-source models, sandboxed execution, and continual learning across deterministic harnesses. Divergence of Long-Horizon and Real-Time Agents (1:22) Chase forecasts that agent architectures are separating into two primary archetypes with divergent technical demands. Long-horizon agents manage complex, multi-step knowledge work over hours or days by leveraging code execution, subagents, and modular skills. In contrast, customer experience agents prioritize low latency, brand consistency, and interactive modalities such as voice and video. Chase notes that current enterprise voice implementations primarily rely on modular pipeline 'sandwiches' (speech-to-text, reasoning, text-to-speech); while native speech-to-speech models are emerging rapidly, enterprise consensus currently views them as lacking the steerability required for mission-critical applications. To expand what autonomous systems can achieve, Chase contends that nearly every agent—especially those performing deep research or data analysis—requires an isolated code execution sandbox. Viewing code generation as a general problem-solving tool rather than just a software engineering utility, LangChain introduced its own sandbox product, anticipating sandboxed environments will become standard infrastructure. Open-Source Economics and Agent Identity (4:47) Enterprise adoption of open-source and open-weights foundation models is expected to accelerate significantly over the next twelve months. According to Chase, this transition is propelled by base open models approaching performance parity with closed frontier models on complex agent benchmarks, the economic unsustainability of burning millions of tokens in proprietary coding agents, and the necessity of fine-tuning open weights on proprietary execution traces. Simultaneously, permissioning and identity have split into two distinct architectural patterns: agents that assume the runtime identity and OAuth credentials of individual callers, and agents that operate under dedicated service accounts with fixed permissions. In the former model, two colleagues querying the same agent receive different outputs based on their internal data permissions. Chase predicts both credential models will persist, requiring engineering teams to carefully delineate authentication contexts for enterprise actions. Continual Learning Across Scaffolding and Context (7:26) LangChain frames continual learning as systemic optimization across three tiers: the model layer (base weights), the harness layer (scaffolding code and deterministic execution loops), and the context layer (dynamic instructions and skills files like agent.md). Chase emphasizes that while foundation models update via gradient descent, optimization at the harness and context tiers uses structured benchmark evaluations and trace logs as an analogous forcing function. Demonstrating this harness-level optimization, LangChain modified only its scaffolding code on the TerminalBench 2 benchmark—keeping underlying model weights untouched—which vaulted its agent from outside the top thirty into the top five. To operationalize these feedback loops from execution traces stored in LangSmith, Chase announced the formation of LangChain Labs, a research group focused on harness and context optimization. Democratizing Agent Creation for Domain Practitioners (11:18) Brace Sproul and Caroline di Vittorio outlined a transition in enterprise operations from non-technical staff merely supplying feedback to domain practitioners directly building and deploying production agents. LangChain introduced LangSmith Fleet, a natural-language agent builder featuring built-in human-in-the-loop checkpoints, cost tracking, and access to third-party tools via Arcade and the Model Context Protocol. Di Vittorio demonstrated an internal Go-to-Market agent built in Fleet that integrates Slack, Salesforce, BigQuery, and Gmail. Internal metrics indicate that 84% of LangChain's sales team uses the agent weekly, resulting in a 240% increase in lead-to-qualified conversions and saving roughly 40 hours per representative each month. Fleet also offers pre-built software engineering agents operating within sandboxes that submit Git pull requests for human review, supported by a promotional tier running open-source models hosted on Fireworks AI. While LangChain anticipates that open-source models, modular harnesses, and non-technical builders will dominate agent development toward 2027, Chase explicitly acknowledged the speculative nature of emerging technology forecasts. Key engineering challenges remain unresolved, including whether customer-facing systems can safely transition to end-to-end voice-to-voice models and how organizations will manage unified infrastructure across increasingly divergent agent archetypes.

Source quotes

[12:39] Brace Sproul: the best people to build the agents are the ones who actually do the job.

Original transcript

[0:06] I don't know about you guys, but this is the coolest tech conference I've ever been to. [0:10] And I have had nothing to do with it. [0:12] So before we get started, I do want to shout out everyone who's working behind the scenes, [0:16] in particular, Jess, Julia, Jacob, and Brianna for making this event fantastic. [0:21] So let's give them a big round of applause. [0:29] Now yesterday, we talked a lot about what building agents today [0:33] looks like and how a lot of the most successful teams are [0:35] bringing agents into production. [0:37] And so for today, I want to talk a little bit about the future. [0:41] One of the things that we think a lot about at LinkedIn-- [0:44] it's actually in our mission and vision statement-- [0:47] is what do the agents of the future look like? [0:50] And so for the rest of this talk, I [0:53] want to pretend like we're a year in the future. [0:55] It's interrupt 2027. [0:57] And what are the topics that we're going to be talking about? [1:00] What are the topics we're going to be discussing? [1:01] And I'm going to be wrong in a lot of these. [1:03] This is going to look really silly and really stupid. [1:05] But hopefully this gives you a glimpse [1:08] into where we think that the space in the industry is going. [1:14] One thing that I think will start to happen [1:16] is there will be a divergence in the types of agents [1:20] that people are building. [1:21] So I think there will be two types of agents, [1:22] and we're already starting to see some of this emerge. [1:26] So one of the types I think will be these long horizon style [1:29] agents. [1:30] So these are agents that run for minutes and hours [1:32] and maybe even in the future days. [1:34] They do code execution. [1:36] They do planning. [1:37] They use subagents. [1:38] They maybe use multi-agent systems. [1:40] They use skills. [1:41] And they operate over longer and longer time horizons. [1:44] Things like outcomes and goals are [1:46] starting to become ways to increase the horizons at which [1:50] these can operate. [1:52] And so I think we'll see a big push in these [1:54] is they do more and more valuable knowledge work. [1:57] At the same time, there's a completely different set [2:00] of agents that latency is a huge factor for. [2:04] And these often end up looking like customer experience [2:06] agents. [2:07] So this could be customer support. [2:08] This could be sales. [2:10] This is places when you're talking to an end user. [2:12] Brand is really important here. [2:14] Voice becomes a really interesting modality. [2:17] Maybe video will in the future as well. [2:19] And so I think these are these two directions [2:22] that agents are going in. [2:24] There is a shared stack underneath. [2:26] There are also differences in terms of the technology. [2:29] And I think one of the big questions that we'll [2:31] be thinking about over the next year [2:33] is how common is this shared stack versus how particular [2:37] are the technology pieces that you need for each? [2:42] Speaking of voice, I think we'll be talking a lot more [2:44] about voice in a year. [2:46] This is a place where we're starting to invest more and more. [2:49] We see this be particularly relevant for these customer [2:52] experience style agents. [2:53] voice is a great modality. [2:55] The typical voice pipeline today looks something like this. [2:59] There's this speech to text, text to speech, [3:02] kind of like sandwich. [3:03] So the user speaks, that's transcribed into text, [3:07] that's passed to an agent. [3:08] The agent operates in kind of like the text space, [3:11] output some text, and then that text is transformed [3:14] back into speech, which is the audio that you hear [3:16] from the agent as you're talking to it. [3:19] And so this is the pipeline that we see today, [3:21] But there are these native speech-to-speech native voice [3:25] models that are coming out. [3:26] So OpenAI released V2 of theirs, I think, two weeks ago. [3:30] And while I would say the consensus today [3:34] seems to be for applications where you really care [3:38] about having control, they're not quite steerable enough yet, [3:41] we do expect that to change. [3:42] And so I think one of the big things [3:43] that we're looking at in the future for voice agents [3:45] is which will it be? [3:46] Will it be this pipeline approach? [3:48] Will it be this native voice-to-voice approach? [3:50] Will it be a combination? [3:51] What are the pros? [3:52] What are the cons? [3:53] I think we'll be talking a lot more about voice [3:55] in the next year or so. [3:58] We think all agents will need a sandbox, [4:01] especially these long horizon style agents. [4:03] So coding is really good for a variety of tasks. [4:05] It's not just writing software, it's for data analysis, [4:08] it's for web browsing, it's for image gen, [4:10] for deep research. [4:11] I was talking to someone yesterday who said [4:14] that when they think about building agents [4:16] for their marketing team, one of the ways [4:17] that they think about it is they think about [4:19] giving that marketing team a software engineer. [4:21] What would that software engineer build? [4:23] What apps would it build to make the marketing team's job [4:26] easier? [4:27] That's what giving an agent the ability [4:29] to write and execute code is. [4:30] That's why we think sandboxes are really important, [4:33] and that's why we launched sandboxes yesterday. [4:35] So I actually think agents are very early on. [4:38] Sandboxes are very, very early on. [4:40] It's still just the dawn of those. [4:42] I think we'll be talking a lot about them over the next year. [4:47] Open models are a place that we expect [4:49] to see significant increase in over the next year. [4:52] So the performance of these base open models [4:55] without any type of post training for particular tasks [4:58] is already approaching that of frontier models. [5:00] So this is some benchmarking that we did on deep agents [5:03] comparing closed frontier models to open models. [5:06] And you can see that it does lag in some places, [5:09] but it's starting to get really, really close [5:12] to that frontier. [5:13] The other big thing that is happening [5:15] is cost is starting to become more and more of an issue. [5:19] So there are multiple cases where, [5:21] in particular for coding agents, [5:23] these agents are burning through a ton of tokens [5:25] really, really fast. [5:27] I think open models offer a cheap alternative to these, [5:31] and we expect that to be a big driver of open models. [5:34] A third reason that we think open models [5:35] are really interesting is because they can be trained [5:38] for your particular domain. [5:40] And so I think that's yet another reason [5:42] As companies build up a lot of these traces, [5:46] a lot of these agent runs, how can you use those? [5:48] How can you use those to improve the model over time? [5:50] I'll talk a little bit more about that in a second. [5:52] But this type of post-training is something [5:55] that you can do with open models. [5:56] And so we expect a big rise in interest in open models. [6:01] Agent identity is really, really interesting to us. [6:03] So as agents start to do more work in the real world, [6:06] they take actions. [6:08] How do they take those actions? [6:09] On whose behalf do they take those actions? [6:11] I think it's still early here. [6:12] We see two emerging trends. [6:14] One is when the agents act on behalf of individual users. [6:18] So if I'm accessing an agent and that agent has access to Slack [6:22] and I tell it to look up something in Slack, [6:23] it will use my credentials and it'll have access [6:25] to whatever I see in Slack. [6:27] And so if Julia or a colleague uses it, [6:30] they might get a different answer [6:31] because it might see different things. [6:34] Another type of auth is when they have a fixed set [6:36] of credentials, usually a service account [6:38] or something like that. [6:39] And then whoever is interacting with that agent, [6:42] they will always use that fixed set of credentials. [6:44] So they'll see the same responses. [6:46] This, I think, started to get really, really popular [6:48] with things like OpenAI, where you had this concept [6:51] of an agent that was its own thing, [6:53] and it had its own fixed set of credentials, [6:54] and you'd expose it through separate channels, [6:56] and you'd interact with it. [6:57] And we started to see actually some SAS providers [7:01] make it really easy for agents to create their own accounts [7:03] so that they could have their own fixed set of credentials. [7:06] And so I think this will be an interesting trend to watch. [7:08] I actually think we'll see both of these in the future. [7:11] I think we'll have agents that act on behalf of users, [7:13] but also agents with their own fixed set of credentials. [7:16] And I think being really, really precise about when [7:19] to use which one and which one which one is, [7:21] and making that clear to users will be important. [7:26] Continual learning is maybe one of the areas [7:28] that we're most excited about as a company. [7:32] So when we think about continual learning, [7:34] we think about improving the agentic system over time. [7:38] And there's three layers to this agentic system, [7:40] and all of them can be improved. [7:41] There's the model layer, there's the harness layer, [7:43] and there's the context layer. [7:45] So the model, I mean things like Sonnet, GLM4, GPT-4, [7:49] harness, this is the code surrounding the model [7:51] that connects it to the environment. [7:52] This is deep agents, Claude Code, pi. [7:55] And then context might be what we provide to the harness [7:58] as ways to guide it on particular tasks. [8:00] So agent.md, skills. [8:03] You can't edit Claude Code directly, [8:06] but you can give it skills and give it an agent.md [8:09] that tunes it for your particular task. [8:11] And so these are three different layers [8:12] of the agentic system, [8:13] and we think all of them are involved in continual learning. [8:19] So maybe starting at the model layer first, [8:21] this is taken from research done by Ramp [8:23] and Prime Intellect that came out last week, [8:25] where they fine-tuned a model to be really good [8:27] at Ramp sheets. [8:28] And you can see here that the latency is very, very low [8:31] and the accuracy is very, very high. [8:33] And this is an advantage of using an open source model, [8:36] Qwen 3.5, and fine-tuning it for their particular domain. [8:41] And so this is an example of continual learning [8:43] at the model level. [8:46] You can also learn at the harness level. [8:48] So there's a great paper out of MIT and Stanford [8:51] called MetaHarness, where they used an agent [8:53] to optimize a coding harness. [8:56] They optimized it on terminal bench 2. [8:58] And you can see that it outperforms human-written [9:01] harnesses. [9:02] And so this is an example where they used the feedback [9:05] from the environment, the feedback from running it [9:07] on terminal bench. [9:07] They took that feedback, they passed it [9:09] to an agentic system itself that would make edits [9:12] to the harness. [9:12] So it wasn't changing the model at all, [9:14] it was just editing the harness. [9:15] And they got a really good score there. [9:20] My backgrounds in classical machine learning, [9:22] then there are a lot of similarities [9:24] between how you use data there and how you use it [9:27] in this new world of agent development. [9:30] And so in classical machine learning, [9:31] You have the model, you have the training data, [9:34] you do some gradient descents, [9:35] and that updates the weights of the model. [9:38] When you're updating the agent in general, [9:39] depending on the layer you're at, [9:41] if you're working at the harness or context layer, [9:44] it's not exactly gradient descents, [9:45] but the evals that you write act as a forcing function. [9:49] So in the example of the meta-harness that I just gave, [9:53] you have these evaluations, terminal bench two, [9:55] you run the agent on terminal bench, you get some feedback, [9:57] you then pass that into the agentic system and updates it. [10:01] So those evals are providing a similar type [10:03] of this training gradient. [10:06] And so evals and traces are incredibly important [10:09] for this learning. [10:12] We did this ourselves, [10:13] and so this is a few months old at this point, [10:16] and so all of these, you know, the leaderboard [10:18] no longer looks like this [10:19] because the space moves really fast, [10:21] but we moved from top 30 on terminal bench two to top five [10:24] just by changing the harness itself. [10:26] So no changes to the model, [10:28] only changes to the harness, [10:29] and we saw a big increase in performance. [10:32] And so we think that more and more companies [10:34] will be doing this type of continual learning, [10:36] whether it's at the model layer, the harness layer, [10:38] or the context layer, for their particular use cases. [10:42] We wanna help people do this. [10:43] And so one of the things that we're announcing today [10:46] is LangChain Labs, which will be a research group [10:49] inside of LangChain aimed in particular [10:52] at continual learning. [10:54] We think that, yeah. [10:55] (audience applauding) [10:58] (audience applauding) [11:00] We think that LangSmith, with all these traces already [11:03] in there and all the feedback associated with it, [11:05] this is a really, really solid foundation [11:08] for doing this type of continual learning, [11:10] whether it's at the model layer or the harness layer [11:11] or the context layer. [11:13] And so we're excited to work with a bunch of our customers [11:15] going forward in this direction. [11:18] The last thing that I'll say is we think that everyone [11:22] will help build agents in the future. [11:23] And we already see this today. [11:25] So we already see that everyone in an org [11:27] is involved in improving the agent with feedback. [11:30] So you've got UX research, there's domain specialists, [11:33] customer support pokes, product people, engineers, [11:36] they're all giving feedback in some form, [11:38] whether direct feedback or by tweaking the prompts [11:40] or by just debugging in Slack, [11:42] they're all giving feedback that improves these agents. [11:44] And oftentimes it's the domain experts themselves [11:47] who have the best type of feedback [11:48] and know how the agent should perform best. [11:51] And so we think in the future, [11:52] they'll be even more involved in creating these agents. [11:55] we think they're actually going to be building their agents. [11:57] They're not just going to be giving feedback on them [11:59] and handing that off to a separate team, [12:01] they're actually going to be involved [12:02] in building these agents. [12:05] We've started to see a glimpse of this at LangChain, [12:08] where we have a bunch of agents created by people [12:11] in all different domains and expertise. [12:14] And we've seen them build these over the past few months. [12:16] And so to talk more about what that future looks like, [12:20] I want to welcome onto the stage Caroline di Vittorio. [12:23] (audience applauding) [12:39] All right, all right, how's everyone doing? [12:41] (audience cheering) [12:42] Good, good. [12:43] Anyone else get sunburned yesterday or was that just me? [12:47] All right, Harrison painted a picture [12:49] of what the future of agents in the workforce [12:51] will look like. [12:52] I'm excited to tell you all how we're actually [12:54] doing that at Langchain today. [12:57] First, I'm going to start with a few use cases. [12:59] Our talent acquisition team sources [13:01] candidates using our sourcing agent. [13:04] Our sales team automates outbound and account intelligence [13:07] with our go-to-market agent. [13:09] Our marketing team researches the competitive landscape [13:12] with our Intel bot. [13:14] And our engineering teams triage and fix incidents [13:17] automatically with OpenSuite. [13:20] Across the company, agents are constantly running, [13:23] monitoring the business, and providing real-time updates [13:25] and Slack. [13:27] What do all these agents have in common? [13:30] Well, they were all built by the LangChain team members who [13:33] actually use them without having to write a single line of code. [13:37] How do we do that? [13:39] I'm glad you asked. [13:40] They use LangSmith Fleet, our managed agent builder, [13:43] which allows anyone to build agents [13:45] with just natural language. [13:47] They don't have to write any code. [13:50] Over the last three years of building agents, [13:53] we've learned three main things. [13:55] One, the best people to build the agents [13:58] are the ones who actually do the job. [14:01] Two, agents need to work where you work [14:04] and have access to the same systems you use. [14:08] And three, as your agent scale, governance [14:11] can become a bottleneck. [14:14] So why is it that the best people to build the agents [14:17] are the ones who actually do the job? [14:19] Well, at the end of the day, [14:21] agents are just a collection of instructions, [14:24] skills, and tools. [14:26] And who best to codify that [14:28] than the people actually doing the jobs? [14:30] Also, just like how all of us improve over time, [14:34] fleet agents do as well. [14:35] They have memory built directly into them. [14:38] So the more you use them, the better they become. [14:42] Now, in order to work in conjunction [14:44] these agents, they need to have access to all the systems you use. [14:48] We solve that through tools and channels. [14:51] We have over 200 tools built directly into fleets that cover the most common integrations [14:57] that companies require. [14:59] We also have a first-class partnership with Arcade, allowing you to access an extra 7,500 [15:04] tools out of the box to cover the long tail of your integration requirements. [15:09] And of course, we support everyone's favorite tool framework, MCP. [15:13] means you can connect your custom tools and proprietary data [15:17] sources directly to Fleet. [15:20] Now, in order to use them easily, [15:23] Fleet agents are integrated natively [15:25] into Slack, Gmail, Outlook, and more. [15:29] So you can utilize the full power of Fleet [15:31] without having to learn a new workflow. [15:34] We also have a comprehensive user interface, [15:37] which you can use to build, manage, and run your agents [15:41] directly within our app. [15:43] And of course, I haven't forgotten about you developers [15:45] out there. [15:46] We're opening up the fleet APIs. [15:48] So you can use them directly within your own production [15:50] applications and harness all of the incredible features [15:53] we've built. [15:57] So people working teams, these agents [15:59] need to be able to work seamlessly alongside you. [16:02] How do we handle that? [16:04] Sharing, of course. [16:05] You can share and collaborate on your agents and skills [16:09] directly in fleet, just as easy as sharing a Google Doc [16:12] with your team. [16:14] When you actually go to use these agents, [16:16] you need credentials and authentication management [16:19] so they can connect to all your different services. [16:21] And this can be really tricky. [16:23] Trust me. [16:24] Luckily, we've solved this for you in fleet, [16:27] meaning you can connect all your accounts [16:29] and pick which agents use which accounts depending [16:32] on which user is using it. [16:34] Everyone still with me? [16:37] We've also seen how cost can skyrocket [16:40] as your agents are adopted internally. [16:42] So for that, we've built cost tracking and usage controls [16:46] directly into the app. [16:48] So you can inspect exactly how much your agents and users [16:51] are spending and set spend limits on them. [16:56] Human in the Loop is also a first class feature in Fleet. [16:59] So you can give your agents access to powerful tools [17:02] without having to worry. [17:04] And of course, Fleet integrates natively [17:06] with the rest of the LangSmith platform. [17:09] So you can look at your agent traces [17:11] and see exactly how your fleet agents are operating [17:14] under the hood. [17:16] Finally, fleet's open. [17:18] It's model agnostic. [17:19] So you can use your favorite open or closed source models. [17:23] It's built on top of everyone's favorite open source agent [17:26] harness. [17:27] You guessed it, deep agents. [17:29] And we make it easy for you to download your agent files [17:33] directly into your code so you can make whatever modifications [17:36] you would like. [17:38] Now, I'm going to hand it off to Caroline, who's going to give us a live demo. [17:41] Yeah, you heard that right. [17:42] Live demo of fleet. [17:45] >> Thanks, Brace. [17:46] So we've talked-- [17:48] [APPLAUSE] [17:53] So we've talked about why we built fleet and some of its capabilities. [17:57] And I'm excited to show you what that looks like in practice. [18:01] So here we have our go-to-market agent. [18:04] This agent can surface account intelligence based on data [18:07] from your CRM, your call recording platform, [18:10] and your data warehouse. [18:11] It can research accounts and contacts, [18:13] and it can draft personalized outbound emails. [18:17] In order to do that, we've connected it to the tools [18:20] that we use here at Langchain. [18:22] So in our case, that's Salesforce, BigQuery, Slack, Gmail, [18:26] et cetera. [18:27] We've written certain subagents for common research tasks [18:31] that we wanted to perform. [18:33] And we've given it a long list of skills [18:35] for step-by-step instructions of common tasks [18:38] that we wanted to get right every time. [18:42] We've also connected the Slack channel. [18:44] So instead of having to come into the UI here [18:47] in order to use the agent, [18:49] you can use it directly in Slack by tagging @gtmagent. [18:54] Okay, enough said, let's run it. [18:57] Here we go. [18:59] Where did we leave things off with a Pied Piper account? [19:01] What should our next steps be? [19:05] As it runs, this go-to-market agent has been a game changer for our team. [19:10] The go-to-market team, 84% of the go-to-market team uses it weekly. [19:14] Lead to qualified conversion is up 240%, and it has saved on average 40 hours per month [19:22] per rep. [19:23] Originally, an engineer had built this agent directly in code. [19:28] But when we built Fleet, we rebuilt this agent directly in Fleet so that the go-to-market [19:33] team could own this agent's implementation entirely end-to-end without having to write [19:39] a single line of code. [19:41] Okay. [19:41] So, the agent has wrapped up. [19:44] We're seeing an at-risk account. [19:45] That's not great. [19:47] We're seeing some hesitation around pricing and recommended next steps to reengage Jared [19:54] by email. [19:55] So let's do that. [19:57] Great. [19:57] Get an email to Jared, please. [20:01] As Brace mentioned, human in the loop is first class in fleet. [20:07] So before we just send off an email to a potential future customer, this agent is going to check [20:12] in with us so that we can double check the copy, make sure everything looks good before [20:16] we send. [20:17] So let's take a look here. [20:19] Let's capitalize, LangGraph. [20:23] Correctly. [20:24] Everything looks good. [20:26] pretty cool, right? Okay. Many of the agents, thank you. [20:33] [applause] [20:39] Many of the agents that we use every day here at Langchain are available as pre-built agents [20:45] directly in fleet. So there's a go-to-market agent, which you just saw, but also our software [20:51] software engineer agent, which allows you to fully own an agent that you can tag and [20:55] Slack, have it write code in a sandbox, and then put up a PR for you to merge. [21:01] All you have to do to use it is create the agent, connect it to the tools that your organization [21:05] uses, and then go through a short onboarding flow so it gets to know your company, and [21:11] then you're good to go. [21:12] And with that, I'm going to hand it back over to Harrison. [21:19] [APPLAUSE] [21:28] So you guys can try out Fleet today. [21:31] I use it myself for a variety of tasks. [21:34] We actually added a free model in there. [21:37] So for a limited time, there'll be a free model. [21:39] And backing up what we were talking about earlier, [21:41] it's an open source model powered by Fireworks, one [21:45] of our fantastic partners here. [21:47] So we try to live what we preach in terms of open source [21:50] models and also trying to have the best partners here. [21:53] There's a fantastic ecosystem of folks out there at the booth. [21:57] And so I'd encourage you to go talk to them. [22:00] So that's going to wrap it up for the keynote today. [22:29] [BLANK_AUDIO]