Emergent Worlds Lab

Simulação multi-agente em tempo real para observação de comportamentos emergentes em sistemas autônomos.

Contexto e Motivação

Sistema de simulação que modela agentes autônomos competindo por recursos limitados em um ambiente dinâmico. O objetivo é observar padrões emergentes que surgem da interação entre agentes com diferentes arquiteturas de decisão, sem programação explícita desses comportamentos.

Aplicável para:

• Estudo de sistemas multi-agente e teoria de jogos
• Visualização de dinâmicas de competição/cooperação
• Prototipagem de algoritmos de decisão distribuída
• Análise de estabilidade em sistemas autônomos

Arquitetura

Componentes Principais

useSimulation (hook): Motor de simulação centralizado

• Gerencia estado global (agentes, ambiente, eventos, métricas)
• Executa ciclos de simulação com intervalo configurável
• Calcula métricas agregadas e detecta condições de estabilidade

Componentes de Visualização:

• SimulationCanvas: Renderiza agentes em movimento com Framer Motion
• ControlPanel: Controles de execução (play/pause/step/reset/velocidade)
• AgentPanel: Lista detalhada de estado individual dos agentes
• MetricsPanel: Dashboard de métricas agregadas do sistema
• EventLog: Stream de eventos em tempo real
• EnvironmentPanel: Estado atual do ambiente (recursos, ruído, latência)

Fluxo de Execução

1. Inicialização: Cria N agentes com propriedades aleatórias (posição, recursos, arquitetura, objetivo)
2. Ciclo de Simulação (executado a cada intervalo):
   • Atualização de Agentes:
     • Consumo de recursos (energia, dados, compute time)
     • Decisão de ação baseada em arquitetura e estado (explorar/atacar/cooperar/enganar/defender/observar)
     • Movimento físico com física simplificada (velocidade, colisões com bordas)
     • Detecção de estados críticos (stressed/critical/terminated)
   • Interações: Detecção de proximidade entre agentes, formação de alianças
   • Ambiente: Degradação gradual de recursos globais, ruído e latência variáveis
   • Eventos: Geração de eventos (alliance, deception, anomaly, collision)
   • Métricas: Cálculo de estabilidade, eficiência, comportamentos emergentes
3. Renderização: Atualização visual em tempo real via React state
4. Histórico: Manutenção de buffer circular (últimos 50 ciclos, 100 eventos)

Decisões Técnicas

• Estado centralizado no hook: Facilita controle de ciclo de vida e sincronização
• Física simplificada: Movimento baseado em velocidade, sem colisões complexas (trade-off performance/clareza)
• Probabilidades fixas: Pesos de ação por arquitetura são determinísticos, aleatoriedade apenas na seleção
• Buffer circular: Limita memória para execuções longas
• Detecção de estabilização prematura: Alerta quando sistema converge muito rápido (indicador de falha experimental)

Stack e Dependências

Core:

• React 18.3 + TypeScript 5.8
• Vite 5.4 (build tool, HMR)
• React Router 6.30 (roteamento)

UI:

• shadcn/ui (componentes baseados em Radix UI)
• Tailwind CSS 3.4 (estilização)
• Framer Motion 12.23 (animações do canvas)
• Lucide React (ícones)

Estado e Dados:

• TanStack Query 5.83 (preparado, não utilizado atualmente)
• React Hook Form 7.61 + Zod 3.25 (preparado, não utilizado)

Justificativas:

• Vite: Build rápido, HMR eficiente para desenvolvimento iterativo
• Framer Motion: Animações suaves de posicionamento sem overhead manual
• shadcn/ui: Componentes acessíveis e customizáveis, sem dependência de framework UI pesado
• TypeScript: Tipagem forte para modelos de dados complexos (Agent, SimulationState)

Como Rodar Localmente

Pré-requisitos

• Node.js 18+ (recomendado via nvm)
• npm ou bun

Setup

# Clone o repositório
git clone <repository-url>
cd emergent-worlds-lab

# Instale dependências
npm install
# ou
bun install

# Inicie servidor de desenvolvimento
npm run dev
# ou
bun dev

A aplicação estará disponível em http://localhost:8080.

Build para Produção

npm run build
# ou
bun run build

Artefatos gerados em dist/.

Casos de Uso

1. Experimento de Comportamento Emergente:

   • Execute simulação com 6-10 agentes
   • Observe formação espontânea de alianças
   • Monitore métricas de estabilidade vs. eficiência

2. Comparação de Arquiteturas:

   • Compare estratégias de diferentes arquiteturas (symbolic vs. reactive)
   • Analise padrões de sobrevivência por tipo

3. Análise de Degradação:

   • Execute até exaustão de recursos
   • Observe ordem de terminação e fatores críticos

4. Teste de Estabilidade:

   • Sistema alerta se estabilização ocorre antes de ciclo 10
   • Use para validar parâmetros de simulação

Limitações e Trade-offs

Limitações Conhecidas

1. Lógica de Simulação Simplificada:

   • Decisões baseadas em probabilidades fixas, não aprendizado
   • Física 2D básica, sem colisões reais entre agentes
   • Interações limitadas a detecção de proximidade

2. Sem Persistência:

   • Estado perdido ao recarregar página
   • Sem exportação de dados ou histórico

3. Configuração Hardcoded:

   • Número de agentes fixo (6) no código
   • Parâmetros de ambiente não configuráveis via UI
   • Pesos de ação por arquitetura não ajustáveis

4. Performance:

   • Renderização de todos os agentes a cada ciclo (sem virtualização)
   • Cálculo O(n²) para detecção de interações (não otimizado para muitos agentes)
   • Limite prático: ~20 agentes antes de degradação perceptível

5. Sem Validação Científica:

   • Modelo não validado contra dados reais
   • Métricas são heurísticas, não medidas rigorosas

Trade-offs Assumidos

• Simplicidade vs. Realismo: Modelo simples permite observação clara, mas não representa sistemas reais
• Tempo Real vs. Precisão: Execução em tempo real prioriza fluidez sobre precisão numérica
• Visualização vs. Dados: Interface rica em UI, mas sem exportação para análise externa

Possíveis Extensões Futuras

Técnicas (Implementáveis)

1. Sistema de Configuração:

   • UI para ajustar número de agentes, recursos iniciais, parâmetros de ambiente
   • Presets de cenários (alta competição, cooperação forçada, etc.)

2. Persistência e Exportação:

   • LocalStorage para salvar estado
   • Export CSV/JSON de histórico de métricas
   • Import/export de configurações de simulação

3. Otimizações de Performance:

   • Spatial indexing para detecção de colisões (quadtree)
   • Virtualização de renderização para muitos agentes
   • Web Workers para cálculo de ciclos (desacoplar UI de lógica)

4. Lógica de Decisão Avançada:

   • Árvores de decisão configuráveis por arquitetura
   • Memória de interações passadas (agentes lembram de alianças/enganos)
   • Aprendizado simples (ajuste de pesos baseado em sucesso)

5. Análise e Visualização:

   • Gráficos de tendência temporal (Recharts já incluído)
   • Heatmap de densidade de agentes
   • Análise de rede de alianças

6. Multiplayer/Comparação:

   • Múltiplas simulações paralelas com parâmetros diferentes
   • Comparação side-by-side de resultados

7. Backend Opcional:

   • API para execução de simulações longas
   • Banco de dados para histórico de experimentos
   • Compartilhamento de configurações entre usuários

Estrutura do Código

src/
├── hooks/
│   └── useSimulation.ts      # Motor de simulação
├── components/
│   ├── simulation/            # Componentes específicos da simulação
│   └── ui/                    # Componentes shadcn/ui
├── types/
│   └── simulation.ts          # Tipos TypeScript (Agent, SimulationState, etc.)
├── pages/
│   └── Index.tsx              # Página principal
└── App.tsx                     # Setup de providers (Router, Query, etc.)

Observação Final

Este projeto é um laboratório de observação, não um simulador científico rigoroso. O valor está na visualização de padrões emergentes e na exploração de diferentes configurações, não em resultados quantitativos precisos.

Se o sistema estabilizar muito rápido, o experimento falhou — essa é a regra implícita do sistema.