Démarrage rapide

Mets Muse Code en route en quelques minutes.

Muse Code est désormais disponible en version finale pour macOS et Linux, et tourne sous Windows via WSL2. Il prend en charge des tâches d’ingénierie logicielle complexes dans de grands dépôts — planifier les changements, écrire le code et valider les résultats — sans quitter ton terminal.

1. Installation

Une seule commande installe la CLI :

$curl -fsSL https://dev.meta.ai/install.sh | bash

Le script place le binaire muse dans ton PATH — vérifie avec muse --version. Tu préfères examiner le script d’abord ? Télécharge-le avec -o install.sh, audite-le, puis exécute-le.

Windows (via WSL2)

Il n’existe pas de version native pour Windows — l’installeur prend en charge macOS et Linux. Sous Windows 10 ou 11, lance wsl --install dans un PowerShell administrateur pour installer WSL2 avec Ubuntu, ouvre le shell Linux et exécute-y le même installeur en une ligne. Garde tes dépôts sur le système de fichiers Linux (par exemple ~/code) plutôt que sous /mnt/c : l’accès aux fichiers d’un système à l’autre est bien plus lent.

2. Authentification

Au premier lancement, le navigateur s’ouvre pour t’authentifier sur dev.meta.ai avec ton compte développeur Meta. Les identifiants sont mis en cache localement — pas de ré-authentification à chaque session. L’usage est facturé sur ton forfait mensuel ou, en paiement à l’usage, via la Meta Model API.

Exécutions non interactives. Pour la CI, les scripts et les machines headless, utilise une clé API à la place du flux navigateur : crée-la dans le tableau de bord de la Model API (API keys → Create API key) et définis-la comme MODEL_API_KEY.

3. Lance ta première tâche

Une fois l’authentification faite, tu peux démarrer dans n’importe lequel de tes répertoires de projet :

$ cd my-repo$ muse

Décris le résultat que tu veux en langage naturel. Une bonne première tâche est petite et vérifiable — « ajoute le test manquant pour parseDate et assure-toi qu’il passe » — tu verras un worker rédiger le changement, un reviewer le critiquer et le test s’exécuter.

Deux leviers de coût à connaître dès le premier jour : Muse Spark est un modèle de raisonnement — il réfléchit avant de répondre, et ces tokens sont facturés en sortie — /effort ajuste donc la réflexion à la hausse ou à la baisse selon la tâche. Quant au ton, au format et à tes autres règles permanentes, place-les dans un message système pour ne pas les répéter dans chaque prompt.

Agents asynchrones en arrière-plan

Muse Code fonctionne avec une boucle d’agent simple, complétée par un ensemble d’agents asynchrones en arrière-plan qui renforcent l’agent principal. Ces agents spécialisés restent actifs pendant toute la session au lieu d’être créés à chaque tâche, ce qui évite de collecter plusieurs fois les mêmes informations. Ils mènent les étapes suivantes de leur propre initiative et choisissent quand faire remonter l’information à l’agent principal — leur persistance réduit la latence et le besoin de pilotage sur les tâches difficiles en plusieurs étapes.

Fan-out d’agents et worktrees git

Quand un travail se découpe en plusieurs tâches, celles-ci sont automatiquement réparties entre des agents distincts : le parent crée un agent enfant avec droits d’écriture par tâche, et chaque enfant reçoit son propre git worktree — les enfants qui tournent en parallèle n’entrent jamais en collision sur les mêmes fichiers, et ta copie de travail reste propre.

Workflows

Arrivés avec la sortie de bêta de Muse Code, les Workflows orchestrent une équipe d’agents spécialisés sur un travail plus conséquent : chaque étape transmet son travail intermédiaire à la suivante, et tu obtiens un résultat unique à la fin. Pour en lancer un, demande à Muse Code d’« utiliser un workflow » ; régler l’effort sur ultra peut en déclencher un automatiquement. /workflows affiche chaque exécution en direct — tu peux l’y arrêter, la relancer ou l’annuler — et les workflows enregistrés sont réutilisables.

Messagerie entre sessions

Les sessions qui tournent sur la même machine peuvent s’envoyer des messages via un socket Unix local. Quand un changement dans une session touche ce qu’une autre est en train de construire, elle lui transmet un avertissement ; quand une session tranche une question qui en bloquait une autre, elle lui envoie la réponse — plus besoin de retaper quoi que ce soit d’un terminal à l’autre. L’agent découvre ses pairs et envoie des messages grâce à deux outils intégrés.

Event log et retour arrière

Muse Code utilise un event log local auquel s’ajoutent chaque appel au modèle, chaque exécution d’outil, chaque approbation et chaque édition. Cette source de vérité unique rend le runtime rejouable à l’identique et sûr au redémarrage : après un crash, l’agent reprend exactement là où il s’était arrêté, ce qui lui permet d’assumer des tâches de longue durée sans dérailler à la moindre panne. Chaque création, chaque recadrage et chaque annulation de sous-agent est observable — muse replay parcourt une session pas à pas, et les traces complètes s’exportent pour une passation ou un audit. Appuie deux fois sur Esc pour ramener la conversation à un point antérieur ; Muse Code ne propose que les points de retour que l’event log marque comme sûrs.

Skills et commandes intégrées

Muse Code est livré avec plusieurs skills par défaut — tu y mets une idée brute, tu en sors une fonctionnalité passée au gril et validée :

/planTransforme une tâche en plan soumis à approbation avant de toucher au code

/grillMet le plan sous pression jusqu’à ce qu’il tienne la route

/goalTravaille jusqu’à l’accomplissement de l’objectif fixé — ce que tu voulais au départ est ce qui finit mergé

/workflowsListe les exécutions de workflows en direct — arrête, relance ou annule n’importe laquelle

/modelChange le modèle sous-jacent — p. ex. vers muse-spark-1.3 au tarif standard de la Model API

/effortAjuste le raisonnement à la hausse ou à la baisse — les tokens de réflexion sont facturés en sortie, réserve donc le raisonnement profond aux tâches difficiles

Esc EscRamène la conversation à un point sûr de l’event log

muse replayParcourt l’event log d’une session pas à pas ; les traces complètes s’exportent pour une passation ou un audit

Muse Spark 1.3

Muse Spark 1.3, sorti le 2 septembre 2026, est le modèle qui fait tourner Muse Code. Il conserve la recette d’entraînement qui distinguait 1.2 — co-entraînement avec le harness de Muse Code, travail intensif à long horizon et boucle d’auto-amélioration — et se concentre sur l’utilisabilité en conditions réelles. Le tarif est inchangé par rapport à 1.2. Trois choses se démarquent :

Des fils plus longs

Tient un travail à plus long horizon sur plusieurs workflows dans un seul fil, en transportant le contexte d’une étape à l’autre.

Demande au lieu de deviner

Collabore plus activement : il pose des questions de clarification, signale quand il est bloqué et évalue mieux ses propres limites, au lieu d’annoncer des résultats qu’il n’a pas atteints.

Des exécutions plus sobres

Dans les comparaisons des ingénieurs de Meta, il a bouclé le même travail de code avec environ 20 % d’appels d’outils et 25 % de tokens en moins que 1.2 — au même prix par token, la facture est donc plus légère.

Benchmarks (configuration de raisonnement maximale, selon Meta) : DeepSWE 1.1 · 75,4 % — Terminal-Bench 2.1 · 88,8 % — SWEAtlas CodeBase QnA · 59,4 %. Au lancement, la configuration maximale était encore en tests de sécurité ; la configuration dont dispose la plupart des développeurs obtient des scores plus bas. Méthodologie sur research.meta.ai.

Étude de cas : optimisation de kernels

Meta a testé la capacité de Muse Spark 1.2 à optimiser itérativement des kernels GPU sur plus de 1 000 appels d’outils — jusqu’à 24 heures. Dans l’environnement agentique de Muse Code, le modèle écrit, compile, profile et améliore progressivement la performance des kernels par rapport à une référence, mesurée sur les kernels KDA et MLA pour GPU NVIDIA Hopper. Interdit d’encapsuler des bibliothèques de kernels tierces, il a implémenté les algorithmes directement en Triton — et n’a cessé de trouver des améliorations substantielles par rapport à la référence.

Meta Model API

Les modèles derrière Muse Code sont aussi accessibles en direct — Muse Spark 1.3 est disponible dans Muse Code, la Meta Model API, OpenRouter et Cursor. L’API est compatible sans modification avec l’OpenAI SDK, l’Anthropic SDK et les CLI d’agents comme OpenCode et Claude Code : pointe ton client vers la base URL et garde le reste de ton code tel quel. La fenêtre de contexte est de 1 048 576 tokens.

# export MODEL_API_KEY="LLM|{numeric_id}|{secret}"client = OpenAI( base_url="https://api.meta.ai/v1", api_key=os.environ["MODEL_API_KEY"], ) response = client.chat.completions.create( model="muse-spark-1.3", messages=[{"role": "user", "content": "Hello, world!"}], )

SDK Muse Code

Proposé en préversion pour les développeurs depuis la sortie de bêta de Muse Code, le SDK permet aux équipes de construire leurs propres agents sur le Muse Session Protocol (MSP) — un protocole ouvert qui passe par les entrées/sorties standard, sans serveur ni réseau : tout reste sur ta machine. La bibliothèque TypeScript couvre les sessions, les outils et le contrôle des permissions, et le schéma lisible par machine de MSP te permet de générer des clients dans d’autres langages. Code source : github.com/meta-models/muse-code-sdk.

Cookbook

Des recettes qui tournent dès la première copie — chacune résout un problème précis, montre du code qui fonctionne et indique la suite. Trois sections, plus des recettes pour les patterns clés de Muse Code.Parcourir les 28 recettes →

Fondamentaux de l’API · 10 recettes

Vérifie que chaque primitive fonctionne : chat completions, streaming, appels d’outils, sortie structurée, prompt caching, tokens de raisonnement, entrée vision, contexte long, gestion des erreurs et search grounding avec citations en ligne.

Patterns d’agents · 5 recettes

Les boucles qui transforment un modèle en agent : la boucle percevoir-décider-agir, le raisonnement entrelacé avec l’usage d’outils, la gestion de contexte multi-tours et les éditions sur place validées.

Cas d’usage · 13 recettes

De bout en bout : design web et développement de jeux vérifiés dans le navigateur, un studio produit multi-agents à quatre profils coordonné via un tableau Kanban partagé, un bot GitHub Actions autonome sur OpenCode, l’usage de l’ordinateur sous Linux et macOS, et plus encore.

Recettes Muse Code

Fan-out d’agents — répartis un gros travail entre des sous-agents dans des worktrees isolés ; skills intégrées — une idée brute en entrée, une fonctionnalité passée au gril et validée en sortie ; suivi d’objectif — garde un agent sur sa tâche jusqu’à ce qu’il merge ce que tu voulais.