Démarrage rapide

Mets Muse Code en route en quelques minutes.

Muse Code est désormais disponible en version finale pour macOS, Linux et Windows. 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

Windows dispose de son propre installeur natif : lance irm https://dev.meta.ai/install.ps1 | iex dans PowerShell, puis vérifie avec muse --version. Sous Windows, l’agent exécute les commandes dans PowerShell plutôt que dans Bash, le sandbox peut afficher une invite UAC à son premier démarrage, et ni la saisie vocale ni la messagerie entre sessions ne sont disponibles. Si tu en as besoin, ou si tu veux une chaîne d’outils Bash, passe plutôt par WSL2 : lance wsl --install dans un PowerShell administrateur, puis exécute l’installeur macOS/Linux dans le shell Linux. Garde alors tes dépôts sur le système de fichiers Linux (par exemple ~/code), pas sous /mnt/c, car 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), puis exporte-la dans META_API_KEY ou enregistre-la avec muse auth set. Les clés commencent par LLM_. Muse Code regarde d’abord META_API_KEY, puis une clé enregistrée, et enfin une session navigateur ; /login rouvre les options de connexion et muse logout efface les identifiants enregistrés.

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.

Mise à jour et désinstallation

Muse Code se met à jour tout seul : l’installeur met en place un lanceur qui garde le binaire à jour et, depuis la CLI 1.4.11, une session restée ouverte pendant une mise à jour automatique reprend avec son historique. Vérifie ta version avec muse --version et compare-la au changelog ; relancer la commande d’installation te donne aussi la dernière build. Meta ne documente pas de commande de désinstallation. Sur macOS et Linux, l’installeur place le lanceur dans ~/.local/bin (muse, plus des fichiers versionnés muse-bin-*) et ajoute ce répertoire au profil de ton shell : il suffit de supprimer ces fichiers pour désinstaller. Les réglages se trouvent dans ~/.config/muse/. Sous Windows, Get-Command muse indique où se trouve le binaire. Si tu as un abonnement, résilie-le à part dans Accounts Center — supprimer la CLI n’arrête pas la facturation.

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-wonder-1.0 ; le sélecteur règle aussi le niveau de raisonnement
/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

Permissions et modes d’approbation

Au démarrage, Muse Code active les approbations et un sandbox au niveau du système (Seatbelt sur macOS, bubblewrap sur Linux, le sandbox Windows sous Windows). Les écritures sont limitées à l’espace de travail et à un répertoire temporaire, et .git, .muse et .agents restent en lecture seule. Les nouvelles sessions démarrent avec le profil Auto-review : un juge intégré tranche les demandes d’approbation courantes et te laisse le reste ; les autres profils sont Ask me, Read-only et Unrestricted. Le profil par défaut se règle avec permissions.default_profile dans ~/.config/muse/settings.json. Les options qui comptent :

--approval-mode on-requestPar défaut. Les étapes shell sans risque s’exécutent ; les dangereuses, comme rm -rf, s’arrêtent pour validation
--approval-mode untrustedPlus strict : toute étape shell sans règle d’autorisation correspondante s’arrête pour validation
--approval-mode neverRien ne s’arrête pour approbation ; seul le sandbox contient ce qui s’exécute
--disable-approvalSupprime les demandes d’approbation mais garde le sandbox actif
--yoloNi approbations ni sandbox, espace de travail considéré comme fiable. Meta recommande de ne l’utiliser que dans des conteneurs isolés et jetables
--sandbox-networkproxy-only (par défaut, approuve chaque destination), restricted ou unrestricted

Quand une commande est mise en attente, tu peux l’autoriser une fois, l’autoriser toujours dans cet espace de travail ou la refuser. Les outils MCP et les hooks tournent hors du sandbox : ne connecte que des serveurs de confiance.

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.

Muse Wonder

Muse Wonder et Muse Wonder Full, sortis le 12 octobre 2026, sont les premiers modèles frontière de Meta : plus grands que Muse Spark, ils visent les tâches longues et difficiles, en code comme dans des domaines tels que le droit ou la finance. Meta met en avant Active Memory, qui conserve le contexte utile d’une conversation à l’autre, et Active Focus, qui maintient un agent sur son objectif et le fait revenir vers toi avant toute action importante. Passe sur Wonder avec /model muse-wonder-1.0 ; via l’API, il coûte $4 / $0.20 / $20 par million de tokens en entrée / en cache / en sortie, sans variante Contributor. Muse Wonder Full n’est inclus que dans les forfaits Power et Maximum.

Muse Spark Open

Sorti le 15 octobre 2026, Muse Spark Open est un modèle Muse à poids ouverts : 816B paramètres au total, dont 42B actifs par token, un contexte de 1M de tokens et des entrées texte, image, vidéo et audio. Il est publié sous la Muse Model License, une licence propre à Meta, et les poids sont sur Hugging Face sous meta-models/Muse-Spark-Open-816B-A42B. Ce n’est pas un modèle pour ordinateur portable : il lui faut environ 700 Go de mémoire d’accélérateur en NVFP4. Meta a montré Muse Code tournant dessus sur deux Mac Studio, sans documenter de configuration locale. Pour un modèle qui tient sur un seul GPU grand public, regarde plutôt Muse Glimmer.

É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` et `muse-wonder-1.0` sont proposés sur la Model API, et Muse Spark 1.3 est aussi 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_..."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!"}], )

Mode headless et CI

muse exec "<prompt>" exécute une tâche jusqu’au bout puis se termine — c’est la forme à utiliser dans les scripts et la CI. Ajoute --json pour obtenir des événements JSONL sur stdout, --prompt-file pour lire le prompt depuis un fichier, --max-model-steps pour plafonner le travail et --session-id pour reprendre une session précédente. Authentifie-toi avec META_API_KEY, tiré du coffre à secrets de ta CI. Un code de sortie 0 signifie que le tour est terminé, pas que le travail est correct : conditionne donc les merges à tes propres tests. Sur les runners Linux, le sandbox a besoin de bubblewrap et d’une build non musl.

# CI: key from your secret store, JSONL events on stdout$ META_API_KEY="$MUSE_KEY" muse exec --json "fix the failing test in tests/date.test.ts"

Les modèles Muse dans d’autres agents

Meta documente la configuration d’OpenCode, de Codex et de Claude Code avec la Model API. Utilise la base URL compatible OpenAI https://api.meta.ai/v1 (pour OpenCode et Codex) ou la base URL au format Anthropic https://api.meta.ai, sans /v1 (pour Claude Code), avec ta MODEL_API_KEY et un ID de modèle comme muse-spark-1.3 ou muse-wonder-1.0. Dans Claude Code, définis ANTHROPIC_AUTH_TOKEN plutôt que ANTHROPIC_API_KEY, et fais pointer chaque alias de modèle vers un modèle Muse pour que rien ne retombe sur Claude. Dans Codex, utilise wire_api = "responses" pour que le raisonnement soit conservé d’un tour à l’autre. Tout cela est facturé au token sur la Model API ; ton forfait Muse Code ne le couvre pas.

# Claude Code on Meta's Model APIexport ANTHROPIC_BASE_URL="https://api.meta.ai"export ANTHROPIC_AUTH_TOKEN="$MODEL_API_KEY"export ANTHROPIC_MODEL="muse-wonder-1.0"export ANTHROPIC_DEFAULT_OPUS_MODEL="muse-wonder-1.0"export ANTHROPIC_DEFAULT_SONNET_MODEL="muse-spark-1.3"export ANTHROPIC_DEFAULT_HAIKU_MODEL="muse-spark-1.3"export CLAUDE_CODE_SUBAGENT_MODEL="muse-spark-1.3"

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.