Kimi K3 Swarm Max : comment exécuter 300 agents de recherche à partir d'une seule invite

Kimi K3 est sorti le 16 juillet 2026. 2,8 billions de paramètres. 1 million de tokens de contexte. Le plus grand modèle open-weight jamais publié.

La fonction phare est K3 Swarm Max : jusqu'à 300 sous-agents fonctionnant en parallèle, coordonnés sur 4 000 étapes, produisant de vrais fichiers au lieu de réponses de chat. Deux variantes partagent le même cerveau. K3 Max gère les tâches quotidiennes. K3 Swarm Max dirige une flotte vers le problème.

La plupart des gens ouvrent Kimi, tapent une question, obtiennent une réponse, ferment l'onglet. Cela représente environ 10 % de ce que le produit fait. Ce guide couvre les 90 % restants.

Le swarm n'est pas un ajout rapporté. L'orchestrateur est une politique apprise entraînée avec l'apprentissage par renforcement multi-agents parallèle (Parallel-Agent Reinforcement Learning). Vous décrivez l'objectif. Le swarm décide comment le diviser, combien d'agents créer et comment assembler les résultats. Les swarms excellent sur les travaux larges et parallélisables : recherche sur plus de 50 sources, analyse par lots, veille concurrentielle, construction de datasets. Ils peinent sur les tâches séquentielles profondes où l'étape 3 dépend de l'étape 2.

• Rédigez un cahier des charges, pas un prompt

« Recherche le marché des applications fitness » : voilà comment vous brûlez des crédits et obtenez des déchets. Un prompt d'une ligne donne au swarm la permission de tout décider. Il décidera mal.

Traitez le swarm comme un entrepreneur. Un cahier des charges définit quoi collecter, ce qui est valide, quelles sources sont autorisées, le format de sortie exact et que faire en cas de conflit. Le cahier des charges est l'artefact le plus important de tout le workflow, car au niveau 2, il devient la graine de votre compétence (Skill) réutilisable.

1# PROJET : [nom]
2OBJECTIF : [une phrase, le livrable, pas le sujet]
3PÉRIMÈTRE : [ce qui est inclus, ce qui est explicitement exclu]
4RÈGLES : [validation, ce qui constitue un résultat vérifié]
5SOURCES : [publications officielles, articles, sources primaires uniquement, pas d'agrégateurs]
6SORTIE : [type de fichier / nombre / nommage / détails de format]
7EN CAS DE CONFLIT : signaler la ligne, ne jamais résoudre en silence
8CONDITION D'ARRÊT : [quand s'arrêter et signaler au lieu de deviner]

• Lisez le plan de décomposition avant de dépenser

Après avoir soumis le cahier des charges, Kimi vous montre le plan d'exécution avant de lancer : combien de sous-agents, ce que chacun gère, l'ordre des dépendances, le budget d'étapes. C'est l'étape que les débutants sautent, et c'est la plus coûteuse à sauter.

Un swarm de 200 agents mal décomposé coûte de l'argent réel. Vérifier le plan ne coûte rien. Vous cherchez trois choses : est-ce qu'il comprend le périmètre, le nombre d'agents est-il raisonnable pour la tâche, et le plan de sortie correspond-il à ce dont vous avez vraiment besoin.

1Montrez-moi la décomposition proposée avant d'exécuter :
2- combien de sous-agents, et ce que chacun gère
3- l'ordre des dépendances (ce qui bloque quoi)
4- le budget d'étapes estimé
5- où se situe le plus grand risque de baisse de qualité
6N'exécutez pas encore. Attendez ma confirmation.

Un détail intéressant : les 4 000 étapes sont un budget total coordonné sur l'ensemble du swarm, pas 4 000 par agent. Une exécution avec 300 agents donne en moyenne environ 13 étapes chacun. Cela vous indique si votre tâche correspond à la forme.

• Lancez-le

Maintenant, vous exécutez. Jusqu'à 300 sous-agents se déclenchent par vagues parallèles, chacun dans son propre contexte délimité. Seule la sortie structurée retourne au coordinateur.

1Exécutez le cahier des charges de bout en bout.
2Parallélisez partout où le plan le permet.
3Signalez immédiatement tout blocage, ne contournez pas en silence.
4Fusionnez le tout dans la SORTIE définie dans le cahier des charges.

Ce que vous avez après le niveau 1

Une seule sortie de swarm construite à partir de votre cahier des charges. Brute, non vérifiée, mais structurée. La plupart des gens s'arrêtent ici. La valeur commence au niveau 2.

• Exigez de vrais fichiers, pas une réponse de chat

« Un rapport complet » donne aux agents la permission de s'arrêter tôt. « Un PDF de 40 pages + un CSV de 20 000 lignes + 14 graphiques PNG prêts à exporter » leur donne un objectif de qualité. Commencez toujours le cahier des charges par la sortie. La spécificité au niveau de la sortie fait la différence entre une équipe de recherche et une boîte à suggestions coûteuse.

1# exemples de sorties solides :
2SORTIE : 1 .xlsx, une ligne par modèle, + résumé de 200 mots
3SORTIE : 30 fichiers HTML, un par magasin, nommés par entreprise
4SORTIE : PDF de 40 pages + CSV de 20 000 lignes + 14 graphiques PNG

• Exigez de vrais fichiers, pas une réponse de chat

« Un rapport complet » donne aux agents la permission de s'arrêter tôt. « Un PDF de 40 pages + un CSV de 20 000 lignes + 14 graphiques PNG prêts à exporter » leur donne un objectif de qualité. Commencez toujours le cahier des charges par la sortie. La spécificité au niveau de la sortie fait la différence entre une équipe de recherche et une boîte à suggestions coûteuse.

1# exemples de sorties solides :
2SORTIE : 1 .xlsx, une ligne par modèle, + résumé de 200 mots
3SORTIE : 30 fichiers HTML, un par magasin, nommés par entreprise
4SORTIE : PDF de 40 pages + CSV de 20 000 lignes + 14 graphiques PNG

• Dirigez un modèle distinct sur la sortie

Le défaut connu du swarm : à moins que vous n'exigiez explicitement une vérification, il produit des affirmations confiantes mais mal sourcées, et les sous-agents indépendants se contredisent parfois. « Ça a l'air fini » et « c'est correct » sont deux mondes différents.

Utilisez un second modèle comme porte de vérification. Son seul travail : réfuter, pas louanger. Vous ne payez pas des tokens premium pour générer. Vous les payez pour attraper le défaut silencieux avant que l'étape suivante ne sauvegarde le workflow en tant que compétence (Skill) réutilisable.

1Vous êtes le VÉRIFICATEUR. Un swarm d'agents a produit la sortie ci-jointe.
2Votre seul travail est de trouver ce qui ne va pas.
3
4Vérifiez :
5- Chaque chiffre avancé remonte-t-il à une source nommée ?
6- Deux sections quelconques se contredisent-elles ?
7- Y a-t-il quelque chose présenté comme un fait qui est en réalité une inférence ?
8- La sortie correspond-elle aux exigences de format du cahier des charges ?
9
10Pour chaque problème : citez l'emplacement exact et la correction.
11Si tout tient : APPROUVÉ.
12Si quelque chose échoue : REJETÉ + la correction la plus critique en premier.

• Sauvegardez l'ensemble du workflow en tant que compétence (Skill)

Après une exécution vérifiée, dites à Kimi de capturer l'ensemble du workflow : format d'entrée, étapes des agents, format de sortie, règles de validation. La première exécution prend 20 minutes. Chaque exécution suivante prend 30 secondes. La compétence (Skill) est la raison pour laquelle le système s'accumule au lieu de redémarrer à chaque fois.

1Sauvegardez ce workflow entier en tant que compétence (Skill) réutilisable : « [nom] »
2Capturez :
3- le format d'entrée (quels fichiers / forme de cahier des charges il attend)
4- les étapes d'agents qui ont fonctionné
5- le format de sortie et la convention de nommage
6- les règles de validation du cahier des charges
7La prochaine fois que je l'exécute, je joins de nouveaux fichiers et j'obtiens la même forme.

Ce que vous avez après le niveau 2

Une sortie vérifiée en laquelle vous pouvez avoir confiance, et une compétence (Skill) sauvegardée que vous pouvez rejouer sans reconstruire le cahier des charges. C'est là que la boucle commence à s'accumuler.

• Nourrissez vos propres documents en tant que connaissance du swarm

Les compétences (Skills) capturent le processus. Le passage de document à compétence capture le domaine. Téléchargez vos meilleurs travaux et Kimi capture son empreinte structurelle en tant que compétence que chaque futur swarm appliquera.

Chaque PDF, transcription ou feuille de calcul que vous introduisez devient un contexte sur lequel les 300 agents s'appuient, au lieu de se rabattre sur les données d'entraînement. Plus vous en introduisez, plus la sortie ressemble à votre travail plutôt qu'à de l'IA générique.

1Capturez ce document en tant que compétence (skill) réutilisable. Identifiez ce qui le fait fonctionner :
2- structure et ordre des sections
3- ton et registre de voix
4- profondeur d'analyse par section
5Sauvegardez-le sous le nom « [nom] ». Produisez ensuite un nouveau document sur [sujet différent]
6en utilisant la compétence capturée. Respectez le niveau de qualité, pas le contenu.

• Transformez chaque rejet en une règle permanente

L'étape de vérification attrape un défaut une fois. Cette étape garantit que le swarm ne le refera jamais. Distillez les retours en règles strictes et écrivez-les dans un fichier de contraintes que le swarm lit avant de faire quoi que ce soit.

1# CONTRAINTES.md, chargé automatiquement
2- chaque chiffre avancé doit remonter à une source primaire ou être signalé
3- pas de résolution de conflit en silence : surfacez les contradictions
4- [règle distillée à partir des retours du vérificateur de la dernière exécution]
5- [l'erreur que vous ne voulez jamais voir répétée]
6Verrouillage du périmètre : ne touchez à rien en dehors du bloc PÉRIMÈTRE du cahier des charges.

• Rejouez la compétence sur de nouvelles entrées

C'est là que « l'accumulation » cesse d'être un mot à la mode et apparaît sur la facture. La deuxième exécution ne part pas de zéro. Elle part de la compétence, de la connaissance du swarm et du fichier de contraintes que vous avez construits ci-dessus. Même workflow, nouveaux fichiers, une fraction de la configuration.

L'économie change radicalement lors de la relecture. Le tarif de cache-hit de K3 descend à 0,30 $ par million de tokens pour le contexte répété, 10 fois moins cher que le prix d'entrée de la première exécution. La compétence, les contraintes et le cahier des charges sont tous du contexte répété. Seuls vos nouveaux fichiers d'entrée coûtent le plein tarif. La première exécution est un investissement. Chaque exécution suivante récolte le retour.

La sortie s'améliore également structurellement. La compétence (Skill) impose le format. Les contraintes bloquent toutes les erreurs déjà détectées par le vérificateur. La connaissance du swarm ancre chaque agent sur vos documents réels plutôt que sur les données d'entraînement. La quatrième exécution ne coûte pas seulement moins cher que la première. Elle produit de meilleurs résultats, car le système a appris de trois cycles de retours réels.

1Exécutez la compétence (Skill) sauvegardée « [nom] » sur ces nouvelles entrées.
2Appliquez CONTRAINTES.md. Utilisez le format de sortie capturé.
3[joindre les nouveaux fichiers]
4
5Comparez la sortie de cette exécution avec la dernière exécution.
6Rapportez :
7- les nouvelles découvertes non présentes la dernière fois
8- les découvertes qui ont changé depuis la dernière exécution
9- tout ce qui a disparu (signalez comme écart potentiel)
10- les écarts par rapport à la forme attendue de la compétence

Ce que vous avez après le niveau 3

Un pipeline de recherche auto-améliorant. Chaque exécution est moins chère, plus rapide et plus précise que la précédente car la bibliothèque de compétences, la base de connaissances et le fichier de contraintes continuent de croître.

• Promouvez la compétence en agent programmé

Une fois la boucle stable et soutenue par la compétence, vous arrêtez de la lancer manuellement. Pointez Kimi vers un déclencheur : un planning, un dépôt de nouveaux fichiers, une URL surveillée. Laissez-le exécuter tout le swarm de manière proactive, en ne remontant que le livrable et les écarts dignes d'attention.

La veille concurrentielle est l'exemple parfait. Exécution un : vous construisez et vérifiez à la main. Au moment où c'est un agent en arrière-plan, il vérifie chaque concurrent en parallèle chaque semaine et dépose un résumé dans votre boîte de réception à un coût de temps marginal nul. Le seul humain restant dans la boucle est la question que vous posez et la décision que vous prenez sur la réponse.

1Exécutez la compétence « [nom] » selon un planning hebdomadaire.
2Déclencheur : [planning / nouveau fichier / URL surveillée]
3À chaque exécution : exécutez le swarm, appliquez CONTRAINTES.md,
4vérifiez, puis délivrez la SORTIE + un diff par rapport à la dernière exécution.
5Ne me contactez que si un écart dépasse [seuil].

Ce que 2,8 billions de paramètres ne résolvent pas

L'hallucination augmente avec le parallélisme. Plus d'agents cherchent signifie des réponses erronées plus confiantes, à moins que vous n'effectuiez une vérification. Le swarm ne se vérifie pas lui-même.

K3 coûte 3 à 4 fois plus que K2.6. Entrée : 3,00 $/M contre 0,95 $/M. Sortie : 15,00 $/M contre 4,00 $/M. Le cache aide sur les relectures, mais la première exécution est coûteuse. Pour une optimisation pure des coûts, K2.6 reste le choix économique.

Les poids ouverts ne sont pas encore disponibles. Moonshot a promis de les fournir d'ici le 27 juillet 2026. D'ici là, K3 ne fonctionne que via l'API et l'application Kimi.

Les swarms amplifient les mauvais cahiers des charges. Un prompt vague via un agent gaspille une fenêtre de contexte. Via 300 agents, il en gaspille 300 en parallèle.

La liste concise

• Les prompts d'une ligne. Le swarm décide tout. Il décide mal.
• Sauter la revue de décomposition. L'étape la plus coûteuse à sauter.
• Pas de vérification. « Ça a l'air fini » n'est pas « c'est correct ».
• Sauvegarder une sortie non vérifiée comme compétence. L'erreur s'accumule à chaque exécution future.
• 300 agents sur une tâche séquentielle. Un swarm ne peut pas paralléliser une chaîne de pensée.
• Utiliser K3 là où K2.6 suffit. Toutes les tâches n'ont pas besoin de 2,8 billions de paramètres.

Conclusion

La plupart des gens ouvriront Kimi, taperont une question, fermeront l'onglet. C'est la boîte de chat. Cela représente environ 10 % de ce que K3 fait.

Les 90 % restants sont une équipe de recherche que vous construisez une fois et que vous rejouez à l'infini. Chaque niveau débloque plus de levier : d'abord l'exécution, puis la confiance, puis l'accumulation, puis l'autonomie. Vous n'avez pas besoin des quatre dès le premier jour. Commencez au niveau 1 avec un cahier des charges. Si la sortie est utile, passez au niveau 2 et vérifiez-la. Si vous prévoyez de l'exécuter à nouveau, sauvegardez la compétence (Skill). Le système s'améliore tout seul à partir de là.

Rédigez le cahier des charges, pas le prompt. Vérifiez avant de sauvegarder. Ensuite, regardez chaque exécution devenir moins chère et plus précise que la précédente.