Arquitetura de Agentes de IA: Ferramentas para Memória e Planejamento
Oi, eu sou Lena. Quando olho para a arquitetura de um agente de IA, não começo pelo nome do framework. Começo com uma pergunta mais silenciosa: onde o sistema decide, onde ele lembra, onde ele age e onde um humano ainda pode entender o que aconteceu? Esse é o verdadeiro trabalho por trás das ferramentas de planejamento e memória da arquitetura de agentes de IA. Um sistema de agente confiável não é apenas um modelo com algumas APIs anexadas. É um conjunto de limites entre planejamento, memória, ferramentas, orquestração e recuperação.
Este guia é um mapa de decisão para fundadores técnicos, arquitetos de agentes e pequenas equipes que estão escolhendo como construir ou substituir uma pilha de agentes. Não vou argumentar sobre uma "melhor" arquitetura universal, porque não acredito que ela exista. A melhor pergunta é qual padrão de planejamento, padrão de memória e modelo de controle de ferramentas se encaixa na realidade de risco, custo, latência e manutenção do trabalho.
As Camadas Principais da Arquitetura de Agentes de IA
Modelos e planejamento
O modelo é o motor de raciocínio, mas não deve ser tratado como toda a arquitetura. Em um fluxo de trabalho simples, o modelo pode apenas classificar a solicitação do usuário, escolher uma rota e chamar uma ferramenta aprovada. Em uma arquitetura de planejamento de agente mais séria, o modelo pode dividir um objetivo em etapas, inspecionar resultados intermediários, tentar novamente ações falhas, pedir contexto faltante e parar quando o risco se tornar muito alto.
Normalmente penso sobre planejamento em três camadas. A primeira é roteamento de intenção: que tipo de tarefa é esta? A segunda é decomposição de tarefas: o que precisa acontecer antes que a resposta final ou artefato exista? A terceira é controle de execução: o que deve acontecer se o plano se tornar desatualizado, caro, inseguro ou impossível?
Essa terceira camada é onde muitos sistemas de agentes se tornam frágeis. Um modelo pode escrever um plano de cinco etapas lindo, mas o sistema ainda precisa de regras para falha de ferramentas, resultados parciais, limites de orçamento e aprovação humana. Se uma etapa planejada depender de um estado desatualizado, o agente deve verificar novamente antes de agir. Se a resposta de uma ferramenta contradizer a memória, o agente não deve simplesmente continuar como se nada tivesse acontecido.
Para equipes que trabalham com sistemas de maior risco, o NIST Generative AI Profile é uma referência útil porque enquadra a gestão de riscos ao longo do ciclo de vida da IA, não apenas no momento da implantação. Isso importa para agentes porque a parte arriscada frequentemente não é a saída de texto. É a ação tomada após o texto.
Memória e contexto
A arquitetura de memória de agentes de IA é frequentemente descrita de forma muito casual. "Adicionar memória" parece simples, mas a memória muda o comportamento ao longo do tempo. Isso significa que ela precisa de regras de ciclo de vida.
O contexto de trabalho é a informação temporária que o agente precisa durante a execução atual: a solicitação atual do usuário, mensagens recentes, documentos recuperados, outputs de ferramentas e estado de tarefas local. A memória durável é a informação que deve permanecer após a execução: preferências, fatos de projetos, restrições estáveis, políticas da equipe ou escolhas recorrentes no fluxo de trabalho. A experiência reutilizável é uma categoria mais forte. Não se trata apenas de "o usuário gosta de Markdown." Pode ser um procedimento validado, um caminho de recuperação conhecido ou um padrão de tarefa reutilizável que funcionou anteriormente.
O limite entre essas categorias deve ser explícito. Um documento recuperado não deve se tornar automaticamente memória durável. Uma execução bem-sucedida não deve se tornar automaticamente experiência reutilizável. Uma preferência do usuário não deve substituir silenciosamente uma regra de segurança. Eu sei que isso soa um pouco cauteloso, mas é aqui que a arquitetura se torna real. Memória sem escopo, proveniência, validação e esquecimento se torna uma fonte silenciosa de deriva.
Ferramentas, orquestração e execução
Ferramentas são onde o agente deixa o mundo seguro da linguagem e interage com sistemas. Uma ferramenta pode ler um arquivo, consultar um banco de dados, enviar uma mensagem, modificar código, abrir um navegador ou acionar um fluxo de trabalho. A orquestração de ferramentas do agente decide qual ferramenta pode ser chamada, com quais argumentos, sob qual limite de permissão e como o resultado é verificado.
Protocolos como a especificação do Model Context Protocol são úteis aqui porque incentivam as equipes a descrever ferramentas, recursos, prompts, autorização, cancelamento e consentimento do usuário de forma mais explícita. Mesmo que uma equipe não adote o MCP diretamente, o hábito arquitetural é valioso: ferramentas devem ter contratos estruturados, não promessas vagas em linguagem natural.
A execução também precisa de estado. O que já foi tentado? Qual chamada de ferramenta foi bem-sucedida? Quais efeitos colaterais ocorreram? Qual etapa pode ser repetida com segurança? Qual etapa requer reversão ou revisão humana? Sem estado de execução, um agente pode repetir falhas, duplicar ações ou resumir com confiança uma tarefa que na verdade nunca foi concluída.
Escolha um Padrão de Planejamento
Roteamento de etapa única e planejamento de múltiplas etapas
O roteamento em único passo é suficiente quando a tarefa é estreita e o risco é baixo. Por exemplo, o agente pode classificar uma solicitação recebida, recuperar um documento relevante, preencher um modelo conhecido ou chamar uma API interna. Esse padrão é mais fácil de testar, mais barato de executar e menos provável de produzir comportamento estranho em múltiplos passos.
O planejamento em múltiplos passos se torna útil quando a saída depende de decisões intermediárias. Um agente de pesquisa pode precisar buscar, comparar, filtrar, rascunhar e verificar. Um agente de codificação pode precisar inspecionar o repositório, propor uma alteração, editar arquivos, rodar testes e revisar. Um agente de operações de suporte pode precisar checar o estado da conta, ler políticas, rascunhar uma resposta e escalonar se a confiança for baixa.
O trade-off é simples, mas nem sempre confortável: mais poder de planejamento cria mais pontos de falha. O planejamento em múltiplos passos adiciona latência, custo de tokens, custo de chamadas de ferramentas e requisitos de observabilidade. Também dificulta a avaliação, porque o sucesso não se resume mais a uma única saída. O sucesso se torna um caminho: o agente escolheu os passos corretos, usou as ferramentas certas, recuperou-se de problemas e produziu um resultado em que alguém pode confiar.
Quando o planejamento multiagente merece sua complexidade
A arquitetura multiagente vale a pena quando a tarefa contém perspectivas separáveis que realmente se beneficiam do trabalho paralelo. Uma tarefa de pesquisa de mercado pode precisar que um agente colete fontes, outro critique premissas e outro prepare a síntese final. Uma migração de código pode precisar de um agente lendo arquitetura, outro escrevendo testes e outro checando compatibilidade retroativa.
Mas o enxame não é uma atualização mágica. Ele justifica sua complexidade apenas quando a arquitetura inclui regras de coordenação. Quem é responsável pela decisão final? Como os agentes compartilham estado? Um agente pode sobrescrever a conclusão de outro? O que acontece quando dois agentes discordam? Como o sistema evita trabalho repetido ou poluição de contexto?
Eu não usaria o planejamento multiagente apenas porque uma tarefa parece grande. Eu o usaria quando o trabalho puder ser dividido em papéis com entradas, saídas e limites de revisão claros. A camada final ainda precisa de um orquestrador responsável, seja software, um agente líder ou um revisor humano.
Escolher um Padrão de Memória
Contexto de trabalho, memória durável e experiência reutilizável
Um bom padrão de memória começa com contenção. O contexto de trabalho deve ser fresco e específico à tarefa. A memória durável deve ser seletiva. A experiência reutilizável deve ser validada antes de moldar execuções futuras.
Por exemplo, se um agente aprende que uma equipe prefere um determinado formato de pull request, isso pode se tornar memória durável. Se ele aprende que uma estratégia de migração específica passou nos testes em um repositório, isso não deve se aplicar automaticamente em todos os lugares. Só pode se tornar experiência reutilizável depois que o sistema registra onde funcionou, quais suposições estavam presentes, que validação foi realizada e quais riscos permanecem.
É aqui que o EvoMap pode ser mencionado naturalmente: vejo sua ideia arquitetônica mais interessante não como "agentes lembram de tudo", mas como "experiência útil precisa de estrutura antes de poder ser reutilizada". Essa distinção é importante. A memória não é valiosa porque é longa. Ela é valiosa quando está escopada, inspecionável e segura para aplicar.
Recuperação, validação e esquecimento
A recuperação deve produzir candidatos, não comandos. Se uma memória for recuperada, o agente ainda deve verificar se ela se aplica à tarefa atual, às permissões atuais, às versões atuais das ferramentas e aos dados atuais. Uma memória sobre uma API anterior pode estar errada após uma mudança de versão. Uma memória sobre a preferência de um usuário pode ser inadequada em um fluxo de trabalho de equipe compartilhado.
Esquecer não é uma fraqueza. Faz parte da saúde do sistema. As equipes devem expirar memórias obsoletas, revogar procedimentos inseguros, rebaixar memórias que falham repetidamente e separar preferências pessoais de políticas organizacionais. Um sistema de memória útil deve responder a quatro perguntas: quem criou essa memória, quais evidências a sustentam, onde ela pode ser usada e quando deve parar de ser confiável?
Conecte Ferramentas Sem Perder o Controle
Limites de permissão e contratos de ferramenta estruturados
O controle de ferramentas começa antes da primeira chamada de ferramenta. Cada ferramenta deve definir suas ações permitidas, esquema de entrada exigido, formato de saída, efeitos colaterais e nível de aprovação. Uma ferramenta de busca somente leitura não deve compartilhar a mesma categoria de permissão que uma ferramenta que envia e-mails ou modifica dados de produção. Uma ferramenta de arquivos local não deve ser tratada da mesma forma que um conector SaaS de terceiros.
Os limites de permissão também precisam aparecer em diagramas. Se uma ferramenta envia dados para um processador de terceiros, a arquitetura deve mostrar quais dados saem do sistema, por que saem, se são armazenados e quem aprovou esse caminho. Eu prefiro ver um diagrama ligeiramente simples com limites de confiança claros do que um diagrama bonito que esconde o fluxo de dados.
Contratos estruturados reduzem a ambiguidade. O agente deve saber quais campos são obrigatórios, o que significam os erros, se a tentativa de repetição é segura e se o resultado é final ou precisa de validação. Descrições em linguagem natural podem ajudar o modelo a escolher ferramentas, mas não devem ser a única camada de segurança.
Observabilidade, tentativas de repetição e revisão humana
Agentes confiáveis precisam de observabilidade porque falhas raramente são um evento único. Uma resposta final ruim pode surgir de uma recuperação ruim, uma permissão ausente, uma ferramenta lenta, um loop de repetição ou uma memória que não deveria ter sido usada. Sem rastros, a equipe está apenas adivinhando.
O Guia de observabilidade OpenTelemetry GenAI é útil porque conecta chamadas de modelo, uso de tokens, chamadas de ferramentas, latência, rastros, métricas e eventos. Para sistemas de agentes, essa visibilidade não é apenas para depuração. Ela também suporta análise de custos, revisão de incidentes e decisões de arquitetura.
As tentativas de repetição devem ser projetadas cuidadosamente. Retentar uma pesquisa que falhou é de baixo risco. Retentar um pagamento, uma mutação de banco de dados ou uma mensagem enviada não é. O sistema precisa de chaves de idempotência, registros de efeitos colaterais e regras de escalonamento. A revisão humana deve ocorrer quando o custo de uma ação incorreta é maior do que o custo de desacelerar.
Avalie Todo o Sistema
Sucesso da tarefa, recuperação, custo e manutenibilidade
Uma arquitetura de agente deve ser avaliada como um sistema completo, não apenas como uma demonstração do modelo. O sucesso da tarefa importa, mas não é suficiente. A equipe também deve medir a taxa de recuperação, a taxa de erros de ferramentas, a taxa de intervenção humana, a latência, o custo por tarefa concluída, a qualidade da reutilização de memória e o esforço necessário para manter prompts, ferramentas, testes e políticas.
O custo deve estar vinculado ao trabalho concluído, não apenas ao volume de tokens. Uma execução barata que falha três vezes pode ser mais cara do que uma execução mais lenta com melhores verificações de estado. Um fluxo de trabalho multiagente pode parecer caro por execução, mas economizar tempo se reduzir a revisão humana. A única resposta honesta é medir com base em tarefas reais.
A manutenibilidade é a parte que eu não ignoraria. Um novo engenheiro consegue entender as regras de planejamento? Um Product Owner consegue inspecionar o comportamento da memória? A segurança consegue revisar permissões de ferramentas? O suporte consegue explicar por que o agente fez algo? Se a resposta for não, a arquitetura pode ser inteligente, mas frágil.
Perguntas Frequentes
Quando uma equipe deve substituir um framework de agente?
Substitua um framework de agentes quando seu modelo de estado, sistema de permissão de ferramentas, observabilidade ou ciclo de vida da memória bloquear o trabalho que você precisa realizar com segurança. Não o substitua apenas porque um framework mais novo tem exemplos melhores. A migração é justificada quando o stack atual torna falhas difíceis de inspecionar, memórias difíceis de gerenciar ou ferramentas difíceis de controlar.
Quem deve tomar decisões de arquitetura entre equipes?
Um pequeno grupo de arquitetura deve ser responsável pelos limites compartilhados: identidade, permissões, observabilidade, política de memória, padrões de ferramentas e requisitos de avaliação. As equipes de produto individuais ainda devem ser responsáveis pelo comportamento das tarefas, experiência do usuário e testes de aceitação. Se tudo for centralizado, a entrega desacelera. Se tudo for local, o sistema se torna inconsistente.
Como as equipes podem migrar memórias entre stacks de agentes?
Exporte memórias com metadados, não apenas texto. Cada memória deve incluir fonte, hora de criação, proprietário, escopo, confiança, evidência de validação, versões de ferramentas relacionadas e status de revogação. Durante a migração, trate as memórias como candidatas. Reteste-as antes da promoção, especialmente se afetarem o uso de ferramentas, política de segurança ou saída voltada para o usuário.
Qual orçamento de latência se encaixa no planejamento de agentes com múltiplos passos?
O orçamento de latência correto depende da interação. Para chat ao vivo, os usuários precisam de progresso parcial rápido e checkpoints visíveis. Para pesquisas em segundo plano, um planejamento mais longo pode ser aceitável se o resultado final for melhor. Para ações de alto risco, o tempo de aprovação importa mais do que a velocidade do modelo. Eu definiria orçamentos por classe de tarefa, não por um número global.
Como os diagramas devem mostrar processadores de dados de terceiros?
Mostre os processadores de terceiros fora do limite principal de confiança. Rotule quais dados são enviados, se incluem conteúdo do usuário, se o processador os armazena, qual ferramenta iniciou a transferência e onde ocorre a aprovação. O diagrama deve tornar o movimento de dados óbvio o suficiente para que um não autor possa identificar o risco.
Reflexão Final
Uma boa arquitetura de agentes não se trata de dar mais liberdade ao modelo em todos os lugares. Trata-se de decidir onde a liberdade ajuda e onde a estrutura protege o trabalho. Planejamento, memória, ferramentas e orquestração não devem ser projetados separadamente. Eles moldam uns aos outros. O agente só pode planejar bem se conhecer suas ferramentas. Só pode reutilizar memória com segurança se a memória tiver um ciclo de vida. Só pode se recuperar se o estado de execução for observável.
Esse é o mapa que eu manteria na parede: decidir, lembrar, agir, observar, recuperar. Todo o resto é uma escolha de implementação.
Posts Anteriores:
- Se você quer entender o que envolve o modelo em uma pilha de agente de produção, engenharia de harness de agente de IA explora como memória, orquestração, frameworks e infraestrutura de runtime se encaixam.
- Para um exemplo concreto de uma arquitetura de runtime modular, arquitetura DeepSeek Harness mostra como ferramentas, sessões, permissões, sandboxing e o loop do agente podem ser separados em componentes substituíveis.
- Se a camada de memória é a parte que você está projetando a seguir, memória de fluxo de trabalho de agente examina mais de perto como o contexto de trabalho pode se tornar uma experiência de fluxo de trabalho estruturada e reutilizável.
- Para entender melhor como as ações se conectam em uma execução de múltiplas etapas, cadeias de execução de agente explica os hooks e a estrutura de execução por trás de fluxos de trabalho de agente mais longos.
- Para o lado de observabilidade e recuperação da arquitetura, padrões de reprodução determinística examina o que os sistemas de agente precisam registrar para que as execuções possam ser inspecionadas, comparadas e verificadas posteriormente.



