Por dentro do Managed Deep Agents: mda CLI, Context Hub e Harbor Evals | Interrupt London

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: Inside Managed Deep Agents: mda CLI, Context Hub, and Harbor Evals | Interrupt London · Canal: LangChain · 14:42 · Assistir no YouTube

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

Resumo

Victor, gerente de produto da LangChain, apresenta como levar agentes especializados do protótipo à produção com Managed Deep Agents. Ele explica o papel do harness, do gerenciamento de contexto, da delegação e da infraestrutura para operar agentes com segurança e confiabilidade. A apresentação também mostra recursos de autenticação, memória, Context Hub e evals com Harbor, além de novidades como canais HTTP e agendamentos criados por agentes.

Pontos-chave

Um agente combina um modelo com um agent harness que fornece contexto, skills, memória e instruções adequadas à tarefa.
Deep Agents oferece uma base personalizável com ambiente de execução, gerenciamento de contexto, delegação a subagents e supervisão humana.
Levar agentes à produção exige lidar com multi-tenancy, persistência, execução durável, streaming e filas de tarefas.
Managed Deep Agents integra harness e infraestrutura, com recursos como LangSmith Deployment, LangSmith Sandboxes, MCP, A2A, governança, tracing e evals.
O CLI mda permite iniciar um projeto com mda init, executá-lo localmente com mda dev e publicá-lo com mda deploy.
A autenticação e as credenciais podem ser definidas por usuário ou por agente, e a execução pode pausar até que uma pessoa autorize o acesso.
Memórias pessoais e memórias do agente podem ser usadas conforme o canal, evitando expor informações privadas em espaços compartilhados.
Context Hub permite que equipes colaborem na edição e no controle de versão do contexto e das skills dos agentes.
A integração com Harbor facilita configurar ambientes, verificações e conjuntos de dados para evals.
Novidades apresentadas incluem canais HTTP personalizados, agendamentos criados por agentes e configuração dinâmica por execução.

Capítulos

Início	Capítulo	Resumo
00:06	O que é um agente e como funciona o Deep Agents	A palestra apresenta a evolução da definição de agente e os componentes centrais de um harness personalizável.
03:14	Do conhecimento de domínio à produção	O exemplo da Madrigal ilustra como transformar expertise em skills, enquanto a palestra descreve as camadas necessárias para operar agentes em produção.
06:54	Estrutura de projeto e configuração de agentes	Victor mostra como criar, executar e publicar projetos com o CLI mda e como organizar instruções, skills, ferramentas e identidade.
10:34	Memória, Context Hub e evals	A apresentação aborda memórias com diferentes escopos, colaboração no Context Hub e configuração de evals com Harbor.
13:39	Novidades e parceiros de design	Victor destaca parceiros de design e novos recursos, incluindo canais HTTP personalizados, agendamentos e configuração por execução.

Citações

Acreditamos de verdade que os modelos são tão poderosos quanto o contexto que recebem. — 01:08

Isso facilita para você e seus desenvolvedores trabalharem no que realmente melhora o agente: a lógica de negócio. — 05:21

Com a execução durável, fica muito fácil fazer coisas no meio de uma tarefa. — 10:34

Estamos animados para ver vocês experimentarem o Managed Deep Agents e trazerem sua expertise de domínio. — 14:42

Conceitos e entidades

LangChain (empresa): Empresa responsável pelo Managed Deep Agents e pelas ferramentas apresentadas na palestra.
Managed Deep Agents (ferramenta): Plataforma que combina um harness de agente com infraestrutura para executar agentes em produção.
Deep Agents (ferramenta): Base personalizável para criar harnesses específicos para diferentes domínios e casos de uso.
agent harness (conceito): Conjunto de componentes em torno do modelo, como skills, memória e system prompt, que fornece contexto para a execução.
LangSmith Deployment (ferramenta): Runtime de produção no qual o Managed Deep Agents é executado.
LangSmith Sandboxes (ferramenta): Ambientes que permitem executar código de agentes com segurança.
Context Hub (ferramenta): Espaço de colaboração para equipes visualizarem, editarem e controlarem versões do contexto e das skills de agentes.
Harbor (ferramenta): Ferramenta integrada ao Managed Deep Agents para configurar ambientes e verificações de evals.
LangGraph (ferramenta): Runtime usado pelo Deep Agents que oferece recursos como execução durável, checkpointing e human in the loop.
Madrigal (empresa): Empresa de pesquisa farmacêutica que criou um harness específico para apoiar e padronizar o trabalho de pesquisadores.
Parallel (empresa): Parceira da LangChain que oferece acesso a APIs de busca com zero retenção de dados, segundo a apresentação.
Kyth (empresa): Organização de Zahid, um parceiro de design que contribuiu para definir credenciais e memórias com escopo de usuário.
Consensus (empresa): Parceira de design que desenvolveu agentes internos para diferentes áreas da organização.

Tradução completa (pt-BR)

00:06 Certo. Olá, pessoal. Sou Victor. Sou gerente de produto aqui na LangChain. Hoje vamos falar sobre como colocar agents de missão crítica em produção e, em linhas gerais, sobre tudo o que é necessário para pegar um Deep Agent, por exemplo, e colocá-lo em produção com Managed Deep Agents. Então, o primeiro ponto por onde gostamos de começar — e é uma pergunta que recebemos com frequência — é: o que é um agent? Harrison falou um pouco sobre isso mais cedo hoje. A primeira definição que tínhamos na LangChain era a ideia de um agent no estilo ReAct, ou um agent no estilo raciocínio e ação.

00:38 Esse é, em linhas gerais, um agent que consegue reagir, usar um conjunto de ferramentas e raciocinar e agir em uma tarefa específica para alcançar aquele objetivo. O que aconteceu recentemente foi que essa ideia evoluiu para o conceito de agent harness. Então, agora estamos falando de modelo mais harness, e é isso que define um agent para nós. E isso inclui tudo o que colocamos em torno do próprio modelo, certo? Skills, memória, system prompt e todas essas coisas.

01:08 A pergunta que recebemos bastante é: por que fazemos esse esforço? Por que nos damos ao trabalho de construir um agent harness específico para nosso caso de uso? A razão é realmente fornecer ao modelo o conjunto correto de contexto, no momento certo, para que ele execute sua tarefa específica. Acreditamos de verdade que os modelos são tão poderosos quanto o contexto que recebem. Então, quando começamos a construir nossos próprios harnesses, queríamos nos concentrar em criar um harness base personalizável. E é isso que Deep Agents é. É uma ótima maneira de começar e construir

01:41 aquele harness específico para o domínio do seu caso de uso. Então, o que entra nesse harness do Deep Agents? Há quatro áreas principais. A primeira é o ambiente de execução, que é realmente a espinha dorsal do Deep Agents: a ideia de que um agent pode usar um sistema de arquivos. Hoje, os modelos são muito, muito bons em usar sistemas de arquivos, escrever código e coisas do tipo, e queremos mesmo aproveitar isso ao criar nossos agents. Então, o Deep Agents oferece suporte de primeira classe a isso, e também podemos combiná-lo com um sandbox para que ele possa executar esse código em um ambiente seguro

02:13 ambiente. A segunda área central é o gerenciamento de contexto. O gerenciamento de contexto é muito importante para a divulgação progressiva de skills. Precisamos conseguir gerenciar a memória e fazer com que o próprio agent gerencie a memória. Em alguns casos, queremos poder resumir conversas, compactá-las e descarregar o contexto quando necessário. Então, se uma ferramenta, por exemplo, retornar uma saída muito grande, podemos armazená-la no nosso sistema de arquivos e esperar que o modelo consulte esse contexto quando precisar dele. A terceira área principal é a delegação.

02:43 É muito, muito importante conseguir decompor uma tarefa e delegá-la a subagents especializados ou de propósito geral. E a última área é a condução com human in the loop. Isso é essencial para o que fazemos aqui na LangChain. E parte da razão de esta conferência se chamar Interrupt é essa função de promover o human in the loop e permitir que seu agent espere a aprovação de uma pessoa para realizar uma ação. Então, ao pensarmos em criar esses harnesses específicos para cada domínio, uma das empresas que estou animado para destacar, por ter trabalhado bastante com ela, é a Madrigal.

03:14 É uma empresa de pesquisa farmacêutica, e eles conseguiram criar um harness específico para o domínio que ajuda seus PhDs e pesquisadores a realmente melhorar e padronizar a forma como fazem suas pesquisas. Eles pesquisam em várias áreas diferentes da indústria farmacêutica e queriam mesmo codificar esse conhecimento e torná-lo muito valioso para que o restante da organização pudesse criar agents para seus casos de uso e agents de pesquisa para seus domínios específicos. E, para fazer isso, eles dividiram essas áreas e organizaram sua expertise em skills.

03:45 A equipe de plataforma e seus engenheiros os ajudam a criar evals e a fazer essa roda girar, algo sobre o qual tenho certeza de que vocês ouviram bastante hoje. Então, quando pensamos em criar um agent, algo que Harrison mencionou um pouco mais cedo hoje é que tudo se divide em três camadas. A primeira é a lógica de negócios, que é o que vocês trazem, certo? É a sua expertise. É o que vocês precisam para criar agents para si mesmos. A segunda é o harness. Precisamos de um lugar para essa expertise ser executada, certo? Precisamos de um sistema para executá-la. E é isso que esse harness, ou esse harness base do Deep Agents, oferece.

04:17 E a terceira é a infraestrutura. Isso inclui tudo o que envolve transformar um agent em um sistema multi-tenant e dar a ele um ambiente de execução de produção. Cada uma dessas camadas — todas as três — precisa funcionar em conjunto, de forma coesa, para colocar um agent em produção de maneira confiável. Quando falamos em colocar um agent em produção, geralmente o primeiro passo é assim: vamos prototipar localmente. Fazer o agent funcionar localmente é uma experiência quase mágica, certo? Conseguimos demonstrar que um agent pode realizar determinada tarefa para nós. E esse é um momento muito empolgante, muito valioso.

04:47 É nesse momento que nós, como desenvolvedores e engenheiros de agents, demonstramos que conseguimos criar um agent para fazer algo específico de um domínio. Depois, começamos a levá-lo para produção, e é aí que as coisas começam a ficar um pouco complicadas. Precisamos lidar com multi-tenancy, persistência, execução durável e streaming. Todas essas coisas necessárias para colocar um agent em produção passam a ser responsabilidade da sua equipe se vocês fizerem tudo do zero, certo? E há muitas camadas diferentes que podem falhar. Por exemplo, uma fila de tarefas pode ser algo que

05:21 pode ser complicado. É preciso conseguir priorizar quais tarefas o agent vai assumir e qual prioridade será dada à execução delas. Tudo isso fica complicado à medida que você escala para muitos, muitos, muitos usuários. O que fizemos agora com Managed Deep Agents, e por que estamos tão animados com isso, foi combinar estreitamente esse ambiente de execução, o próprio harness, com a infraestrutura. Esse é um passo muito importante para facilitar que você e seus desenvolvedores trabalhem naquilo que realmente torna o agent melhor,

05:51 que é a lógica de negócios. Quando falamos em colocar um agent em produção com Managed Deep Agents, é mais ou menos assim que funciona. Todas aquelas coisas e conexões que sua equipe antes precisava manter, gerenciando o harness e a infraestrutura — como a execução durável e a fila de tarefas que mencionei — já vêm prontas com Managed Deep Agents, que roda no LangSmith Deployment, um ambiente de execução de produção comprovado que temos aqui. Você tem MCP e A2A para fazer a orquestração entre

06:22 muitos agents. Temos o Context Hub, uma ótima interface para interagir com usuários de negócios sobre uma lógica de negócios específica e outras coisas, como instruções e skills. Você pode colaborar com eles nesse Context Hub. Temos os LangSmith Sandboxes para executar código com segurança. Isso é muito importante quando você pensa em dar ao seu agent acesso para escrever e executar código. É preciso oferecer a ele um ambiente seguro para isso. Depois, temos nossas camadas de governança com o LLM Gateway e, claro, nossos recursos de rastreamento e evals.

06:54 Agora, como cuidamos de boa parte dessa infraestrutura com o harness, conseguimos estruturar esse projeto em uma organização muito coerente. Isso já trouxe muitos benefícios internamente aqui na LangChain. Temos muitos desenvolvedores e engenheiros de agents trabalhando em diferentes agents dentro da empresa. E definir nossos agents com essa estrutura de projeto tem sido muito útil para entrar em qualquer projeto de agent e entender exatamente como ele funciona. Fazemos essa estruturação com um único comando simples. Podemos executar mda init e dar um nome, como GTM agent, e isso vai

07:25 e criar essa estrutura de projeto para nós. Depois que definirmos nossa lógica de negócios, poderemos executá-la localmente com o LangSmith Studio usando mda dev. E, quando estivermos prontos para ir para produção, basta executar mda deploy e fazer o deploy em produção. Então, para mostrar como isso funciona na prática, gostaria de usar o exemplo de um agent de GTM que Harrison mencionou hoje mais cedo. Esse é um agent muito poderoso. Nossos vendedores, nossa equipe de GTM e as pessoas — eu inclusive — adoram usá-lo. Ele realmente ajuda no dia a dia, acompanhando tudo

07:56 que pode acontecer no ambiente de trabalho. Mas tudo o que entra no Deep Agents agora também pode ser refletido nessa definição do agent de GTM. Assim, agent.ts ou agent.py — vocês podem usar TypeScript ou Python — definirá o loop do seu agent. As instruções definirão a lógica do agent, ou seja, a definição central de como vocês querem que ele se comporte. Depois, podemos fornecer a ele algo como playbooks. Por exemplo, para o agent de GTM, damos a ele determinados playbooks para diferentes ações por meio de skills e também podemos conectá-lo a todos os sistemas necessários com tools, conectando-o

08:27 a servidores MCP e coisas desse tipo. E os dois últimos itens são muito importantes para definir como queremos lidar com autenticação e identidade, além de definir o que ele lembra e como lembra. Então, configurar esse agent é uma parte empolgante, assim como deixá-lo pronto para funcionar. Aí começamos a pensar na próxima camada, certo? E uma das partes mais difíceis de criar agents e colocá-los em produção é garantir que eles tenham acesso ao contexto certo e as permissões corretas para acessar esse contexto ou essas diferentes tools.

08:59 Então, a primeira camada essencial que começamos a perceber é que precisamos descobrir quem pode chamar o agent, certo? No Managed Deep Agents, fazemos isso com um serviço centralizado, por assim dizer, de tratamento de autenticação que, dependendo do canal ou de onde você está chamando esse agent, identifica quem é o principal dessa chamada — seja o próprio agent ou um usuário específico — e repassa essa informação ao contexto de execução. Assim, é possível identificar o usuário e garantir que essa informação seja repassada para diferentes tools ou outras conexões.

09:31 À medida que avançamos… Temos o contexto desse usuário e, agora, durante a execução, precisamos ver, certo, qual conta o usuário deve usar — ou, melhor dizendo, qual conta o agent deve usar. Em alguns casos, talvez você queira garantir que o agent use apenas credenciais vinculadas ao usuário. Como desenvolvedor, você pode definir isso com muita facilidade, como mostrado aqui. Em outros casos, talvez queira usar uma conta de serviço ou uma credencial vinculada ao agent, e isso também é muito fácil. Como podem ver, há simplesmente dois tipos que vocês definem como desenvolvedores para determinar isso ao usar tools ou servidores MCP, coisas

10:02 desse tipo. Como o Deep Agents roda no runtime do LangGraph, temos execução durável, checkpointing e human in the loop, e também podemos pausar e esperar indefinidamente pelo acesso a determinados sistemas. Então, por exemplo, quando eu usar o agent de GTM no Slack pela primeira vez, se precisar me autenticar para que ele use nosso CRM em meu nome, ele vai me pedir autorização e enviar uma mensagem que só eu consigo ver. Posso voltar três dias depois e dizer: “Ah, é mesmo, eu tinha esquecido que precisava fazer isso.” Aí, clico em autorizar e a execução continua exatamente

10:34 de onde parou. Então, graças à execução durável, fica muito fácil fazer coisas no meio de uma tarefa. A próxima parte é a memória. A memória realmente nos ajuda a acumular conhecimento e aprender com o tempo. Há certos cenários em que você quer que um agent consiga usar uma espécie de memória no nível do agent para aprimorar sua memória procedural, ou que use a memória do usuário: preferências pessoais, como gosto de escrever e-mails, como gosto de entrar em contato com clientes e coisas desse tipo. Também é muito fácil definir isso no Managed Deep Agents.

11:04 Uma coisa muito boa é que, como gerenciamos isso no código e podemos definir essas configurações conforme o canal que chama o agent, além da própria tool específica, posso controlar se ele vai usar um conjunto de memórias pessoais e credenciais pessoais dependendo de onde eu o chamo — por exemplo, em uma mensagem direta no Slack. E, se também quiser usar esse agent em um canal compartilhado do Slack, é claro que não queremos vazar informações privadas. Então, nesses casos, podemos fazer com que o agent use credenciais vinculadas ao agent ou contas de serviço, para termos certeza de que é seguro.

11:34 Como mencionei antes, temos uma integração nativa com o Context Hub do LangSmith, que nos permite colaborar com os usuários de negócios no contexto ao qual o agent tem acesso. Isso é muito valioso para manter o controle de versão desse contexto em um espaço compartilhado, onde todos podemos visualizá-lo, interagir com ele e editá-lo. E uma das coisas boas que percebemos é que as pessoas costumam colaborar em skills. Elas podem promover skills para workspaces e fazer coisas desse tipo. E, quando vocês começam a fazer essas alterações, uma coisa que sabemos ser muito valiosa ao trabalhar com muitos clientes, especialmente clientes

12:06 que usam o LangSmith, são os evals. Os evals são muito, muito fáceis no Managed Deep Agents. Temos uma integração nativa com o Harbor, que facilita bastante configurar todos esses detalhes complexos que o Harbor oferece, de forma gerenciada. Posso executar mda evals init e, se passar a flag interativa, ele vai executar com um agent de programação e ajudar vocês a configurar os ambientes do Harbor, definir as verificações e todas essas coisas que fazem parte da criação de bons evals. Depois, vocês podem começar a iterar e a subir gradualmente o desempenho desses

12:37 conjuntos específicos de dados de eval e experimentos. Algo que nos deixa muito empolgados é que lançamos uma parceria com a Parallel, que vocês podem encontrar nos espaços de demonstração, e estamos oferecendo retenção zero de dados. Essencialmente, vocês podem usar o serviço diretamente pelo LangSmith, sem precisar obter sua própria chave de busca da Parallel. Acreditamos que isso é muito importante. Ter acesso a dados realmente bons por meio de diferentes APIs de busca é muito valioso para a maioria dos casos de uso com agents. É muito fácil adicioná-lo ao seu Deep Agent gerenciado por meio de MCP, assim como

13:08 acessá-lo pelo próprio LangChain ou pelo LangSmith. Estamos muito empolgados em destacar alguns dos nossos parceiros de design, que estiveram conosco desde o início deste projeto. À esquerda está Zahid, da Kyth, que trabalhou conosco e realmente nos ajudou a definir como implementar credenciais e memórias vinculadas ao usuário, entre outras coisas. Ele também tinha opiniões bem firmes, o que é muito útil em um parceiro de design. O segundo é a Consensus, que, junto com Derek e sua equipe, tinha um caso de uso muito interessante: atuar como uma equipe de resposta rápida em diferentes

13:39 áreas da organização e criar agents internos para cada uma delas. E isso é algo que estamos vendo se tornar cada vez mais popular à medida que os clientes começam a ampliar a variedade de agents internos nas empresas e a disponibilizar essa expertise para outras equipes. Então, as novidades do Managed Deep Agents desta última semana são todas essas coisas maravilhosas. Há algumas que gostaria de destacar. A primeira são os canais HTTP, que permitem definir canais personalizados. Temos integrações nativas com Slack, GitHub e alguns outros. Mas também queríamos definir uma especificação flexível para que vocês, desenvolvedores, possam implementar seus próprios canais e decidir como querem usar o agent. E, mais abaixo, os agendamentos criados pelo agent são muito úteis. Vocês podem dizer ao agent: “Ei, toda segunda-feira às 9h, execute este relatório para mim ou descubra quais reuniões com clientes eu tenho”, e coisas desse tipo; então ele pode criar os próprios agendamentos. Por fim, a configuração por execução permite criar agents dinâmicos. Assim, dependendo do contexto em que chamo o agent, posso inserir alguns

14:11 mais alguns. Mas também queríamos definir uma especificação flexível para que vocês, como desenvolvedores, pudessem implementar seus próprios canais e decidir como querem usar seu agent. Mais abaixo, os cronogramas criados pelo agent são muito úteis. Você pode simplesmente dizer ao agent: “Ei, toda segunda-feira às 9h, gere este relatório para mim ou veja quais reuniões com clientes eu tenho”, coisas desse tipo, e ele pode criar os próprios cronogramas. E, por último, a configuração por execução permite criar agents dinâmicos. Assim, dependendo do contexto em que chamo o agent, posso inserir alguns

14:42 configuração de execução e criar esse agent dinamicamente, na hora. E ambas são muito, muito poderosas. Ótimo. Estamos animados para ver todos vocês experimentarem o Managed Deep Agents e trazerem sua experiência no domínio, e mal podemos esperar para ver o que vocês vão criar. Obrigado.

Transcrição original

[00:06] Alrighty. Hello, everyone. I’m Victor. I’m a product manager here at LangChain. And today we’re going to be talking about deploying mission-critical agents into production, and sort of everything that it takes to take a deep agent, for example, and bring it into production with Managed Deep Agents. So the first place that we like to start, and it’s a question we often get, is: what is an agent? Harrison talked about this a bit earlier today. The first definition that we sort of had at LangChain was this idea of a ReAct-style agent, or a reason and action style agent.

[00:38] And this is sort of an agent that can essentially react, use a set of tools, and reason and act over a particular task in order to accomplish that goal. What has sort of happened as of late is that’s evolved into this idea of an agent harness. So we’re now going into this model plus harness, and that’s sort of what defines an agent for us. And this is everything that we put around our model itself, right? So the skills, memory, system prompt, all of those things.

[01:08] The question that we get a lot is: why do we go through the effort of this? Why do we go through the task of building out an agent harness specific for our use case? And it’s really in order to get the model the correct set of context at the correct time in order to do its particular task. And we truly believe that models are only as powerful as the context that they’re given. And so when we start to build harnesses ourselves, we really wanted to start focusing on building a customizable sort of base harness. And that’s what Deep Agents is. It’s a great way to get started and build

[01:41] out that domain-specific harness for your use case. So what kind of goes into this Deep Agents harness? So there’s sort of four key areas. The first being the execution environment, and this is really the backbone of Deep Agents: the idea that you can have an agent use a file system. So models are very, very good at using file systems now, writing code, things of that nature, and we really want to take advantage of that when we’re creating our agents. So Deep Agents has first-class support for that, and we can also pair it with a sandbox so that it can sort of execute that code in a safe

[02:13] environment. The second core area is context management. So context management is very important through progressive disclosure of skills. We need to be able to manage memory and have the agent manage memory itself. In some cases, we want to be able to summarize conversations, compact them down, and offload context when needed. So if a tool, for example, returns a really large output, we can sort of store that in our file system and wait for the model to sort of reference that context when it needs it. The third key area is delegation.

[02:43] So being able to decompose a task and delegate it to either specialized or general-purpose subagents is very, very important. And lastly is steering through human in the loop. And that’s something that is core to what we do here at LangChain. And part of why this conference is named Interrupt is that function to be able to encourage human in the loop and allow your agent to wait for a human to approve an action. So as we think about building out these domain-specific harnesses, one of the companies that I’m excited to highlight, as I’ve worked with them a decent amount, is Madrigal.

[03:14] It’s a pharmaceutical research company, and they were able to build a domain-specific harness to help their PhDs, their researchers, really improve and standardize how they’re doing their research. So they have a variety of different areas of work that they do research on in the pharma industry, and they really wanted to codify this and make it really valuable for the rest of the organization to come in and build agents for their use case and build research agents for their particular domain. And the way that they did this was they broke these down, and they broke down their expertise into skills.

[03:45] Their platform team and their engineers help them create evals and really start to spin that flywheel that I’m sure you’ve heard a lot about today. So when you think about building out an agent, something that Harrison sort of touched on a bit earlier today is it really breaks down into three layers. The first is the business logic, and this is what you bring, right? This is your expertise. This is what you need to build agents for yourself. The second is the harness. So we need somewhere for that expertise to execute, right? We need a system to execute it. And that’s sort of what this harness, or this Deep Agents base harness, provides.

[04:17] And the third is going to be the infrastructure. So this is all the stuff around bringing an agent, making it multi-tenant, giving it a production runtime. Each one of these layers, all three of these, sort of really need to work together in a cohesive fashion in order to take an agent into production reliably. So we talk about taking an agent into production. The first step usually looks like this. We’re going to prototype it locally. Getting it running locally is sort of a magical experience, right? We can sort of prove that an agent can do a certain task for us. And that’s a very exciting moment. It’s a very valuable moment.

[04:47] This is where we sort of prove, as developers, as agent engineers, that we can build an agent to sort of do something that is domain-specific. Then we start to go into production, and this is where things start to get a little bit messy. We need to be able to handle multi-tenancy, we need to be able to handle persistence, we need durable execution, we need to handle streaming. All of these different things that go into taking an agent into production start to become things that your team has to own if you’re doing this from scratch, right? And there’s a lot of different layers to this that can break down. So, for example, a task queue can be something that

[05:21] can be tricky. You need to be able to prioritize which tasks are going to get picked up by the agent, what priority that you’re going to execute those. That all becomes tricky as you scale to many, many, many users. What we’ve done with Managed Deep Agents now, and why we’re so excited about it, is we’ve sort of taken that execution environment, the harness itself, and we’ve tightly coupled it together with the infrastructure. And this is a really important step in terms of making it really easy for you and your developers to go and work on what actually makes the agent better,

[05:51] which is the business logic. When we talk about taking an agent into production with Managed Deep Agents, this is sort of how it looks. So all of those things, all those connections that you had to maintain as a team before by managing the harness and the infrastructure, things like durable execution, things like the task queue that I mentioned, these all come out of the box with Managed Deep Agents, as it runs on LangSmith Deployment, which is a proven production runtime that we have here. You get MCP and A2A in terms of doing your sort of orchestration across

[06:22] many agents. We have Context Hub as a great surface for you to interact with business users on particular business logic and other things, such as instructions and skills. You can sort of collaborate with them in that Context Hub. We have LangSmith Sandboxes for safe code execution. This is very important when you think about giving your agent access to write and run code. You need to give it a safe environment to do so. Then we have our layers of governance with LLM Gateway and our tracing and evals, of course.

[06:54] Now, since we’re handling a lot of this infrastructure with the harness, we’re able to sort of scaffold this project into a very coherent project structure. And this has actually paid dividends internally here at LangChain. We have a lot of developers and agent engineers that work across different agents internally. And having our agents defined in this project structure has now been very valuable in terms of being able to jump into any agent project and understand exactly how it works. So the way that we scaffold it is through one simple command. We can do mda init and give it a name like GTM agent, and that will go ahead

[07:25] and scaffold this project structure for us. Once we define our business logic, we can then run it locally with LangSmith Studio using mda dev. And once we’re ready to go into production, we can simply run mda deploy and deploy it into production. So, walking through what this actually looks like, I’d love to use the example of a GTM agent that Harrison mentioned earlier today. This is a very powerful agent. Our sellers and our GTM team and people, including myself, absolutely love using it. It really helps on the day-to-day, keeping track of everything

[07:56] that can go on in the workplace. But everything that goes into the deep agent now can be reflected for GTM agent into this definition. So the agent.ts or agent.py, you can do TypeScript or Python, will define your actual agent loop. The instructions will define your agent logic, sort of that core definition of how you want it to behave. We can then give it sort of like playbooks. For GTM agent, for example, we give it certain playbooks for different actions through skills, and then we can also connect it to all the systems that we need to with tools, connecting

[08:27] to MCP servers, things of that nature. And then the last two are pretty important in terms of defining how we want to handle auth and handle identity, as well as handle what it remembers and how it remembers. So setting up this agent is an exciting part, and getting it all ready to go. You start to think about this next layer, right? And one of the hardest parts of building agents and putting them into production is ensuring that it gets access to the right context and it has the right permissions to get access to that context or these different tools.

[08:59] So the first kind of key layer that we sort of start to see is we need to figure out who can call the agent, right? And the way that we do this in Managed Deep Agents is we have a centralized sort of like auth handler service that, depending on the channel or where you’re calling this agent from, we will go ahead and make sure that we establish who the principal is for that call, whether it’s the agent itself or a particular user, and we’ll go ahead and pass that along into the runtime context. So you’re able to identify the user, and you’re able to make sure that gets passed into different tools or other connections.

[09:31] As we start to go into… We have that user’s context, and now as the run is going through, we need to see, okay, what account should the user use, or should the agent use, rather? In some cases, you might want to always ensure that the agent is only using user-scoped credentials. As a developer, you can define that very easily, as you see here. In other cases, you might want to have a service account or an agent-scoped credential, and that’s also very easy. You can see there’s just simply two types that you define as a developer in order to define that when you’re using tools or MCP servers, things

[10:02] like that. One thing that we’re able to do as well, since Deep Agents runs on the LangGraph runtime, we have that element of durable execution, checkpointing, human in the loop, is we can also pause and wait indefinitely for access to certain systems. So, as a user, the first time that I use GTM agent in Slack, for example, if I need to authenticate with it to use our CRM on my behalf, it’ll ask me to go ahead and authorize, will send me a message only I can see. I can then come back three days later and say, “Oh yeah, I forgot I needed to do that.” Go ahead and hit authorize, and it’ll continue the run exactly

[10:34] from where it left off. So because we have that durable execution, it makes it very easy to do things mid-task. The next portion is memory. So memory really helps us compound and learn over time. And there’s certain scenarios where you want an agent to be able to take sort of like agent-level memory to improve its procedural memory, or you want it to take user memory: personal preferences, how I like to write emails, how I like to reach out to customers, things of that nature. You’re able to define that very easily in Managed Deep Agents as well.

[11:04] What’s really nice, since we’re managing this in code and we’re able to define this by the channel that it’s calling it, as well as the particular tool itself, I can control, based on where I call the agent, whether it’s going to use a set of personal memories, personal credentials, let’s say in a Slack DM, for example. And then if I want to use this agent also in a shared Slack channel, we also don’t want to leak any private information, of course. So we can have our agent use agent-scoped credentials or service accounts in those scenarios so that we know that it’s safe.

[11:34] As I mentioned before, we have a first-class integration with LangSmith’s Context Hub, and that allows us to collaborate with our business users on the different context that your agent has access to. This is really valuable in terms of having version control over this context in a shared space that we can all sort of visualize it, interact with it, edit it. And one of the nice things that we see is people often collaborate on skills. They can promote skills to workspaces, things of that nature. And once you start making these changes, one thing that we know is very valuable in terms of working with a lot of customers, especially customers

[12:06] that use LangSmith, is evals. So evals are very, very easy in Managed Deep Agents. We have a first-class integration with Harbor, which makes it really quite easy to set up all of these sort of intricate details that Harbor allows for, in a very managed process. So I can run mda evals init, and if I pass this interactive flag, it’ll actually run with a coding agent and help you set up the Harbor environments, set up the checks, all these different things that go into building really good evals. And then you can start to iterate and hill climb on those

[12:37] particular set of eval datasets and experiments. Something we’re really excited about is we launched a partnership with Parallel, who you can find in the demo stations, and we are offering zero data retention, and you can essentially use it directly through LangSmith without having to go get your own Parallel search key. We think that this is really important. Having access to really good data through different search APIs is very valuable for most agentic use cases. You can really easily add it to your managed deep agent via MCP, as such, and

[13:08] access it through LangChain itself or LangSmith. We’re really excited to highlight a few of our design partners that were with us from the very beginning of working on this project. So on the left side is Zahid, who worked with us from Kyth, and really helped us define how we did user-scoped credentials, memories, things of that nature. He was very opinionated as well, which is very helpful in a design partner. The second would be Consensus, which Derek and his team had a really cool use case of actually going around as a tiger team into different

[13:39] parts of the org and building out these internal agents for different parts of the organization. And that’s something that we’re seeing become more and more popular as customers start to sort of expand the sort of breadth of internal agents at their companies and providing that expertise for other teams. So what’s new in Managed Deep Agents as of this past week is all of these wonderful things. There’s a few different ones that I’d like to highlight. The very first one, HTTP channels allow you to define custom channels. So we have a first-class integration with Slack, as well as GitHub and a

[14:11] few others. But we also wanted to define a flexible spec for you as developers to go ahead and implement your own channels and how you want to use your agent. And then towards the bottom here, agent-created schedules are really nice. You can sort of tell an agent, “Hey, every Monday at 9:00 a.m., run this report for me, or go and find what customer meetings I have,” things of that nature, and it can go ahead and create its own schedules. And then lastly, the per-run config allows for you to create dynamic agents. So depending on the context of where I call the agent, I can insert some

[14:42] runtime configuration and sort of dynamically create that agent on the fly. And those are both very, very powerful. Awesome. So we’re excited to see you all try out Managed Deep Agents and bring your domain expertise, and can’t wait to see what you build. Thank you.