Durante o último ano, construir um agente de IA geralmente significava uma coisa: configurar um loop while, pegar um prompt do usuário, enviá-lo para um LLM, analisar uma chamada de ferramenta, executar a ferramenta, enviar o resultado de volta e repetir. Isto é o que chamamos de Agente Raso ou Agente 1.0.

Esta arquitetura é fantasticamente simples para tarefas transacionais como “Qual é o clima em Tóquio e o que devo vestir?”, mas quando solicitado a realizar uma tarefa que requer 50 etapas ao longo de três dias, eles invariavelmente se distraem, perdem contexto, entram em loops infinitos ou alucinam porque a tarefa requer muitas etapas para uma única janela de contexto.

Estamos vendo uma mudança arquitetônica em direção aos Agentes Profundos ou Agentes 2.0. Esses sistemas não apenas reagem em um loop. Eles combinam padrões agênticos para planejar, gerenciar uma memória/estado persistente e delegar trabalho a sub-agentes especializados para resolver problemas complexos de múltiplas etapas.

header_post_01_27

Agentes 1.0: Os Limites do Loop “Raso”

Para entender para onde estamos indo, devemos entender onde estamos. A maioria dos agentes hoje são “rasos”. Isso significa que dependem inteiramente da janela de contexto do LLM (histórico de conversação) como seu estado.

  1. Prompt do Usuário: “Encontre o preço das ações da Apple e me diga se é uma boa compra.”
  2. Raciocínio do LLM: “Preciso usar uma ferramenta de busca.”
  3. Chamada de Ferramenta: search("preço ação AAPL")
  4. Observação: A ferramenta retorna dados.
  5. Resposta do LLM: Gera uma resposta baseada na observação ou chama outra ferramenta.
  6. Repetir: Loop até concluir.

Esta arquitetura é sem estado e efêmera. Todo o “cérebro” do agente está dentro da janela de contexto. Quando uma tarefa se torna complexa, por exemplo “Pesquise 10 concorrentes, analise seus modelos de precificação, construa uma planilha comparativa e escreva um resumo estratégico”, ela falhará devido a:

  • Overflow de Contexto: O histórico se preenche com saídas de ferramentas (HTML, dados confusos), empurrando as instruções para fora da janela de contexto.
  • Perda de Objetivo: Em meio ao ruído de etapas intermediárias, o agente esquece o objetivo original.
  • Nenhum Mecanismo de Recuperação: Se ele entra em um beco sem saída, raramente tem a perspicácia para parar, voltar atrás e tentar uma nova abordagem.

Agentes rasos são ótimos para tarefas que levam 5-15 etapas. Eles são terríveis para tarefas que levam 500.

A Arquitetura dos Agentes 2.0 (Agentes Profundos)

Agentes Profundos desacoplam planejamento de execução e gerenciam memória externa à janela de contexto. A arquitetura consiste em quatro pilares.

Pilar 1: Planejamento Explícito

Agentes rasos planejam implicitamente via cadeia de pensamento (“Eu deveria fazer X, depois Y”). Agentes profundos usam ferramentas para criar e manter um plano explícito, que pode ser uma lista de tarefas em um documento markdown.

Entre cada etapa, o agente revisa e atualiza este plano, marcando etapas como pendente, em_progresso ou concluído ou adiciona notas. Se uma etapa falha, ele não apenas reexecuta cegamente, ele atualiza o plano para acomodar a falha. Isso mantém o agente focado na tarefa de alto nível.

Pilar 2: Delegação Hierárquica (Sub-Agentes)

Tarefas complexas exigem especialização. Agentes Rasos tentam ser pau-para-toda-obra em um único prompt. Agentes Profundos utilizam um padrão Orquestrador → Sub-Agente.

O Orquestrador delega tarefa(s) para sub-agente(s), cada um com um contexto limpo. O sub-agente (por exemplo, um “Pesquisador”, um “Programador”, um “Escritor”) executa seus loops de chamadas de ferramentas (buscando, errando, retentando), compila a resposta final e retorna apenas a resposta sintetizada para o Orquestrador.

Pilar 3: Memória Persistente

Para prevenir o overflow da janela de contexto, Agentes Profundos utilizam fontes de memória externas, como sistema de arquivos ou bancos de dados vetoriais como sua fonte de verdade. Frameworks como Claude Code e Manus dão aos agentes acesso de leitura/escrita a eles. Um agente escreve resultados intermediários (código, texto de rascunho, dados brutos). Agentes subsequentes referenciam caminhos de arquivo ou consultas para recuperar apenas o que é necessário. Isso muda o paradigma de “lembrar tudo” para “saber onde encontrar informações.”

Pilar 4: Engenharia de Contexto Extrema

Modelos mais inteligentes não requerem menos prompting, eles requerem melhor contexto. Você não pode obter comportamento de Agente 2.0 com um prompt que diz, “Você é uma IA útil.”. Agentes Profundos dependem de instruções altamente detalhadas, às vezes com milhares de tokens de comprimento. Estas definem:

  • Identificar quando parar e planejar antes de agir.
  • Protocolos para quando gerar um sub-agente vs. fazer o trabalho eles mesmos.
  • Definições de ferramentas e exemplos de como e quando usar.
  • Padrões para nomenclatura de arquivos e estruturas de diretórios.
  • Formatos estritos para colaboração humano-no-loop.

Visualizando um Fluxo de Agente Profundo

Como esses pilares se juntam? Vamos olhar um diagrama de sequência para um Agente Profundo lidando com uma solicitação complexa: “Pesquise Computação Quântica e escreva um resumo em um arquivo.”

image

Conclusão

Mover de Agentes Rasos para Agentes Profundos (Agente 1.0 para Agente 2.0) não é apenas sobre conectar um LLM a mais ferramentas. É uma mudança de loops reativos para arquitetura proativa. É sobre melhor engenharia em torno do modelo.

Implementando planejamento explícito, delegação hierárquica via sub-agentes e memória persistente, nos permitem controlar o contexto e ao controlar o contexto, controlamos a complexidade, desbloqueando a habilidade de resolver problemas que levam horas ou dias, não apenas segundos.

Agradecimentos

Esta visão geral foi criada com a ajuda de pesquisa profunda e manual. O termo “Deep Agents” foi notavelmente popularizado pela equipe LangChain para descrever esta evolução arquitetônica.

Créditos

Esta postagem é uma tradução autorizada do post Agents 2.0: From Shallow Loops to Deep Agents, de autoria de Philipp Schmid, AI Developer Experience do Google.