Como criar enxames de agentes de IA (Guia Completo)

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

E por que eles mudam completamente a forma como você trabalha com IA.

Salve isto antes de esquecer.

O Kimi K2.6, o modelo de pesos abertos flagship da Moonshot AI de abril de 2026, é a implementação open-source mais séria desta 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 swarm de agentes é a arquitetura para isso.

Este guia detalha como funciona, desde a infraestrutura de treinamento até a API, e então 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ção 1: O que é um swarm de agentes?

Um swarm de agentes são 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.
• Swarm: Orquestrador divide o objetivo, os agentes A, B, C executam ao mesmo tempo em subtarefas independentes, os resultados são mesclados. Tempo total ≈ max(A, B, C).

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

Um swarm também resolve o problema de estouro de contexto. Um único agente em uma tarefa longa acumula tokens até que sua janela se esgote. Um swarm dá a cada subtarefa seu próprio contexto delimitado, e apenas saídas estruturadas fluem de volta para o orquestrador.

Os seis blocos de construção

Todo swarm tem os mesmos componentes principais:

Componente

O que Faz

Orquestrador

Decompõe a tarefa, atribui subtarefas, monitora a execução, agrega resultados

Subagentes

Trabalhadores especializados, focados em um domínio (pesquisa, código, análise, redação)

Ferramentas

Funções que os agentes podem chamar: busca na web, interpretador de código, E/S de arquivos, APIs

Memória

Estado compartilhado que o swarm pode ler/gravar

Handoffs / Roteamento

Mecanismo para passar controle ou dados entre agentes

Guardrails (Barreiras de Proteção)

Limites de iteração, timeouts, gatilhos de intervenção humana, recuperação de erros

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

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

Antes de mergulhar no comportamento do swarm, 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 - portanto, é praticamente gratuito para a maioria dos desenvolvedores.

0:29

Especificações da Arquitetura

Especificação

Valor

Parâmetros totais

~1,04 trilhão

Ativados por token

~32 bilhões (8 especialistas selecionados + 1 compartilhado)

Total de especialistas

384, distribuídos por 61 camadas transformer

Janela de contexto

262.144 tokens (262K)

Atenção

Atenção Latente Multicabeça (MLA) - menor pegada de cache KV

Função de ativação

SwiGLU

Codificador de Visão

MoonViT-3D (400M parâmetros, imagem + vídeo até 2K)

Quantização

INT4 via Treinamento Ciente de Quantização (~594GB em disco)

Tamanho total em FP16

~2TB

Licença

MIT Modificada

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

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

Treinar um MoE esparso de trilhão de parâmetros sem que ele exploda é difícil. O modo específico de falha: à medida que o comprimento da sequência cresce, o produto escalar query-key (QK) nas camadas de atenção pode crescer ilimitadamente. Você tem picos de perda, e nesta 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 termos de tokens que o AdamW. Mesma qualidade, menos etapas de treinamento. O problema: apenas o Muon produz instabilidade de atenção na escala de trilhão 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 termos de tokens, com um mecanismo de estabilidade chamado QK-Clip... Usando o MuonClip, o Kimi K2 atinge desempenho competitivo enquanto requer significativamente menos tokens de treinamento do 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 ao longo 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 Swarm de Agentes opera.

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

O Swarm 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 (Aprendizagem por Reforço com Agentes Paralelos), 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 modelos ao vivo 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 pontos de decisão diferenciáveis. Isso desacopla dois problemas difíceis de uma só 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 com base em três sinais.

Uma recompensa de paralelismo o incentiva a gerar subagentes simultâneos em vez de executar as coisas sequencialmente. Sem isso, o modelo padrão é um agente de cada vez: seguro, previsível, lento.

Uma recompensa de conclusão garante que os subagentes realmente concluam suas tarefas. Isso bloqueia o "paralelismo espúrio", onde o orquestrador gera uma multidão de agentes que não fazem nada apenas para obter 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 todo o resto serve.

O detalhe que acho mais interessante: a métrica de otimização são as 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 real (wall-clock time).

Resultados do PARL

• BrowseComp: O modo Swarm 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 empurra isso para 86,3%.
• WideSearch: Melhora absoluta de 6,3 pontos no Item-F1 (72,7% para 79,0%)
• Tempo real (Wall-clock time): Redução de 3 a 4,5 vezes 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 se estrutura bem para Tarefas de Contexto Longo

Arquitetura desagregada centrada em KVCache

A plataforma de serviço da Moonshot é chamada de 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 o preenchimento (prefill - processamento do prompt de entrada) e a decodificação (decode - geração de tokens) nas mesmas instâncias de GPU. O Mooncake os desagrega em clusters separados:

• Cluster de preenchimento (Prefill): lida com o processamento inicial do prompt, escala de forma independente para entradas de contexto longo
• Cluster de decodificação (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 autoregressiva eficiente, é gerenciado como um recurso de sistema de primeira classe. O Mooncake constrói um cache KV distribuído que abrange VRAM da GPU, DRAM da CPU e SSDs, com um mecanismo de transferência personalizado movendo o cache entre nós.

Por que isso é importante para o Swarm de Agentes

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

• Os caches KV de subagentes concluídos podem ser removidos para DRAM ou SSD e recuperados se necessário
• O cluster de preenchimento 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.

Desagregaçã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 Desagregação Preenchimento-Decodificação (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 preenchimento e decodificação via seletores de rótulo
• Paralelismo de Especialistas: Os 384 especialistas do K2 distribuídos entre os 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ê estiver hospedando o K2.6 por conta própria, este é seu modelo.

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

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

Passo 1: Decomposição da tarefa

O orquestrador analisa a tarefa e constroi 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 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 para a 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 verificadores de fatos: referência cruzada e validação

Cada subagente opera dentro de seu próprio contexto local delimitado. Ele lida com uma tarefa com escopo definido, produz uma saída estruturada e termina. O contexto local não carrega tudo o 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. À medida que 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 seja resolvido.
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 parados e reassume suas tarefas automaticamente.
3. Essa tolerância a falhas é o que torna possíveis execuções autônomas de 12+ horas sem um humano observando.

Passo 4: Agregação e saída

Assim que todos os subagentes são concluídos, o orquestrador agrega os resultados em uma entrega 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 swarm 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 à ferramenta é retida." O swarm 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 swarm. O Kimi K2.6 é construído para escala horizontal - execução paralela em centenas de agentes, execuções autônomas longas, processamento em lote de baixo custo.

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[Kimi K2.6 Swarm de Agentes - 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 em relação aos critérios de sucesso
16  Sinaliza falhas, lacunas, inconsistências
17  Sintetiza a entrega 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 antecessor de permitir que falhas no código que escreveu passem despercebidas." Em sistemas de agente, a confiança falsa é o modo de falha catastrófico.

• Um orquestrador que diz "concluído" quando não está pode cascatear erros por 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 de tokens, o que importa para a passagem de verificação quando você está puxando saídas de 50+ agentes de pesquisa paralelos para um único contexto de revisão.

Por que Kimi para execução?

O Swarm de Agentes do K2.6 suporta até 300 subagentes paralelos e 4.000 etapas de ferramentas 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 (Dynamic Workflows) no Claude Code, mas está atualmente em prévia de pesquisa e limitado a planos Enterprise/Max.
• A capacidade de swarm do Kimi está disponível para todos através da API agora. 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, não é desprezível.

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

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

Mantenha-se com agente único quando:

• A tarefa cabe dentro de uma única janela de contexto (menos de ~50K tokens de trabalho real)
• A tarefa é sequencial por natureza, cada etapa depende 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 maneira

Recorra ao Swarm de Agentes quando:

• A tarefa tem n subtarefas paralelas e independentes, onde n > 5
• O estouro de contexto é um problema genuíno (pesquisa aprofundada, 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 em uma única sessão sequencial
• Você quer um agente crítico ou verificador verificando o trabalho de outro agente

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

• A qualidade do planejamento é importante e você quer um modelo que questione se o plano estiver errado
• A saída é enviada sem revisão humana adicional - então a verificação precisa estar incorporada
• Você está executando um alto volume de tarefas 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 swarm

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

Um orquestrador central atribui subtarefas aos trabalhadores, os trabalhadores executam em paralelo, os resultados são agregados.

1[Objetivo do Usuário]
2    |
3[Orquestrador - Claude Opus 4.8]
4    +-- [Trabalhador: Kimi Agente de Pesquisa x N]
5    +-- [Trabalhador: Kimi Agente de Dados x N]
6    +-- [Trabalhador: Kimi Agente de Código 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[Kimi K2.6 Construtor] -> rascunho -> [Claude Opus 4.8 Crítico] -> feedback -> [Kimi K2.6 Construtor]
2                                        |
3                                   (aprovado)
4                                [Saída Final]

Melhor para: geração de código, redação técnica, saídas sensíveis à conformidade. Sempre defina 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    +-- [Kimi K2.6 Swarm - Equipe de Pesquisa (50 agentes)]
3    +-- [Kimi K2.6 Swarm - Equipe de Construção (50 agentes)]

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

Padrão 4: Grupos Claw (swarm 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 prévia 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 (human-in-the-loop).

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

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 isoladamente
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, programador, redator, verificador

O prompt de sistema 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. Destaque 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: As sete barreiras de proteção (guardrails) 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 swarm 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 falhas. Um subagente com falha não deve derrubar o orquestrador.

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

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

6. Pontos de verificação de intervenção humana (Human-in-the-loop). Para swarms com acesso de gravação (implantar código, enviar e-mails, fazer mutações de API), insira pausas de aprovação obrigatórias.

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 em 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 swarm do que outra hora de leitura.

Construa. Quebre-o 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 em testes" e "funciona às 3 da manhã sem ninguém olhando", e essa lacuna está inteiramente nas barreiras de proteção, na observabilidade e no design de memória.

Conclusão

O Kimi 2.6 é uma revolução na forma como a aprendizagem por reforço pode estabelecer swarms de agentes.

Ele também mostra como horizontes de contexto longo podem fazer uso de tais infraestruturas baseadas em orquestradores, 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 anotações do autor, e editado por uma IA, Opus 4.7.