De Boids a Agentes: Regras de Agrupamento para Sistemas de IA

Em 1986, Craig Reynolds fez uma pergunta que parece trivial: como os pássaros formam bandos? Não uma pergunta filosófica. Uma pergunta de engenharia. Ele queria renderizar bandos convincentes em computação gráfica sem criar um script para o caminho de cada pássaro.

O algoritmo boids de Craig Reynolds, de 1986, prova que três regras locais simples (separação, alinhamento, coesão) produzem comportamento global coerente sem controle centralizado, e as mesmas dinâmicas governam sistemas de IA multiagente. Agentes que seguem instruções locais produzem coordenação emergente quando as regras são bem escolhidas e caos emergente quando não são. Adicionar mais regras para corrigir casos extremos torna os agentes piores, não melhores.

A resposta dele usava três regras. Separação: direcionar-se para evitar aglomeração com vizinhos. Alinhamento: direcionar-se para o rumo médio dos vizinhos. Coesão: direcionar-se para a posição média dos vizinhos. Sem líder, sem plano de voo, sem controlador central. Apenas três regras aplicadas localmente a cada pássaro, produzindo uma coordenação global indistinguível do agrupamento real.¹

Quarenta anos depois, eu opero um sistema de IA multiagente projetado em torno de dez papéis de agentes especializados que pesquisam, debatem e votam em decisões. Na noite em que um único prompt gerou 23 agentes dinamicamente — cada um gerando mais em uma cascata descontrolada — e todos alcançaram consenso perfeito sobre a pergunta errada, percebi que estava observando as mesmas dinâmicas que Reynolds descreveu: coordenação emergente a partir de regras simples e falha emergente a partir do mesmo mecanismo.

TL;DR

O algoritmo boids de Reynolds demonstra que três regras locais simples produzem comportamento global coerente sem controle centralizado. Agentes que seguem instruções locais (avalie este código, verifique aquela superfície de segurança, revise esta arquitetura) produzem coordenação emergente quando as regras são bem escolhidas e caos emergente quando não são. Adicionar mais regras para corrigir casos extremos torna os agentes piores, não melhores. Meu incidente descontrolado com 23 agentes provou isso: um orçamento de spawn restringindo a largura, não apenas a profundidade, é o equivalente em agentes da regra de separação de Reynolds.

Três regras, infinitos bandos

Alterne as regras acima para ver o que acontece. Com as três ativas, os boids formam bandos naturalmente. Remova a separação, e eles colapsam em uma única massa. Remova o alinhamento, e eles se dispersam em movimento aleatório. Remova a coesão, e eles se afastam enquanto mantêm o rumo local. Cada regra é necessária. Nenhuma é suficiente sozinha.

Reynolds apresentou isso no SIGGRAPH 1987 como “Flocks, Herds, and Schools: A Distributed Behavioral Model.”¹ O artigo mudou a computação gráfica. Antes dos boids, bandos animados exigiam caminhos criados à mão. Depois dos boids, os bandos emergiam de regras. Mais de uma década depois, em 1998, Reynolds recebeu o Scientific and Engineering Award da Academy of Motion Picture Arts and Sciences por esse trabalho.²

A contribuição mais profunda não foram as regras específicas. Foi a prova de que a coordenação global não exige conhecimento global. Cada boid conhece apenas seus vizinhos imediatos. Nenhum boid tem um mapa do bando. Nenhum boid conhece o destino do bando. O bando não tem destino. O que parece movimento coordenado são decisões locais produzindo um padrão global.

De pixels a processos

O mapeamento de boids para agentes de IA não é metafórico. Um artigo do workshop NeurIPS 2025, “Revisiting Boids for Emergent Intelligence via Multi-Agent Collaboration”, aplica explicitamente os princípios dos boids a sistemas multiagente.³ O artigo usa as regras de Reynolds como orientação em linguagem natural para agentes em um ambiente colaborativo de construção de ferramentas: alinhamento e separação derivam dos metadados de ferramentas dos vizinhos, enquanto a coesão injeta o resumo global da rodada anterior.

Meu mapeamento é mais simples e vem de construir o sistema antes de ler o artigo:

O paralelo não é perfeito. As regras dos boids são contínuas (direcionar-se para o rumo médio). As regras dos agentes são discretas (gerar no máximo 12 filhos). Os boids operam em coordenadas espaciais. Os agentes operam no espaço do problema. Mas o insight estrutural se mantém: regras locais, aplicadas independentemente por cada agente, produzem comportamento coerente de grupo. E os modos de falha são os mesmos.

A noite em que 23 agentes concordaram com a pergunta errada

Fevereiro de 2026. Pedi ao meu agente para “investigar a melhoria do sistema de despacho de hooks”. O agente avaliou sua própria confiança em 0,58, o que acionou o sistema de deliberação. Três agentes de pesquisa foram gerados. Cada um encontrou subproblemas e gerou seus próprios agentes de pesquisa. Esses agentes geraram mais.

Sete minutos depois: 23 processos de agente ativos. US$ 4,80 em créditos API. Consumo de tokens subindo a US$ 0,70 por minuto.

A proteção contra recursão rastreava a profundidade (pai gera filho, filho gera neto), mas não a largura (pai gera 12 filhos que cada um geram mais 12). O limite de profundidade de 3 nunca foi acionado porque os agentes se espalharam horizontalmente. Matei os processos manualmente.

Todos os agentes concordaram que o sistema de despacho de hooks precisava de melhorias. Todos os agentes propuseram mudanças razoáveis. Nenhum agente questionou se a própria investigação tinha o escopo correto.

O resultado demonstra o que acontece quando se tem coesão e alinhamento, mas nenhuma separação. Os agentes convergiram para a mesma conclusão (coesão) e se alinharam nos mesmos critérios de avaliação (alinhamento). Mas nada impediu que se aglomerassem no mesmo subproblema. Nos termos de Reynolds, 23 boids ocuparam o mesmo ponto no espaço, um comportamento que sua regra de separação previne explicitamente.

O orçamento de spawn como separação

A correção levou 20 minutos. Um orçamento de spawn que rastreia o total de filhos ativos por pai, limitado a 12.⁴ Uma restrição de largura, não apenas de profundidade.

A implementação é um contador, não uma regra:

# Simplified spawn budget (actual implementation uses hooks)
active_children = count_active_agents(parent_id=self.id)
if active_children >= MAX_CHILDREN:  # MAX_CHILDREN = 12
    return "Budget exhausted. Synthesize existing findings instead."
# else: allow spawn

O hook aplica isso de forma determinística. O agente não consegue racionalizar contra um contador da mesma forma que pode racionalizar contra uma instrução de prompt como “tente não gerar muitos agentes”. O contador permite ou bloqueia. Sem argumento, sem interpretação.

Em termos de boids, o orçamento de spawn é a regra de separação: não se aglomere com os vizinhos. Em termos de agentes: não coloque mais de N agentes em um subproblema, porque o N+1-ésimo agente adiciona custo sem adicionar perspectiva. O incidente dos 23 agentes me ensinou que a regra de separação é a mais importante das três. Sem ela, o alinhamento e a coesão se tornam patológicos: agentes convergindo entusiasticamente para a mesma resposta errada.

Implementações comuns do algoritmo de Reynolds atribuem à força de separação um peso 1,5-2x maior do que ao alinhamento ou à coesão exatamente por essa razão — uma convenção documentada no próprio artigo de acompanhamento de Reynolds, “Steering Behaviors for Autonomous Characters” (GDC 1999), onde ele discute a combinação de forças baseada em prioridade e observa que a prevenção de colisões (separação) normalmente recebe a maior prioridade.⁸ No meu sistema, hooks aplicam o orçamento de spawn (determinístico, imune à racionalização do agente), enquanto prompts e contexto moldam o alinhamento e a coesão (mais suaves, flexíveis). A restrição mais rígida recebe a aplicação mais rígida.

Por que mais regras tornam os agentes piores

Alterne a simulação de boids acima. Agora imagine adicionar uma quarta regra: “evite o centro da tela”. Uma quinta: “prefira a metade superior”. Uma sexta: “inverta o curso a cada 100 frames”.

Cada regra é individualmente razoável. Juntas, elas destroem o bando. Os boids tremem entre forças concorrentes, incapazes de satisfazer todas as restrições simultaneamente. O agrupamento elegante colapsa em ruído porque cada regra cria um vetor de força, e quando seis vetores de força puxam em direções diferentes, o movimento resultante é efetivamente aleatório.

Observei o mesmo padrão na orquestração de agentes. As primeiras versões do meu sistema de deliberação tinham regras elaboradas: profundidade mínima de pesquisa, contagens obrigatórias de citações, geração exigida de contra-argumentos, passagens forçadas de advogado do diabo. Cada regra melhorava algum caso específico de falha. Juntas, produziam agentes que gastavam mais tokens satisfazendo regras do que resolvendo problemas. Um exemplo concreto: a regra de “contra-argumento obrigatório” exigia que todo agente argumentasse contra sua própria descoberta. A regra de “contagem mínima de citações” exigia três fontes por alegação. Quando um agente gerava um contra-argumento genuíno, a regra de citações o obrigava a encontrar três fontes apoiando a posição contrária — o que às vezes produzia evidências mais fortes para a resposta errada do que para a certa. As duas regras interagiam para recompensar o contrarianismo bem fundamentado em vez da análise correta.

A filosofia da engenharia composta que documentei explica por que isso acontece no nível do sistema: cada nova regra interage com cada regra existente, criando complexidade combinatória. Dez regras não produzem dez restrições. Elas produzem potencialmente 45 interações pareadas. O comportamento do sistema torna-se mais difícil de prever, mais difícil de depurar e mais provável de produzir falhas emergentes.

O artigo original de Reynolds entendeu isso implicitamente. O artigo original apresentou três regras. Reynolds explorou comportamentos adicionais (prevenção de obstáculos, busca de objetivos), mas manteve o modelo central de agrupamento mínimo. Adicionar uma quarta regra central teria exigido reequilibrar os pesos de todas as quatro, um problema que cresce combinatoriamente com cada adição.

A lição para agentes: comece com as regras mínimas que produzem o comportamento que você deseja. Adicione regras apenas quando observar uma falha específica que nenhuma regra existente aborda. E, quando adicionar uma regra, verifique se ela interfere com as outras.

Descentralização como arquitetura

A ausência de um controlador central não é uma limitação dos boids. É a arquitetura. O bando se coordena porque nenhum pássaro individual tem autoridade sobre os outros. Se um pássaro se tornasse o líder, o sistema se tornaria frágil — dependente do julgamento desse pássaro, vulnerável à sua falha. O padrão espelha o princípio da resiliência distribuída que a vacuidade estrutural cria em outros domínios.⁵

O mesmo padrão aparece em sistemas de IA multiagente. O AutoGen da Microsoft (v0.4+, 2025) coordena agentes por meio de protocolos de conversação em vez de orquestração centralizada — cada agente decide quando falar com base no contexto local, e o framework evita explicitamente designar um agente “líder”.⁶ O CrewAI (v0.28+, 2025) define papéis de agentes e regras de transferência por meio de sua abstração de “crew”, mas não confere a nenhum agente individual autoridade de sobreposição sobre os outros.⁷ No meu sistema de deliberação, nenhum agente tem poder de veto. Cada um avalia independentemente. O protocolo de consenso agrega suas descobertas. Se um agente produz lixo, os outros o superam na votação. O controle centralizado reintroduziria o ponto único de falha que a coordenação descentralizada elimina.

Quando as três regras funcionaram: um sucesso silencioso

O incidente dos 23 agentes é memorável porque falhou dramaticamente. Os sucessos são mais silenciosos e mais numerosos.

Uma semana depois de adicionar o orçamento de spawn, pedi ao sistema para “avaliar se a infraestrutura de testes A/B do blog deveria usar atribuição de variante no lado do servidor ou no lado do cliente”. O sistema de deliberação gerou três agentes de pesquisa. O Agente 1 investigou abordagens do lado do servidor (baseadas em cookies, baseadas em sessão). O Agente 2 investigou abordagens do lado do cliente (localStorage, parâmetros de URL). O Agente 3 avaliou padrões híbridos. Cada agente trabalhou independentemente (coesão: convergindo para a mesma pergunta de avaliação). Cada um usou os mesmos padrões de evidência (alinhamento: critérios de qualidade compartilhados). O orçamento de spawn impediu que qualquer agente gerasse seus próprios subagentes para esta tarefa (separação: sem aglomeração).

Os três agentes retornaram descobertas. O Agente 1 favoreceu a atribuição do lado do servidor para consistência de SEO. O Agente 2 favoreceu o lado do cliente pela simplicidade de implementação. O Agente 3 identificou uma abordagem híbrida que correspondia aos padrões existentes da base de código. O protocolo de consenso sintetizou as descobertas: atribuição do lado do servidor para o blog (onde o SEO importa), com sobreposição do lado do cliente para os componentes interativos (onde JavaScript já roda).

A deliberação inteira levou quatro minutos e custou US$ 1,40. Nenhum agente gerou subagentes. Nenhum agente concordou prematuramente com os outros. As recomendações foram independentes e genuinamente complementares. A arquitetura de três regras produziu exatamente o comportamento que Reynolds descreveu: decisões locais produzindo saída global coordenada.

Padrões emergentes em outros domínios

O padrão “regras simples, comportamento emergente” não é exclusivo dos boids ou agentes. Ele aparece onde quer que decisões locais se agreguem em estrutura global:

Códigos de Hamming demonstram uma forma relacionada de emergência. A colocação estratégica de bits de paridade em posições que são potências de 2 cria um sistema onde a posição do erro emerge do XOR das posições de todos os bits “1”. Nenhum bit sabe onde está o erro. A localização do erro emerge da estrutura. Um único bit de paridade isolado não informa quase nada. Múltiplos bits de paridade nas posições certas informam tudo.

O Jogo da Vida de Conway produz planadores, osciladores e computação Turing-completa a partir de quatro regras aplicadas a uma grade. As regras são mais simples do que as dos boids (uma célula vive se tiver 2-3 vizinhos, morre caso contrário). A complexidade emergente é ilimitada.

Em todos os casos, o padrão é o mesmo: regras locais, sem coordenador central, comportamento global emergente. E em todos os casos, o mesmo modo de falha se aplica: adicione regras demais e o sistema colapsa de uma emergência elegante para uma interferência caótica.

Pontos-chave

Para engenheiros projetando sistemas multiagente:

• Três regras produzem agrupamento. Quatro regras podem não produzir. O insight de Reynolds foi que três regras bem escolhidas são suficientes para a coordenação emergente. Adicionar uma quarta cria interferência que pode destruir o comportamento que as três primeiras produziram. Comece com as regras mínimas que produzem o comportamento que você deseja.

• Separação é a regra mais importante. Sem ela, o alinhamento e a coesão tornam-se patológicos, com agentes convergindo para a mesma resposta errada. O orçamento de spawn (restrição de largura) foi a mudança individual mais impactante que fiz no meu sistema multiagente.

Para arquitetos construindo sistemas distribuídos:

• A ausência de um líder é a arquitetura. O controle centralizado cria um único ponto de falha. A coordenação descentralizada por meio de regras locais é mais resiliente. Projete seus sistemas de agentes sem um “agente líder”, a menos que você tenha uma razão específica para adicionar um.

• Mais regras criam mais interações. N regras produzem até N(N-1)/2 interações pareadas. O comportamento torna-se mais difícil de prever a cada adição. Adicione regras apenas quando observar uma falha específica que nenhuma regra existente aborda.

Exercício: mapeie seu próprio sistema. Diagrame seu sistema multiagente atual (ou um sistema que você planeja construir). Para cada agente, identifique qual das três regras de Reynolds ele segue. Se a separação estiver faltando, adicione um orçamento de spawn ou limite de concorrência. Se o alinhamento estiver faltando, defina critérios de avaliação compartilhados. Se a coesão estiver faltando, adicione uma etapa de síntese. O diagrama revela a qual modo de falha seu sistema é mais vulnerável.

FAQ

O que são boids e por que importam para o design de agentes de IA?

Boids são agentes simulados (originalmente “bird-oid objects”) que seguem três regras locais: separação (evitar aglomeração com vizinhos), alinhamento (direcionar-se para o rumo médio dos vizinhos) e coesão (direcionar-se para a posição média dos vizinhos). Craig Reynolds os apresentou no SIGGRAPH 1987. Eles importam porque provaram que um comportamento global complexo e coordenado pode emergir de regras locais simples sem qualquer controlador central — um princípio que se aplica diretamente a sistemas de IA multiagente, robótica de enxame e computação distribuída.

Como as regras dos boids se aplicam à orquestração de agentes de IA?

Cada regra dos boids mapeia para uma restrição de design de agente. A separação torna-se um orçamento de spawn (limita quantos agentes trabalham no mesmo subproblema). O alinhamento torna-se critérios de avaliação compartilhados (todos os agentes usam o mesmo padrão de qualidade). A coesão torna-se um protocolo de consenso (agentes convergem para descobertas do grupo). O mapeamento é estrutural, não metafórico: ambos os sistemas produzem coordenação emergente a partir de regras locais aplicadas independentemente por cada agente.

Por que mais regras tornam os sistemas de IA multiagente piores em vez de melhores?

Cada nova regra interage com cada regra existente, criando complexidade combinatória. Dez regras produzem até 45 interações pareadas. Os agentes gastam tokens satisfazendo restrições de regras em vez de resolver problemas. A mesma dinâmica aparece nos boids: adicionar uma quarta regra (por exemplo, “evite o centro”) força o reequilíbrio com as três originais, e o comportamento de agrupamento elegante frequentemente degrada em tremor enquanto os agentes tentam satisfazer forças concorrentes simultaneamente.

Quando devo usar controle centralizado em vez de coordenação emergente?

Use controle centralizado quando precisar de garantias estritas de ordenação (estágios sequenciais de pipeline), quando as falhas devem ser tratadas deterministicamente (transações financeiras) ou quando o sistema exige uma única decisão autoritativa em vez de consenso (resolução de conflitos de merge). Use coordenação emergente quando os agentes podem avaliar independentemente, quando a redundância melhora a confiabilidade e quando nenhum agente individual precisa do panorama completo para fazer bem o seu trabalho.

Parte da série Interactive Explorations, onde algoritmos encontram a intuição visual: desde códigos de Hamming que detectam seus próprios erros até boids que formam bandos sem líder. Os padrões de orquestração de agentes aparecem em detalhes em The Ralph System e Multi-Agent Deliberation. A camada de programação metacognitiva adiciona automonitoramento individual dos agentes para complementar a coordenação interagente acima.