LangChain Deep Agents: um runtime estruturado para planejamento, memória e isolamento de contexto

A LangChain lançou o Deep Agents em 15 de março de 2026 — um runtime estruturado que fornece aos agentes de IA planejamento integrado, gerenciamento de contexto baseado em sistema de arquivos e delegação de subagentes. Ele preenche uma lacuna que a maioria dos frameworks de agentes ignorou: o que acontece quando uma tarefa exige mais do que algumas chamadas de ferramentas para ser concluída.

O que o Deep Agents realmente é

O Deep Agents é um "harness de agentes" construído sobre o LangGraph, o runtime da LangChain para execução durável. Ele agrupa um conjunto de padrões e ferramentas integradas em torno do loop padrão de chamada de ferramentas (tool-calling). Os desenvolvedores obtêm planejamento, descarregamento de contexto (context offloading) e delegação de sub-tarefas sem precisar construir esses sistemas do zero.

A biblioteca vem com vários componentes principais: uma ferramenta de planejamento write_todos, ferramentas de sistema de arquivos (read_file, write_file, edit_file, ls, glob, grep), acesso a shell em sandbox via execute, uma ferramenta task para gerar subagentes e auto-sumarização para gerenciamento de contexto.

Chamar create_deep_agent(...) retorna um CompiledStateGraph — um objeto padrão do LangGraph. Isso significa que o Deep Agents não é uma camada de abstração separada. Ele roda no mesmo runtime, suporta streaming, LangGraph Studio e checkpointers nativamente.

Por que o planejamento importa para agentes de múltiplas etapas

A maioria dos agentes de LLM funciona bem para sequências curtas de chamadas de ferramentas: pesquisar na web, analisar um resultado, retornar uma resposta. Eles começam a degradar quando a tarefa requer dez, vinte ou cinquenta etapas com decisões intermediárias.

Sem uma camada de planejamento, o modelo improvisa cada etapa com base no que estiver atualmente na janela de prompt. O Deep Agents resolve isso com o write_todos, uma ferramenta integrada que permite ao agente dividir uma tarefa complexa em etapas discretas, acompanhar o progresso e atualizar o plano conforme novas informações surgem.

Isso é útil para fluxos de trabalho concretos: tarefas de pesquisa que exigem múltiplas buscas e referências cruzadas, sessões de codificação que abrangem vários arquivos ou trabalhos de análise onde cada etapa depende do resultado anterior. O agente escreve seu plano, executa-o e marca os itens como concluídos conforme avança.

Gerenciamento de contexto baseado em sistema de arquivos

O estouro da janela de contexto é o principal modo de falha para agentes de longa duração. Uma única janela de contexto do Claude Opus 4 comporta cerca de 200.000 tokens. Isso parece muito até que um agente acumule resultados de pesquisa, saídas de código, notas intermediárias e histórico de conversas ao longo de dezenas de etapas.

O Deep Agents usa ferramentas de sistema de arquivos para resolver isso. Em vez de manter tudo no prompt ativo, o agente grava grandes saídas — código gerado, notas de pesquisa, relatórios intermediários — em arquivos e os recupera quando necessário. Essa abordagem reduz a pressão na janela de prompt e mantém o contexto de trabalho relevante.

O sistema suporta vários tipos de backend: StateBackend (efêmero, armazenado no estado do LangGraph), FilesystemBackend, LocalShellBackend, StoreBackend e CompositeBackend. O padrão é o StateBackend, que armazena um sistema de arquivos efêmero para uma única thread.

Compressão de contexto autônoma

Em 11 de março, a LangChain lançou um recurso complementar: compressão de contexto autônoma. Em vez de compactar em um limite fixo de tokens (a abordagem padrão, normalmente em 85% do contexto disponível), o Deep Agents agora expõe uma ferramenta que permite ao próprio agente acionar a compressão.

O raciocínio é simples. Existem momentos bons e ruins para compactar o contexto:

• Ruim: no meio de uma refatoração, quando o agente precisa de detalhes recentes para fazer edições corretas.
• Bom: após terminar uma entrega, antes de iniciar uma nova tarefa ou após extrair uma conclusão de uma grande pesquisa.

Ao dar ao modelo o controle sobre quando comprimir, o sistema evita situações em que um limite fixo aciona a compactação no pior momento possível. A compressão retém mensagens recentes (10% do contexto disponível) e sumariza tudo o que veio antes desse ponto.

Isso segue o que a LangChain chama de "a lição amarga" (the bitter lesson) — deixar o modelo lidar com mais de suas próprias decisões operacionais em vez de codificar rigidamente o comportamento do harness.

Subagentes e isolamento de contexto

O Deep Agents inclui uma ferramenta task integrada para gerar subagentes com contexto isolado. O agente principal pode delegar sub-tarefas específicas — por exemplo, pesquisar uma única API, escrever um arquivo de teste ou sumarizar um documento — a um subagente que começa com uma janela de contexto limpa.

Isso resolve um modo de falha comum. Quando uma única thread de agente acumula múltiplos objetivos, saídas de ferramentas e decisões temporárias, a qualidade da saída cai. O modelo perde o rastro do que estava fazendo. O isolamento de subagentes mantém a thread principal limpa, permitindo um trabalho mais profundo em sub-tarefas específicas.

O padrão é semelhante ao modo como OpenClaw, Codex CLI e outros harnesses de agentes lidam com a delegação, mas o Deep Agents o incorpora ao runtime padrão em vez de deixá-lo para os desenvolvedores de aplicações.

Memória de longo prazo entre conversas

O Deep Agents suporta memória persistente através do Memory Store do LangGraph. Isso permite que o agente salve e recupere informações de conversas anteriores — preferências do usuário, contexto específico do projeto ou decisões tomadas em sessões anteriores.

Esta é uma camada acima do gerenciamento de contexto baseado em sistema de arquivos. O sistema de arquivos lida com o estado dentro da sessão. O Memory Store lida com a persistência entre sessões. Juntos, eles dão ao agente tanto memória de trabalho quanto memória de longo prazo.

Como começar

A configuração é mínima. Instale o deepagents e quaisquer provedores de ferramentas que você precisar:

pip install -qU deepagents tavily-python

from deepagents import create_deep_agent

def search_web(query: str) -> str:
    """Search the web for information."""
    from tavily import TavilyClient
    client = TavilyClient()
    return client.search(query)["results"]

agent = create_deep_agent(
    model="anthropic:claude-opus-4",
    tools=[search_web],
    system_prompt="You are a research assistant."
)

result = agent.invoke({"messages": [{"role": "user", "content": "Research the latest AI agent frameworks"}]})

Para compressão de contexto autônoma, adicione o middleware de sumarização:

from deepagents.middleware.summarization import create_summarization_tool_middleware
from deepagents.backends import StateBackend

agent = create_deep_agent(
    model="anthropic:claude-opus-4",
    middleware=[
        create_summarization_tool_middleware("anthropic:claude-opus-4", StateBackend),
    ],
)

Como o Deep Agents se compara a outros frameworks de agentes

Recurso	Deep Agents	OpenClaw	AutoGen	CrewAI
Planejamento integrado	Sim (write_todos)	Via skills	Manual	Decomposição de tarefas
Contexto em sist. arquivos	Sim (vários backends)	Sim (workspace)	Não	Não
Isolamento de subagentes	Sim (ferramenta task)	Sim (sessions_spawn)	Sim (agentes)	Sim (crews)
Compressão de contexto	Autônoma	Auto-compactação	Manual	Não
Memória de longo prazo	LangGraph Memory Store	SOUL.md + arquivos	Manual	Limitada
Runtime	LangGraph	Node.js daemon	Python	Python
Implantação	LangGraph Cloud	Self-hosted	Self-hosted	Self-hosted

Quem deve usar o Deep Agents

O Deep Agents foi construído para desenvolvedores que já usam ou estão considerando a LangChain e precisam de agentes que lidem com tarefas que duram mais do que algumas chamadas de ferramentas. Casos de uso específicos incluem:

• Automação de pesquisa: tarefas que exigem múltiplas buscas, referências cruzadas de fontes e produção de saída estruturada.
• Geração de código: projetos de múltiplos arquivos onde o agente precisa rastrear dependências entre arquivos.
• Análise de dados: exploração iterativa onde cada etapa depende das descobertas da anterior.
• Processamento de documentos: documentos longos que excedem os limites da janela de contexto e precisam ser processados em partes.

Se as tarefas do seu agente são concluídas em menos de cinco chamadas de ferramentas, agentes mais simples da LangChain ou chamadas diretas de API provavelmente são suficientes. O Deep Agents agrega valor quando a tarefa é complexa o suficiente para que o planejamento, o descarregamento de contexto e a delegação façam uma diferença mensurável.

Conclusão

O Deep Agents é um runtime estruturado da LangChain para agentes de IA de várias etapas, lançado em 15 de março de 2026. Ele inclui planejamento integrado (write_todos), gerenciamento de contexto baseado em sistema de arquivos e delegação de subagentes. A compressão autônoma de contexto permite que o agente decida quando compactar sua própria janela de contexto. O sistema roda no LangGraph e retorna um CompiledStateGraph padrão, para que o ferramental existente do LangGraph funcione. A memória persistente em várias conversas é suportada através do Memory Store do LangGraph. O Deep Agents é mais adequado para tarefas que exigem mais de cinco chamadas de ferramentas e se beneficiam de planejamento e isolamento de contexto.

Principales Puntos

• Deep Agents, lançado pela LangChain em 15 de março de 2026