Meta lance Muse Code, le premier agent de programmation en terminal avec des agents à exécution prolongée et une option de réduction de 95 %

Le 5 août 2026, Meta a lancé son premier agent de programmation terminal, Muse Code, accompagné du modèle Muse Spark 1.2 spécialement optimisé pour la programmation. Muse Code peut lire de grandes bases de code, élaborer des plans de modification, écrire du code, exécuter des tests et valider les résultats, tout en permettant à plusieurs agents en arrière-plan de fonctionner en continu pendant toute la session, sans avoir à réinterpréter le projet à chaque nouvelle tâche. Meta a également conçu pour le système un journal d'événements local en ajout uniquement, sans possibilité de remplacement, permettant une reprise précise à l'endroit d'interruption même en cas de plantage. Ce qui a particulièrement suscité le débat parmi les développeurs, c'est le prix : la version standard coûte 1,25 $ pour un million de tokens d'entrée et 4,25 $ pour un million de tokens de sortie ; si les utilisateurs autorisent Meta à utiliser les entrées et sorties pour améliorer ses produits, la version « contributeur » descend à 0,10 $ et 0,20 $ respectivement. La contrepartie de ce prix réduit n'est pas une simple promotion, mais bien les données de code et d'utilisation. Les évaluations officielles montrent que Muse Spark 1.2 approche les meilleurs modèles de programmation, mais ne les dépasse pas encore pleinement, et certains résultats n'ont pas été indépendamment reproduits. Le signal envoyé par Meta est clair : l'unité de concurrence en programmation par IA passe désormais des modèles individuels à des systèmes complets composés de modèles, de frameworks d'exécution d'agents, d'états persistants et de boucles de données.

Auteur et source de l'article : Meta AI Research

Muse Code est le premier agent de programmation terminal lancé par Meta, actuellement disponible en version bêta pour macOS et Linux. Il ne vise pas la complétion de code, mais des tâches complètes d'ingénierie logicielle : entrer dans un grand dépôt de code, comprendre la structure existante, élaborer un plan, modifier plusieurs fichiers, exécuter des commandes et des tests, puis ajuster en fonction des résultats.

Cela place Muse Code directement sur le marché que des produits tels que Claude Code, Codex et Gemini CLI cherchent à conquérir. Le modèle ne se contente plus de répondre à la question « Comment écrire ce code ? », mais acquiert l'accès au terminal, au système de fichiers et aux outils de développement pour exécuter des tâches de manière continue avec moins d'intervention humaine.

Meta présente Muse Code et Muse Spark 1.2 comme un système intégré, et non comme deux produits indépendants pouvant être séparés arbitrairement. Muse Spark 1.2 est chargé de la compréhension, du raisonnement et de la génération, tandis que Muse Code gère l'organisation du contexte, la planification des sous-Agents, l'appel des outils, la sauvegarde de l'état et la validation des résultats. Les deux ont été conjointement optimisés pendant la phase d'entraînement, ce qui signifie qu'un même modèle transféré dans un autre cadre d'Agent ne permettra probablement pas de reproduire les performances présentées par Meta.

La conception la plus différenciante de Muse Code est un ensemble d'agents d'arrière-plan qui s'exécutent de manière asynchrone.

Les systèmes multi-agents courants créent temporairement un assistant lorsqu'ils doivent exécuter une sous-tâche, par exemple pour rechercher des fichiers pertinents, analyser un échec de test ou étudier une dépendance spécifique. Une fois la tâche terminée, le contexte de cet assistant est généralement perdu ; la prochaine fois qu'un problème similaire se présente, le système peut à nouveau analyser les mêmes codes et recueillir de manière redondante les mêmes informations.

Les agents arrière-plan de Muse Code restent actifs tout au long de la session. Ils peuvent accumuler progressivement une compréhension de la base de code, avancer automatiquement vers les étapes suivantes et décider du moment où transmettre les résultats à l'agent principal. L'agent principal coordonne les objectifs, tandis que les agents arrière-plan peuvent étudier séparément différents modules, vérifier les tests, rechercher des relations d'appel ou valider des solutions d'implémentation.

Cette conception vise à résoudre un gaspillage courant dans les tâches longues : l'agent oublie répétitivement ce qu'il a déjà vu. Tant que l'état de l'agent en arrière-plan est conservé de manière fiable, il n'a pas besoin de relire la structure du projet à chaque étape, et l'utilisateur humain n'a pas à lui rappeler constamment « ce fichier a déjà été vérifié ».

Cependant, plusieurs agents modifiant simultanément le code peuvent entraîner des conflits, des problèmes de permissions et des coûts supplémentaires. L'article public de Meta ne divulgue pas complètement comment les tâches sont partitionnées, comment les modifications de code sont fusionnées, ni comment les autres agents évitent d'hériter des conclusions erronées en cas d'erreur d'un agent arrière-plan. Ainsi, les agents continus constituent une direction architecturale à surveiller, mais il est trop tôt pour juger de leur stabilité dans des projets d'équipe réels uniquement sur la base des démonstrations officielles.

Les agents de programmation à long terme font face à un problème bien réel : plus une tâche est longue, plus elle est susceptible de rencontrer des interruptions de réseau, des erreurs d'outils, des plantages de processus ou des dépassements de contexte. Si le système ne sauvegarde l'état actuel que dans la conversation du modèle, une seule défaillance peut entraîner la perte de plusieurs heures de travail.

Muse Code a créé un journal d'événements local pour cela. Chaque appel de modèle, exécution d'outil, approbation utilisateur et modification de fichier est écrit en mode ajout au journal ; les historiques déjà survenus ne sont pas directement remplacés par les états ultérieurs.

Meta appelle ce mécanisme « reproductibilité précise » et « sécurité de redémarrage ». Lorsqu'un Agent échoue en cours de route, le système peut reprendre le travail à partir des enregistrements d'événements, au lieu de deviner ce qui s'est produit précédemment. Cela transforme en réalité les Agents de programmation d'une conversation temporaire en un processus d'ingénierie plus proche d'un état persistant.

Muse Code intègre également plusieurs compétences appelables :/plangénère d'abord un plan d'exécution à valider par l'utilisateur ;/grillattaque et remet en question ce plan pour identifier les oublis, risques et hypothèses erronées ;/goalpermet à l'agent d'exécuter en continu l'objectif spécifié jusqu'à ce que les conditions de réussite soient remplies.

L'idée derrière ces fonctionnalités est claire : si l'IA doit accomplir des heures de travail d'ingénierie logicielle, il ne s'agit pas seulement de générer du code élégant à chaque étape, mais aussi de pouvoir sauvegarder l'avancement, accepter des revues, détecter les failles dans le plan et continuer à exécuter après une défaillance.

Muse Spark 1.2 est une version améliorée en programmation publiée moins d'un mois après la version 1.1. Meta affirme qu'elle a augmenté la puissance de calcul et la diversité des environnements d'entraînement pour les tâches de programmation, en ciblant principalement l'amélioration de la génération de code, le dépannage de problèmes complexes, la compréhension des bibliothèques de code et les processus de développement end-to-end.

La portée de l'entraînement ne se limite pas à la réparation de fichiers individuels, mais couvre également la génération de dépôts de code complets, des projets end-to-end de grande envergure et des tâches de recherche automatisées. Le modèle utilise des plans pour organiser les étapes de travail, maintient la direction grâce à des conditions cibles, et compresse les informations à mesure que le contexte s'agrandit, en conservant uniquement les données essentielles pour les étapes suivantes.

Meta fait également participer Muse Spark 1.1 à l'entraînement du prochain modèle. L'ancien modèle génère des environnements de programmation plus complexes et des modèles d'instructions, puis évalue les solutions candidates pour déterminer si elles répondent aux exigences, afin de produire en masse des données destinées à l'apprentissage de la version 1.2.

L'« amélioration de soi » mentionnée ici ne signifie toujours pas que le modèle modifie automatiquement ses poids sans contrôle humain. Une formulation plus précise serait que le modèle de la génération précédente est utilisé comme générateur et évaluateur de données pour aider l'équipe à élargir les données d'entraînement de la prochaine génération. Le flux de données, les runs d'entraînement et la publication finale du modèle restent sous le contrôle de Meta.

Plus important encore, Meta n'a pas entraîné séparément un modèle « capable d'écrire du code », mais a intégré dans l'entraînement les outils, la gestion des objectifs, la compression du contexte et les trajectoires des sous-agents de Muse Code. La capacité des futurs modèles de programmation dépendra probablement de plus en plus de la connaissance acquise dès la phase d'entraînement d'un cadre d'agent particulier.

Un cas fourni par Meta consiste à faire optimiser par Muse Spark 1.2 les noyaux KDA et MLA sur GPU NVIDIA Hopper dans l'environnement Muse Code. Le système doit écrire lui-même le code, le compiler, analyser les performances, puis le modifier itérativement en fonction des résultats.

Le test complet dure au maximum 24 heures, avec plus de 1000 appels d'outils. Les chercheurs interdisent au modèle d'importer directement des bibliothèques de noyaux tiers existantes et exigent qu'il implémente l'algorithme dans Triton et cherche de véritables améliorations de performance, plutôt que de simplement emballer des implémentations existantes comme ses propres résultats.

Dans la tâche KDA, le modèle combine des noyaux de préparation parallèles à l'intérieur des blocs avec un balayage séquentiel entre les blocs, tout en intégrant des optimisations spécifiques pour la décroissance accumulée avec portes. Dans la tâche MLA, il conçoit un pipeline Triton composé de deux noyaux et tente de réutiliser les représentations latentes KV partagées.

L'importance de ces cas ne réside pas dans un seul chiffre d'accélération, mais dans la capacité de l'Agent à maintenir l'objectif, à comprendre les données d'analyse de performance et à générer la prochaine série d'expériences après avoir subi des centaines d'échecs et de résultats intermédiaires. Si le système ne fonctionne de manière stable que pendant quelques dizaines de minutes, il ressemble davantage à un outil de complétion avancé ; il ne commence à approcher un Agent pouvant être chargé d'une recherche d'ingénierie que lorsqu'il parvient à progresser pendant 24 heures.

Les évaluations de Meta couvrent Terminal-Bench 2.1, DeepSWE 1.1, GDPVal-AA v2, MCP Atlas et des tests de programmation internes. Terminal-Bench 2.1 comprend 89 tâches à accomplir dans un environnement terminal ; DeepSWE 1.1 comprend 113 tâches issues de 91 dépôts de code, couvrant cinq langages de programmation.

Selon les graphiques publiés par Meta, Muse Spark 1.2 obtient 82,9 % avec Muse Code sur Terminal-Bench 2.1, soit un score inférieur aux 86,7 % de Claude Opus 5, mais supérieur à Codex et Grok Build dans leurs évaluations respectives. Sur DeepSWE 1.1, Muse Spark 1.2 atteint 59,3 %, sans obtenir la première place. Sur les 440 tâches d'ingénierie réelles internes à Meta, il obtient 70,6 %, toujours en dessous d'Opus 5.

Ces résultats indiquent que Muse Code entre dans la compétition des principaux agents de programmation, mais ne permettent pas de conclure que « Meta a largement surpassé Claude Code et Codex ».

OfficielDocument de méthode d'évaluationindique également que chaque modèle est associé à son propre produit Agent : Muse Spark utilise Muse Code, Claude utilise Claude Code, GPT utilise Codex, Gemini utilise Antigravity et Kimi utilise Kimi Code. Cette comparaison est plus proche d'un affrontement entre produits complets, mais ne permet pas de déterminer si les résultats proviennent du modèle ou du cadre Agent.

Meta reconnaît également que son environnement d'évaluation interne et ses invites ne sont peut-être pas optimisés de manière optimale pour les modèles propriétaires tiers. Les résultats de Muse Spark 1.2 sur Terminal-Bench n'ont pas encore été intégrés à la liste de vérification indépendante. Par conséquent, l'expression la plus prudente actuelle est : les tests internes de Meta indiquent qu'il est proche du niveau de pointe, mais une reproductibilité indépendante fait toujours défaut.

Muse Spark 1.2 Standard coûte 1,25 $ par million de tokens d'entrée, 0,15 $ pour les entrées en cache et 4,25 $ pour les sorties. Les entrées et sorties de cette version ne seront pas utilisées pour améliorer les produits Meta.

Un autre modèle est identifié commemuse-spark-1.2-contributor. Son prix pour un million de tokens d'entrée est de seulement 0,10 $, avec 0,002 $ pour les entrées en cache et 0,20 $ pour les sorties. Par rapport à la version standard, les entrées sont 92 % moins chères et les sorties environ 95 % moins chères.

Le prix est que les invites et les sorties du modèle de contributeur peuvent être utilisés par Meta pour améliorer ses produits. Pour les projets open source, les expériences personnelles ou les travaux ne contenant pas d'informations sensibles, il s'agit peut-être d'un échange très attrayant ; mais pour le code privé d'entreprise, les produits non encore publiés, les données clients, les configurations de clés et les projets soumis à des accords de confidentialité, il s'agit avant tout d'une question de gouvernance des données, et non de prix.

Les entreprises ne doivent pas supposer qu'il est approprié de confier l'ensemble du codebase aux contributeurs uniquement en raison du prix unitaire du token. L'autorisation d'utiliser les données pour l'entraînement doit être évaluée en fonction des conditions d'utilisation spécifiques de Meta, de la propriété du code, des contrats clients et des politiques internes de sécurité. Les versions standard et contribuée utilisent des capacités similaires, mais correspondent à deux relations de données totalement différentes.

Cela révèle également la véritable stratégie concurrentielle de Meta : elle ne cherche pas seulement à attirer les développeurs avec des prix bas, mais aussi à créer un nouveau cycle de données d'entraînement en exploitant les tâches, modifications, retours et résultats générés par les développeurs lorsqu'ils utilisent Muse Code. Les développeurs obtiennent un accès quasi gratuit aux agents, tandis que Meta pourrait acquérir des données plus précieuses que les codes publics sur GitHub — à savoir comment les tâches réelles sont décomposées, modifiées et validées.

Par le passé, l'évaluation des IA de programmation se basait principalement sur le nombre de problèmes que le modèle pouvait résoudre. Muse Code présente une autre logique de compétition : le modèle n'est qu'une partie du système ; la capacité du Agent en arrière-plan à maintenir l'état, à effectuer des appels d'outils de manière fiable, à reprendre les tâches, à compresser correctement le contexte, et à continuer à itérer après un échec, peut être plus importante que la simple capacité de générer du code en une seule tentative.

Meta a également indiqué qu'il lancera de plus grands modèles et davantage de fonctionnalités de cadre Agent à l'avenir. Cela signifie que Muse Spark 1.2 n'est pas le produit phare final, mais plutôt la première infrastructure complète de Meta pour le marché des Agent de programmation.