Interrupt NYC: palestra de abertura

Autoria: LangChain · Assistir no YouTube

Vídeo de autoria do canal indicado, não da IANIA; todos os direitos pertencem ao criador. Transcrição, resumo e tradução gerados automaticamente; o conteúdo no idioma original é preservado na versão em idioma original.

Idioma original: inglês

Vídeo original: Interrupt NYC: Opening Keynote · Canal: LangChain · 31:39 · Assistir no YouTube

Tópicos: Agentes de IA, Avaliação e benchmarks de IA, Governança e regulação de IA, Modelos de IA

Resumo

Na palestra de abertura do Interrupt em Nova York, LangChain apresenta a ideia de “owning your intelligence”: construir agentes especializados com controle sobre o harness, aprimoramento contínuo e governança. A apresentação descreve a estrutura organizacional e o ciclo de desenvolvimento necessários para criar agentes, além dos componentes de runtime, observabilidade, evals e inteligência da plataforma LangSmith. Também anuncia novidades em Managed Deep Agents, modelos de decisão, LangSmith LLM Gateway, trajetórias, fine-tuning, Custom Apps e Engine v2. O objetivo dessas iniciativas é ajudar empresas a criar agentes de domínio específico e levá-los à produção com mais controle e rapidez.

Pontos-chave

“Owning your intelligence” significa adaptar modelos com contexto, dados e componentes especializados para atender às necessidades de cada domínio.
Os três pilares apresentados são um harness aberto e controlável, o aprimoramento contínuo da inteligência dos agentes e a governança.
A criação de agentes exige colaboração entre equipes de plataforma, agent engineers e especialistas de domínio, além de um ciclo de build, teste, deploy e monitoramento.
Managed Deep Agents combina harness e infraestrutura gerenciada, com recursos para autenticação, identidade de agentes, canais, memória por usuário e busca na web.
Decision models como Jev e SemIf podem apoiar evals, guardrails e roteamento de modelos, agentes, skills ou ferramentas.
LangSmith Trajectories padroniza a representação de interações de agentes para facilitar depuração, anotação e fine-tuning.
LangSmith Fine-Tuning conecta dados de traces e trajetórias a provedores de treinamento e inference, como Fireworks e Baseten.
LangSmith Engine v2 identifica problemas, testa correções em ambientes de preview e usa red teaming para encontrar falhas antes ou depois do lançamento.

Capítulos

Início	Capítulo	Resumo
00:06	Agentes especializados e a ideia de owning your intelligence	A palestra contextualiza a evolução das aplicações de IA e apresenta agentes de domínio específico como forma de criar valor além do modelo.
04:25	Os pilares para controlar a inteligência	LangChain define os pilares de harness aberto e controlável, aprimoramento contínuo e governança.
07:33	Pessoas, processos e tecnologia para criar agentes	A apresentação descreve os papéis organizacionais, o ciclo iterativo de desenvolvimento e as camadas tecnológicas da plataforma.
10:40	Runtime e Managed Deep Agents	A palestra detalha a lógica de negócio, o harness e a infraestrutura dos agentes e anuncia novidades de Managed Deep Agents.
15:58	Decision models e LangSmith LLM Gateway	Jev e SemIf são apresentados como modelos para decisões específicas, enquanto o gateway oferece controles de uso e acesso a modelos.
19:41	Trajetórias, observabilidade e fine-tuning	LangSmith Trajectories padroniza dados de agentes para facilitar depuração, anotação e fine-tuning.
23:59	SmithDB e LangSmith Custom Apps	A palestra apresenta o armazenamento de trajetórias no SmithDB e apps personalizados para explorar dados e envolver pessoas no processo.
25:49	Engine v2, red teaming e encerramento	LangSmith Engine v2 testa correções e simula falhas, e a palestra conclui com a visão da LangChain para agentes especializados.

Citações

A expressão que tem sido usada para resumir tudo isso é “owning your intelligence”. — 02:16

Quando você lança um agente, está longe de ter um agente bem-sucedido. — 06:01

Se você consegue pontuar rapidamente o trabalho de um agente enquanto ele está em execução, pode detectar erros em tempo real. — 17:00

Esse ciclo de iteração é tudo quando se está criando agentes. — 30:08

Conceitos e entidades

owning your intelligence (conceito): Abordagem de construir e controlar componentes especializados em torno dos modelos para gerar valor específico para cada domínio.
Harness (conceito): Camada que conecta o modelo ao contexto e às instruções necessárias para orientar o comportamento de um agente.
LangChain (empresa): Empresa que organiza o evento Interrupt e desenvolve ferramentas para criar agentes de IA.
LangGraph (ferramenta): Framework open source da LangChain para criar agentes com fluxos controláveis baseados em grafos.
Deep Agents (ferramenta): Biblioteca open source da LangChain para criar agentes com recursos como ambiente de execução, sistema de arquivos e gerenciamento de contexto.
Managed Deep Agents (ferramenta): Oferta gerenciada que combina o harness Deep Agents com infraestrutura para executar agentes.
Jev (modelo): Decision model descrito na palestra como um modelo que pontua opções e toma decisões sem gerar texto.
SemIf (modelo): Decision model open source hospedado pela LangChain por meio do LangSmith LLM Gateway.
LangSmith (ferramenta): Plataforma comercial da LangChain para runtime, observabilidade, evals e desenvolvimento de agentes.
LangSmith LLM Gateway (ferramenta): Gateway para acessar e governar o uso de modelos, com controles de custos, limites de taxa e fallbacks.
LangSmith Trajectories (ferramenta): Recurso que organiza interações de agentes em um formato padronizado para depuração, anotação e treinamento.
LangSmith Engine (ferramenta): Camada de inteligência que analisa traces para identificar problemas e ajudar a melhorar agentes.
SmithDB (ferramenta): Banco de dados desenvolvido pela LangChain para ingestão, armazenamento e consulta de workloads de agentes.
Rogo (empresa): Empresa citada como exemplo de agente especializado para o setor financeiro com model routing.
Harvey (empresa): Empresa citada por adaptar modelos para tarefas especializadas no domínio jurídico.
JPMorgan Chase (empresa): Empresa mencionada como exemplo de personalização de harness para agentes internos.
Parallel (empresa): Provedor do recurso de busca na web integrado a Managed Deep Agents.
Fireworks (empresa): Provedor de infraestrutura de treinamento e inference citado no fluxo de fine-tuning da LangSmith.
Baseten (empresa): Provedor de infraestrutura de treinamento e inference citado no fluxo de fine-tuning da LangSmith.
Jev (pessoa): Nome mencionado como anfitrião do evento, a quem a pessoa palestrante dá as boas-vindas ao palco.

Tradução completa (pt-BR)

00:06 Bem-vindos ao Interrupt, pessoal. Isso não é incrível? É uma loucura. Sim, esta é a primeira vez que fazemos isso em Nova York. Fizemos isso em SF nos últimos dois anos, mas estamos trazendo o evento para cá por um dia inteiro. Temos uma programação incrível. Vamos anunciar muitas coisas incríveis e teremos várias ótimas conversas ao pé da lareira com pessoas da área, além de muitas palestras excelentes de pessoas que estão criando agents e de profissionais da área. Então, esperamos que haja muito a aprender. Quero falar um pouco sobre o estado atual da IA e para onde

00:39 achamos que ela está indo. Mas, antes de mergulhar nisso, quero fazer uma breve retrospectiva dos últimos anos, porque parece que as coisas avançam muito rápido, mas foi há apenas uns 3 anos que tudo isso realmente começou. Na verdade, foi um pouco antes, quando a LangChain foi lançada, mas, em 2023, estávamos criando protótipos. Em 2024, estávamos colocando algumas dessas aplicações simples em produção, mas ainda eram apenas chamadas únicas a um LLM. Em 2025, começamos a explorar agents. E foi mesmo neste ano que começamos a ver os agents transformarem a camada de aplicações.

01:12 E, por isso, muitas das palestras que vocês vão ouvir hoje serão de empresas que estão fazendo exatamente isso. Elas estão pegando esses LLMs e realmente transformando-os em experiências diferenciadas. Ou seja, não é só o modelo que elas oferecem aos clientes. É tudo o que há em torno do modelo. Estamos vendo que esses agents específicos de cada domínio não são apenas wrappers. Eles oferecem valor real às pessoas. E é preciso criar muitas coisas em torno do modelo para aproveitá-lo adequadamente. Vou citar alguns exemplos. A Rogo: teremos uma conversa ao pé da lareira com eles mais tarde, hoje.

01:44 Eles publicaram um ótimo blog sobre como criaram um harness especializado, com roteamento de modelos, para oferecer um agent específico do domínio financeiro. A Harvey, que já ouvimos em edições anteriores do Interrupt, tem falado bastante sobre como fez fine-tuning de modelos para tarefas especializadas, a fim de obter o melhor desempenho no domínio jurídico. E, mais tarde, hoje, ouviremos a JPMorgan Chase. É um caso de uso um pouco diferente, interno, mas eles personalizaram o harness em torno do modelo para proporcionar muitas vantagens internas aos agents que estão desenvolvendo como parte da linha de montagem Jarvis.

02:16 Todos esses são exemplos de empresas que pegam o modelo e criam muitas coisas em torno dele para torná-lo realmente delas. A expressão que tem circulado para resumir tudo isso é “ser dono da própria inteligência”. Quando falamos em ser dono da própria inteligência, estamos falando de todos esses exemplos: basicamente, criar muitas coisas específicas do domínio dentro e em torno dos modelos para que sejam realmente os melhores para o domínio que você está tentando abordar — e, de fato, ser dono da própria inteligência. Achamos que há alguns motivos pelos quais essa expressão se tornou tão presente na cabeça de tantas pessoas hoje em dia.

02:50 Primeiro, os custos de token estão subindo muito. As pessoas estão gastando cada vez mais com IA e, por isso, querem garantir que estejam obtendo o ROI adequado. Poder controlar e monitorar os custos de token é muito importante. E ser dono da própria inteligência é um fator essencial nesse sentido. Segundo, vemos os modelos open source se tornando cada vez mais populares. Isso oferece não só uma alternativa muito barata, que permite controlar melhor os custos de token, como também possibilita personalizar mais as coisas. E, à medida que esses modelos base open-weight ficam cada vez melhores, você pode começar

03:21 a fazer post-training neles. Pode começar a usá-los de maneiras especializadas, e isso torna mais fácil do que nunca ser realmente dono da própria inteligência. E a última coisa que ficou bastante clara no último ano é que os próprios modelos estão se tornando, de certa forma, commodities. O que diferencia e oferece muito valor às pessoas são todas as coisas em torno do modelo, em particular os dados, sejam eles o contexto que você fornece ou alguns dos caminhos específicos do domínio que incorpora ao harness. Por causa de todos esses fatores, vemos que as pessoas querem ser cada vez mais donas da própria

03:53 inteligência. É assim que entendemos a missão da nossa empresa. Sempre foi assim. A LangChain começou um mês antes do ChatGPT, mas só decolou depois, quando as pessoas viram o que tinha sido lançado e disseram: “Quero isso, mas para o meu setor, para o meu segmento.” E um dos grandes diferenciais da LangChain sempre foi, de certa forma, a possibilidade de escolher entre modelos. Desde o começo, as pessoas criavam essas soluções específicas de cada domínio, que eram naturalmente, de certa forma, independentes do modelo. Essa missão de ser dono da própria inteligência é algo em que

04:25 pensamos muito, e acreditamos que há três pilares fundamentais para isso. É nisso que ajudamos as pessoas. O primeiro pilar fundamental é um harness aberto e controlável. Há duas partes importantes nisso. Primeiro, acreditamos que o harness precisa ser neutro em relação ao modelo. Você não deve ficar preso a um modelo específico. Isso é tanto uma vantagem ofensiva quanto defensiva. Quando surgir o melhor modelo novo, seja da OpenAI, da Anthropic ou da TypeSafe, com alguns de seus modelos Jev, você vai querer poder mudar o harness para ele o mais rápido possível.

04:57 Assim, seu harness precisa ser capaz de se adaptar ao melhor modelo novo. Isso também é uma medida defensiva. Você não quer ficar preso a um único provedor de modelos, para que ele possa aumentar os preços e coisas assim. A outra parte desse harness aberto e controlável tem a ver, mais uma vez, com o que falamos sobre tornar esses agents realmente específicos de cada domínio. Tudo isso diz respeito a trazer contexto especializado ao modelo de maneiras específicas, para fornecer o contexto certo no momento certo. É preciso controlar de verdade o que o harness faz, e esse controle pode ter formas diferentes conforme o cenário. Há algum tempo temos o LangGraph, um framework open source para criar esses grafos direcionados, que é uma maneira muito controlável de estruturar esse harness.

05:29 Também temos o Deep Agents agora, e vou falar dele mais tarde, mas esse é outro tipo de harness de modelo open source. Temos nele o conceito de middleware, que é outra maneira de inserir decisões a tomar e ações a executar nesse loop central do agent. Seja qual for a abordagem, é preciso ter uma maneira de controlar, em detalhes, o que entra no modelo. O segundo pilar fundamental que, em nossa opinião, constitui ser dono da própria inteligência é o aprimoramento cumulativo,

06:01 especificamente, o aprimoramento cumulativo da inteligência que você obtém quando as pessoas usam seu sistema. Lançar um agent está longe de significar que você tem um agent bem-sucedido. É preciso aprender com a forma como as pessoas usam o agent, com o que ele faz, observar onde comete erros e conseguir aprimorar cumulativamente a inteligência desse agent, seja manualmente, identificando erros e atualizando o código ou o prompt, seja de forma mais automática, com memória ou técnicas de otimização de prompt. É muito importante incorporar esse ciclo de aprimoramento cumulativo aos seus sistemas e

06:31 assumir o controle dele. Se você consegue definir melhor do que qualquer outra pessoa o que é bom e o que é excelente no seu domínio, poderá criar o melhor agent para esse domínio. E ter eval… …inteligência é uma ótima maneira de criar esses agents específicos de cada domínio. E, por fim, governança. Isso é realmente crucial para agents internos. Estamos vendo muitas empresas transformarem a maneira como realizam suas operações internas. Mas, quando há muitos agents em funcionamento, é preciso garantir que

07:02 eles sejam devidamente governados. É preciso saber quantos existem, poder controlar os custos e gerenciar a autenticação com confiabilidade, para que diferentes pessoas tenham acesso apenas ao que devem acessar. Vemos, portanto, que a governança está se tornando um tema cada vez mais importante em relação a ser dono da própria inteligência. É assim que entendemos os três pilares fundamentais de ser dono da própria inteligência. E acreditamos que há várias maneiras diferentes de chegar lá. Vou destacar três, em linhas gerais: pessoas, processos e tecnologia. E, no restante da keynote, vamos falar principalmente sobre tecnologia,

07:33 Mas quero falar bem brevemente sobre pessoas e processos, porque eles também são necessários para transformar sua organização em uma organização capaz de ser dona da própria inteligência. Então, falando bem brevemente sobre pessoas, é mais ou menos assim que vemos muitas organizações sendo estruturadas. Há um primeiro nível, formado por engenheiros da plataforma central. Eles fornecem muitas ferramentas para que outras pessoas criem agents. Quando falamos de governança, quando falamos desse tipo de ciclo de acumulação de evals, eles fornecem a plataforma que outras equipes internas de desenvolvimento de agents podem usar para criar, governar e aprimorar seus agents.

08:06 Além desse nível, vemos engenheiros de agents. Esse é um ótimo termo para descrever a mistura híbrida e peculiar de cientista de dados, engenheiro e engenheiro de machine learning que compõe as pessoas responsáveis por conduzir esses agents. É um novo conjunto de habilidades, e vemos muitas pessoas de diferentes áreas se tornando engenheiros de agents e usando os recursos da equipe da plataforma central. Por fim, há muitos especialistas no assunto, dentro e fora da empresa, que costumam ser as melhores pessoas para decidir como é um bom resultado para um agent. Por isso, é muito importante ter uma plataforma que também alcance esses não desenvolvedores nas pontas

08:37 da organização. E é isso que vemos as pessoas fazerem: estruturar a organização para adotar esse tipo de modelo. Também vemos pessoas adotando, de maneira implícita ou explícita, um novo processo para criar agents. Como mencionei antes, é um processo muito iterativo. Primeiro, você lança um agent, e ele não vai ser bom. É preciso iterar. Então, existe esse ciclo de vida, esse ciclo que as pessoas estão adotando para realmente fazer com que os agents fiquem bons o suficiente. Em termos gerais, é criar, testar, fazer deploy, monitorar e, então, crucialmente, quando

09:07 você pega os aprendizados do monitoramento e os leva de volta à etapa de criação. E, é claro, você quer fazer tudo isso de maneira governada. Voltaremos a esse assunto um pouco mais adiante, mas as pessoas estão usando esse tipo de processo o tempo todo para melhorar seus agents. Agora quero falar sobre tecnologia. Quando pensamos na tecnologia, e na tecnologia que ajudamos a criar e fornecemos, há duas partes principais. Uma delas é o ambiente de execução. Foi assim que começamos, com as bibliotecas open source LangChain, e continuamos desenvolvendo projetos open source com LangGraph e Deep Agents. E, claro, queremos criar agents que não apenas

09:38 rodem localmente no seu laptop, mas também na nuvem, atendendo a todas as pessoas da sua organização ou aos clientes para quem você está criando. Portanto, esse ambiente de execução também envolve uma parte de deploy. E há ainda a parte de observabilidade e evals, que é realmente crucial para a camada de aprimoramento contínuo. Por isso, é muito importante conseguir ver o que os agents estão fazendo e medir o quanto se comportam bem. Esses são os dois pilares principais do que criamos. E, recentemente, também nos concentramos em uma terceira parte: uma camada de inteligência que fica acima deles.

10:09 Então, quando pensamos no LangSmith, nossa plataforma comercial, pensamos nela como algo que atende às necessidades do ambiente de execução e de observabilidade e evals, além de incorporar inteligência em toda a plataforma para realmente ajudar as pessoas a usar esses componentes e acelerar o processo, o ciclo de desenvolvimento de agents que mencionei antes. Nos próximos minutos, quero apresentar essas três partes principais da nossa plataforma, falar sobre algumas das coisas interessantes que estamos fazendo e sobre para onde achamos que o futuro está caminhando. Quero começar pelo ambiente de execução.

10:40 Então, como é o ambiente de execução de um agent? Quando pensamos em um agent, geralmente consideramos que ele tem três componentes. Há a lógica de negócio. Isso inclui coisas como instruções, ferramentas, skills e hooks. São coisas que vocês precisam fornecer ao criar seus agents específicos de cada domínio. As skills de um agent financeiro podem ser muito diferentes das skills de um agent jurídico. Essa é a lógica de negócio que todos vocês aqui vão fornecer aos agents. Depois, há o harness. O harness pega o modelo e boa parte desse

11:11 contexto específico do domínio e, basicamente, conecta tudo para que o modelo possa ver o contexto certo na hora certa. Pode ser um harness bastante personalizado, que você talvez crie no LangGraph, ou um harness mais genérico, que vemos cada vez mais. Foi por isso que criamos o Deep Agents. Deep Agents é nossa biblioteca open source mais recente. Nós a lançamos há cerca de um ano. É um harness de agent pronto para usar. Ele aprende muito com o que os agents de programação fazem. Por isso, tem um ambiente de execução com sistema de arquivos e sandbox. Também faz bastante gerenciamento de contexto, de maneiras semelhantes às usadas pelos agents de programação, com compactação,

11:46 mas foi criado para que você possa desenvolver esses agents específicos de cada domínio. Por fim, há a infraestrutura. Se esse agent está rodando localmente no seu laptop, ótimo. Você quer levá-lo para a nuvem. Há todos esses componentes que você precisará adicionar para que ele possa rodar remotamente. Você vai precisar de um ambiente de execução em um servidor que ofereça execução durável. Vai precisar de uma maneira segura de acessar ferramentas. Vai precisar de uma maneira de executar o código que ele escreve. E vemos muitos agents escrevendo código, mesmo quando não são agents de programação. Você precisará acessar modelos. Portanto, toda essa infraestrutura também faz parte do conjunto.

12:18 Muitos desses componentes foram incorporados ao LangSmith em partes. Temos o LangSmith Deployment, que se concentra no ambiente de execução do agent. Temos o LangSmith Sandboxes, para executar código, em beta. Temos um LLM Gateway no LangSmith, sobre o qual vou falar, que serve para acessar modelos. E estamos trabalhando em um servidor de ferramentas para facilitar o acesso a ferramentas. Esses são os diferentes componentes que compõem a infraestrutura. Um dos recursos que lançamos em beta no último Interrupt, mas que quero destacar rapidamente, é o Managed Deep Agents.

12:48 O Managed Deep Agents combina esse harness com a infraestrutura gerenciada. Assim, ao criar um agent, você fornece apenas a lógica de negócio e recebe o harness e a infraestrutura gerenciada juntos. É muito mais fácil começar assim do que passar da lógica de negócio para o harness e, depois, montar essas três, quatro ou cinco partes diferentes da infraestrutura. Estamos muito, muito empolgados com a plataforma Managed Deep Agents como uma forma de acelerar o tempo até gerar valor e levar muitos desses agents à produção mais rapidamente.

13:20 Há algumas coisas que estamos anunciando hoje como parte de uma nova versão do Managed Deep Agents e que, acreditamos, vão ajudar ainda mais com isso. Primeiro, uma das partes mais difíceis de criar esses agents, especialmente os agents internos de uma empresa, é a autenticação: garantir que as pessoas certas possam acessar e usar o agent e também que, quando o usarem, se o agent se conectar ao Notion ou ao Jira, essa conexão seja feita em nome do usuário ou usando a identidade fixa do próprio agent. A resposta certa pode variar, então estamos introduzindo várias primitivas diferentes

13:52 no Managed Deep Agents para facilitar esse tipo de conexão. A primeira são as conexões. Basicamente, são ferramentas que você usa quando tem um servidor de ferramentas, que é como o Managed Deep Agents se conecta às ferramentas. Você pode especificar como quer que os usuários finais se autentiquem nessas conexões. É aí que usamos a autenticação. Relacionada a isso, temos a ideia de identidade para agents. Isso define se o agent, como um todo, terá permissões concedidas ao usuário ou permissões de serviço. A terceira coisa são os canais. Uma parte importante da criação desses agents é disponibilizá-los às pessoas.

14:24 O Slack é um caso enorme. Quando você tem agents no Slack, como lida com a autenticação em um canal compartilhado? Se eu mandar uma mensagem para ele em um canal público compartilhado e meu colega também mandar uma mensagem, de quem será a autenticação usada em cada execução? Estamos incorporando boa parte disso aos canais prontos para uso no Managed Deep Agents, para, esperamos, tornar o problema de autenticação muito mais fácil de resolver. Em segundo lugar, estamos adicionando mais recursos relacionados à memória ao Managed Deep Agents. O Managed Deep Agents sempre teve o conceito de memória no nível do agent, mas agora estamos adicionando memória no nível do usuário. Isso significa que ele pode se lembrar de coisas específicas dos usuários individuais

14:55 com quem interage. Isso é muito poderoso para personalizar agents. E, em terceiro lugar, estamos adicionando ferramentas integradas. Uma das coisas mais comuns que os agents precisam fazer é pesquisar na web. Por isso, estamos adicionando uma ferramenta integrada por meio do Parallel, para que os agents possam acessar a web. Assim, você não precisa mais obter uma API key separada para isso. Basta usar sua API key do LangSmith com o Managed Deep Agents e ter acesso ao MCP de pesquisa na web do Parallel. Juntando tudo isso, achamos que o Managed Deep Agents é a maneira mais fácil

15:26 de passar da lógica de negócios para um agent que realmente está em execução em produção. Temos trabalhado com vários parceiros iniciais de projeto nisso e vimos resultados muito bons, especialmente para colocar um agent em funcionamento e usá-lo como esse harness da empresa. É assim que pensamos no Managed Deep Agents: como esse harness da empresa que facilita muito começar a criar e compartilhar agents dentro de uma organização… …que quero destacar são os decision models. No fim de semana, como imagino que muitos de vocês fizeram, experimentei o Jev.

15:58 Ele foi lançado no fim de semana. É um tipo novo e muito interessante de modelo. Então, o que exatamente é o Jev? É um decision model. O que isso significa? Basicamente, significa que ele toma decisões. Você envia um estado. Envia uma lista de perguntas. Ele pode então atribuir pontuações a essas perguntas. Há diferentes coisas que você pode pedir que ele avalie. Pode ser um valor booleano, uma pontuação propriamente dita ou uma escolha categórica, mas, basicamente, ele toma decisões. Ele não consegue gerar texto, mas consegue tomar decisões. Embora seja mais limitado, achamos isso muito interessante. Achamos que serão criados muitos tipos diferentes de modelos e muitos tipos diferentes de agent harnesses.

16:29 Então, acreditamos que, sem dúvida, haverá esses modelos de ponta impulsionando harnesses muito complexos, e é isso que vocês vão usar em coisas como Claude Code, Codex e Deep Agents. Eles aproveitam esses modelos realmente de ponta. Mas também há muitas outras decisões que precisam ser tomadas. É aí que achamos que um decision model pode ser muito útil. Talvez sejam pequenas coisas que funcionam junto com o modelo de ponta; talvez deem suporte às arquiteturas cognitivas do LangGraph e ao roteamento entre coisas diferentes. Vou destacar algumas das coisas para as quais achamos que esses decision models

17:00 são muito úteis. A primeira são os evals. Seja executando-os depois do fato ou durante o fluxo. Se um agent estiver realizando uma tarefa, poder atribuir rapidamente uma pontuação a ela, de acordo com alguns critérios, enquanto ele está em execução é muito poderoso, porque assim você pode detectar erros em tempo real. A segunda são as proteções. Ou seja, sinalizar rapidamente as entradas dos usuários. Ontem, conversei com algumas pessoas sobre proteções. Uma das desvantagens das proteções é que elas sempre adicionam latência. Se agora pudermos adicioná-las com latência muito baixa, isso será muito legal e poderoso. Por isso, estamos animados com essa possibilidade. E, por fim, também há o roteamento de modelos: escolher quais agents, modelos, skills ou ferramentas carregar.

17:33 Achamos que coisas como o Jev serão muito, muito úteis para isso. Você pode acessar o Jev pelo LangSmith LLM Gateway. Também pode acessar um decision model open source que estamos hospedando lá, chamado SemIf. Desde o lançamento do Jev, houve uma enorme explosão de decision models open source. Achamos que esse é um novo tipo de modelo para o qual, sem dúvida, haverá muitas opções, e estamos muito, muito animados para viabilizar e hospedar muitos deles pelo nosso gateway. Falando rapidamente do nosso gateway, esta é a última coisa do ambiente de execução que quero destacar. Lançamos o LangSmith LLM Gateway em beta há

18:07 um ou dois meses. Quero destacar duas coisas principais. Primeiro, tentamos fazer com que o gateway possa ser usado em todos os aplicativos com LLM que vocês estão criando, sejam voltados para clientes ou para uso interno. Especificamente, normalizamos tudo nos formatos de mensagem da OpenAI e, na verdade, também da Anthropic. Assim, você pode acessá-lo por lá. Mas também permitimos a passagem direta, caso surjam novos recursos nessas APIs que você queira aproveitar. E também temos várias integrações com agentes de programação, como Codex, Claude Code e Cursor.

18:38 Mais uma vez, achamos que vocês deveriam direcionar todo o tráfego por um único LLM gateway, por motivos de governança e controle de custos. Isso significa que ele precisa se integrar com todos os aplicativos que usam IA. Queremos, portanto, facilitar muito a conexão com todos eles. E, entre os principais recursos em que estamos nos concentrando, o primeiro é o controle de custos: ter visibilidade dos custos, mas também definir limites de gastos para diferentes equipes, usuários e API keys. O segundo é o controle de taxa. Ou seja, garantir que nenhum aplicativo específico esteja realmente limitando ou consumindo muito do uso.

19:09 E, em terceiro lugar, há os fallbacks. Você pode recorrer a diferentes provedores de modelos quando ocorre um erro. Um dos recursos que vamos lançar em breve são fallbacks com estado. Assim, se você perceber que as solicitações estão falhando e que a Anthropic talvez esteja fora do ar, nem tenta mais enviar solicitações para ela por um tempo. Você simplesmente muda para a OpenAI pelos próximos 10 ou 30 minutos, e pode configurar isso de forma bem flexível. Queremos fazer do LangSmith LLM Gateway a maneira mais segura e confiável de monitorar, governar e recorrer a diferentes provedores de LLM

19:41 quando você os estiver usando. Isso é tudo o que temos acontecendo na área de ambiente de execução. Agora quero falar sobre observabilidade e evals. Achamos que essa área é crucial para impulsionar esse ciclo de aprimoramento contínuo, e fizemos muita coisa ao longo do último ano, mas especialmente no último mês. Achamos que os traces são realmente o núcleo desse ciclo. Quando vocês pensam nesse ciclo, nesse processo que mencionei, achamos que os traces, como registro oficial do sistema e como forma de mostrar o que o agent faz em todas as etapas, são

20:13 muito, muito importantes para viabilizar esse tipo de ciclo de aprendizado. Quando falamos de traces anteriormente, falamos basicamente de runs, traces e threads. Um run é como uma única chamada de LLM. Um trace é como uma única invocação de um agent. E uma thread é basicamente uma série de traces, quando há uma interação com várias etapas. Esses são todos elementos básicos muito úteis, mas, ao longo do último ano, ficou bastante claro que existe um padrão mais útil para representar

20:45 o que os agents fazem. É isso que estamos chamando de trajetórias. Hoje em dia, muitos agents, sejam agents de programação ou agents próprios, funcionam de maneira semelhante: basicamente, executam um LLM em um loop e compilam essa lista de mensagens. Essa lista de mensagens é um formato padrão que pode ser usado de muitas maneiras interessantes. Então, hoje, uma das coisas que estamos animados para lançar é o LangSmith Trajectories, uma forma padronizada de interagir com essas trajetórias e usá-las em vários lugares. Vamos dar uma olhada.

21:49 Então, o que as trajetórias fazem? Achamos que elas têm dois benefícios principais. Primeiro, tornam a depuração muito mais rápida. Se você já usou LangSmith e teve um trace bem complexo, com milhares de iterações, talvez tenha percebido que é bem difícil analisar tudo aquilo. As trajetórias do LangSmith na interface têm uma experiência muito mais amigável para visualizar o que está acontecendo. Elas vão parecer basicamente como se você estivesse usando um agent de programação ou um agent de chat. Nós condensamos e exibimos as chamadas de ferramentas da mesma forma que esses agents fazem. Assim, você consegue passar os olhos por elas com facilidade.

22:21 Um grande benefício disso é a anotação mais simples. Agora que você consegue ver o que está acontecendo, pode deixar feedback com muito mais facilidade. Um terceiro grande benefício, na nossa opinião, é que isso facilita bastante o pós-treinamento de modelos. Ao fazer pós-treinamento de modelos, é comum ter essas trajetórias em um formato padrão desse tipo. Por isso, fazemos muito trabalho no backend para analisar esses formatos de trace realmente complicados, recebidos de todos esses diferentes SDKs e agents de programação, e expô-los em um formato padrão de trajetória.

22:54 Isso pode ser usado com muita, muita facilidade em fine-tuning. Quando falamos de fine-tuning, geralmente há duas partes. Há os dados, que virão de muitos dos traces e de muitas das trajetórias, e há a infraestrutura de inference e treinamento. Queremos tornar o mais fácil possível combinar essas duas coisas, e é por isso que também estamos anunciando hoje o LangSmith Fine-Tuning. O que isso significa? Você tem todos os seus dados no LangSmith. São todos os traces, que agora estamos convertendo para esse formato de trajetória, uma representação muito mais condensada e padronizada do que está acontecendo

23:26 Você pode então usar o smithtune CLI, um CLI que estamos lançando hoje, para selecionar traces, filtrar os relevantes e pré-processá-los de uma forma que os deixe ainda mais prontos para fine-tuning. Depois, você os envia para Fireworks ou Baseten, que fornecem a infraestrutura de treinamento e inference para realizar o treinamento propriamente dito. A partir daí, podemos avaliar os modelos e, como resultado, você obtém um modelo otimizado. Achamos que essa é uma forma muito poderosa de começar a fazer fine-tuning, seja em agents, tarefas de classificação, guardrails ou qualquer outra coisa desse tipo.

23:59 Queremos ajudar todos vocês a aproveitar ao máximo todos os dados que estão no LangSmith. E achamos que as trajetórias possibilitam grande parte disso. Agora, o lugar onde armazenamos essas trajetórias é o SmithDB. Lançamos isso no Interrupt alguns meses atrás. É um banco de dados que desenvolvemos internamente e que é muito bom para cargas de trabalho de agents. É muito mais rápido para ingerir, armazenar e consultar muitas dessas cargas de trabalho. Fizemos com que as trajetórias apareçam muito bem nele. Por exemplo, eu estava falando antes sobre como elas poderiam ser. Esta é uma captura de tela. Dá para ver que condensamos muitas das chamadas longas de ferramentas

24:30 que estão acontecendo, mas você pode clicar nelas e expandi-las. Também pode clicar em uma chamada de LLM e ir diretamente para ela. Tentamos deixar tudo com a melhor aparência possível, mas sabemos que há muitas maneiras diferentes de visualizar os dados com que você está trabalhando. É por isso que também estamos lançando hoje o LangSmith Custom Apps. Vamos assistir a um vídeo sobre isso.

25:16 Oi. Pense no LangSmith Custom Apps basicamente como o Lovable, mas para os dados que você já tem no LangSmith. Você pode conversar com ele, e ele vai criar um app totalmente personalizado. Nós até disponibilizamos nosso sistema de design como open source para que o agent de programação que usamos nos bastidores possa aproveitá-lo. Ele já vem com todas as

25:49 permissões para compartilhar com sua equipe e respeitar os limites do workspace, do RBAC ou do ABAC que você configurou. Achamos que essa é uma forma muito poderosa de incluir pessoas no processo e inspecionar dados. Isso é o que estamos lançando para observabilidade e evals. A última coisa de que quero falar é inteligência. Mencionei antes que existe um processo, um ciclo de vida para criar agents. Você cria um agent, depois o testa, faz o deploy e monitora. Uma das coisas que lançamos anteriormente no Interrupt foi o LangSmith Engine. O LangSmith Engine é um mecanismo que fica no topo desse ciclo inteiro.

26:22 Mais especificamente, ele fica no topo dos seus traces em um projeto de tracing. Ele roda em segundo plano e basicamente faz tudo o que um engenheiro de IA faria. Analisa issues, tenta agrupá-las, cria esse tipo de quadro de issues, tenta corrigi-las com código, tenta adicionar um avaliador e incluir coisas em um conjunto de dados. Estamos trabalhando nisso há cerca de seis meses e fizemos muitas melhorias. Por isso, hoje estamos reunindo várias delas e anunciando o Engine v2. Vamos dar uma olhada rápida em um vídeo e, depois, vou explicar algumas das coisas

26:52 mais interessantes que há nele.

28:04 Quero destacar algumas das coisas que apareceram ali. Primeiro, quero destacar que agora o Engine pode testar suas correções de forma proativa. O que isso significa exatamente? Isso se integra muito bem ao LangSmith Deployment, que comentamos na parte sobre runtime. Mais especificamente, agora o Engine detecta problemas nos traces. Ele inicia uma branch de pré-visualização no seu deploy. Confirma que o problema de fato é um problema. Depois, faz uma correção, inicia uma branch de pré-visualização para essa correção, executa-a para confirmar que o problema foi corrigido e, então, apresenta isso como um issue que

28:36 você pode abrir para ver todas as evidências de que o problema realmente existia e de que a correção o resolve. De novo, isso se integra, no momento, ao LangSmith Deployment, e é assim que fazemos nesse caso. Outra coisa que quero destacar é o red teaming. Antes, o Engine só identificava problemas que existiam nos traces enviados a ele pelas pessoas, que aconteciam em situações reais. Com red teaming, o Engine agora pode simular diferentes problemas e observar o que acontece. Mais especificamente, por enquanto o Engine vai — e, mais uma vez, isso se integra ao LangSmith Deployment

29:06 por enquanto, que é assim que sabemos como chamá-lo. O LangSmith Engine basicamente terá acesso ao deploy. Ele vai gerar diferentes problemas e hipóteses, executá-los contra o deploy e identificar quais produzem resultados ruins. Um resultado ruim pode ser, por exemplo, ele ter aprendido algo que não deveria, produzir um resultado ruim ou não estar alinhado à marca de alguma forma. Depois, ele vai sinalizar qualquer problema para você. Isso é muito útil para identificar situações em que seu agent falha.

29:37 Também é muito útil para criar um conjunto inicial de dados para evals. Há algum tempo ouvimos que criar evals é muito difícil e trabalhoso. Isso ajuda a automatizar boa parte desse processo. É claro que isso pode ser usado antes mesmo de você lançar seu agent em produção e antes que esses problemas sequer ocorram. Outra coisa que quero destacar são as melhorias de desempenho que a equipe fez. Trabalhamos muito para melhorar a capacidade de encontrar problemas e corrigi-los, além de reduzir bastante o custo. Muitas dessas melhorias estão reunidas no Engine v2, que está disponível a partir de

30:08 agora. O Engine já analisou mais de 70 milhões de traces e detectou mais de 21.000 problemas. Muitas das empresas de IA que mais crescem estão usando-o para acelerar o ciclo de iteração. Esse ciclo de iteração é tudo quando você está criando agents. Então, qualquer coisa que pudermos fazer para ajudar a acelerá-lo, certamente faremos. E a última coisa que quero anunciar é que agora o Engine também está disponível na versão auto-hospedada, com a opção de usar sua própria chave. Isso será lançado na versão V17 da versão auto-hospedada, que deve sair em

30:38 uma semana ou duas. Então estamos animados para levar isso a ainda mais clientes com quem trabalhamos. Isso é tudo o que lançamos e como pensamos sobre a tecnologia que desenvolvemos. Acreditamos que há esse ambiente de execução, e pensamos nele como open source, mas também como implantações. Cada vez mais, vemos que esses ambientes de execução gerenciados para agents estão se tornando muito poderosos para levar sistemas à produção. Temos observabilidade e avaliação. Pensamos muito em como podemos tornar isso mais nativo para agents com trajetórias, como podemos tornar isso mais personalizável com Custom Apps e como podemos ajudar

31:08 vocês a usar esses dados para ajustar modelos e atender melhor às suas cargas de trabalho. Por fim, temos essa camada de inteligência que fica acima, e queremos fazer com que o Engine realize muitas das coisas que os engenheiros de agents e de IA estão fazendo agora. E a análise de traces e o red teaming são apenas o começo. Queremos desenvolver tudo isso para ajudar vocês a criar agents específicos para cada domínio e realmente serem donos da própria inteligência. Mais uma vez, sejam agents que vocês estão criando e incorporando a produtos ou agents que estão criando para transformar as operações internas da sua

31:39 empresa. Hoje, vocês ouvirão muitos palestrantes e participantes de painéis falando sobre diferentes maneiras de fazer isso, diferentes técnicas e diferentes exemplos de como isso se parece. Estamos muito animados por realizar o Interrupt em Nova York. Somos muito gratos a todos vocês por estarem aqui. Acho que teremos um dia fantástico. Então, vou me retirar por um tempo e gostaria de dar as boas-vindas a Jake, que será nosso mestre de cerimônias hoje. Muito obrigado a todos por terem vindo.

Transcrição original

[00:06] Welcome to Interrupt, everyone. Isn’t this awesome? This is crazy. Yeah, this is the first time we’ve done this in New York. So, we’ve done this in SF the past two years, but we’re bringing it here for a full day. We’ve got an awesome lineup. We’ll be announcing a lot of awesome stuff, and we’ve got a ton of great fireside chats with folks in the field, and then a lot of great talks from people that are building agents and practitioners. So, a lot to hopefully learn from. So, I want to talk a little bit about the state of AI now and where

[00:39] we think it’s going. But before diving into that, I just want to do a brief kind of like tour over the past few years, because it seems like things move so fast, but it’s only like 3 years ago was when all of this kind of like really kicked off. Actually, a little bit before that was when LangChain launched, but in 2023, we were building prototypes. In 2024, we were shipping some of these simple applications to production, but they were still like single LLM calls. 2025, we started exploring agents. And really this year, we’ve started seeing that agents have transformed the

[01:12] application layer. And so, a lot of the talks that you’ll hear from today are companies that are doing exactly that. They’re taking these LLMs and they’re really building them into differentiated experiences. So it’s not just the model that they’re providing to their customers. It’s everything around the model. And so we’re seeing that these domain-specific agents, they’re not just wrappers. They’re providing real value to folks. And people are having to build a lot of things around the model to properly take advantage of that. And so, calling out a few. So Rogo, we’ll do a fireside chat with them later today.

[01:44] They had a great blog where they wrote about how they built a specialized harness with model routing to provide a domain-specific agent for finance. Harvey, who we heard from at some previous Interrupts, has been talking a lot about how they’ve fine-tuned models for specialized tasks to get the best performance on legal domain. And then JPMorgan Chase, we’ll hear from them later today. A little bit of a different use case, internal use case, but customizing the harness around the model to provide a lot of internal advantages for the agents that they’re building as part of their Jarvis assembly line.

[02:16] So, all of these are examples of companies taking the model, building a lot of stuff around it to make it truly theirs, and the phrase that has been going around to really exemplify all of this is owning your intelligence. When we talk about owning your intelligence, we talk about all of these examples. Basically building a lot of domain-specific things in and around the models to make it truly best for the domain that you’re trying to tackle, and really owning your intelligence. And we think there’s a few reasons why this has become a phrase that’s top of mind for so many people these days.

[02:50] First, token costs are rising a lot. People are spending more and more on AI, and so as they do so, they want to make sure that they’re getting the proper ROI, and being able to control and monitor token costs is really important. And so owning your intelligence in that regard is a key factor. Second, we see open models becoming more and more popular. So this provides not only a really cheap alternative in order to own the token costs more, but it also lets you customize things more. And so as these base open-weight models get better and better, you can start

[03:21] to post-train them. You can start to use them in specialized ways, and that just makes it easier than ever to really own your intelligence. And then the last thing that I think has become pretty clear over the past year is that the models themselves are becoming somewhat commoditized, and it’s all of this stuff around the model, in particular the data, whether that is actual kind of like context you’re providing or some of the domain-specific paths that you’re baking into the harness. This is becoming the differentiator to provide a lot of value for folks. And so because of all of these factors, we’re seeing people want to own their

[03:53] intelligence more and more. And that’s how we think about our mission as a company. It’s always been this way. LangChain got started a month before ChatGPT, but really took off after, when people saw that came out and they were like, “I want that, but for my industry, for my vertical.” And then a big value prop of LangChain has always been kind of like model optionality. So from the beginning, people were building these domain-specific things that were naturally kind of like decoupled from the model. And so this mission of kind of like owning intelligence has been something

[04:25] we’ve thought a lot about, and we think there’s three core pillars to this. And this is what we help folks with. So the first core pillar is open and controllable harness. And so there’s two kind of like key parts to this. One, we think the harness needs to be model neutral. So you shouldn’t be coupled to a particular model. This is both offensive and defensive. When the best new model comes out, whether it’s from OpenAI or Anthropic or TypeSafe with some of their Jev models, you want to be able to switch your harness to that as quickly as possible.

[04:57] And so your harness needs to be able to adapt to the best new model. It’s also defensive. You don’t want to get locked into a single model provider so that they can raise rates and things like that. The other part of this open and controllable harness is again what we talked about in terms of making these agents like really domain-specific. All of that is about bringing specialized context in particular ways to the model, to bring the right context at the right point in time, and you need to really control what the harness does, and what that control looks like could look different for different scenarios. So we’ve had LangGraph for a while, which is an open source framework for really

[05:29] creating these directed graphs, and that’s a really controllable way of bringing this harness. We also have Deep Agents now, and I’ll talk about that later, but that’s another kind of like open source model harness. We have a concept of middleware in there, which is a different way of injecting like decisions to make and things to do into this core agentic loop. And so regardless of what it is, you need a way to control really in real detail what’s going into the model. The second core pillar that we think makes up owning your intelligence is compounding,

[06:01] specifically compounding the intelligence that you get from when people use your system. So when you launch an agent, that is far from having a successful agent. You need to learn from how people use the agent, what the agent does, see where it makes mistakes, and being able to compound that agent’s intelligence, whether manually, by seeing errors and updating the code or updating the prompt, or more automatically, whether that’s with memory or prompt optimization things. This compounding loop is really important to build into your systems and

[06:31] to own. If you can define what better and what best looks like for your domain better than anyone else, you will be able to build the best agent for that domain. And so having eval… …intelligence is a really good way to build these domain-specific agents. And then lastly, governed. And so this is really crucial for internal agents. We’re seeing a ton of companies transform how they do internal operations. But when you have a lot of agents running around, you need to make sure that

[07:02] they’re properly governed. You need to make sure that you know how many exist, that you can control costs, that you can handle auth reliably. So different people accessing it only have access to what they should have access to. And so we see that governance is becoming an increasingly big topic around owning your intelligence. And so this is how we think about the three core pillars of owning intelligence. And we think there’s a bunch of different ways that you can get there. And so calling three out at a high level: people, process, and technology. And we’re going to talk most about technology during the rest of the keynote,

[07:33] but I want to touch really briefly on people and process, because those are also needed to transform your organization into an organization that can own its intelligence. So touching really briefly on people, this is roughly how we see a lot of organizations being built. There’s a ring one of like core platform engineers. These provide a lot of tools for other people to build agents. When we talk about governance, when we talk about this kind of like eval compounding loop, these provide the platform that other agent building teams internally can use to build and govern and compound their agents.

[08:06] Outside of that, we see agent engineers. So, this is a great term to describe the weird hybrid mix of data scientist and engineer and machine learning engineer that makes up the people who are driving these agents. And it’s a new skill set, and we see a lot of people from different disciplines coming in to be agent engineers, consuming things from the core platform team. And then lastly, there are a ton of subject matter experts inside and outside the company who are often the best people to decide what good looks like for an agent. And so having a platform that can touch those non-developers at the edges is

[08:37] super important. And so people, and kind of like setting up your organization to have this type of model, is what we see people doing. We also see people either implicitly or explicitly adopting a kind of like new process for building agents. As I mentioned before, it’s very iterative. You first launch an agent, it’s not going to be good. You need to iterate. And so there’s this life cycle, this loop that people are adopting in order to really get agents to be good enough. Roughly speaking, it’s build, test, deploy, monitor, and then crucially, when

[09:07] you take those monitor learnings and you bring them back into the build step. And of course, you want to do all of this in a governed way. And we’ll come back to this a little bit later, but people are doing this type of process all the time to improve their agents. And then I want to talk about the technology. And when we think about the technology, and the technology that we help build and provide, there’s really like two core parts to it. So one is the runtime. And this is how we got started, with the open source LangChain libraries, and continue to do open source things with LangGraph and Deep Agents. And then of course we want to build agents that don’t just

[09:38] run locally on your laptop but run in the cloud and can serve everyone inside your org, or the customers that you’re building for. And so there’s a deployment aspect to this runtime as well. And then there’s this observability and eval part, which is really crucial for the compounding layer. And so being able to see what agents are doing and measure how good they are behaving is really important. So these are the two kind of like core pillars of things that we build. And recently we’ve also focused on kind of like a third part, which is an intelligence layer that sits above them.

[10:09] So now when we think about LangSmith, our commercial platform, we think about it serving the runtime aspect, serving the observability and eval aspect, and then building in intelligence across the platform to really help people utilize these components and speed up that process, that agent development life cycle that I talked about earlier. And so, for the next few minutes, I want to walk through these kind of like three core parts of our platform and talk about some of the cool things that we’re doing and where we think the future’s going. So, I want to start with runtime.

[10:40] And so, what does the runtime for kind of like an agent look like? When we think of an agent, we generally think of there being three components. There’s the business logic. So, this is things like instructions, tools, skills, hooks. These are things that you guys have to provide when you’re building your domain-specific agents. What skills for a financial agent might look like are very different than what skills for a legal agent might look like. And so this is the business logic that everyone out here will provide to the agents. Then there’s the harness. And so the harness is what takes the model, takes a lot of this domain-specific

[11:11] context, and basically wires it all up so that the model can see the right context at the right point in time. This can be a very kind of like custom harness that you might build in LangGraph, or it can be a more kind of like general purpose harness, which we’re seeing more and more of. And so that’s why we built Deep Agents. And so Deep Agents is our newest open source library. We launched it about a year ago. It’s an off-the-shelf agent harness. It learns a lot from what coding agents do. So it has an execution environment with a file system and sandbox. It does a lot of context management in ways that coding agents do it, with compaction,

[11:46] but it’s built so that you can build these domain-specific agents. And then lastly, there’s the infrastructure. And so if you take this agent and it’s running locally on your laptop, great. You want to bring it to the cloud. There’s all of these components that you’re going to need to add in so that it can run remotely. You’ll want a runtime in a server that has durable execution. You’ll want some way to access tools securely. You’ll want some way to run this code that it writes. And we see a lot of agents writing code even if they’re not coding agents. You’ll need to access models. And so there’s all this infrastructure that goes into it as well.

[12:18] And so these are a lot of the components that we’ve built into LangSmith in pieces. So we have LangSmith Deployment, that’s really around the agent runtime. We have LangSmith Sandboxes for running code, in beta. We have an LLM Gateway in LangSmith, and I’ll talk about that, but that’s for access to models. And then a tool server is something that we’re working on for easy access to tools. And so there’s these different components that make up the infrastructure. And one of the things that we launched in beta at last Interrupt, but I want to spotlight real quick, is Managed Deep Agents.

[12:48] So Managed Deep Agents basically takes this harness and the managed infrastructure and combines it into one. And so now when you’re building an agent, you just provide your business logic, and then you get the harness and managed infrastructure together. And so that’s a lot easier to get started with than having to go business logic to harness to assembling all these three or four or five different pieces of infrastructure. And so we’re really, really excited about the Managed Deep Agents platform as a way to accelerate time to value and speed to kind of like production for a lot of these agents.

[13:20] There’s a few things that we’re announcing today as part of a new Managed Deep Agents release that we think will help even more with this. So first, one of the hardest parts of building these, especially internal kind of like company agents, is auth, and making sure that the right people can access and use the agent, but also that when they use the agent, if the agent connects to Notion or Jira, it’s connecting either on behalf of the user or as the agent’s kind of like fixed set of identity. And what the right answer is might depend, and so we’re introducing a lot of different primitives

[13:52] in Managed Deep Agents to facilitate this type of connections. So first is connections. These are basically tools, when you have a tool server, which is how Managed Deep Agents connects to tools. You can specify how you want your end users to auth to those connections. So we’re using auth there. Related to that, we have this idea of identity for agents. This just defines the agent to be either kind of like user permissioned or service permissioned on a whole. And then third is channels. So a big part of building these agents is exposing them to people.

[14:24] Slack is a massive one. When you have agents in Slack, how do you deal with auth in like a shared channel? If I message it in a shared public channel and my coworker messages it, whose auth is used for which runs? A lot of that we’re baking into off-the-shelf channels in Managed Deep Agents to hopefully make the auth problem a lot easier. Second, we’re adding more things around memory into Managed Deep Agents. And so, Managed Deep Agents has always had a concept of agent-level memory, but we’re now adding in user-level memory. So this means that it can remember things specific to the individual users

[14:55] that it interacts with. This is really powerful for customizing agents. And then third, we’re adding in built-in tools. So one of the most common things that agents need to do is search the web. And so we’re adding in a built-in tool via Parallel so that agents can access the web. And so now you no longer have to go get a separate API key for that. You can just use your LangSmith API key, use it with Managed Deep Agents, and get access to the Parallel web search MCP. And so putting this all together, Managed Deep Agents, we think, is the easiest

[15:26] way to go from the business logic to an agent that’s actually running in production. We’ve been working with a number of early design partners on this, and we’ve seen really good results, especially for just getting an agent up and running and having it be like this company harness, and that’s how we think about Managed Deep Agents, is this company harness that makes it really easy to get started building and sharing agents inside an org… …that I want to spotlight is decision models. And so over the weekend I, as I’m sure many of you did, played around with Jev.

[15:58] So it launched over the weekend. It’s a really interesting new type of model. And so what exactly is Jev? It’s a decision model. What does that mean? It basically means that it makes decisions. You send it a state. You send it a list of questions. It can then score those questions. And there’s different things that you can have it score on. So it can either be like a boolean or an actual score or a categorical choice, but it basically makes decisions. It can’t generate text, but it can make decisions. And so even though it’s more limited, we think this is really interesting. We think there are a bunch of different types of models and a bunch of different types of agent harnesses that will be built.

[16:29] So we think absolutely there will be these frontier models that are driving these really complex harnesses, and that’s what you’re going to use in like Claude Code and Codex and Deep Agents. These take advantage of these really frontier models. But there’s also a ton of other decisions that need to be made. And that’s where we think a decision model can be really helpful. And maybe these are small things that actually go along with the frontier model, or maybe they empower the LangGraph cognitive architectures and routing between different things. And so calling out a few of the things that we think these decision models

[17:00] are really useful. One is eval. So either running after the fact or in the loop. If you have an agent doing work, if you can score it quickly according to some criteria as it’s running, that’s really powerful, because then you can catch mistakes in real time. Two, guardrails. So flagging user input really fast. So I was talking to some people yesterday, and we were talking about guardrails. One of the downsides of guardrails is that it always adds latency. If now we can add them in a really low latency way, that’s really cool and powerful. And so we’re excited about it for that. And then lastly, model routing as well. Choosing which agents or which models or which skills or tools to load.

[17:33] We think things like Jev will be really, really useful for that. So you can access Jev through the LangSmith LLM Gateway. You can also access an open source decision model that we’re hosting there called SemIf. There’s been a massive explosion in these open source decision models since Jev launched. We think this is a new type of model that there will absolutely be a lot of options for, and we’re really, really excited to power and host a lot of these through our gateway. Speaking really quickly of our gateway, this is the last thing in the runtime that I want to spotlight. So, we launched LangSmith LLM Gateway in beta about

[18:07] a month or two ago. There’s two main things that I want to highlight. One, we try to make it so that the gateway can be used in all of the LLM applications that you’re building, whether they are customer-facing or internal. So, specifically, we normalize everything through OpenAI and actually Anthropic message format. So you can access it there. But we also allow straight pass-through in case there are new features that come out in these APIs and you just want to take advantage of. And then we also have a bunch of coding agent integrations, so Codex and Claude Code and Cursor.

[18:38] Again, we think you should be routing all of your traffic, for governance and cost control reasons. We think you should be routing all of it through a single LLM gateway. And so that means it needs to integrate with every application that’s using AI. And so we want to make it really easy to plug into all of those. And then the main kind of like features that we’re focusing on: one is cost controls, having cost visibility, but also setting spend limits for different teams, different users, different API keys. Two is rate limiting. So making sure that there’s not a single application that’s really throttling or taking up a lot of usage there.

[19:09] And then third is fallbacks. So you can fall back to different model providers when you get an error. And then one of the things that we’ll be launching soon is actually more stateful fallbacks. So if you notice that requests are failing and Anthropic might be down, you don’t even try them for the future. You just switch over to OpenAI for the next 10 minutes or 30 minutes, and make it really configurable in that way. And so we want to make LangSmith LLM Gateway the most kind of like secure and reliable way to monitor and govern and fall back on different LLM providers

[19:41] when you’re using them. So that’s everything that we’ve got going on in the runtime space. I now want to talk about observability and eval. This is a space that we think is crucial to really power that compounding loop, and where we’ve done a ton of stuff over the past year, but especially over the past month. So, we think traces are really the core of this loop. When you think about this loop, this process that I mentioned, we think traces being the system of record and showing what the agent does at all steps are

[20:13] really, really important to be able to power this kind of like learning loop. When we’ve talked about traces previously, we’ve talked about basically runs, traces, and threads. And so a run is like a single LLM call. A trace is like a single invocation of an agent. And then a thread is a series of traces, basically. So when you have a multi-turn interaction. So these are all really useful primitives, but it’s become pretty clear over the past year or so that there’s a more useful standard for how to represent

[20:45] what agents do. And this is what we’re calling trajectories. And so a lot of the agents these days, whether they’re coding agents or first-party agents, run in a similar way where they basically run an LLM in a loop and compile this list of messages. This list of messages is a standard format that can be used in a lot of really interesting ways. And so today, one of the things that we’re excited to launch is LangSmith Trajectories, a way to standardly interact with these trajectories and use them in a bunch of places. So let’s take a look.

[21:49] So what do trajectories do? We think there’s two main benefits to them. One, they make debugging a lot faster. So if you’ve used LangSmith before and you’ve had a really complex trace, ones that have thousands of kind of like iterations, you might have noticed that it’s pretty hard to parse through all of that. So the LangSmith Trajectories in the UI have a much more user-friendly interface for viewing what’s going on. They’ll look basically as if you’re using like a coding agent or a chat agent. We basically condense and display tool calls in the same way that those do. So you can easily kind of like scan through them.

[22:21] One big benefit of this is simpler annotation. So now that you can see what’s going on, you can leave feedback on them much more easily. A third big benefit that we think is this actually makes it much easier for post-training models. So when you post-train models, you commonly have these trajectories that are in this kind of like standard format. And so we do a lot of work in the back end to parse these really complicated kind of like trace formats that come in from all these different SDKs and different coding agents and expose them in a standard trajectory format.

[22:54] This can be used really, really easily in fine-tuning. When we talk about fine-tuning, there’s generally two pieces. There’s the data, and this will come from a lot of the traces and from a lot of the trajectories, and then there’s the inference and training infrastructure. And so we want to make it as easy as possible to bring these two things together, which is why we’re also announcing LangSmith Fine-Tuning today. So what does this mean? So you have all your data in LangSmith. These are all the traces, which now we’re porting into this trajectory format, which is a much more condensed and standard representation of what’s going

[23:26] on. You can then use the smithtune CLI, which is a CLI that we’re launching today to basically select traces, filter down to relevant ones, pre-process those traces in a way that makes them even more fine-tune ready, then pass them into Fireworks or Baseten, which is the training and inference infrastructure to do the actual training. We can then evaluate the models from there, and as the output, you get an optimized model. And so we think this is a really powerful way to get started fine-tuning, whether it’s on agents or classification tasks or guardrails or anything like that.

[23:59] We want to help you all take the most advantage of all the data that’s in LangSmith. And so we think trajectories power a lot of this. Now, where we’re storing these trajectories is SmithDB. We launched this at Interrupt a few months ago. This is a database that we built in house, and it’s really good for agent workloads. It’s a lot faster to ingest and store and query a lot of these workloads. We’ve made trajectories show up really nicely in them. So for example, I was talking about what they might look like earlier. This is a screenshot. You can see that we condense a lot of the long tool

[24:30] calls that are going on, but you can click into those, expand those. You can click into an LLM call and jump directly into that. So we try to make it look as nice as possible, but we know there’s a ton of different ways to actually visualize the data that you’re working with. And so that’s why today we’re also launching LangSmith Custom Apps. Let’s watch a video on that.

[25:16] Hey. So, LangSmith Custom Apps you can basically think of as Lovable, but for your data that’s already on LangSmith. So, you can chat with it. It will create a completely custom app. We actually open sourced our design system so that the coding agent that we use under the hood can leverage it, and it comes built in with all the

[25:49] permissions for sharing with your team and respecting the workspace or RBAC or ABAC boundaries that you’ve set up. And so we think this is a really powerful way to bring humans into the loop and inspect data. So that’s what we’re launching for observability and eval. The last thing I want to talk about is intelligence. So I mentioned earlier that there is this process, this life cycle for building agents. You build an agent, you then test it, deploy it, monitor. One of the things that we launched previously at Interrupt is LangSmith Engine. So LangSmith Engine is an engine that sits on top of this whole loop.

[26:22] Specifically, it sits on top of your traces in a tracing project. It runs in the background, and it basically does all the things that an AI engineer would do. It looks at issues. It tries to cluster them. It creates this like issue board. It tries to fix it with code. It tries to add an evaluator, add things to a dataset. And so this is something we’ve been working on for the past six months or so, and we’ve been working on a lot of improvements, and so today we’re packaging up a lot of those and announcing Engine v2. So let’s take a quick look at a video, and then I’m going to walk through a

[26:52] few of the exciting things in here after that.

[28:04] So I want to call out a few of the things in there. First, I want to call out that Engine can now test its fixes proactively. So what exactly does this mean? So this integrates really nicely with LangSmith Deployment, which we talked about in the runtime. So specifically, Engine now will spot issues in traces. It will spin up a preview branch on your deployment. It will confirm that that issue is in fact an issue. It will then make a fix, spin up a preview branch for that fix, run it against that to confirm that it’s fixed, and then basically present it as an issue that

[28:36] you can go in and see all that evidence that that issue actually was real and that the fix now fixes it. So again, this integrates right now with LangSmith Deployment, and that’s how we do it there. Another thing that I want to call out is red teaming. So previously, Engine only identified issues that existed in traces that people were sending to it, that were happening in the wild. With red teaming, Engine can now simulate different issues and then see what happens. So specifically, Engine will, and again this integrates with LangSmith Deployment

[29:06] for now, which is how we know how to call it. So LangSmith Engine will basically have access to the deployment. It will spin up different issues, different hypotheses, run these against the deployment, identify which ones produce bad results, where bad could be it learned something that it shouldn’t have. It produces a bad result. It is off-brand in some way. And then it will flag any issues to you. So, this is really good for identifying places where your agent fails.

[29:37] It’s also really good for creating an initial eval dataset. So, we’ve heard for a while that creating evals is really hard and really painful. And so, this helps automate a lot of that. This can absolutely be used before you even ship your agent into production and before those issues even occur. Another thing I want to call out is the performance improvements that the team has made. So, we’ve worked really hard on making it both better at finding issues, better at fixing issues, and then also making it a lot cheaper as well. And so, a lot of these are packaged up into Engine v2, which is live as of

[30:08] now. Engine has already scanned over 70 million traces and detected over 21,000 issues. It’s used by a lot of the fastest growing AI companies out there to really speed up that iteration cycle. That iteration cycle is everything when you’re building agents. And so anything we can do to help speed that up, we will absolutely do. And the last thing I want to announce is that Engine is now also available in self-hosted with bring your own key. And so this will be rolling out in V17 of self-hosted, which should be out in

[30:38] a week or two. So we’re excited to bring this to even more of the customers that we work with. So this is everything that we’ve launched and how we think about the technology that we build. We think there’s this runtime, and we think about this as the open source but also deployments, and more and more we’re seeing that these managed agent runtimes are becoming really powerful for going to production. We have observability and eval. We think a lot about how we can make this more agent native with trajectories, how we can make this more customizable with Custom Apps, and how we can help

[31:08] you use this data to tune models to better serve your workloads. And then lastly, we have this intelligence layer that sits above, and we want to make Engine do a lot of the things that agent engineers and AI engineers are doing now. And so the scanning of traces and the red teaming are just the start. All of this we want to build to help you guys build domain-specific agents and really own your intelligence. Again, whether that is agents that you’re building and putting in products or agents that you’re building to transform the internal operations of your

[31:39] company. And so you’ll hear from a lot of speakers and panelists later today about different ways to do that, different techniques, different examples of what that looks like. We’re really excited to be doing Interrupt in New York. We’re really thankful for all of you guys to be joining us. I think we’re going to have a fantastic day, and so I’m going to step off for a little bit, and I’d like to welcome up Jake, who will be our MC for the day. Thank you guys all for coming.