Managed Deep Agents: implantando agentes de missão crítica em produção

Ver no idioma original →

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: Managed Deep Agents | Deploying mission critical agents to production · Canal: LangChain · 15:32 · Assistir no YouTube

Tópicos: Agentes de IA, Avaliação e benchmarks de IA

Resumo

Victor, gerente de produto da LangChain, apresenta os componentes dos Deep Agents e explica como o harness combina contexto, execução, delegação e supervisão humana. Managed Deep Agents reúne o harness e a infraestrutura para facilitar a passagem de agentes do protótipo local à produção, permitindo que as equipes se concentrem na lógica de negócio e na melhoria dos agentes. A apresentação também aborda autenticação, conexões, memória, controle de acesso, versionamento e evals. Por fim, Victor destaca novas integrações e recursos, como canais HTTP, transferências de arquivos no Slack e busca integrada com Parallel.

Pontos-chave

• Um agent usa ferramentas para realizar tarefas, e o harness reúne os elementos que permitem ao modelo receber o contexto certo na hora certa.
• Deep Agents combina ambiente de execução, gerenciamento de contexto, delegação a subagents e supervisão humana.
• Managed Deep Agents agrupa harness e infraestrutura para facilitar a implantação e deixar as equipes focadas na lógica de negócio.
• A estrutura de arquivos permite definir instruções, skills, ferramentas e identidade em projetos Python ou TypeScript.
• Os comandos MDA init, MDA dev e MDA deploy permitem criar, testar localmente e implantar um agente.
• Conexões podem usar credenciais do usuário, do próprio agent ou de uma conta de serviço; a autenticação pode ser solicitada durante a execução.
• A memória e o controle de acesso podem variar conforme o usuário e o canal de interação.
• Context Hub oferece versionamento e colaboração em instruções, skills e memória; Harbor permite configurar evals e acompanhar experimentos no LangSmith.
• Os recursos anunciados incluem canais HTTP, acesso ao sistema de arquivos do sandbox, memórias no escopo do usuário, conexões, transferências de arquivos no Slack e busca com Parallel.

Capítulos

Início	Capítulo	Resumo
00:05	O que são agents, harnesses e Deep Agents	Victor define agents e harnesses e apresenta os componentes dos Deep Agents, incluindo execução, gerenciamento de contexto, delegação e supervisão humana.
03:50	Da prototipagem à produção	A apresentação explica como Managed Deep Agents combina harness e infraestrutura e mostra a estrutura de projeto e os comandos para criar, testar e implantar agentes.
07:34	Exemplo de agente e controle de acesso	O exemplo de um agente de go-to-market introduz a identificação de usuários, o uso de credenciais e as conexões com sistemas empresariais.
11:17	Memória, versionamento e evals	Victor aborda o controle de acesso à memória por canal, o versionamento com Context Hub, as evals com Harbor e a integração com Parallel.
13:57	Clientes e recursos anunciados	A apresentação destaca experiências de clientes e novos recursos, como canais HTTP, acesso a arquivos, memórias de usuário e transferências no Slack.

Citações

Um harness é basicamente todo o restante que incorporamos para criar o agent. — 00:38

Queremos dar ao modelo o contexto certo na hora certa. — 01:10

Queremos que as equipes se concentrem principalmente na lógica de negócio. — 05:22

Quando estiver pronto para entrar em produção, basta executar MDA deploy. — 07:01

Conceitos e entidades

• Deep Agents (conceito): Harness personalizável para criar agentes voltados a tarefas de diferentes domínios.
• Managed Deep Agents (ferramenta): Produto que combina o harness dos Deep Agents com infraestrutura gerenciada para facilitar a implantação em produção.
• LangChain (empresa): Empresa apresentada como desenvolvedora de Managed Deep Agents.
• LangGraph (ferramenta): Runtime sobre o qual Deep Agents é construído, com suporte a interrupções e execução pausada.
• LangSmith (ferramenta): Plataforma mencionada para implantação, traces e acompanhamento de experimentos.
• Context Hub (ferramenta): Recurso para armazenar e versionar instruções, skills e memória do agent.
• Harbor (ferramenta): Framework de evals integrado ao fluxo de Managed Deep Agents.
• Parallel (empresa): Parceira cuja ferramenta de busca foi integrada a Managed Deep Agents.
• Magical (empresa): Cliente que usa Deep Agents para apoiar pesquisas farmacêuticas com relatórios baseados em fontes.
• Victor (pessoa): Gerente de produto da LangChain que apresenta Managed Deep Agents.

Tradução completa (pt-BR)

00:05 Olá, pessoal, sou Victor. Sou gerente de produto aqui na Langchain. Meu foco principal são nossos produtos de runtime e, hoje, vamos falar sobre como implantar agents de missão crítica em produção. Vamos começar com uma pequena recapitulação do que são deep agents e, depois, falar sobre managed deep agents e por que estamos tão empolgados com eles. O primeiro ponto por onde sempre gostamos de começar é: o que é um agent? Essa é uma pergunta que recebemos bastante, e a ideia central de um agent é um modelo que usa ferramentas para concluir uma tarefa. Isso se baseia nos agents no estilo ReAct, que se popularizaram há

00:38 mais de um ano e que se baseiam em raciocínio e ação. Então, eles vão usar ferramentas e raciocinar sobre elas para realizar uma tarefa para você. A próxima pergunta que recebemos com frequência é: o que é um harness? Um harness é basicamente todo o restante que incorporamos para criar o agent. Isso pode incluir skills, ferramentas, contexto, subagents — realmente, todas essas coisas diferentes que colocamos em um agent para que ele consiga realizar uma tarefa. Por que fazemos isso? Por que todo esse esforço para construir um harness, construir um agent e passar

01:10 por todo esse desenvolvimento? Para dar ao modelo o contexto certo na hora certa. Muitas vezes, ao construir um agent, sabemos que o modelo só é tão poderoso quanto o contexto que fornecemos a ele. E precisamos sempre conseguir dar a ele o contexto certo na hora certa. Deep agents é um harness personalizável que podemos criar para qualquer tarefa específica de um domínio. Aproveitamos muitos dos aprendizados com agents de programação e com os diferentes harnesses disponíveis e reunimos tudo isso neste harness-base altamente personalizável, que você pode usar em praticamente qualquer caso de uso.

01:41 A anatomia de um deep agent é composta, essencialmente, por quatro áreas principais. A primeira é o ambiente de execução. Isso é fundamental para a filosofia de deep agents: abstraímos o sistema de arquivos para o agent. Assim, nós, como desenvolvedores, podemos definir uma espécie de barreira entre o modelo e os arquivos com os quais ele interage, por meio de um sistema de arquivos virtual. Esse sistema de arquivos pode estar em qualquer lugar. Pode ser composto por arquivos no S3. Pode até ser um sandbox onde o agent consiga escrever e executar código ou seu equivalente mais leve, um interpretador de código ou um REPL. Outra coisa muito legal nisso é que

02:13 isso ajuda no gerenciamento de contexto. Por exemplo, a divulgação progressiva de skills e coisas como memória entre threads. Se você quiser se lembrar de informações sobre agents ou usuários entre threads, pode fazer isso com o sistema de arquivos. Também podemos fazer coisas como sumarização. À medida que nosso contexto cresce cada vez mais, conseguimos resumir a conversa anterior, compactá-la e armazená-la no sistema de arquivos. E também podemos descarregar contexto. Por exemplo, se recuperarmos uma resposta muito grande de uma ferramenta, podemos descarregá-la no sistema de arquivos, em vez de carregá-la diretamente

02:45 na context window do nosso modelo. A terceira área principal é a delegação. Delegação é a capacidade de o modelo planejar, raciocinar sobre esse plano e, então, iniciar subagents para executar tarefas. Por fim, temos a participação humana no processo. Isso é fundamental para tudo o que fazemos aqui na Langchain. Esta conferência, na verdade, recebeu o nome da função interrupt, que é uma função do langraph. Deep agents é construído sobre o runtime do langraph. Portanto, você tem a capacidade de interromper e pausar a execução. Um bom exemplo de como levar um deep agent

03:16 para produção é o caso de um cliente nosso, a Magrical. A Magical tem muitos casos de uso diferentes, mas seu foco principal é um agent de pesquisa farmacêutica. Isso permite que os pesquisadores farmacêuticos carreguem um harness específico do domínio, capaz de raciocinar sobre uma determinada base de conhecimento para o domínio daquele pesquisador, sintetizar todos esses resultados e responder com um relatório coeso, com fontes citadas e tudo mais. Eles conseguiram criar tudo isso com deep agents, e uma tarefa que antes levava semanas para criar um novo agent para um pesquisador

03:50 agora leva apenas algumas horas, colocando tudo isso no harness de deep agents e fazendo o deploy no Langmith. Legal. Vamos falar sobre o que é necessário para levar um agent que funciona localmente e colocá-lo de fato em produção. Há, em linhas gerais, três áreas principais na construção de um agent. A primeira é a lógica de negócios, que consideramos a parte mais importante que desenvolvedores e equipes devem trazer: a expertise deles e as diferentes instruções e skills que o agent pode usar. A segunda é o próprio harness,

04:21 sobre o qual falamos: deep agents dá ao agent a capacidade de usar arquivos, gerenciar contexto e fazer todas essas coisas maravilhosas. A terceira área é a infraestrutura. Provavelmente, a infraestrutura é a parte mais entediante, mas é a mais importante quando se trata de realmente levar um agent para produção, de um jeito que outras pessoas possam usá-lo. Legal. Uma das primeiras coisas que fazemos quando estamos construindo um agent é criar um protótipo local. Fazemos ele funcionar na nossa máquina, ele funciona muito bem e ficamos empolgados. Então, queremos compartilhar isso com todo mundo.

04:52 Essa é, na verdade, uma etapa muito, muito valiosa. É aqui que podemos comprovar a mágica do agent, certo? Que ele realmente consegue fazer aquilo para que o estamos projetando. O que acontece, então, é que tentamos colocá-lo em produção e, nesse momento, precisamos pensar em muitas coisas diferentes, certo? Precisamos pensar em onde as pessoas vão usar esse agent, nas diferentes interfaces por meio das quais talvez queiram usá-lo e em como vamos conciliar os pontos de entrada dessas diferentes interfaces com o runtime propriamente dito. Precisamos conseguir enfileirar as execuções para que o agent consiga atendê-las de forma adequada. Precisamos estabelecer o streaming.

05:22 Precisamos fazer todas essas coisas diferentes para que o agent funcione de maneira confiável em produção. E, do ponto de vista da infraestrutura, isso exige que sua equipe considere aspectos diferentes. Com managed deep agents, queríamos tornar esse processo muito, muito fácil. Então, reunimos o harness e a infraestrutura para facilitar muito o trabalho das equipes, que podem se concentrar principalmente na lógica de negócios e em melhorar seus agents com evals, traces e engine, além de iterar sobre a lógica dos próprios agents, em vez de se concentrar na infraestrutura e nos aspectos do harness. Então, é mais ou menos assim que isso

05:55 fica: aquele diagrama anterior, com todas aquelas caixas diferentes que você precisava gerenciar por conta própria, agora fica muito mais simples com managed deep agents. Ele roda no nosso deploy comprovado do Langmith, com recursos como streaming, checkpointing, handlers de offload e coisas desse tipo. Integra-se diretamente aos sandboxes do Langmith para todo o controle do sandbox quando você precisa que os agents executem código. Também usa o context hub, sobre o qual falaremos um pouco mais adiante, que nos permite coordenar instruções e skills com usuários de negócios e iterar sobre elas. E, claro, também se conecta ao nosso gateway de LLM e aos traces. E o que é realmente bom é que, à esquerda

06:29 Do lado da interface do agente, fazemos um ótimo trabalho permitindo que você use seu agent em diferentes interfaces e as concilie. Então, como cuidamos de toda essa infraestrutura, agora podemos tornar muito fácil para você, como desenvolvedor, definir o agent. Em vez de defini-lo na sua própria lógica, podemos fornecer essa estrutura de pastas para você definir as coisas. Seu agent ficará em um arquivo como agent.ts ou agent.py. Isso funciona com Python ou TypeScript. Suas instruções, skills, ferramentas, identidade e todas essas diferentes primitivas que você precisa adicionar ao próprio agent ficarão em diferentes pastas ou arquivos no seu diretório.

07:01 É muito fácil começar. Tudo o que vamos fazer é executar MDA init e dar um nome ao nosso agent. Isso vai criar a estrutura de diretórios do projeto para nós. Depois de adicionar toda essa lógica, podemos executar MDA dev. Isso vai iniciar um servidor local do agent para nós, o mesmo servidor que alimenta o deploy do Langmith. Assim, você pode testar tudo localmente e garantir que esteja funcionando como esperado. E, quando estiver pronto para realmente colocá-lo em produção, tudo o que precisa fazer é executar MDA deploy. Isso vai fazer o deploy dele na infraestrutura gerenciada do Langmith. Isso torna muito, muito fácil passar de uma ideia para um protótipo, algo que funciona localmente e, depois, para produção. Legal. Então, vamos ver um exemplo real de um agent que talvez você queira criar e que alguém da sua organização possa usar. Este é um exemplo que usamos bastante internamente na Langchain: nosso agent de go-to-market, com o qual qualquer pessoa da organização pode interagir para fazer qualquer coisa relacionada a go-to-market. Então, vamos pedir que ele me prepare para uma determinada reunião e redija um e-mail para

07:34 eu revisar. Esse pedido é enviado para este agent de GTM. A aparência e o modo como podemos projetar esse agent são realmente bem simples. Agora, tudo isso corresponde a arquivos diferentes. Mais uma vez, as definições do nosso agent, ou seja, o tipo de manual sobre como queremos que ele execute diferentes tarefas, podem ficar tanto nas instruções quanto nas skills. Todas as conexões com diferentes sistemas de negócios, como Salesforce, Gong e outras plataformas, ficam em tools. E podemos definir como os usuários se autenticam e como nos lembramos de coisas sobre eles nos outros dois arquivos. Uma das principais questões que surgem quando conversamos com clientes sobre a criação de agents é que há quatro coisas assustadoras que costumam ser levantadas quando se leva um agent para produção: como identificamos quem está pedindo ao agent para fazer algo — por exemplo, preparar o e-mail ou a reunião? De quem são os dados que ele vai usar? A que memória ele poderá recorrer ou que poderá editar? E, por fim, o que acontece se ele não tiver acesso quando a execução for iniciada? Começando pela primeira questão, pensamos bastante nisso no managed deep agents: como conciliar quem faz as chamadas entre diferentes interfaces. O managed deep agents oferece suporte de primeira classe a diferentes canais. Você

08:04 pode criar facilmente um aplicativo do Slack e usar este agent, mas também pode querer disponibilizá-lo na interface web, no aplicativo web ou na sua própria plataforma. E você não quer que um usuário tenha que se autenticar novamente e refazer o processo de concessão de permissões toda vez. Então, criamos um gerenciador de autenticação muito bom que ajuda a conciliar esses usuários. Você pode conciliá-los entre essas diferentes interfaces, e tudo isso é passado facilmente para o runtime do managed deep agent. A segunda questão é: qual conta ele deve usar? Como desenvolvedores, podemos querer definir determinadas conexões e ferramentas que o agent pode usar e conectá-las de uma maneira específica.

08:37 Por exemplo, podemos dizer: quando ele usar nossa ferramenta de CRM, queremos sempre que use as credenciais do usuário. Queremos que ele aja em nome de quem fez a chamada. Então, se eu estiver em uma DM com esse agent e disser: “Prepare-me para esta reunião”, ele poderá usar minhas credenciais do Salesforce para acessar os dados. Há outros cenários em que você pode querer que seu agent tenha credenciais próprias, no escopo do agent, ou credenciais de uma conta de serviço. No managed deep agents, isso fica muito fácil com a primitiva de connections. Basta definir essas connections e enviar os tokens; se estiverem associados a usuários, nós cuidaremos disso

09:08 para você. E cuidamos disso facilmente durante a tarefa. Como temos human in the loop integrado ao deep agents e ao runtime do LangGraph, quando você faz uma solicitação e o agent não tem um token específico para determinado usuário, e esse token deve ser usado em nome dele, o agent pode simplesmente pausar e pedir que o usuário se autentique. O usuário clica no link e tudo continua normalmente. Isso pode acontecer quantas vezes forem necessárias, pois mantemos os interrupts em checkpoints. A segunda, ou terceira, área fundamental que se torna importante é a memória.

09:40 Há muitas abordagens diferentes para memória, e queríamos oferecer padrões muito bons. A primeira convenção é a memória no nível do agent, ou memória procedural. Temos uma ótima maneira de permitir que seu agent registre e lembre certos procedimentos relacionados aos usuários no managed deep agents. A segunda é a memória no nível do usuário: preferências pessoais que conto ao agent sobre mim. É muito importante que seu agent possa lidar com esses diferentes tipos de memória. E é aí que o controle começa a entrar em cena. Uma coisa que incorporamos ao managed deep agents é a possibilidade de definir o controle de acesso

10:14 com base no canal de onde vem a chamada. Por exemplo, se estou em uma DM do Slack, o agent pode usar minhas memórias pessoais e minhas credenciais pessoais, além de registrar memórias pessoais sobre mim, e isso não tem problema. Mas, se estou falando em um canal compartilhado com meus colegas de trabalho, provavelmente não quero que ele revele certas informações sobre mim. Então, como desenvolvedor, posso definir essas primitivas, se precisar. Outro aspecto muito bom do managed deep agents é que temos controle de versão para o contexto do agent com o context hub. Assim, podemos armazenar todas as nossas instruções,

10:45 skills e memórias em um repo do context hub. Isso nos permite colaborar nessa interface dentro do Lang. É ótimo para iterar em coisas diferentes, como instruções, manter o controle de versão, promover alterações para produção e coisas do tipo. Mas promover alterações para produção pode dar medo. Uma das coisas que incorporamos ao managed deep agents e em que investimos bastante tempo foi a integração com Harbor como framework de evals. Sei que falamos sobre Harbor hoje, mas realmente achamos que é uma ótima maneira de executar evals.

11:17 Mas o que descobrimos com os clientes é que pode ser um pouco difícil começar. Então, queríamos tornar tudo muito fácil no managed deep agents. Se você executar MDA eval, ele vai inicializar um ambiente Harbor para você e ajudar a configurar as tarefas e as verificações. Tudo isso será rastreado no Langmith e aparecerá na aba de experimentos do Langmith, permitindo que você aprimore seu agent com o tempo. Você pode executar as mesmas tarefas novamente e, na verdade, otimizar iterativamente seu agent diretamente na sua própria máquina. Uma das coisas que estamos anunciando hoje é nossa integração com Parallel.

11:48 skills e memória dentro de um repo de context hub. E isso vai nos permitir colaborar nessa superfície dentro do Lang. O que é ótimo para iterar em diferentes coisas, como instruções, ter controle de versão sobre elas, promovê-las para produção e coisas desse tipo. Promover para produção, porém, pode ser assustador. Então, uma das coisas que incorporamos ao manage deep agents, na qual realmente dedicamos bastante tempo, foi a integração com Harbor como framework de evals. Sei que falamos sobre Harbor hoje, mas realmente achamos que é uma ótima maneira de executar evals.

12:21 Mas o que descobrimos com os clientes é que pode ser um pouco difícil começar. Então, queríamos tornar isso realmente fácil para managed deep agents. Se você executar esse MDA eval nele, ele vai inicializar um ambiente Harbor para você. Vai ajudar a configurar as tarefas e as verificações. Tudo isso será rastreado no Langmith e aparecerá na aba de experimentos do Langmith, e você poderá melhorar seu agent ao longo do tempo. Você pode executar as mesmas tarefas novamente e, na verdade, melhorar iterativamente seu agent na sua própria máquina. Uma das coisas que estamos anunciando hoje é nossa integração com Parallel.

12:53 Estamos muito animados para anunciar essa integração. Ela será gratuita durante nossa beta pública. Então, fiquem à vontade para usá-la. A forma como funciona é basicamente esta: vocês podem simplesmente adicionar essa ferramenta ao seu deep agent gerenciado. Não precisam adicionar chaves de API paralelas nem nada do tipo. Tudo vai funcionar praticamente direto, sem configuração. Estamos muito animados com a parceria com a Parallel nesse projeto para deep agents gerenciados. Algo de que gostamos muito foi trabalhar não só internamente nos nossos próprios casos de uso de agents, como nosso agent de go-to-market e o Open Suite, que é um tipo de agent de fábrica de software, e iterar neles para deep agents gerenciados, mas também trabalhar com muitos dos nossos clientes. E

13:25 iterar neles para deep agents gerenciados, mas também trabalhar com muitos dos nossos clientes. Queríamos destacar dois clientes em particular. Zahed, da Kith, foi fundamental para nos ajudar a começar com alguns dos recursos básicos para colaborar com usuários no-code e usuários de negócios, além de definir como funcionariam as conexões e a memória. Tem sido ótimo trabalhar com Zahed, e o valorizamos como parceiro. Além disso, foi muito bom ver como Derek, da Consensus, usou deep agents gerenciados da maneira como realmente pretendíamos que fossem usados. Ele

13:57 e sua equipe de desenvolvedores circulam pela organização na Consensus e criam diferentes casos de uso de deep agents para várias áreas da organização. Como os deep agents gerenciados cuidam de toda a infraestrutura, eles conseguem implantar esses agents com muita facilidade. E conseguiram aumentar rapidamente a quantidade de agents usados em toda a Consensus, o que é muito empolgante. Então, o que há de novo hoje nos deep agents gerenciados? Primeiro, os canais HTTP. Esse recurso permite que você defina seus próprios canais personalizados. Temos ótimas integrações prontas, como a do Slack, por exemplo, mas sabemos que talvez vocês queiram usar seus agents de várias maneiras e em diferentes interfaces. Por isso, agora ficou muito fácil definir como o agent responde a determinados eventos e fazer com que ele responda a esses eventos por vocês. Então, com os novos canais HTTP, isso ficou muito fácil. Também adicionamos APIs bem melhores para acessar o sistema de arquivos do sandbox. Assim, não só o agent pode acessar o sistema de arquivos, como agora você também pode acessá-lo, como usuário, pelos seus frontends em diferentes lugares. O terceiro item são as memórias no escopo do usuário. Como mencionei, nós

14:29 pensamos bastante nas memórias no escopo do usuário e em como implementá-las de forma confiável e segura, e agora elas estão disponíveis nos deep agents gerenciados. E, claro, as conexões, que permitem autenticar e definir isso como desenvolvedores, também já estão disponíveis. A penúltima novidade são as transferências de arquivos no Slack. É muito comum querer colaborar em arquivos. Talvez você queira que um agent crie uma apresentação do PowerPoint ou um PDF. Você quer poder iterar nesses arquivos diretamente no Slack, e isso agora é um recurso nativo dos deep agents gerenciados. Por último, a busca integrada com a Parallel que acabei de mencionar. Ótimo. Obrigado a todos por participarem

15:00 pensamos bastante nas memórias no escopo do usuário e em como implementá-las de forma confiável e segura, e agora elas estão disponíveis nos deep agents gerenciados. E, claro, as conexões, que permitem autenticar e definir isso como desenvolvedores, também já estão disponíveis. A penúltima novidade são as transferências de arquivos no Slack. É muito comum querer colaborar em arquivos. Talvez você queira que um agent crie uma apresentação do PowerPoint ou um PDF. Você quer poder iterar nesses arquivos diretamente no Slack, e isso agora é um recurso nativo dos deep agents gerenciados. Por último, a busca integrada com a Parallel que acabei de mencionar. Ótimo. Obrigado a todos por participarem

15:32 hoje. Estamos muito animados para anunciar os deep agents gerenciados na nossa versão 0.8 e mal podemos esperar para ver o que vocês vão criar com eles e quais agents específicos de domínio vão desenvolver. Obrigado.

Transcrição original

[00:05] Hi everyone, I’m Victor. I’m a product manager here at Langchain. I primarily focus on our runtime products and today we’re going to talk about deploying mission critical agents into production. Um we’re going to start first with like a little refresher on what deep agents are and then we’ll talk about managed deep agents and why we’re so excited about them. So the first place we always love to start with this is what is an agent? Um it’s a question we get a lot and the core idea of an agent is it’s a model using tools um in order to complete a task and this is based on the React style agents that have become

[00:38] popular um over a year ago and that’s based on like reason and action. So they’re going to use tools they’re going to reason over it to accomplish a task for you. The next question we often get is what is a harness? So a harness is basically everything else that we bake in to create the agent. So that can be skills, it can be tools, context, sub aents, really all of these different things that we put into an agent um in order for it to accomplish a task. Why why do we do this? Like why do we go through all the effort of building a harness, building an agent and and going

[01:10] through all this development? And that’s to get the model the right context at the right time. So a lot of times um when we’re building an agent, we know that the model is only as powerful as the context that we give it. and we need to always be able to get it the right context at the right time. Deep agents is a customizable harness that we can build for any domain specific task. So we took a lot of the learnings of coding agents and different harnesses that are out there in the wild and we’ve really put it into this very customizable base harness that you can use for virtually any use case.

[01:41] The anatomy of a of a deep agent is really comprised of four core areas. The first being the execution environment. Um, and this is really core to the philosophy of deep agents is we sort of abstract away the file system for the agent. So us as developers, we can define sort of this wall between your model and the files it interacts with through a virtual file system. That file system can actually live anywhere. It could be S3 files. It could even be a sandbox where your agent can write and execute code or its lighter weight cousin, a code interpreter or a ripple. What’s really cool about this too is

[02:13] this helps with context management. So things like uh progressive disclosure of skills, doing things like cross thread memory. So you want to remember things about agents or about users across threads, you can do that in that with the file system. Um we can do things like summarization. So as our context grows and grows, we’re able to summarize that previous conversation, compact it down and store it in the file system. And then we can also offload context. So let’s say we retrieve like a very large tool response, we can actually offload that into the file system rather than directly loading that

[02:45] into our um our our model’s context window. The third kind of key area is delegation. So delegation is the ability for the model to plan reason over that plan and then kick off sub agents to execute things. And then lastly is human in the loop. Um human in the loop is very core to everything that we do here at Langchain. Um this this conference is actually named after the interrupt function which is a function of langraph. Um, deep agents is built on top of that langraph runtime. So you have that ability to interrupt and pause for execution. So a good example of taking a deep agent

[03:16] into production is a customer of ours which is Magrical. Magical has a a ton of different use cases but primarily focuses on a pharmaceutical research agent. Um, and this is for their pharmaceutical researchers to be able to load in a domain specific harness that is able to reason over a certain knowledge base for that particular researchers domain, synthesize all of those results and respond back with a cohesive report report with cited sources and all of that. They were able to build all of this with deep agents and a task that used to take them weeks to spin up a new agent for a researcher

[03:50] now just takes a few hours by putting this all into the deep agents harness and deploying it onto Langmith. Cool. So, let’s talk about like what it takes to take an agent from something that works uh locally and actually put it into production. So, there’s kind of like three core areas of building an agent. The first is the business logic and this is what we think is the most important thing for um developers and for teams to bring is this core idea of like their expertise and the different instructions and skills that your agent might use. The second is the harness

[04:21] itself which we talked about uh as deep agents gives our agent the ability to use files and do context management and all these wonderful things. And the third area is going to be infrastructure. So infrastructure is probably the the more boring area but the most important area when you talk about actually taking an agent and putting into production in a way that others can use it. Cool. So one of the first things that we do um when we’re building an agent, right, is we’re prototyping it locally. we get it running locally on our machine and it works great and we’re really excited and then we want to go and actually share this with everyone else.

[04:52] Um this is actually a very very valuable stage. Uh this is this is where we can kind of prove the magic of the agent, right? That that the agent can actually do what we’re designing it for. What happens then is we try to go into production and now we need to think about a lot of different things, right? We need to think about where people are going to use this agent, the different surfaces you might want your agent to be used from. um how you’re going to reconcile where those where those different surfaces are entering into your actual runtime. You need to be able to queue up the runs so that your agent can kind of serve them reasonably. You need to be able to establish streaming.

[05:22] You need to do all these different things in order to have this agent run reliably in production. And it requires kind of different things uh that your team has to consider from an infrastructure standpoint. With managed deep agents, we wanted to make this process very very easy. So what we’ve done is we’ve sort of bundled together the harness and the infrastructure to make it really really easy for your teams to work on primarily the business logic and actually improving your agents with eval with traces with engine and iterating on your actual agent logic rather than focusing on the infrastructure and the harness level stuff. So this is kind of what it

[05:55] looks like that that previous graph of all these different boxes that you had to manage yourself now becomes very easy with managed deep agents. It runs on our proven Langmith deployment um for things like streaming, checkpointing, um off handlers, things of that nature. It integrates directly with Langmith sandboxes for all of that sandbox control when you need agents to run and execute code. It also uses context hub, which we’ll talk about a little bit later, but allows us to kind of coordinate on instructions and skills with business users and iterate on things. And then of course, it plugs into our LLM gateway and traces as well. And what’s really nice is on the left

[06:29] side you’ll see this agent interface is we do a really good job of allowing you to use different use your agent from different interfaces and reconcile those. So since we’re handling all of this infrastructure, we now can make it really easy for you as a developer to define the agent. So rather than um kind of defining it in your own logic, we can go ahead and give you this folder structure in order to define things. So your agent will live in like the agent.ts um or agent.py. So this works for Python or TypeScript. your instructions, skills, tools, identity, all of these different primitives that you need to add to the agent itself will

[07:01] live in different folders or different files in your directory. Getting started is really easy. So, all we’re going to do is run MDA init and give our agent a name. That’ll scaffold this project directory for us. After we add in all of that logic, we can then go ahead and run MDA dev. And that’s going to start up a local agent server for us, which is the same server that powers Langmith deployment. So you’re able to test everything out locally and make sure that it’s working as intended. And then once you’re ready to actually go into production, all you need to do is run MDA deploy. And that’s going to go ahead and deploy it onto Langmith’s managed infrastructure. This makes it really,

[07:34] really easy to go from an idea to a prototype, something that works locally and then into production. Cool. So let’s take a look at an actual example of an agent that you might want to build and and someone something that people in your organization might use. This is sort of an example that we use a lot internally here at Langchain, which is our go to market agent and it’s something that anyone in our organization can interact with in order to do anything related to go to market. So, we’re going to ask it to prep me for a certain meeting and draft an email for

[08:04] me to review and that kind of gets sent into this GTM agent. The way that this looks and the way that we can design this agent is really quite easy. This now all maps to different files. So again our agent definitions at the beginning the sort of playbook for how we wanted to do different things can live in both the instructions and the skills and then all of the connections to different business systems like Salesforce Gong all these other sort of platforms lives in tools and then we can define how users authenticate and how we remember things about users in the other two files. So, one of the core things that when we talk about building agents with

[08:37] customers, there’s kind of four scary things that then get brought up when you bring it into production is how do we identify who’s who’s asking this agent to do what you know prep for the email or prep for the meeting. Whose data is it going to use? Which memory is it going to be able to reference or edit? And then lastly, what happens if it is actually missing access when that run it gets initiated. So jumping into the first one, this is something that we thought about a lot with managed deep agents is being able to reconcile the callers between different surface areas. So we have first class support for different channels in in managed deep agents. You

[09:08] can really easily just create a slack application, go ahead and use this agent, but you also might want to expose this agent in your web UI or your web application or your own platform. And you don’t want to have to have a user always like reauthenticate and re go through the permissioning over and over again. So what we did is built a very nice off handler that will help you reconcile those users and you can have them reconcile across these different surface areas and that all gets passed into the runtime for the manage deep agent quite easily. The second is whose account should it use. So as a developer we might want to define certain connections certain tools

[09:40] that your agent can use and connect them in a certain way. So we might want to say okay when it uses our CRM tool for example we always want it to use um the user’s credentials. So we want to have it operate on behalf of the caller. So, if I’m in a DM with this agent and I say, “Prep me for this meeting.” It’s then going to be able to use my Salesforce credentials and go and access that. There’s other scenarios where you might want your agent to have its own agent scope credentials or be able to have service account credentials. We make this really easy in managed deep agents with this connections primitive. So, all you need to do is define these connections, upload tokens, if they’re user based, we’ll actually handle that

[10:14] for you. And how we handle that is really easily midtask. So since we have built-in human in the loop in deep agents and in the langraph runtime, what happens is when you make a request and the agent doesn’t have a particular token for a particular user and it’s an on behalf of token, it’s actually able to really easily pause, ask the user to go ahead and authenticate. They’ll click the link, everything um proceeds as normal and this will happen indefinitely since we have the uh the interrupts checkpointed. The second or the third kind of core area that becomes interesting is memory.

[10:45] Um there’s a lot of different uh approaches to memory and we wanted to have really good defaults for this. So the first kind of convention is agent level memory or procedural memory. We have a really great way for your agent to be able to take and remember certain procedural things about users and manage deep agents. The second is user level memory. So personal preferences that I tell the agent about myself. Um and it’s really important that your agent is able to kind of take these different types of memory. And this is where control starts to come into place. So, one thing that we’ve built into manage deep agents is allowing you to define the access

[11:17] control based on the channel that it’s calling from. So, if I’m in a Slack DM, for example, it can use my personal memories. It can use my personal credentials. It can take personal memories about me, and that’s totally fine. But if I’m talking in a shared channel with my other co-workers, I probably don’t want it to be able to unveil certain information about me. So, as a developer, I can define those those sort of primitives um if I need to. Another really nice part of manage deep agents is we get version control for our agent context with context hub. So we’re able to store all of our instructions,

[11:48] skills, and memory inside of a context hub repo. And that will allow us to collaborate in this in the surface within lang. Um which is really great for kind of iterating on different things like instructions, having version control over it, promoting it to production, things of that nature. Promoting it to production though can be scary. So, one things that we built into manage deep agents that we’ve um really spent a lot of time on was its integration with Harbor as an eval framework. So, I know we’ve talked about Harbor today, but we really think it’s a great great way for running evals. Um,

[12:21] but what we found from customers is that it can be a bit difficult to get started with. So, we wanted to make it really easy for managed deep agents. If you run this MDA eval in it, it’ll go ahead and initialize a Harbor environment for you. Help you set up the tasks, help you set up the checks. All of that will get traced into Langmith and show up in your Langmith experiments tab and you’re able to kind of improve your agent over time. You can rerun the same tasks and you can actually hill climb your agent right in your own machine. One of the things that we’re announcing today is our integration with Parallel.

[12:53] So, we’re really excited to announce this integration. Um, it’s going to be free during our public beta. So, please feel free to go ahead and use it. Um, but the way that it works is essentially you can just go ahead and add this tool to your managed deep agent. You don’t have to add any parallel API keys, anything like that. It’ll all kind of work just out of the box. So, we’re really excited about partnering with Parallel on this for managed deep agents. So something that we’ve um really really enjoyed was working not only internally with our own agent use cases like our go to market agent um open suite which is like a software factory type agent and

[13:25] iterating on that for managed deep agents but also working with a lot of our customers. Um and we wanted to highlight two customers in particular. Um Zahed from Kith was instrumental in really helping us getting started with some of the primitives of collaborating with no code users with business users. Um also setting up how connections and memory will work. So, it’s been really great working with Zahed and we we value him as a partner. Additionally, Derek from Consensus um has been really really great to see how he’s actually used managed deep agents in a way that um we really intended it to be used. So, him

[13:57] and his team of developers kind of go around the org there at Consensus and they build out different deep agent use cases um for different parts of the org. And because manage deep agents handles all of the infrastructure, they’re able to really easily kind of go and deploy these agents. And they’ve been able to really rapidly um increase the amount of agents that are being used across consensus, which is really exciting. Um so what’s new as of today in managed deep agents? The first is um HTTP channels. And the primitive here allows you to basically define your own custom channels. So we have great pre-built

[14:29] integrations for Slack, for example, but we know that you might want to use your agents in a variety of different ways across a variety of different surfaces. So we make it very easy for you now to define how your agent responds to certain events where it then responds to those events for you. So um it’s very very easy now with the new HTTP channels. We also added much better um APIs for accessing your sandbox’s file system. So not only can the agent access the file system, but you as a user can now access it from your front ends in different places. The third is user scope memories. So as I mentioned um we

[15:00] thought a lot about user scope memories and how to do it reliably and safely and that’s now available in manage deep agents. And then of course connections which is how we’re going to actually authenticate and define that as developers is now available. The the second to last is file transfers in Slack. So very commonly you’re going to want to collaborate on files. You maybe want an agent to create a PowerPoint for you, create a PDF. You want to be able to iterate on it with right within Slack and that is now first class and managed deep agents. And lastly, um the built-in search with parallel that I just mentioned. Awesome. Thank you all for for joining

[15:32] today. Um we’re really excited to announce uh manage deep agents in our point8 release and we can’t wait to see what you build with it and build your domain specific agents. Thank you.