A Novel Multi-Agent Architecture to Reduce Hallucinations of Large Language Models in Multi-Step Structural Modeling

Este estudo apresenta uma nova arquitetura de agentes múltiplos que automatiza a modelagem e análise estrutural usando OpenSeesPy, reduzindo significativamente as alucinações e erros de modelos de linguagem grandes ao dividir tarefas complexas em etapas especializadas e paralelas.

O essencial

Imagine que você precisa construir um arranha-céu virtual, mas em vez de usar um computador complexo, você pede para um "engenheiro de IA" (uma Inteligência Artificial) escrever o código para você. O problema é que, quando a tarefa é grande e cheia de passos, essas IAs tendem a alucinar: elas inventam fatos, esquecem números ou confundem as instruções, como se estivessem sonhando acordadas.

Este artigo apresenta uma solução genial para esse problema: em vez de ter um engenheiro tentando fazer tudo sozinho (o que gera erros), eles criaram uma equipe de especialistas trabalhando juntos.

Aqui está a explicação do funcionamento dessa "equipe", usando analogias do dia a dia:

1. O Problema: O "Maratonista" Cansado

Antes, existia um modelo onde uma única IA tentava fazer tudo em sequência: ler o pedido, desenhar o prédio, colocar as cargas (peso) e escrever o código final.

• A analogia: É como pedir para uma única pessoa cozinhar um banquete gigante, lavar a louça e servir os convidados, tudo ao mesmo tempo, sem parar. No meio do caminho, ela fica cansada, esquece de temperar o prato ou coloca sal onde deveria ser açúcar. Quanto maior o prédio (mais passos), mais erros ela comete.

2. A Solução: A "Orquestra" de Agentes

Os autores criaram uma arquitetura de Multi-Agentes. Imagine uma orquestra ou uma equipe de construção onde cada pessoa faz apenas o que sabe fazer melhor, e há um supervisor garantindo que ninguém erre.

A equipe funciona em quatro etapas principais:

• O Arquiteto (Análise e Planejamento):

  • Função: Ele lê o pedido do cliente (que pode ser escrito de qualquer jeito, como "um prédio de 3 andares com janelas grandes") e transforma isso em uma lista de tarefas organizada e matemática.
  • Analogia: É o gerente de obra que pega a ideia do cliente e desenha o plano no papel, garantindo que todos entendam o que precisa ser feito antes de começar.

• Os Construtores Paralelos (Montagem da Geometria):

  • Função: Aqui, a mágica acontece. Em vez de um construtor fazer tudo, dois agentes trabalham ao mesmo tempo (em paralelo). Um coloca os "pontos" (nós) e o outro coloca as "vigas" (elementos).
  • Analogia: Imagine dois operários: um segura o nível e marca onde vão os pilares, enquanto o outro já começa a colocar as vigas. Eles não esperam um pelo outro, o que torna o trabalho muito mais rápido. Se um errar, há um "inspetor de qualidade" (um checkpoint) que verifica se os pontos batem com as vigas antes de prosseguir.

• O Engenheiro de Cargas (Integração de Cargas):

  • Função: Ele decide onde colocar o peso do prédio, a neve no telhado ou o vento batendo na fachada.
  • Analogia: É como um especialista em logística que sabe exatamente onde colocar caixas pesadas no caminhão para que ele não tombe. Ele traduz "vento forte" em números exatos para o computador.

• Os Tradutores (Conversão de Código):

  • Função: Eles pegam todas as informações organizadas e escrevem o código final que o software de engenharia (OpenSeesPy) consegue ler e executar.
  • Analogia: São tradutores que pegam o plano em português e o transformam em "idioma de máquina" (código de computador) perfeito, sem erros de gramática.

3. O Segredo: Usando a Ferramenta Certa para o Trabalho

O artigo descobre que nem todas as IAs são iguais.

• Para tarefas que exigem raciocínio complexo (como planejar a estrutura), eles usam uma IA muito inteligente e "pensante" (GPT-OSS 120B).
• Para tarefas que exigem precisão e tradução (como escrever o código), eles usam uma IA mais rápida e que segue regras à risca (Llama).
• A analogia: É como ter um mestre de obras genial para desenhar o projeto, mas usar um assistente super-rápido e obediente para escrever as etiquetas e os códigos. Misturar os dois evita que o genial cometa erros bobos de digitação e que o rápido cometa erros de lógica.

4. Os Resultados: Precisão e Velocidade

• Precisão: A nova equipe acertou 100% das vezes em 18 de 20 testes complexos. O modelo antigo (o "maratonista") falhava muito em prédios grandes.
• Velocidade: Como eles trabalham em paralelo e não esperam um pelo outro, o tempo de processamento caiu drasticamente. O que levava quase 15 minutos, agora leva cerca de 2 minutos.
• Escalabilidade: A equipe consegue construir prédios gigantes (com 10 andares e 10 seções) sem "travar" ou ficar confusa, algo que o modelo antigo não conseguia fazer.

Conclusão

Basicamente, este artigo diz: "Não confie em um único gênio cansado para construir um prédio inteiro. Contrate uma equipe organizada, onde cada um faz sua parte, com supervisores verificando o trabalho no meio do caminho."

Isso permite que engenheiros e até estudantes de arquitetura descrevam seus projetos em linguagem natural e recebam, em segundos, um modelo matemático perfeito pronto para análise, sem precisar saber programar ou ter medo de erros humanos.

Resumo técnico

Título: Uma Nova Arquitetura Multi-Agente para Reduzir Alucinações de Modelos de Linguagem de Grande Escala (LLMs) na Modelagem Estrutural Multi-Etapas

1. O Problema

A análise estrutural é fundamental para a engenharia civil, mas a modelagem usando software de elementos finitos (como OpenSees) permanece um processo manual, intensivo em mão de obra e propenso a erros humanos. Embora os Modelos de Linguagem de Grande Escala (LLMs) tenham demonstrado capacidades notáveis em raciocínio e compreensão de contexto, sua aplicação direta na automação de modelagem estrutural enfrenta barreiras significativas:

• Alucinações e Acúmulo de Erros: Em tarefas de sequências longas (como construir modelos complexos de quadros), LLMs tendem a alucinar (gerar informações falsas) e acumular erros à medida que o número de etapas aumenta.
• Limitações de Arquiteturas Sequenciais: Arquiteturas existentes que usam agentes de LLM em uma cadeia sequencial (um após o outro) falham em problemas complexos, apresentando baixa precisão (até 60% em estruturas de 5 vãos), tempos de inferência excessivos (até 949 segundos) e falta de escalabilidade (falhas por limite de tempo de API em estruturas maiores).
• Falta de Confiabilidade Quantitativa: LLMs gerais muitas vezes não possuem a precisão numérica rigorosa necessária para cálculos estruturais, resultando em modelos inválidos que podem comprometer a segurança.

2. Metodologia: Arquitetura Multi-Agente Proposta

O estudo propõe uma arquitetura multi-agente inovadora baseada em OpenSeesPy para automatizar a modelagem e análise de quadros estruturais 2D. A arquitetura decompõe o fluxo de trabalho em quatro módulos coordenados, utilizando checkpoints para validação e regeneração de saídas, mitigando a propagação de erros.

Componentes Principais:

1. Análise e Planejamento:
   • Agente de Análise de Problema: Extrai parâmetros-chave da descrição textual do usuário e os organiza em um arquivo JSON estruturado (geometria, condições de contorno, materiais e cargas).
   • Agente de Planejamento de Construção: Gera um plano passo a passo para a montagem do quadro (vão a vão, andar a andar), definindo "tipos de etapa" baseados em conhecimento de domínio.
   • Checkpoint: Verifica a consistência entre o plano gerado e os parâmetros extraídos antes de prosseguir.
2. Montagem da Geometria (Execução Paralela):
   • Agente de Nós e Agente de Elementos: Operam em paralelo (diferente das abordagens sequenciais) para definir coordenadas, identificadores e conectividade.
   • Função de Mapeamento de Conectividade: Converte coordenadas em conectividade de nós (formato OpenSeesPy).
   • Checkpoint: Valida a consistência geométrica (nós duplicados, elementos sem nós correspondentes, etc.). Se falhar, reexecuta a geração.
3. Integração de Cargas:
   • Agente de Atribuição de Cargas: Mapeia descrições de cargas (pontuais e distribuídas) para os componentes estruturais corretos (nós e elementos).
   • Compilador de Arquivo JSON: Integra todas as informações (geometria, materiais, cargas) em um único arquivo JSON estruturado.
4. Tradução de Código:
   • Tradutor de Código Geométrico e Gerador de Código Completo: Convertem o JSON em scripts executáveis OpenSeesPy. O primeiro gera a definição de nós e elementos; o segundo integra as cargas e configurações do modelo.

Estratégia de Modelos (Backbones):
A arquitetura utiliza uma estratégia híbrida de dois modelos de linguagem para otimizar custo e desempenho:

• GPT-OSS 120B: Utilizado para agentes que exigem raciocínio complexo (Análise, Planejamento, Nós, Elementos).
• Llama-3.3 70B Instruct Turbo: Utilizado para agentes focados em mapeamento de informações e tradução (Atribuição de Cargas, Tradução de Código), onde a aderência a regras de sintaxe é mais crítica do que o raciocínio profundo.

3. Contribuições Chave

• Redução de Alucinações: A introdução de checkpoints de consistência e a decomposição de tarefas complexas em agentes especializados reduzem drasticamente a taxa de erro.
• Paralelismo Eficiente: A execução paralela dos agentes de nós e elementos supera o gargalo de tempo das arquiteturas sequenciais.
• Adaptabilidade Linguística: O sistema demonstra robustez ao processar descrições textuais variadas (desde templates técnicos até descrições informais de não especialistas).
• Escalabilidade: A arquitetura consegue lidar com estruturas muito maiores (até 10 vãos e 10 andares) sem falhar por limites de tempo de API, algo que as abordagens anteriores não conseguiam.

4. Resultados

A arquitetura foi avaliada em um conjunto de dados de referência com 20 problemas de quadros estruturais (com 3 e 5 vãos) e testada em estruturas maiores.

• Precisão:
  • Alcançou 100% de precisão em 18 dos 20 casos de referência e 90% nos 2 restantes (média de 99%).
  • Superou significativamente a arquitetura sequencial anterior (que caiu para 60% em casos complexos) e modelos de propósito geral como Gemini 2.5 Pro (37%) e GPT-4o (0% de sucesso na geração de código correto).
• Eficiência Computacional:
  • Redução drástica no tempo de inferência: de 269–949 segundos (arquitetura sequencial) para 75–194 segundos (arquitetura proposta).
  • Em casos específicos, a redução foi de até 85% no tempo de processamento.
• Escalabilidade:
  • Testes em estruturas de 7 e 10 vãos mantiveram taxas de precisão de 90%, 100% e 80%, com tempos de execução lineares e gerenciáveis (371s a 548s).
• Custo:
  • O custo por problema de benchmark foi extremamente baixo, variando entre $0,013 e $0,023 (USD de 2026), demonstrando viabilidade econômica.
• Adaptação a Usuários:
  • Testes com estudantes de arquitetura (não especialistas) mostraram que o sistema processa corretamente descrições com estilos linguísticos diversos, mantendo 100% de precisão.

5. Significado e Impacto

Este trabalho representa um avanço significativo na automação da engenharia civil. Ao resolver o problema crítico de alucinações em tarefas de sequência longa, a arquitetura proposta torna viável o uso de LLMs para modelagem estrutural real e complexa, não apenas para tarefas simples.

• Segurança: A precisão de 90-100% e os mecanismos de validação garantem que os modelos gerados sejam confiáveis para análise.
• Democratização: A capacidade de aceitar descrições em linguagem natural de não especialistas reduz a barreira de entrada para ferramentas de análise estrutural avançada.
• Futuro: A arquitetura foi disponibilizada como uma aplicação web pública (civilbot.netlify.app), permitindo validação comunitária e uso prático. O estudo também aponta limitações atuais (como a restrição a quadros retangulares e comportamento elástico linear) e define direções para futuras pesquisas, incluindo a modelagem de treliças, cantilevers e análises não lineares/dinâmicas.