70 padrões de projeto de IA para LLMs e agentes

Dividir a tarefa em etapas fixas, onde a saída de uma vira a entrada da próxima.

Classificar a entrada e mandar cada tipo para um caminho especializado.

Quebrar a tarefa em partes independentes e rodar todas em paralelo.

Rodar a mesma tarefa várias vezes ou com vários modelos e decidir por maioria ou limiar.

Um modelo decide as subtarefas na hora e distribui para trabalhadores.

Um modelo gera, outro avalia com critério claro, e o ciclo repete até passar.

Exigir que o modelo responda em um schema e validar a resposta.

Escolher na hora os exemplos mais parecidos com a entrada atual.

Guardar prompts como artefatos versionados, com variáveis e histórico.

Processar pedaços em paralelo e depois combinar os resultados em uma resposta.

Buscar trechos relevantes e entregar ao modelo junto com a pergunta.

Combinar busca por palavra-chave e busca vetorial para não perder nem sinônimos nem códigos exatos.

Buscar muitos candidatos e usar um modelo mais preciso para escolher os melhores.

Transformar a pergunta do usuário em uma ou mais buscas melhores.

Navegar relações entre entidades quando a resposta depende de conexões, não de um trecho.

Deixar o agente decidir quando, onde e quantas vezes buscar.

Cortar documentos respeitando a estrutura e anexar a cada pedaço o contexto de onde ele veio.

Resumir ou podar o contexto quando ele cresce, mantendo o que importa.

Rodar subtarefas em contextos separados e trazer de volta só o resultado.

Mostrar ao modelo só o resumo de cada habilidade e carregar o detalhe quando ele pedir.

Exigir que cada afirmação aponte para a fonte e checar se a fonte diz aquilo.

Manter o estado da conversa atual de forma explícita, fora do texto bruto.

Guardar fatos e preferências entre sessões e trazer só os relevantes.

Lembrar de execuções passadas, o que deu certo e o que deu errado, para agir melhor.

Revisar memórias em segundo plano para fundir, corrigir e esquecer.

Dar ao agente um lugar para anotar plano e resultados parciais fora da conversa.

Salvar o estado em pontos seguros para continuar de onde parou.

Rodar o agente sobre um motor que garante cada etapa mesmo com quedas e esperas longas.

Um espaço estruturado onde vários agentes publicam e leem fatos, com dono e formato.

Dar ao modelo funções bem descritas para buscar dados e agir.

Escolher um subconjunto pequeno de ferramentas antes de chamar o modelo principal.

Deixar o modelo escrever e rodar código em um ambiente isolado e descartável.

Operar interfaces gráficas por tela, mouse e teclado quando não existe API.

Navegar, ler e preencher páginas web usando a estrutura do DOM.

Expor sistemas como servidores MCP para qualquer agente usar o mesmo contrato.

Reduzir respostas grandes de ferramentas ao que importa antes de voltar ao modelo.

Gerar o plano da ação e mostrar o efeito antes de executar de verdade.

Garantir que repetir a mesma chamada não duplique o efeito.

Para cada passo com efeito, ter o passo que desfaz, como em uma saga.

Alternar raciocínio, ação e observação até a tarefa terminar.

Escrever o plano inteiro antes e executar os passos com um modelo mais simples ou com código.

Revisar o plano quando a realidade não bate com o esperado.

Fazer o modelo criticar o próprio resultado com base em um sinal externo e corrigir.

Gerar várias linhas de raciocínio e ficar com a resposta mais frequente.

Explorar alternativas em árvore, avaliar cada galho e podar os ruins.

Pausar em pontos definidos para um humano aprovar, editar ou recusar.

Transferir a conversa para outro agente especialista, com o estado necessário.

O agente principal cria subagentes para tarefas focadas e recebe só a conclusão.

Um agente coordena outros, decide quem trabalha e verifica a entrega.

Dois ou mais modelos defendem posições e um juiz decide.

Definir com clareza quando o agente terminou, desistiu ou precisa de ajuda.

Manter um agente trabalhando por horas ou dias com metas, checkpoints e relatórios.

Checar a entrada antes do modelo principal: tema, abuso, injeção e dados sensíveis.

Checar a resposta antes de chegar ao usuário ou a uma ferramenta.

Um modelo em quarentena lê o conteúdo não confiável; outro, com ferramentas, só vê o resultado estruturado.

Cada ferramenta com escopo, credencial e limite próprios.

Avaliar a resposta contra uma lista curta de princípios escritos e revisar se violar algum.

Ter outro modelo ou provedor pronto para assumir quando o principal falha.

Parar de chamar um serviço que está falhando e voltar quando ele se recuperar.

Validar a saída com código e, se falhar, devolver o erro ao modelo para corrigir.

Remover ou mascarar dados pessoais antes do modelo e dos logs, em linha com a LGPD.

Registrar quem pediu, o que o modelo viu, o que decidiu e o que executou.

Rodar casos de teste automaticamente a cada mudança de prompt, modelo ou código.

Usar um modelo com rubrica para avaliar respostas que não têm gabarito exato.

Manter um conjunto curado de entradas e respostas esperadas, crescendo com bugs reais.

Rodar a versão nova em paralelo com tráfego real, sem mostrar ao usuário, e comparar.

Começar pelo modelo mais barato e subir de nível só quando necessário.

Responder perguntas equivalentes com uma resposta já gerada.

Reaproveitar o prefixo fixo do prompt para cortar custo e latência.

Medir e limitar gasto por tarefa, usuário e dia, com alerta e plano de corte.