Harrison Chase e Lance Martin — orquestrar agentes sem perder o controle do contexto

"A parte difícil de construir sistemas agênticos confiáveis é garantir que o LLM tenha o contexto apropriado a cada passo." — Harrison Chase, How to think about agent frameworks (LangChain blog, 2025)

O essencial em 30 segundos

Harrison Chase fundou a LangChain em 2022 e, com ela, popularizou a ideia de que construir aplicações com modelos de linguagem é, antes de tudo, um problema de orquestração: encadear chamadas, gerenciar memória, dar ferramentas ao modelo e decidir quem controla o próximo passo. Lance Martin, engenheiro do mesmo ecossistema, virou uma das vozes mais claras sobre o que acontece depois do "hello world" — agentes que rodam por horas, que vivem no fundo do seu inbox (os "ambient agents"), e a disciplina emergente que ele chama de engenharia de contexto.

Os dois, juntos, encarnam o debate central de quem vai construir agentes em produção: usar um framework (LangChain, LangGraph) ou montar tudo do zero? A resposta honesta dos dois não é "use sempre o framework". É: entenda primeiro o que de fato é difícil — controlar o contexto que entra no modelo a cada passo — e só então escolha a ferramenta que te dá esse controle sem esconder nada de você.

Para um operador que vai colocar nove agentes de IA dentro de um SaaS B2B (o caso do Gestão de Colabs), essa é a dupla certa para começar: ela separa o que é moda do que é engenharia de verdade.

Quem são

Harrison Chase é co-fundador e CEO da LangChain. Formou-se em Ciência da Computação por Harvard em 2017. Antes da LangChain, foi Lead Machine Learning Engineer na Kensho Technologies — aplicando IA a finanças, empresa depois adquirida pela S&P Global — e Head of ML na Robust Intelligence, focado em observabilidade e integridade de modelos. Em outubro/novembro de 2022 lançou a LangChain como um projeto open source em Python (e depois TypeScript) que rapidamente virou o ponto de entrada padrão de quem queria construir algo com LLMs. Da LangChain nasceram peças subsequentes: o LangGraph (orquestração de baixo nível baseada em grafos, para fluxos com estado, ciclos e human-in-the-loop), o LangSmith (observabilidade e avaliação) e abstrações de agentes mais alto nível. Chase escreve com frequência ensaios opinativos — e abertos a contestação pública — sobre como pensar arquitetura de agentes.

Lance Martin é engenheiro de software ligado à LangChain, focado em open source e projetos aplicados. Tem PhD por Stanford em ML aplicado e, antes da LangChain, foi tech lead e gestor trabalhando em visão computacional para veículos autônomos na UberATG, na Ike e na Nuro. Na LangChain, construiu boa parte dos quickstarts (RAG, agentes, prompt engineering), criou o curso "RAG From Scratch" (mais de 450 mil visualizações no FreeCodeCamp) e a primeira versão do LangChain Academy, com dezenas de aulas sobre construção de agentes. Mais recentemente, virou referência em dois temas: RAG local (rodar recuperação e geração com modelos locais, sem depender de uma API de terceiros) e ambient agents — agentes que rodam em segundo plano, disparados por eventos, e não por um chat. Ele construiu um assistente de e-mail desse tipo para gerir o próprio inbox e usa esse caso para discutir o que ele chama de engenharia de contexto.

A grande contribuição

A contribuição de Chase foi dar nome e estrutura ao problema de orquestração num momento (final de 2022, início de 2023) em que praticamente ninguém sabia como ligar um LLM a ferramentas, memória e dados de forma reutilizável. A LangChain ofereceu blocos — prompts, chains, memória, agentes, retrievers — que transformaram um amontoado de chamadas de API numa arquitetura nomeável. Isso teve um efeito de adoção brutal: virou o vocabulário comum. Mesmo quem critica a biblioteca usa as categorias que ela ajudou a popularizar.

Mas a contribuição madura veio depois, quando o próprio Chase reconheceu o limite das abstrações fáceis. No ensaio How to think about agent frameworks (abril de 2025), ele faz uma distinção que vale ouro para quem vai construir: sistemas agênticos vivem num espectro entre workflows (fluxos com passos predefinidos) e agents (o LLM dirige o próprio processo) — e a maioria dos frameworks de agentes não é nem orquestração declarativa nem imperativa, é só "um conjunto de abstrações de agente". O perigo: "abstrações de agente facilitam começar, mas frequentemente ofuscam e dificultam garantir que o LLM tenha o contexto apropriado a cada passo."

A contribuição de Martin é o complemento prático: ele pega esse insight — o difícil é o contexto — e o transforma numa disciplina operacional. Engenharia de contexto, na formulação dele, é a arte de decidir o que entra e o que sai da janela do modelo a cada passo de um agente longo: o que recuperar, o que podar, o que descarregar para fora da janela, o que resumir. É o que separa um agente que degrada depois de vinte passos de um que aguenta cem.

As ideias-chave

1. O espectro workflow ↔ agente (e por que a maioria começa no lugar errado)

Chase insiste que "sistemas agênticos consistem tanto de workflows quanto de agentes (e tudo entre os dois)". Um workflow tem passos predefinidos: você sabe que vai classificar, depois recuperar, depois gerar, depois validar. Um agente decide sozinho qual ferramenta usar e quando parar. O erro clássico é pular direto para o agente totalmente autônomo porque é mais empolgante — e descobrir que ele é imprevisível, caro e difícil de depurar.

Exemplo no portfólio: no Gestão de Colabs, um "agente" de triagem de solicitações de colaborador não precisa ser autônomo no dia um. Ele é um workflow: classifica a solicitação (férias, reembolso, dúvida de benefício), roteia para o template ou sistema certo e só escala para um humano quando a confiança cai. Isso é determinístico, testável e barato. A autonomia entra depois, e só onde paga.

2. O gargalo é o contexto, não o "raciocínio"

A frase de Chase — o difícil é garantir o contexto certo a cada passo — reorganiza prioridades. Não adianta o modelo ser inteligente se você entope a janela dele com lixo (histórico irrelevante, saídas de ferramentas gigantes, instruções contraditórias). Martin sistematiza isso: à medida que mensagens, saídas de ferramentas e interações se acumulam, o contexto cresce rápido e a performance começa a cair. A engenharia de contexto é o conjunto de táticas para conter isso.

Exemplo no portfólio: um agente que responde dúvidas de RH dentro do Gestão de Colabs não deve receber a base inteira de políticas a cada turno. Ele recupera só os 3–4 trechos relevantes (RAG), resume o histórico longo da conversa e descarta saídas de ferramentas já consumidas. Resultado: respostas mais rápidas, mais baratas e mais corretas.

3. Ambient agents: o agente que não mora num chat

Martin defende uma mudança de form factor: a maioria dos agentes úteis no trabalho não será um chat onde você digita, mas processos que rodam em segundo plano disparados por eventos — um e-mail que chega, um ticket que abre, um colaborador que submete um pedido. O assistente de e-mail dele faz triagem sozinho e só te interrompe quando precisa de decisão.

Exemplo no portfólio: em vez de um chatbot que o gestor precisa abrir e perguntar "tem algo pendente?", um ambient agent do Gestão de Colabs observa a fila de solicitações, resolve as triviais, agrupa as duvidosas e manda uma notificação por dia com "estas 4 precisam da sua decisão". Menos interface, mais resultado.

4. Human-in-the-loop não é fraqueza — é o mecanismo de controle

Tanto Chase (com o LangGraph, que tem pontos de interrupção e checkpoints nativos) quanto Martin tratam o humano-no-loop como peça de arquitetura, não como remendo. Quanto mais autônomo o agente, maior o risco de ele se perder numa sequência longa e errada. O antídoto é desenhar pontos de pausa onde um humano aprova, corrige ou desbloqueia — e o estado do agente é persistido para retomar do ponto exato.

Exemplo no portfólio: qualquer agente que tome ação irreversível — aprovar um reembolso, enviar comunicação em massa, alterar dado cadastral — passa por um gate humano. O agente prepara, o gestor confirma. Isso vira recurso de produto ("você revisa antes de enviar"), não limitação.

5. A bitter lesson aplicada à arquitetura de aplicações

Martin retoma a "bitter lesson" de Rich Sutton — métodos gerais que aproveitam computação vencem os artesanais — e a leva para a camada de aplicação: suposições arquiteturais que você embute hoje provavelmente ficam obsoletas em seis meses, quando sai um modelo melhor. A consequência prática: prefira ferramentas de baixo nível, facilmente reconfiguráveis, a estruturas rígidas que viram gargalo. É exatamente o argumento que faz a balança "framework vs. do-it-yourself" pender, em muitos casos, para componentes finos em vez de abstrações grossas.

Exemplo no portfólio: ao desenhar os agentes do Gestão de Colabs, não vale acoplar a lógica de negócio a uma abstração mágica de "agente" de algum framework. Vale isolar a lógica (o que recuperar, quando escalar, qual ação tomar) em código próprio e usar o framework apenas onde ele dá controle real — orquestração com estado, persistência, observabilidade.

Em suas palavras

"A parte difícil de construir sistemas agênticos confiáveis é garantir que o LLM tenha o contexto apropriado a cada passo. Isso inclui tanto controlar o conteúdo exato que vai para o LLM quanto rodar os passos apropriados para gerar conteúdo relevante." — Harrison Chase, How to think about agent frameworks (2025)

"Sistemas agênticos consistem tanto de workflows quanto de agentes (e tudo entre os dois). A maioria dos frameworks agênticos não é nem orquestração declarativa nem imperativa, mas apenas um conjunto de abstrações de agente." — Harrison Chase, How to think about agent frameworks (2025)

"Abstrações de agente podem facilitar começar, mas frequentemente ofuscam e tornam difícil garantir que o LLM tenha o contexto apropriado a cada passo." — Harrison Chase, How to think about agent frameworks (2025)

"Tell me why your agent framework is better than langgraph — i'm writing a blog [...] and i want to be as unbiased as possible, but so far i don't have many examples [of] things other agent frameworks do that langgraph doesn't." — Harrison Chase, em postagem pública no X (2025), convidando contestação antes de publicar o ensaio

"À medida que as mensagens, saídas de ferramentas e interações de um agente se acumulam, o contexto cresce rapidamente e a performance começa a cair." — Lance Martin, parafraseado de Context Engineering for Agents (2025)

Limites e críticas

A crítica mais conhecida à LangChain — feita inclusive por engenheiros que a adotaram cedo — é o excesso de abstração: camadas que escondem a chamada real ao modelo, dificultam debug e impõem opiniões que envelhecem rápido. Para muitos casos simples, foi mais fácil escrever as chamadas à API diretamente do que descobrir qual abstração da biblioteca fazia o quê. O próprio movimento da LangChain em direção ao LangGraph (mais baixo nível, mais explícito) é, em parte, uma resposta a essa crítica.

Há também o risco de lock-in conceitual: ao adotar o vocabulário e os blocos de um framework, você passa a pensar os problemas no formato que ele oferece — e pode deixar de ver a solução mais simples. A própria bitter lesson que Martin cita é uma faca de dois gumes para quem vende framework: se a estrutura embutida hoje vira gargalo amanhã, qualquer abstração grossa é uma aposta contra a melhoria dos modelos.

Por fim, "ambient agents" e agentes de longa duração ainda são fronteira: são mais difíceis de avaliar, mais arriscados quando erram em silêncio, e exigem investimento real em observabilidade e human-in-the-loop antes de virarem confiáveis. Adotar o discurso sem a infraestrutura de avaliação é o caminho mais curto para um agente que parece mágico na demo e quebra em produção.

Como aplicar no seu dia a dia

A regra que se tira da dupla, ao construir agentes de IA, é uma sequência de decisão:

1. Comece pelo workflow, não pelo agente. Para cada agente que você planeja, pergunte: isso pode ser um fluxo de passos predefinidos (classificar → recuperar → gerar → validar)? Se sim, faça assim. É testável, barato e previsível. A autonomia é a exceção que se conquista, não o ponto de partida.

2. A decisão framework vs. build se resolve por "onde está o seu controle de contexto". Use componentes de orquestração com estado (estilo LangGraph) onde você precisa de persistência, ciclos e human-in-the-loop — e mantenha a lógica de negócio (o que recuperar, quando escalar) em código próprio, fino e legível. Fuja de abstrações grossas que escondem a chamada ao modelo: num produto que vai durar, você precisa enxergar exatamente o que entra na janela.

3. Trate engenharia de contexto como requisito, não detalhe. Cada agente recupera só o relevante, resume o histórico e descarta saídas já consumidas. Isso é o que mantém custo e qualidade sob controle quando o produto escala para muitos clientes.

4. Desenhe os pontos de pausa humanos como produto. Toda ação irreversível passa por um gate de aprovação. Transforme isso em diferencial de confiança para o cliente, não em desculpa.

5. Prefira ambient a chat onde fizer sentido. Boa parte do valor de um agente não está num chatbot que alguém abre; está num agente que observa filas, resolve o trivial e interrompe o humano só com o que importa.

A síntese: a LangChain dá vocabulário e blocos para começar; Chase e Martin dão o critério para não se viciar neles — controle de contexto explícito, autonomia só onde paga, humano no loop por design.

Para ir além

Comece por: o ensaio de Harrison Chase, How to think about agent frameworks (LangChain blog, abril/2025) — é a peça que organiza o debate workflow vs. agente e framework vs. build em poucas páginas.

Depois: o conteúdo de Lance Martin sobre Context Engineering for Agents (post no blog dele, junho/2025, e a conversa no podcast Latent Space) e o curso "RAG From Scratch" para entender recuperação na prática. Para agentes de longa duração e human-in-the-loop, o LangChain Academy e a documentação do LangGraph (interrupções, checkpoints, estado persistido).

Avançado: os episódios do podcast Training Data (Sequoia) com Chase sobre "ambient agents", "deep agents" e engenharia de contexto para agentes de horizonte longo; e a leitura de "The Bitter Lesson" de Rich Sutton para entender a aposta de fundo contra estruturas rígidas na camada de aplicação.

Conexões no vault

• IA e Tecnologia
• anthropic-building-effective-agents — o guia da Anthropic sobre workflows vs. agentes, complemento direto deste post
• anthropic-agentes-schluntz-zhang — Schluntz e Zhang (Anthropic) sobre quando a agência se justifica
• andrej-karpathy — visão de software/IA que dialoga com a "bitter lesson"