Simulação Multiagente em Altíssima Escala no AgentScope

Guia de leitura

Problema e motivação

Agentes baseados em modelos de linguagem de grande porte (LLMs) possibilitam simulações interativas e realistas sem a necessidade de programação manual extensiva de regras. Contudo, escalar simulações multiagente para tamanhos demográficos realistas revela três gargalos críticos:

1. Limites de escalabilidade e eficiência: A execução centralizada e o Global Interpreter Lock (GIL) do Python restringem a execução dos agentes. Frameworks de atores existentes (ex.: Ray) criam um novo processo para cada ator, desperdiçando recursos ao lidar com milhões de agentes leves e limitados por I/O (I/O-bound).
2. Distribuições populacionais insatisfatórias e falta de diversidade de agentes: Agentes com prompts de histórico simples e idênticos comportam-se de forma homogênea, falhando em representar distribuições demográficas realistas (ex.: por escolaridade, idade ou ocupação).
3. Dificuldade de gerenciamento: Orquestrar, inicializar, monitorar e encerrar centenas de milhares ou milhões de agentes distribuídos em clusters demanda uma sobrecarga operacional substancial.

Ideias-chave

• Arquitetura distribuída baseada em atores: Os agentes computam de forma independente como atores. A plataforma suporta mapeamentos de um-para-um (um agente por processo, contornando o GIL para tarefas pesadas de computação) e muitos-para-um (agentes compartilham processos, maximizando o compartilhamento de tempo dos núcleos de CPU durante esperas de I/O).
• Conversão distribuída sem refatoração (to_dist): Usuários escrevem fluxos de trabalho centralizados, que são convertidos de forma transparente em configurações distribuídas usando proxies locais e placeholders assíncronos de mensagens.
• Ambiente como um agente: Os ambientes são modelados como agentes especializados que suportam manutenção de estado, acesso de alta concorrência via RPC, gatilhos bidirecionais (por meio de ouvintes/listeners) e estruturas multicamadas aninhadas para simulações em nível de grupo.
• Pipeline configurável de população heterogênea: Usuários definem distribuições demográficas em arquivos de configuração, e um pipeline de metaprompt com LLM gera personas diversas e individualizadas para os agentes.
• Agent-Manager: Uma interface gráfica web e uma rede de servidores remotos persistentes para implantar, monitorar e limpar agentes nos nós do cluster.

Método

Execução Distribuída & Conversão Automática

No AgentScope, agentes independentes executam de forma concorrente. Quando um pipeline centralizado é marcado com .to_dist(), duas etapas ocorrem:

1. Agentes distribuídos são instanciados nos workers remotos; objetos proxy leves permanecem no orquestrador central.
2. Os proxies retornam placeholders de mensagem imediatamente ao receber uma chamada. Agentes downstream só bloqueiam a execução quando inspecionam placeholders que dependem de computação pendente de agentes anteriores.

Dinâmica de Simulação

A plataforma avalia o raciocínio multiagente no clássico jogo de "adivinhar $\frac{2}{3}$ da média". Cada agente $i$ submete $x_i\in [0,100]$. O alvo vencedor é: $$x^{\ast }=\frac{2}{3}\cdot \bar{x}=\frac{2}{3}\left(\frac{1}{N}\sum _{i=1}^N{x}_i\right)$$ Quando iterado sob conhecimento comum de racionalidade, o único equilíbrio de Nash converge para $0$. Em experimentos alternativos para testar a generalização além dos dados de treinamento prévio, a regra-alvo foi ajustada para: $$x^{\ast }=5+\frac{1}{2}\bar{x}$$ Definir $x^{\ast }=\bar{x}$ resulta em um equilíbrio de Nash diferente de zero: $$x^{\ast }=5+\frac{1}{2}{x}^{\ast }⟹x^{\ast }=10$$

Resultados

• Escalabilidade: Uma simulação de 1.000.000 de agentes foi concluída em 12 minutos utilizando 4 nós (cada um com 8 GPUs A100-80G, 64 núcleos de CPU, 1 TB de RAM) usando Llama3-8B com prompts básicos, e em 85 minutos com Chain-of-Thought (CoT) prompting (o que expandiu o volume de tokens em mais de 150 vezes). Em um benchmark computacional sintético que eliminou a latência de inferência do LLM, 1M de agentes rodou em 40 segundos, em comparação com 8,6 horas via I/O assíncrono padrão do Python e ~12 dias via execução serial.
• Escalabilidade horizontal: Com 10.000 agentes fixos por dispositivo, o tempo total de execução permaneceu constante à medida que o tamanho do cluster aumentou de 1 para 4 nós.
• Prompting e profundidade de raciocínio: Sob prompting básico, a maioria dos modelos indicou números em torno de 50 (embora MistralAI-8x7B tenha registrado média de 36,63 e MistralAI-8x22B de 31,69). Adicionar instruções CoT empurrou as respostas em direção a 0 (os números vencedores do Qwen2-72B caíram de 33,70 para 12,76, e as médias da 5ª rodada em múltiplas iterações caíram de 25,16 para 2,02).
• Demografia e papéis: Níveis de escolaridade mais altos atribuídos aos agentes produziram sistematicamente palpites mais baixos e mais ótimos do ponto de vista da teoria dos jogos (agentes com nível de doutorado reportaram números mais baixos do que agentes com nível de ensino fundamental). Ocupações como professores de teoria dos jogos e economistas reportaram os menores números.
• Variantes: Quando o equilíbrio foi deslocado para 10 ($5+\frac{1}{2}\bar{x}$), os agentes convergiram iterativamente em torno de 10 ao longo de várias rodadas.

Limitações e questões em aberto

• Inconsistência de role-playing em casos extremos: Quando instruídos a agir como uma criança de 7 anos, os agentes ainda executavam aritmética em múltiplas etapas e raciocínio recursivo incompatíveis com a persona.
• Erros de aritmética simples: Os agentes ocasionalmente cometeram deslizes em cálculos básicos (especialmente envolvendo frações ou decimais), mesmo quando a lógica do raciocínio estratégico estava correta.
• Sensibilidade a priors do treinamento: Mudar a fração-alvo de $\frac{2}{3}$ para $\frac{51}{100}$ degradou o desempenho porque os modelos dependiam de padrões memorizados da teoria dos jogos; o desempenho só se recuperou quando os prompts declararam explicitamente que o jogo era uma variante de "adivinhar $\frac{2}{3}$ da média".