Voici la traduction complète du texte en français :
Ceci est une analyse complète de A à Z des Agent Swarms d'IA : ce qu'ils sont, comment les utiliser.
Pourquoi ils changent tout dans la façon dont vous travaillez avec l'IA.
Mettez ceci en favori avant d'oublier.
Kimi K2.6, le fleuron open-weight d'avril 2026 de Moonshot AI, est l'implémentation open-source la plus sérieuse de cette idée que j'aie vue.
Les vraies tâches ont de l'ampleur. Cinquante entreprises à étudier.
Deux cents fichiers à analyser. Une douzaine de sous-tâches qui ne dépendent pas les unes des autres et ne devraient pas attendre en file derrière les autres. Un agent swarm est l'architecture pour cela.
Ce guide décompose son fonctionnement, de l'infrastructure d'entraînement jusqu'à l'API, puis aborde le schéma qui me semble le plus important actuellement : Kimi pour l'exécution, Claude Opus 4.8 pour la planification et la vérification.
Voici à quoi ressemble le workflow final
Section 1 : Qu'est-ce qu'un agent swarm ?
Un agent swarm est constitué de plusieurs agents travaillant simultanément sur des sous-tâches décomposées, coordonnés par un orchestrateur qui agrège les résultats.
La distinction avec une chaîne séquentielle est tout l'intérêt :
- Chaîne séquentielle : L'agent A s'exécute, passe le relais à B, B passe à C. Temps total = A + B + C.
- Swarm : L'orchestrateur divise l'objectif, les agents A, B, C s'exécutent en même temps sur des sous-tâches indépendantes, les résultats sont fusionnés. Temps total ≈ max(A, B, C).
Quand une tâche a une véritable structure parallèle, c'est la différence entre quelques minutes et des heures.
Un swarm résout également le problème de débordement de contexte. Un agent unique sur une longue tâche accumule des tokens jusqu'à ce que sa fenêtre soit submergée. Un swarm donne à chaque sous-tâche son propre contexte limité, et seul le résultat structuré remonte vers l'orchestrateur.
Les six blocs de construction
Chaque swarm possède les mêmes composants fondamentaux :
Composant
Ce qu'il fait
Orchestrateur
Décompose la tâche, attribue les sous-tâches, supervise l'exécution, agrège les résultats
Sous-agents
Travailleurs spécialisés cantonnés à un domaine (recherche, code, analyse, rédaction)
Outils
Fonctions que les agents peuvent appeler : recherche web, interpréteur de code, entrées/sorties fichier, API
Mémoire
État partagé que le swarm peut lire/écrire
Transferts / Routage
Mécanisme pour passer le contrôle ou les données entre les agents
Barrières de sécurité
Limites d'itération, délais d'attente, points de contrôle humains, récupération d'erreurs
Maîtrisez ces six éléments et vous avez un swarm. Échouez sur un seul et vous avez une session de débogage coûteuse.
Section 2 : Ce qu'est réellement Kimi K2.6
Avant d'aborder le comportement en swarm, il vaut la peine de comprendre ce qui se trouve en dessous. K2.6 est un modèle Mixture-of-Experts de 1 000 milliards de paramètres de Moonshot AI, publié en open-weight le 20 avril 2026 sous licence MIT modifiée. L'utilisation commerciale est gratuite en dessous de 20 millions de dollars de revenus mensuels ou de 100 millions d'utilisateurs actifs mensuels – c'est donc pratiquement gratuit pour la plupart des développeurs.
0:29
Spécifications techniques
Spécification
Valeur
Paramètres totaux
~1,04 billion
Activés par token
~32 milliards (8 experts sélectionnés + 1 partagé)
Experts totaux
384, répartis sur 61 couches de transformeur
Fenêtre de contexte
262 144 tokens (262 K)
Attention
Multi-Head Latent Attention (MLA) – empreinte mémoire cache KV réduite
Fonction d'activation
SwiGLU
Encodeur visuel
MoonViT-3D (400 M de paramètres, image + vidéo jusqu'en 2K)
Quantification
INT4 via entraînement conscient de la quantification (~594 Go sur disque)
Taille totale en FP16
~2 To
Licence
MIT modifiée
La variante INT4 QAT fonctionne nativement sur 4x H100 80 Go. FP16 nécessite 8x H100 80 Go. Les trois frameworks d'inférence pris en charge (vLLM, SGLang, KTransformers) exposent des API compatibles OpenAI.
Section 3 : L'optimiseur MuonClip, ou pourquoi l'entraînement est stable
Entraîner un MoE sparse de mille milliards de paramètres sans qu'il explose est difficile. Le mode de défaillance spécifique : à mesure que la longueur de séquence augmente, le produit scalaire query-key (QK) dans les couches d'attention peut croître de manière illimitée. Vous obtenez des pics de perte, et à cette échelle, un pic de perte peut être irrécupérable.
L'article technique Kimi K2 (arxiv : 2507.20534) introduit MuonClip pour y remédier.
Muon est un optimiseur de gradient plus efficace en tokens qu'AdamW. Même qualité, moins d'étapes d'entraînement. Le problème : Muon seul produit une instabilité de l'attention à l'échelle du billion de paramètres.
QK-Clip ajoute un clipping par token et par tête directement sur les matrices QK avant le softmax. Cela limite l'amplitude des scores d'attention et élimine la pathologie d'explosion. Pas de réglage manuel, pas de bidouillage du taux d'apprentissage.
Extrait du résumé de l'article :
« Nous présentons MuonClip, un nouvel optimiseur qui intègre l'algorithme Muon efficace en tokens avec un mécanisme de stabilisation appelé QK-Clip... En utilisant MuonClip, Kimi K2 atteint des performances compétitives tout en nécessitant beaucoup moins de tokens d'entraînement que les bases AdamW. »
Pourquoi un développeur devrait-il se soucier d'un détail d'entraînement ? Parce que la raison pour laquelle K2.6 peut soutenir 4 000 appels d'outils sur plus de 12 heures sans dégradation remonte à cela. Un modèle entraîné avec une instabilité de l'attention a tendance à halluciner dans des conditions de long contexte et de nombre d'étapes élevé. C'est exactement le régime dans lequel vit un Agent Swarm.
Section 4 : PARL, la recherche derrière le swarm
Agent Swarm n'est pas un framework ajouté par-dessus K2.6. Le comportement a été intégré au modèle via un paradigme que Moonshot appelle PARL : Parallel-Agent Reinforcement Learning (apprentissage par renforcement multi-agent parallèle), décrit dans l'article technique Kimi K2.5 (arxiv : 2602.02276).
Orchestrateur entraînable, sous-agents figés
La façon habituelle de construire des systèmes multi-agents est de coordonner plusieurs instances de modèles actives au niveau de la couche applicative. Ensuite, l'attribution du crédit devient un désastre : lequel de vos agents a rendu la réponse finale bonne ou mauvaise ? Entraîner de bout en bout à travers ce graphe est informatiquement intraitable.
PARL contourne cela :
- L'orchestrateur est entraînable, mis à jour via RL sur les récompenses de résultat
- Les sous-agents sont figés, des points de contrôle de politique intermédiaires fixes
Les trajectoires des sous-agents sont traitées comme des observations environnementales, pas comme des points de décision différentiables. Cela découple deux problèmes difficiles à la fois. Le crédit ne va qu'aux actions de l'orchestrateur, jamais à 300 sous-agents simultanés. Et l'entraînement reste stable car un seul modèle est mis à jour.
L'orchestrateur apprend quand paralléliser, combien de sous-agents créer et comment diviser le travail. Personne n'a spécifié ces comportements manuellement. Ils émergent de la maximisation de la récompense.
La fonction de récompense en trois parties
L'orchestrateur s'entraîne sur trois signaux.
Une récompense de parallélisme l'incite à créer des sous-agents concurrents plutôt qu'à exécuter les choses séquentiellement. Sans cela, le modèle par défaut est un agent à la fois : sûr, prévisible, lent.
Une récompense d'achèvement garantit que les sous-agents accomplissent réellement leurs tâches. Cela bloque le "parallélisme factice", où l'orchestrateur crée une foule d'agents qui ne font rien juste pour engranger la récompense de parallélisme.
Une récompense de performance évalue la qualité du résultat final par rapport à l'objectif de la tâche. C'est la vérité de terrain à laquelle tout le reste est subordonné.
Le détail que je trouve le plus intéressant : la métrique d'optimisation est le nombre d'étapes critiques (longueur du chemin critique), pas le nombre total d'étapes. Le modèle est récompensé pour raccourcir la plus longue chaîne de dépendances, pas pour maximiser la concurrence brute. C'est ce qui réduit réellement le temps d'exécution.
Résultats PARL
- BrowseComp : Le mode swarm a atteint 78,4 % sur K2.5, un gain absolu de 17,8 points par rapport au K2.5 mono-agent (60,6 %), qui battait GPT-5.2 Pro (77,9 %) à l'époque. K2.6 pousse ce chiffre à 86,3 %.
- WideSearch : Amélioration absolue de 6,3 points sur Item-F1 (de 72,7 % à 79,0 %)
- Temps d'exécution : Réduction de 3 à 4,5x sur les tâches parallélisables par rapport à la base mono-agent
- Appels d'outils parallèles : jusqu'à 4 000 étapes coordonnées dans K2.6
Section 5 : Mooncake, l'infrastructure derrière Kimi
L'infrastructure de service de Moonshot explique pourquoi K2.6 peut supporter 300 agents parallèles sans fondre. Les poids du modèle ne sont que la moitié de l'histoire ; le système qui les sert est l'autre moitié.
L'infrastructure est bien structurée pour les tâches à long contexte
Architecture désagrégée centrée sur le cache KV
La plateforme de service de Moonshot s'appelle Mooncake, décrite dans leur article d'infrastructure de 2024 (arxiv : 2407.00079). C'est le moteur qui fait tourner Kimi à grande échelle, et son choix de conception est inhabituel.
L'inférence LLM traditionnelle exécute le prefill (traitement de la requête d'entrée) et le decode (génération de tokens) sur les mêmes instances GPU. Mooncake les désagrège en clusters séparés :
- Cluster de prefill : gère le traitement initial de la requête, évolue indépendamment pour les entrées à long contexte
- Cluster de decode : gère la génération de tokens, optimisé pour le débit et la latence
Le cache KV, l'état d'attention intermédiaire qui rend la génération autorégressive efficace, est géré comme une ressource système de première classe. Mooncake construit un cache KV distribué couvrant la VRAM GPU, la DRAM CPU et les SSD, avec un moteur de transfert personnalisé déplaçant le cache entre les nœuds.
Pourquoi cela importe pour Agent Swarm
Quand 300 sous-agents s'exécutent simultanément, chacun génère son propre cache KV. Dans une architecture traditionnelle, c'est une pression massive sur la mémoire GPU et des conflits d'ordonnancement. Avec le cache désagrégé de Mooncake :
- Les caches KV des sous-agents terminés peuvent être déplacés vers la DRAM ou le SSD et rappelés si nécessaire
- Le cluster de prefill gère les requêtes système (souvent volumineuses) de chaque sous-agent indépendamment
- L'ordonnanceur maximise le débit global tout en respectant les SLO de latence par agent
Extrait de l'article Mooncake : "Par rapport à la méthode de base, Mooncake peut atteindre jusqu'à 525 % d'augmentation du débit dans certains scénarios simulés tout en respectant les SLO. Sous des charges de travail réelles, l'architecture innovante de Mooncake permet à Kimi de gérer 75 % de requêtes supplémentaires."
L'article mis à jour indique que Mooncake est "opérationnel sur des milliers de nœuds, traitant plus de 100 milliards de tokens par jour" et gère 115 % de requêtes supplémentaires sur les clusters A800 et 107 % sur les clusters H800 par rapport aux systèmes précédents.
Désagrégation PD à grande échelle : le déploiement K2 sur 128 GPU
LMSYS a publié une étude de cas de déploiement pour Kimi K2 utilisant la désagrégation Prefill-Decode (PD) sur 128 GPU H200 via le routeur SGLang. L'architecture :
- Routeur SGLang : service léger pour la découverte dynamique des nœuds de prefill et de decode via des sélecteurs d'étiquettes
- Parallélisme d'experts : les 384 experts de K2 répartis sur les nœuds, avec routage au niveau réseau
- OME (Open Model Engine) : orchestration native Kubernetes pour la couche de service
C'est la pile qui fait tourner la famille K2 à l'échelle de la production. Si vous auto-hébergez K2.6, c'est votre modèle.
Section 6 : Comment fonctionne Agent Swarm, étape par étape
La séquence mécanique lorsque K2.6 exécute une tâche en mode swarm :
Étape 1 : Décomposition de la tâche
L'orchestrateur analyse la tâche et construit le graphe de dépendances : quelles sous-tâches sont indépendantes et peuvent s'exécuter en parallèle, lesquelles dépendent des résultats précédents.
Pour "étudier 100 entreprises YC et produire une analyse sectorielle", l'orchestrateur identifie 100 tâches de recherche indépendantes, puis 1 tâche d'agrégation, puis 1 tâche de synthèse. La première couche est entièrement parallélisable.
Étape 2 : Création d'agents spécialisés
L'orchestrateur crée des sous-agents spécialisés par domaine en fonction du type de sous-tâche. K2.6 instancie des agents dynamiquement avec des instructions spécifiques au rôle et un accès ciblé aux outils :
- Agents de recherche web : outils de recherche + navigateur
- Agents d'analyse de données : exécution Python + outils de tableur
- Agents de rédaction : synthèse et génération de documents
- Agents de vérification des faits : recoupement et validation
Chaque sous-agent opère dans son propre contexte local limité. Il gère une seule tâche circonscrite, produit un résultat structuré et se termine. Le contexte local ne contient pas tout ce que l'orchestrateur sait, seulement ce dont ce sous-agent a besoin. C'est ainsi que K2.6 évite de déborder sur des tâches qui rempliraient la fenêtre de tout agent unique en quelques minutes.
Étape 3 : Exécution parallèle par vagues
Les agents s'exécutent par vagues. La première vague gère les tâches totalement indépendantes.
- Au fur et à mesure que les résultats arrivent, l'orchestrateur lance une deuxième vague sur les tâches qui dépendent des résultats de la première, et ainsi de suite jusqu'à ce que le graphe de dépendances soit résolu.
- K2.6 prend en charge jusqu'à 300 sous-agents et 4 000 étapes coordonnées par session. L'orchestrateur supervise l'exécution en temps réel, détecte les agents ayant échoué ou bloqués, et réattribue leurs tâches automatiquement.
- Cette tolérance aux pannes est ce qui rend possibles des exécutions autonomes de plus de 12 heures sans qu'un humain ne supervise.
Étape 4 : Agrégation et résultat
Une fois que tous les sous-agents ont terminé, l'orchestrateur agrège les résultats en un livrable final : document, tableur, site web, diaporama.
- Il synthétise les résultats des agents plutôt que de les concaténer, de sorte que le résultat tienne structurellement.
- Un autre point à noter : la structure en swarm est aussi la réponse de Kimi au problème de la fenêtre de contexte.
- La politique explicite de K2.6 : "une fois que la fenêtre de contexte dépasse le seuil, seuls les messages les plus récents liés aux outils sont conservés." Le swarm rend cette politique durable sur des horizons de tâches très longs.
Section 7 : L'architecture Kimi x Claude Opus 4.8
Aucun modèle unique n'est la bonne réponse pour chaque couche d'un swarm. Kimi K2.6 est conçu pour le passage à l'échelle horizontal – exécution parallèle sur des centaines d'agents, longues exécutions autonomes, traitement en masse rentable.
Claude Opus 4.8 est conçu pour le jugement – planification, raisonnement nuancé, et détection de ses propres erreurs. Ils se complètent structurellement, et le fossé que chacun laisse est proche de la forme de la force de l'autre.
Le schéma :
1[Objectif utilisateur]2 |3[Claude Opus 4.8 - Planificateur]4 Décompose l'objectif en un cahier des charges structuré5 Identifie les sous-tâches parallèles vs séquentielles6 Définit les critères de succès pour chaque sous-tâche7 |8[Kimi K2.6 Agent Swarm - Exécuteur]9 Reçoit le cahier des charges structuré10 Crée jusqu'à 300 sous-agents spécialisés11 S'exécute en parallèle sur les appels d'outils12 Retourne des résultats structurés13 |14[Claude Opus 4.8 - Vérificateur]15 Examine les résultats de Kimi par rapport aux critères de succès16 Signale les échecs, lacunes, incohérences17 Synthétise le livrable final
Pourquoi Claude pour la planification et la vérification ?
Le changement le plus sous-estimé dans Opus 4.8 est l'amélioration de l'honnêteté : "Opus 4.8 est environ quatre fois moins susceptible que son prédécesseur de laisser passer sans commentaire les défauts dans le code qu'il a écrit." Dans les systèmes agentiques, la fausse confiance est le mode de défaillance catastrophique.
- Un orchestrateur qui dit "terminé" alors que ce n'est pas le cas va cascader les erreurs sur 300 agents en aval. La tendance de Claude à signaler l'incertitude et à détecter ses propres erreurs en cours de tâche en fait l'ancre idéale pour les couches où se tromper coûte cher.
- Opus 4.8 prend également en charge une fenêtre de contexte de 1 million de tokens, ce qui compte pour la passe de vérification lorsque vous rassemblez les résultats de 50+ agents de recherche parallèles dans un seul contexte de révision.
Pourquoi Kimi pour l'exécution ?
L'Agent Swarm de K2.6 prend en charge jusqu'à 300 sous-agents parallèles et 4 000 étapes d'outils coordonnées par session – c'est un comportement entraîné, pas une surcouche applicative.
- Claude dispose bien d'une fonctionnalité Workflows dynamiques dans Claude Code, mais elle est actuellement en préversion de recherche et limitée aux plans Enterprise/Max.
- La capacité swarm de Kimi est disponible pour tout le monde via l'API dès maintenant. L'économie des tokens compte également à grande échelle : K2.6 coûte 0,95 $/4,00 $ par million de tokens d'entrée/sortie. Pour une exécution parallèle en volume, ce n'est pas négligeable.
Section 8 : Quand vous avez besoin d'un swarm (et quand vous n'en avez pas besoin)
L'erreur la plus fréquente dans la conception multi-agent : ajouter la complexité d'un swarm avant d'avoir atteint le plafond d'un agent unique.
Restez mono-agent quand :
- La tâche tient dans une seule fenêtre de contexte (moins de ~50 000 tokens de travail réel)
- La tâche est de nature séquentielle, chaque étape dépendant de la précédente
- Vous êtes encore en phase de prototypage – les modes de défaillance d'un agent unique sont bien plus faciles à déboguer
- La tâche serait terminée en moins de 10 minutes de toute façon
Recourez à Agent Swarm quand :
- La tâche comporte n sous-tâches parallèles et indépendantes où n > 5
- Le débordement de contexte est un vrai problème (recherche approfondie, grandes bases de code, opérations par lots)
- Vous avez besoin d'agents spécialisés par domaine travaillant simultanément
- La tâche est trop longue pour maintenir la qualité sur une seule session séquentielle
- Vous voulez qu'un agent critique ou vérificateur contrôle le travail d'un autre agent
Utilisez l'hybride Kimi + Claude Opus 4.8 quand :
- La qualité de la planification est cruciale et vous voulez un modèle qui vous dira si le plan est mauvais
- Le résultat est livré sans révision humaine supplémentaire – la vérification doit donc être intégrée
- Vous exécutez un volume élevé où les coûts en tokens s'accumulent rapidement
- Vous voulez le jugement de Claude sur les couches de décision et l'échelle de Kimi sur les couches de travail
Section 10 : Les quatre schémas d'architecture de swarm
Schéma 1 : Orchestrateur-travailleur (le plus courant)
Un orchestrateur central attribue les sous-tâches aux travailleurs, les travailleurs exécutent en parallèle, les résultats sont agrégés.
1[Objectif utilisateur]2 |3[Orchestrateur - Claude Opus 4.8]4 +-- [Travailleur : Agent de recherche Kimi x N]5 +-- [Travailleur : Agent de données Kimi x N]6 +-- [Travailleur : Agent de code Kimi x N]7 |8[Synthétiseur - Claude Opus 4.8]9 |10[Résultat final]
Idéal pour : les tâches avec des sous-tâches clairement séparables et un nombre variable de travailleurs.
Schéma 2 : Boucle critiqueur-améliorateur
Un agent produit, un autre critique, répéter jusqu'à atteindre le seuil de qualité.
1[Constructeur Kimi K2.6] -> brouillon -> [Critique Claude Opus 4.8] -> retour -> [Constructeur Kimi K2.6]2 |3 (approuvé)4 [Résultat final]
Idéal pour : génération de code, rédaction technique, résultats sensibles à la conformité. Toujours définir une limite maximale d'itérations.
Schéma 3 : Hiérarchique
Un orchestrateur stratégique gère des orchestrateurs de domaine, qui gèrent des travailleurs.
1[Claude Opus 4.8 - Orchestrateur stratégique]2 +-- [Kimi K2.6 Swarm - Équipe de recherche (50 agents)]3 +-- [Kimi K2.6 Swarm - Équipe de construction (50 agents)]
Idéal pour : les grands workflows d'entreprise avec des domaines distincts.
Schéma 4 : Groupes de griffes (swarm hétérogène natif de Kimi)
K2.6 coordonne des agents exécutant n'importe quel modèle, y compris des modèles locaux, Claude et GPT, aux côtés de travailleurs humains dans un espace opérationnel partagé. Actuellement en préversion de recherche.
1[Coordinateur Kimi K2.6]2 +-- [Claude Opus 4.8 - spécialiste du raisonnement]3 +-- [Llama 3.3 local - tâches volumineuses sensibles aux coûts]4 +-- [Agents Kimi K2.6 x N - couche d'exécution]5 +-- [Réviseur humain - points de contrôle d'approbation]
Idéal pour : les workflows nécessitant une diversité de modèles, un hybride local + cloud, ou des exigences d'intervention humaine.
Section 12 : Conception de prompts pour les tâches en swarm
Le prompt de décomposition (orchestrateurs)
1Vous êtes un architecte de tâches. Décomposez cet objectif en sous-tâches indépendantes et parallélisables.23Règles :4- Chaque sous-tâche doit pouvoir être réalisée par un seul agent spécialisé de manière isolée5- Les sous-tâches avec dépendances doivent être marquées avec leur chaîne de dépendance6- Sortie au format JSON : {task_id, description, agent_type, depends_on, success_criteria}78Objectif : {user_goal}9Types d'agents disponibles : chercheur, analyste, codeur, rédacteur, vérificateur
Le prompt système spécialisé (sous-agents)
1Vous êtes un agent {ROLE} spécialisé dans {DOMAINE}.23Tâche : {subtask_description}45CONTRAINTES :6- Retourner UNIQUEMENT du JSON valide correspondant à : {output_schema}7- Ne pas dépasser le cadre de votre tâche8- Si vous ne pouvez pas terminer la tâche : {"error": "raison", "partial_results": [...]}9- Nombre maximum d'appels d'outils : {max_tool_calls}1011Contexte : {context_from_orchestrator}
Le prompt d'agrégation (synthétiseurs)
1Synthétisez les recherches de {n} agents spécialisés en un résultat cohérent.231. Lisez tous les résultats d'agents fournis42. Identifiez les points d'accord, de désaccord ou les lacunes53. Produisez un {output_type} intégrant toutes les conclusions64. Signalez explicitement les incohérences – ne résolvez pas les contradictions en silence78Résultats des agents : {agent_outputs_as_json}9Format de sortie : {final_output_spec}
Section 13 : Les sept barrières de sécurité non négociables
1. Nombre maximum d'itérations par agent. Limite stricte sur les boucles avant notification de l'orchestrateur.
2. Délai d'attente de session. Si le swarm n'a pas terminé en N minutes, terminez et retournez les résultats partiels.
3. Application d'une sortie structurée. Forcez les agents à retourner du JSON. Le texte en prose des agents intermédiaires crée des échecs d'analyse en aval.
4. Isolation des échecs. Un sous-agent défaillant ne doit pas faire planter l'orchestrateur.
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=40967 )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. Nouvelle tentative avec backoff exponentiel. Gérez les erreurs 429 et les erreurs transitoires sans les faire remonter comme des échecs permanents.
6. Points de contrôle d'intervention humaine. Pour les swarms ayant un accès en écriture (déploiement de code, envoi d'e-mails, mutations via API), insérez des pauses d'approbation obligatoires.
7. Surveillance des coûts. Définissez des budgets de tokens par exécution. Les boucles incontrôlées se manifestent par des anomalies de coût avant de se manifester par des échecs de qualité, à chaque fois.
Que construire en premier
Commencez par le pipeline à trois agents de la Section 9. Il est assez petit pour être débogué en un après-midi, il exerce la planification, l'exécution parallèle et la vérification, et vous pouvez l'exécuter sur une tâche réelle en moins d'une heure de configuration.
Quand il plante – et il plantera – le mode de défaillance vous en apprendra plus sur la conception de swarm qu'une heure de lecture supplémentaire.
Construisez-le. Faites-le planter intentionnellement. Revenez ensuite aux schémas de la Section 11 avec un point de référence concret.
L'architecture n'est pas la partie difficile. La partie difficile est l'écart entre "ça marche en test" et "ça marche à 3h du matin sans personne pour surveiller", et cet écart réside entièrement dans les barrières de sécurité, l'observabilité et la conception de la mémoire.
Conclusion
Kimi K2.6 est une révolution agentique dans la manière dont l'apprentissage par renforcement peut établir des agent swarms.
Cela montre également comment des horizons de contexte longs peuvent tirer parti de telles infrastructures basées sur un orchestrateur, permettant de créer plusieurs sous-agents pour construire des systèmes complexes en utilisant un seul...
Avis de non-responsabilité
Cet article a été rédigé en utilisant la documentation technique et les articles de recherche de Kimi K2.6 dans les notes de l'auteur, et édité par une IA, Opus 4.7.
