Specification-Driven Generation and Evaluation of Discrete-Event World Models via the DEVS Formalism

Este artigo propõe uma abordagem intermediária para a geração de modelos de mundo via formalismo DEVS e pipelines de LLM, que sintetizam simuladores de eventos discretos executáveis a partir de especificações em linguagem natural, permitindo a adaptação online, a verificação rigorosa e a confiabilidade em sistemas agênticos complexos.

O essencial

Imagine que você precisa ensinar um robô a gerenciar um armazém gigante, ou um sistema a prever o tráfego em uma cidade inteira. Para isso, o robô precisa de um "Modelo de Mundo": uma espécie de simulador interno que permite dizer: "E se eu mandar 5 robôs para a zona A? O que acontece?"

O problema é que os modelos de mundo atuais são como dois extremos de uma balança:

1. O "Arquiteto Rigoroso" (Simuladores Manuais): São como maquetes de arquitetura feitas à mão. São perfeitas, consistentes e você sabe exatamente o que vai acontecer. Mas, se você quiser mudar uma parede ou adicionar um elevador, precisa de um engenheiro humano gastando dias para reconstruir tudo do zero. É caro e lento.
2. O "Oráculo Místico" (Modelos de IA Ocultos): São como bolas de cristal treinadas com milhões de dados. São flexíveis e aprendem rápido. Mas, se você perguntar algo complexo, elas podem alucinar, inventar regras que não existem ou falhar sem você saber o porquê. É difícil confiar nelas para tarefas longas e críticas.

Este artigo propõe um meio-termo inteligente: criar um simulador que seja flexível como a IA, mas organizado como a maquete.

A Grande Ideia: "Construindo com Blocos de Lego"

Os autores usam uma linguagem chamada DEVS (Especificação de Sistemas de Eventos Discretos). Pense no DEVS como um kit de Lego extremamente organizado.

Em vez de pedir para uma Inteligência Artificial (IA) escrever um programa gigante e confuso de uma só vez, o método deles divide o trabalho em etapas, como se fosse uma equipe de construção:

1. O Arquiteto (Planejamento Estrutural): Primeiro, a IA lê a descrição em linguagem natural (ex: "Tenho robôs, carregadores e pedidos") e desenha o mapa de conexões. Ela decide: "Ok, o robô é um bloco, o carregador é outro, e eles se conectam assim". Ela cria o esqueleto do sistema.
2. Os Pedreiros (Construção Comportamental): Depois, a IA preenche cada bloco individualmente. "O que o robô faz quando fica sem bateria? Ele vai para o carregador". Como cada bloco é pequeno e tem regras claras, a IA não se confunde.
3. O Inspetor de Qualidade (Verificação por Rastros): Aqui está a mágica. Quando o simulador roda, ele não apenas "funciona"; ele escreve um diário de bordo (um rastro de eventos).
   • Exemplo: "Às 10:00, o robô A recebeu um pedido. Às 10:05, ele começou a mover. Às 10:10, ele chegou."
   • O sistema verifica esse diário contra as regras originais. Se o robô chegou antes de começar a mover, o sistema grita: "Erro! Isso viola a regra de tempo!" e diz exatamente onde está o problema.

Analogia Criativa: A Cozinha de um Restaurante

Imagine que você quer criar um sistema para gerenciar um restaurante lotado.

• O jeito antigo (Manual): Você contrata um chef experiente para desenhar o fluxo da cozinha no papel. Se o dono quiser adicionar um novo prato ou mudar o horário de funcionamento, o chef tem que redesenhar tudo. Demorado.
• O jeito da IA pura: Você pede para um robô cozinheiro "adivinhar" como a cozinha funciona. Ele pode tentar cozinhar 100 hambúrgueres de uma vez e queimar a cozinha, porque não entende a lógica de "forno só cabe 5".
• O jeito deste artigo (DEVS):
  1. Você descreve o restaurante em português: "Tem uma entrada, uma cozinha com 3 fogões e uma saída".
  2. A IA monta a cozinha como blocos separados: um bloco "Entrada", um bloco "Fogo 1", um bloco "Fogo 2".
  3. A IA escreve as regras de cada bloco: "O Fogo 1 só acende se houver um pedido".
  4. O Teste: O sistema roda e gera um log (um vídeo escrito) de tudo que acontece.
  5. Se o "Fogo 1" tentar cozinhar sem pedido, o sistema para e diz: "Ei! O bloco Fogo 1 violou a regra de segurança. Corrija apenas o código do Fogo 1, não precisa reescrever a cozinha toda."

Por que isso é revolucionário?

1. Confiabilidade: Como o sistema é construído em blocos com regras claras, ele não "alucina" tanto quanto as IAs puras. Ele sabe que o tempo é real e que as causas vêm antes dos efeitos.
2. Velocidade: Como os blocos são independentes, você pode construir várias partes ao mesmo tempo (em paralelo). É como ter 10 pedreiros trabalhando em 10 cômodos diferentes ao invés de um só.
3. Correção Fácil: Se algo der errado, o sistema aponta exatamente qual "bloco" (qual parte do código) errou. Você não precisa consertar o mundo inteiro, apenas aquele pequeno pedaço.

Resumo Final

Este trabalho ensina como transformar descrições simples em português (como "quero um sistema de filas de banco") em simuladores de computador robustos e confiáveis. Eles usam uma técnica de desmontar o problema em peças pequenas, construir cada peça com cuidado e depois ler o diário de bordo do sistema para garantir que tudo está funcionando como prometido.

É como dar a uma IA um manual de instruções de Lego em vez de pedir para ela inventar a física do universo do zero. O resultado é um mundo virtual que podemos confiar para planejar o futuro, seja para robôs, redes de internet ou logística de entregas.

Resumo técnico

Resumo Técnico: Geração e Avaliação de Modelos de Mundo de Eventos Discretos via Formalismo DEVS

1. O Problema

O artigo aborda a lacuna crítica na criação de modelos de mundo (simuladores que preveem a evolução de um ambiente sob ações candidatas) para sistemas autônomos e agentes de IA. As abordagens existentes situam-se em dois extremos problemáticos:

• Simuladores Engenharia Manual: Oferecem consistência e reprodutibilidade, mas são caros para adaptar e difíceis de modificar em tempo de execução (online).
• Modelos Neurais Implícitos (LLMs): São flexíveis e adaptáveis, mas carecem de transparência, são difíceis de verificar, e sofrem de "drift" (desvio) não acotovelado em horizontes longos, tornando a depuração de erros complexa.

Existe uma necessidade urgente de um "meio-termo" que combine a confiabilidade de simuladores explícitos com a flexibilidade de modelos aprendidos, permitindo a síntese e adaptação sob demanda durante a execução, especificamente para ambientes governados pela ordenação, temporização e causalidade de eventos discretos (ex: filas, protocolos de rede, coordenação multiagente).

2. Metodologia

Os autores propõem um pipeline de geração baseado em Inteligência Artificial (LLMs) que sintetiza simuladores executáveis diretamente de especificações em linguagem natural, utilizando o formalismo DEVS (Discrete Event System Specification) como representação intermediária.

A abordagem é dividida em três pilares principais:

A. Formalismo DEVS como Representação Operacional

• O modelo de mundo é definido como um sistema de eventos discretos onde o estado muda apenas em tempos de eventos isolados.
• O sistema é decomposto hierarquicamente em modelos atômicos (com estado local e lógica de transição) e modelos acoplados (que definem a estrutura e o roteamento de eventos).
• Isso garante que a evolução do estado seja estruturada, explícita e verificável, evitando a ambiguidade dos modelos neurais puros.

B. Pipeline de Geração em Duas Etapas (DEVS-Gen)
Para lidar com a complexidade estrutural e a falta de uma "verdade absoluta" única na implementação, o pipeline separa a síntese estrutural da lógica comportamental:

1. Síntese Estrutural: Agentes LLMs analisam a especificação natural para inferir a hierarquia de componentes, os esquemas de portas (interfaces) e o grafo de interação. O resultado é uma "Árvore de Planejamento" (PlanTree) que atua como um contrato rígido.
2. Síntese Comportamental: Com base no contrato estrutural, agentes especializados geram a lógica interna de cada componente atômico (transições de estado, funções de tempo, lógica de eventos) de forma paralela.
   • Adaptação: Um mecanismo de "resumo de interface" permite que o modelo acoplado pai se adapte às interfaces reais geradas pelos filhos, corrigindo desvios semânticos antes da montagem final.

C. Avaliação Baseada em Rastros (Trace-Based Evaluation)
Como não há um código de referência único para comparação, a avaliação é orientada por especificação:

• O simulador gerado deve emitir um rastro de eventos estruturado (JSONL) contendo tempo, entidade, tipo e carga útil.
• Um "oráculo de verificação" valida esses rastros contra regras derivadas da especificação original (ex: restrições temporais, invariantes semânticos, causalidade).
• Métricas incluem Sucesso Operacional (o código roda e segue o contrato de I/O) e Conformidade Comportamental (o rastro de eventos satisfaz as regras de domínio).

3. Principais Contribuições

1. Framework de Síntese DEVS-Gen: Um pipeline automatizado que transforma descrições em linguagem natural em simuladores DEVS executáveis, utilizando decomposição modular para escalar a complexidade.
2. Mecanismo de Avaliação sem Oracle de Referência: Uma metodologia de validação que verifica a conformidade do comportamento observável (rastros de eventos) com as restrições da especificação, em vez de comparar código-fonte.
3. Benchmarks Diversificados: Criação de um conjunto de dados com 7 cenários complexos (desde protocolos de rede como ABP até sistemas logísticos e modelos epidemiológicos ODE), derivados de sistemas reais de código aberto para garantir autenticidade.
4. Demonstração de Eficiência e Escalabilidade: Evidência de que a abordagem modular permite síntese paralela e reduz drasticamente o custo computacional (tokens e tempo) em comparação com agentes iterativos tradicionais.

4. Resultados Experimentais

O estudo comparou o DEVS-Gen contra agentes de engenharia de software de ponta (OpenHands, SWE-Agent) em diversos modelos de linguagem (LLMs), tanto grandes quanto pequenos.

• Eficácia: O DEVS-Gen alcançou pontuações de conformidade comportamental (BCS) e sucesso operacional (OSS) comparáveis ou superiores aos agentes iterativos completos, mesmo operando sem feedback de execução (modo "one-pass").
  • Exemplo: Com o modelo GPT-5.2, o DEVS-Gen obteve 0.86 de OSS, superando o SWE-Agent (0.89) e ficando próximo do OpenHands iterativo (0.96), mas com muito menos iterações.
• Robustez em Modelos Pequenos: O DEVS-Gen demonstrou superioridade significativa em modelos menores (ex: GLM-4.7-Flash), onde agentes iterativos frequentemente falham em gerar código executável devido a loops de depuração infinitos.
• Eficiência:
  • Redução de Tokens: O DEVS-Gen reduziu o consumo de tokens em aproximadamente 1 ordem de magnitude (cerca de 6x a 10x menos) em comparação com agentes iterativos.
  • Tempo de Execução: O tempo de síntese foi linear e previsível, evitando os "loops de doom" (estagnação) comuns em agentes que tentam corrigir erros iterativamente.
• Escalabilidade: A arquitetura permitiu uma aceleração de 4.7x na fase de geração de componentes atômicos quando executada em paralelo, validando a teoria de que a complexidade cresce logaritmicamente com o tamanho do sistema, e não linearmente.

5. Significado e Impacto

Este trabalho estabelece um novo paradigma para a construção de modelos de mundo em sistemas autônomos:

• Confiabilidade com Flexibilidade: Permite que agentes de IA planejem em horizontes longos com a segurança de simuladores formais, sem a rigidez de codificação manual.
• Diagnóstico Acionável: Ao focar em rastros de eventos e violações de especificação, o sistema fornece diagnósticos localizados de falhas, facilitando a correção iterativa.
• Fundação para Sistemas Híbridos: O framework prepara o terreno para sistemas onde LLMs podem ser embutidos como componentes dentro de simulações DEVS, permitindo a criação de simulações sociais, organizacionais ou multiagente especificadas inteiramente em linguagem natural.

Em suma, o artigo demonstra que a combinação de formalismos de simulação clássicos (DEVS) com a capacidade de geração de código de LLMs, mediada por uma avaliação baseada em rastros, oferece uma solução escalável, verificável e eficiente para a geração de modelos de mundo complexos.