Como criar enxames de agentes de IA (Guia completo)

Esta é uma análise completa de A a Z sobre Agentes em Enxame (Agent Swarms): o que são e como usá-los.

Por que eles mudam tudo na forma como você trabalha com IA.

Salve isto antes de esquecer.

O Kimi K2.6, carro-chefe de pesos abertos da Moonshot AI lançado em abril de 2026, é a implementação open-source mais séria dessa ideia que já vi.

Tarefas reais têm amplitude. Cinquenta empresas para pesquisar.

Duzentos arquivos para analisar. Uma dúzia de subtarefas que não dependem umas das outras e não deveriam esperar em fila. Um enxame de agentes é a arquitetura para isso.

Este guia detalha como funciona, desde a infraestrutura de treinamento até a API, e depois aborda o padrão que considero mais importante agora: Kimi para execução, Claude Opus 4.8 para planejamento e verificação.

Veja como o Fluxo de Trabalho Final se parece.

Seção 1: O que é um enxame de agentes?

Um enxame de agentes é um conjunto de múltiplos agentes trabalhando simultaneamente em subtarefas decompostas, coordenados por um orquestrador que agrega os resultados.

A distinção de uma cadeia sequencial é o ponto central:

• Cadeia sequencial: Agente A executa, passa para B, B passa para C. Tempo total = A + B + C.
• Enxame: Orquestrador divide o objetivo, agentes A, B, C executam ao mesmo tempo em subtarefas independentes, resultados são mesclados. Tempo total ≈ max(A, B, C).

Quando uma tarefa tem uma estrutura genuinamente paralela, essa é a diferença entre minutos e horas.

Um enxame também resolve o problema de estouro de contexto. Um único agente em uma tarefa longa acumula tokens até que sua janela se sature. Um enxame dá a cada subtarefa seu próprio contexto limitado, e apenas a saída estruturada flui de volta para o orquestrador.

Os seis blocos de construção

Todo enxame tem os mesmos componentes principais:

Acerte esses seis e você terá um enxame. Erre qualquer um e você terá uma sessão cara de depuração.

Seção 2: O que o Kimi K2.6 realmente é

Antes de entrar no comportamento do enxame, vale a pena entender o que está por baixo. O K2.6 é um modelo Mixture-of-Experts de 1 trilhão de parâmetros da Moonshot AI, lançado com pesos abertos em 20 de abril de 2026 sob uma Licença MIT Modificada. O uso comercial é gratuito abaixo de US$ 20 milhões de receita mensal ou 100 milhões de usuários ativos mensais - então é praticamente gratuito para a maioria dos desenvolvedores.

0:29

Especificações da arquitetura

A variante INT4 QAT é executada nativamente em 4x H100 80GB. FP16 precisa de 8x H100 80GB. Todos os três frameworks de inferência suportados (vLLM, SGLang, KTransformers) expõem APIs compatíveis com OpenAI.

Seção 3: O otimizador MuonClip, ou por que o treinamento é estável

Treinar um MoE esparso de um trilhão de parâmetros sem que ele exploda é difícil. O modo de falha específico: à medida que o comprimento da sequência cresce, o produto escalar query-key (QK) nas camadas de atenção pode crescer ilimitadamente. Você obtém picos de perda e, nessa escala, um pico de perda pode ser irrecuperável.

O artigo técnico do Kimi K2 (arxiv: 2507.20534) introduz o MuonClip para lidar com isso.

Muon é um otimizador de gradiente mais eficiente em tokens que o AdamW. Mesma qualidade, menos etapas de treinamento. O problema: o Muon sozinho produz instabilidade de atenção na escala de trilhões de parâmetros.

O QK-Clip adiciona um recorte (clipping) por token e por cabeça diretamente nas matrizes QK antes do softmax. Isso limita a magnitude da pontuação de atenção e elimina a patologia da explosão. Sem ajuste manual, sem hacks na taxa de aprendizado.

Do resumo do artigo:

"Apresentamos o MuonClip, um novo otimizador que integra o algoritmo Muon, eficiente em tokens, com um mecanismo de estabilidade chamado QK-Clip... Usando o MuonClip, o Kimi K2 alcança desempenho competitivo enquanto requer significativamente menos tokens de treinamento que as linhas de base do AdamW."

Por que um desenvolvedor deveria se importar com um detalhe de treinamento? Porque a razão pela qual o K2.6 pode sustentar 4.000 chamadas de ferramenta por mais de 12 horas sem degradação remonta a isso. Um modelo treinado com instabilidade de atenção tende a alucinar sob condições de contexto longo e alto número de etapas. Que é exatamente o regime em que o Enxame de Agentes opera.

Seção 4: PARL, a pesquisa por trás do enxame

O Enxame de Agentes não é um framework acoplado ao K2.6. O comportamento foi treinado no modelo, através de um paradigma que a Moonshot chama de PARL: Parallel-Agent Reinforcement Learning, descrito no artigo técnico do Kimi K2.5 (arxiv: 2602.02276).

Orquestrador treinável, subagentes congelados

A maneira usual de construir sistemas multiagente é coordenar múltiplas instâncias de modelo em tempo real na camada de aplicação. Então a atribuição de crédito se torna uma bagunça: qual dos seus agentes tornou a resposta final boa ou ruim? Treinar de ponta a ponta através desse grafo é computacionalmente intratável.

O PARL contorna isso:

• O orquestrador é treinável, atualizado via RL com base em recompensas de resultado
• Os subagentes são congelados, checkpoints de política intermediária fixos

As trajetórias dos subagentes são tratadas como observações ambientais, não como pontos de decisão diferenciáveis. Isso desacopla dois problemas difíceis de uma vez. O crédito vai apenas para as ações do orquestrador, nunca para 300 subagentes simultâneos. E o treinamento permanece estável porque apenas um modelo está sendo atualizado.

O orquestrador aprende quando paralelizar, quantos subagentes gerar e como dividir o trabalho. Ninguém especificou esses comportamentos manualmente. Eles emergem da maximização da recompensa.

A função de recompensa de três partes

O orquestrador treina contra três sinais.

Uma recompensa de paralelismo o incentiva a gerar subagentes concorrentes em vez de executar as coisas sequencialmente. Sem isso, o modelo padroniza para um agente por vez: seguro, previsível, lento.

Uma recompensa de conclusão garante que os subagentes realmente completem suas tarefas. Isso bloqueia o "paralelismo espúrio", onde o orquestrador gera uma multidão de agentes inativos apenas para acumular a recompensa de paralelismo.

Uma recompensa de desempenho pontua a qualidade da saída final em relação ao objetivo da tarefa. Esta é a verdade fundamental a que tudo mais serve.

O detalhe que acho mais interessante: a métrica de otimização são etapas críticas (comprimento do caminho crítico), não o total de etapas. O modelo é recompensado por encurtar a cadeia de dependência mais longa, não por maximizar a concorrência bruta. Isso é o que realmente reduz o tempo de parede (wall-clock time).

Resultados do PARL

• BrowseComp: O modo Enxame atingiu 78,4% no K2.5, um ganho absoluto de 17,8 pontos sobre o K2.5 agente único (60,6%), que superou o GPT-5.2 Pro (77,9%) na época. O K2.6 eleva isso para 86,3%.
• WideSearch: Melhoria absoluta de 6,3 pontos no Item-F1 (72,7% para 79,0%)
• Tempo de parede: Redução de 3 a 4,5x em tarefas paralelizáveis vs. linha de base de agente único
• Chamadas de ferramenta paralelas: até 4.000 etapas coordenadas no K2.6

Seção 5: Mooncake, a infraestrutura por trás do Kimi

A infraestrutura de serviço da Moonshot explica por que o K2.6 pode sustentar 300 agentes paralelos sem derreter. Os pesos do modelo são apenas metade da história; o sistema que os serve é a outra metade.

A infraestrutura está bem estruturada para tarefas de contexto longo.

Arquitetura dissociada centrada em KVCache

A plataforma de serviço da Moonshot se chama Mooncake, descrita em seu artigo de infraestrutura de 2024 (arxiv: 2407.00079). É o motor que executa o Kimi em escala, e sua escolha de design é incomum.

A inferência LLM tradicional executa prefill (processamento do prompt de entrada) e decode (geração de tokens) nas mesmas instâncias de GPU. O Mooncake os dissocia em clusters separados:

• Cluster de prefill: lida com o processamento inicial do prompt, escala independentemente para entradas de contexto longo
• Cluster de decode: lida com a geração de tokens, otimizado para taxa de transferência e latência

O cache KV, o estado de atenção intermediário que torna a geração autorregressiva eficiente, é gerenciado como um recurso de sistema de primeira classe. O Mooncake constrói um cache KV distribuído que abrange VRAM de GPU, DRAM de CPU e SSDs, com um mecanismo de transferência personalizado movendo o cache entre nós.

Por que isso importa para o Enxame de Agentes

Quando 300 subagentes são executados simultaneamente, cada um gera seu próprio cache KV. Em uma arquitetura tradicional, isso é uma pressão massiva na memória da GPU e conflitos de agendamento. Com o cache dissociado do Mooncake:

• Caches KV de subagentes concluídos podem ser removidos para DRAM ou SSD e recuperados se necessário
• O cluster de prefill lida com os prompts de sistema (geralmente grandes) para cada subagente de forma independente
• O agendador maximiza a taxa de transferência geral enquanto mantém os SLOs de latência por agente

Do artigo do Mooncake: "Em comparação com o método de linha de base, o Mooncake pode alcançar um aumento de até 525% na taxa de transferência em certos cenários simulados, aderindo aos SLOs. Sob cargas de trabalho reais, a arquitetura inovadora do Mooncake permite que o Kimi lide com 75% mais requisições."

O artigo atualizado relata que o Mooncake está "operacional em milhares de nós, processando mais de 100 bilhões de tokens diariamente", e lida com 115% mais requisições em clusters A800 e 107% mais em clusters H800 em comparação com sistemas anteriores.

Dissociação PD em escala: a implantação do K2 com 128 GPUs

O LMSYS publicou um estudo de caso de implantação para o Kimi K2 usando Dissociação Prefill-Decode (PD) em 128 GPUs H200 através do Roteador SGLang. A arquitetura:

• Roteador SGLang: serviço leve para descoberta dinâmica de serviços de nós de prefill e decode através de seletores de rótulo
• Paralelismo de Especialistas: os 384 especialistas do K2 distribuídos entre nós, com roteamento no nível da rede
• OME (Open Model Engine): orquestração nativa do Kubernetes para a camada de serviço

Esta é a pilha que executa a família K2 em escala de produção. Se você está hospedando o K2.6 por conta própria, este é seu modelo.

Seção 6: Como o Enxame de Agentes funciona, passo a passo

A sequência mecânica quando o K2.6 executa uma tarefa no modo enxame:

Passo 1: Decomposição da tarefa

O orquestrador analisa a tarefa e constrói o grafo de dependência: quais subtarefas são independentes e podem ser executadas em paralelo, quais dependem de saídas anteriores.

Para "pesquisar 100 empresas do YC e produzir uma análise setorial", o orquestrador identifica 100 tarefas de pesquisa independentes, depois 1 tarefa de agregação, depois 1 tarefa de síntese. A primeira camada é totalmente paralelizável.

Passo 2: Geração de agentes especialistas

O orquestrador gera subagentes especializados por domínio com base no tipo de subtarefa. O K2.6 instancia agentes dinamicamente com instruções específicas de função e acesso direcionado a ferramentas:

• Agentes de pesquisa web: ferramentas de busca + navegador
• Agentes de análise de dados: execução Python + ferramentas de planilha
• Agentes de redação: síntese e geração de documentos
• Agentes de verificação de fatos: referência cruzada e validação

Cada subagente opera dentro de seu próprio contexto local limitado. Ele lida com uma tarefa com escopo definido, produz saída estruturada e termina. O contexto local não carrega tudo que o orquestrador sabe, apenas o que aquele subagente precisa. É assim que o K2.6 evita estouro em tarefas que preencheriam a janela de qualquer agente único em minutos.

Passo 3: Execução paralela em ondas

Os agentes executam em ondas. A primeira onda lida com tarefas totalmente independentes.

1. Conforme os resultados chegam, o orquestrador lança uma segunda onda em tarefas que dependiam das saídas da primeira onda, e assim por diante até que o grafo de dependência se resolva.
2. O K2.6 suporta até 300 subagentes e 4.000 etapas coordenadas por sessão. O orquestrador monitora a execução em tempo real, detecta agentes com falha ou travados e reassume suas tarefas automaticamente.
3. Essa tolerância a falhas é o que torna possíveis execuções autônomas de mais de 12 horas sem um humano monitorando.

Passo 4: Agregação e saída

Assim que todos os subagentes concluem, o orquestrador agrega os resultados em um entregável final: documento, planilha, site, apresentação de slides.

• Ele sintetiza as saídas dos agentes em vez de concatená-las, para que o resultado se mantenha coeso estruturalmente.
• Mais uma coisa que vale notar: a estrutura do enxame é também a resposta do Kimi para o problema da janela de contexto.
• A política explícita do K2.6: "uma vez que a janela de contexto exceda o limite, apenas a rodada mais recente de mensagens relacionadas a ferramentas é retida." O enxame torna essa política sustentável em horizontes de tarefa muito longos.

Seção 7: A arquitetura Kimi x Claude Opus 4.8

Nenhum modelo único é a resposta certa para todas as camadas de um enxame. O Kimi K2.6 é construído para escala horizontal - execução paralela em centenas de agentes, execuções autônomas longas, processamento em lote com boa relação custo-benefício.

O Claude Opus 4.8 é construído para julgamento - planejamento, raciocínio diferenciado e detecção de seus próprios erros. Eles se complementam estruturalmente, e a lacuna que cada um deixa tem a forma aproximada do ponto forte do outro.

O padrão:

1[Objetivo do Usuário]
2      |
3[Claude Opus 4.8 - Planejador]
4  Decompõe o objetivo em uma especificação de tarefa estruturada
5  Identifica subtarefas paralelas vs. sequenciais
6  Define critérios de sucesso para cada subtarefa
7      |
8[Enxame de Agentes Kimi K2.6 - Executor]
9  Recebe a especificação de tarefa estruturada
10  Gera até 300 subagentes especializados
11  Executa em paralelo através de chamadas de ferramenta
12  Retorna resultados estruturados
13      |
14[Claude Opus 4.8 - Verificador]
15  Revisa as saídas do Kimi contra os critérios de sucesso
16  Sinaliza falhas, lacunas, inconsistências
17  Sintetiza o entregável final

Por que Claude para planejamento e verificação?

A mudança mais subestimada no Opus 4.8 é a melhoria na honestidade: "O Opus 4.8 tem cerca de quatro vezes menos probabilidade que seu predecessor de permitir que falhas no código que escreveu passem despercebidas." Em sistemas agentivos, a falsa confiança é o modo de falha catastrófico.

• Um orquestrador que diz "concluído" quando não está irá propagar erros em cascata para 300 agentes downstream. A tendência do Claude de sinalizar incerteza e detectar seus próprios erros no meio da tarefa o torna a âncora certa para as camadas onde errar é caro.
• O Opus 4.8 também suporta uma janela de contexto de 1M tokens, o que importa para a passagem de verificação quando você está puxando saídas de mais de 50 agentes de pesquisa paralelos para um único contexto de revisão.

Por que Kimi para execução?

O Enxame de Agentes do K2.6 suporta até 300 subagentes paralelos e 4.000 etapas de ferramenta coordenadas por sessão - isso é um comportamento treinado, não um invólucro de camada de aplicação.

• O Claude tem um recurso de Fluxos de Trabalho Dinâmicos no Claude Code, mas está atualmente em preview de pesquisa e limitado aos planos Enterprise/Max.
• A capacidade de enxame do Kimi está disponível para todos através da API agora mesmo. A economia de tokens também importa em escala: o K2.6 custa $0,95/$4,00 por milhão de tokens de entrada/saída. Para execução paralela em massa, isso não é desprezível.

Seção 8: Quando você precisa de um enxame (e quando não precisa)

O erro mais comum no design multiagente: adicionar complexidade de enxame antes de atingir o teto do agente único.

Fique com agente único quando:

• A tarefa cabe em uma única janela de contexto (menos de ~50K tokens de trabalho real)
• A tarefa é sequencial por natureza, cada etapa dependendo da anterior
• Você ainda está prototipando - modos de falha de agente único são muito mais fáceis de depurar
• A tarefa seria concluída em menos de 10 minutos de qualquer forma

Recorra ao Enxame de Agentes quando:

• A tarefa tem n subtarefas paralelas e independentes, onde n > 5
• O estouro de contexto é um problema real (pesquisa profunda, bases de código grandes, operações em lote)
• Você precisa de agentes especializados por domínio trabalhando simultaneamente
• A tarefa é longa demais para sustentar a qualidade ao longo de uma sessão sequencial
• Você deseja um agente crítico ou verificador checando o trabalho de outro agente

Use o híbrido Kimi + Claude Opus 4.8 quando:

• A qualidade do planejamento importa e você quer um modelo que critique se o plano estiver errado
• A saída é enviada sem revisão humana adicional - então a verificação precisa ser incorporada
• Você está executando em alto volume onde os custos de token se acumulam rapidamente
• Você quer o julgamento do Claude nas camadas de decisão e a escala do Kimi nas camadas de trabalho

Seção 10: Os quatro padrões de arquitetura de enxame

Padrão 1: Orquestrador-trabalhador (mais comum)

Um orquestrador central atribui subtarefas aos trabalhadores, trabalhadores executam em paralelo, resultados agregados.

1[Objetivo do Usuário]
2    |
3[Orquestrador - Claude Opus 4.8]
4    +-- [Trabalhador: Agente de Pesquisa Kimi x N]
5    +-- [Trabalhador: Agente de Dados Kimi x N]
6    +-- [Trabalhador: Agente de Código Kimi x N]
7    |
8[Sintetizador - Claude Opus 4.8]
9    |
10[Saída Final]

Melhor para: tarefas com subtarefas claramente separáveis e um número variável de trabalhadores.

Padrão 2: Loop crítico-refinador

Um agente produz, outro critica, repita até que o limite de qualidade seja atingido.

1[Construtor Kimi K2.6] -> rascunho -> [Crítico Claude Opus 4.8] -> feedback -> [Construtor Kimi K2.6]
2                                        |
3                                   (aprovado)
4                                [Saída Final]

Melhor para: geração de código, redação técnica, saídas sensíveis à conformidade. Defina sempre um limite máximo de iterações.

Padrão 3: Hierárquico

Um orquestrador estratégico gerencia orquestradores de domínio, que gerenciam trabalhadores.

1[Claude Opus 4.8 - Orquestrador Estratégico]
2    +-- [Enxame Kimi K2.6 - Equipe de Pesquisa (50 agentes)]
3    +-- [Enxame Kimi K2.6 - Equipe de Construção (50 agentes)]

Melhor para: fluxos de trabalho empresariais grandes com domínios distintos.

Padrão 4: Grupos Claw (enxame heterogêneo nativo do Kimi)

O K2.6 coordena agentes executando qualquer modelo, incluindo modelos locais, Claude e GPT, juntamente com trabalhadores humanos em um espaço operacional compartilhado. Atualmente em preview de pesquisa.

1[Coordenador Kimi K2.6]
2    +-- [Claude Opus 4.8 - especialista em raciocínio]
3    +-- [Llama 3.3 local - tarefas em massa de baixo custo]
4    +-- [Agentes Kimi K2.6 x N - camada de execução]
5    +-- [Revisor humano - pontos de verificação de aprovação]

Melhor para: fluxos de trabalho que precisam de diversidade de modelos, híbrido local + nuvem, ou requisitos de intervenção humana.

Seção 12: Design de prompt para tarefas de enxame

O prompt de decomposição (orquestradores)

1Você é um arquiteto de tarefas. Decomponha este objetivo em subtarefas independentes e paralelizáveis.
2
3Regras:
4- Cada subtarefa deve ser concluível por um único agente especializado de forma isolada
5- Subtarefas com dependências devem ser marcadas com sua cadeia de dependência
6- Saída como JSON: {task_id, description, agent_type, depends_on, success_criteria}
7
8Objetivo: {user_goal}
9Tipos de agente disponíveis: pesquisador, analista, codificador, redator, verificador

O prompt de sistema do especialista (subagentes)

1Você é um agente {ROLE} especializado em {DOMAIN}.
2
3Tarefa: {subtask_description}
4
5RESTRIÇÕES:
6- Retorne APENAS JSON válido correspondendo a: {output_schema}
7- Não vá além do escopo da sua tarefa
8- Se não puder concluir a tarefa: {"error": "motivo", "partial_results": [...]}
9- Máximo de chamadas de ferramenta: {max_tool_calls}
10
11Contexto: {context_from_orchestrator}

O prompt de agregação (sintetizadores)

1Sintetize a pesquisa de {n} agentes especializados em uma saída coerente.
2
31. Leia todas as saídas dos agentes fornecidas
42. Identifique onde eles concordam, discordam ou têm lacunas
53. Produza um/a {output_type} integrando todas as descobertas
64. Aponte inconsistências explicitamente - não resolva contradições silenciosamente
7
8Saídas dos agentes: {agent_outputs_as_json}
9Formato da saída: {final_output_spec}

Seção 13: Os sete guarda-corpos inegociáveis

1. Máximo de iterações por agente. Limite rígido em loops antes que o orquestrador seja notificado.

2. Timeout de sessão. Se o enxame não for concluído em N minutos, termine e retorne resultados parciais.

3. Imposição de saída estruturada. Force os agentes a retornar JSON. Prosa de agentes intermediários cria falhas de análise downstream.

4. Isolamento de falha. Um subagente com falha não deve derrubar o orquestrador.

1async def run_subagent_safely(kimi_client, task, agent_id):
2    try:
3        result = kimi_client.chat.completions.create(
4            model="kimi-k2.6",
5            messages=[{"role": "user", "content": task}],
6            max_tokens=4096
7        )
8        return {"agent_id": agent_id, "status": "success",
9                "output": result.choices[0].message.content}
10    except Exception as e:
11        return {"agent_id": agent_id, "status": "failed", "error": str(e)}

5. Tentativa com backoff exponencial. Lide com 429s e erros transitórios sem apresentá-los como falhas permanentes.

6. Pontos de verificação de intervenção humana. Para enxames com acesso de escrita (implantar código, enviar e-mails, fazer mutações na API), insira pausas obrigatórias de aprovação.

7. Monitoramento de custos. Defina orçamentos de token por execução. Loops descontrolados aparecem como anomalias de custo antes de aparecerem como falhas de qualidade, sempre.

O que construir primeiro

Comece com o pipeline de três agentes da Seção 9. É pequeno o suficiente para depurar em uma tarde, exercita planejamento, execução paralela e verificação, e você pode executá-lo contra uma tarefa real em menos de uma hora de configuração.

Quando quebrar - e vai quebrar - o modo de falha lhe ensinará mais sobre design de enxame do que outra hora de leitura.

Construa. Quebre de propósito. Depois volte aos padrões da Seção 11 com um ponto de referência concreto.

A arquitetura não é a parte difícil. A parte difícil é a lacuna entre "funciona nos testes" e "funciona às 3h da manhã sem ninguém vigiando", e essa lacuna está inteiramente nos guarda-corpos, na observabilidade e no design de memória.

Conclusão

O Kimi 2.6 é uma revolução na forma como o aprendizado por reforço pode estabelecer enxames de agentes.

Ele também mostra como horizontes de contexto longo podem fazer uso de tais infraestruturas baseadas em orquestrador, que permitem gerar múltiplos subagentes para construir sistemas complexos usando um único

Aviso Legal

O artigo foi escrito usando a documentação técnica do Kimi 2.6 e artigos de pesquisa nas notas do autor, e editado por uma IA, Opus 4.7.