# Muse Code et Muse IA : analyser vos documents puis coder une application avec Meta

> Prenez en main Muse Code, l'agent de code de Meta, et Muse IA : installation, AGENTS.md, modèles Muse Spark, niveaux d'effort, skills et erreurs à éviter.

- URL : https://guides-numeriques.fr/ia/muse-ia-muse-code/
- Thématique : IA générative & agents
- Mis à jour : 2026-10-22
- Formation associée : [Guide Complet Muse IA & Muse Code : De l'Analyse au Développement](https://espritacademique.com/formations/guide-complet-muse-ia-muse-code-de-l-analyse-au-developpement/)

## L'essentiel

- Muse Code est l'agent de code de Meta : il s'utilise dans le terminal, planifie, modifie les fichiers et exécute des commandes, avec des autorisations et un bac à sable activés dès le premier lancement.
- Muse Code fonctionne sous macOS, Linux et Windows et s'appuie sur les modèles Muse Spark de Meta, dont la version 1.3 publiée le 2 septembre 2026.
- Muse, souvent appelé Muse IA, est l'agent personnel grand public de Meta, lancé le 8 septembre 2026 sur iOS, Android et le site muse.ai, d'abord aux États-Unis.
- Muse Code lit le fichier AGENTS.md du projet (et CLAUDE.md s'il existe) ; la commande muse init en crée une première version.
- Le niveau d'effort de raisonnement de Muse Code se règle avec la commande /effort, de minimal à ultra, et le modèle avec /models.

**Muse Code** est l'agent de code de Meta : vous lui décrivez une tâche en langage naturel dans votre terminal, il explore le projet, propose un plan, modifie les fichiers, lance les commandes et vérifie le résultat, en vous demandant votre accord pour les actions sensibles. Il s'appuie sur Muse Spark, la famille de modèles de Meta, et complète Muse (souvent appelé « Muse IA »), l'agent personnel grand public de Meta.

Ce guide s'adresse aux professionnels, analystes, créateurs d'applications et développeurs qui veulent découvrir ces deux outils dans l'ordre logique : d'abord Muse IA pour analyser des données, des images et des PDF, puis Muse Code pour construire une application. Vous saurez installer et configurer Muse Code, l'utiliser depuis VS Code, choisir le modèle et le niveau d'effort, et le cadrer avec des règles et des skills.

Un point de vigilance avant de commencer : ces produits sont très récents (été et automne 2026) et évoluent chaque semaine. Nous nous appuyons ici sur la documentation officielle de Meta ; vérifiez-la en cas de doute sur une commande.

## Muse IA, Muse Code, Muse Spark : qui fait quoi chez Meta ?

**Muse** est une famille de produits d'intelligence artificielle de Meta, conçue par Meta Superintelligence Labs. Le nom désigne à la fois l'agent personnel grand public Muse (que beaucoup appellent Muse IA), l'agent de développement Muse Code et les modèles qui les animent, comme Muse Spark. Ce partage de nom crée des confusions qu'il vaut mieux lever d'entrée.


**Schéma — L'écosystème Muse de Meta en un coup d'œil**

Écosystème Muse :
- **Muse (Muse IA)** : Agent personnel : web muse.ai, iOS, Android
- **Muse Code** : Agent de code dans le terminal et en CI
- **Muse Spark** : Famille de modèles, version 1.3 la plus récente
- **Muse Wonder** : Modèle le plus avancé de Meta, en préversion
- **Meta AI** : Assistant de questions-réponses de Meta
- **Meta Model API** : Accès aux modèles pour les développeurs


| Nom | Ce que c'est | Pour qui |
|---|---|---|
| **Muse** (Muse IA) | Agent personnel : il répond et réalise des tâches, sur le web (muse.ai), iOS et Android | Grand public, professionnels |
| **Muse Code** | Agent de code en ligne de commande, pour le terminal et l'intégration continue | Développeurs, profils techniques |
| **Muse Spark** | Famille de modèles de langage de Meta (versions 1.1, 1.2, 1.3) | Utilisés par Muse, Muse Code et la Meta Model API |
| **Muse Wonder** | Modèle le plus avancé de Meta, en préversion, pour les tâches longues et complexes | Selon les offres |
| **Meta AI** | Assistant conversationnel de Meta, pour poser des questions et créer des images | Utilisateurs des applications Meta |

Quelques repères chronologiques vérifiés : Muse Spark a été présenté en avril 2026. Muse Code est sorti en version bêta le 5 août 2026 avec le modèle Muse Spark 1.2, orienté programmation. Muse Spark 1.3, plus efficace sur les tâches agentiques et le code, est arrivé dans Muse Code le 2 septembre 2026. Enfin, l'agent personnel Muse a été lancé le 8 septembre 2026, d'abord aux États-Unis.

## Que peut faire Muse IA avec vos données, images et PDF ?

Meta décrit Muse comme un agent qui « fait le travail » au lieu de seulement répondre. Il fonctionne dans une machine virtuelle dédiée, avec son propre navigateur, peut poursuivre une tâche après la fermeture de l'application et demande votre accord avant d'envoyer un e-mail ou d'effectuer un achat. Il est accessible sur le site muse.ai, dans les applications iOS et Android, et par message dans WhatsApp.

Pour un usage professionnel, l'intérêt principal est l'analyse de documents. Les modèles Muse Spark acceptent en entrée du texte, des images, de la vidéo, de l'audio et des fichiers PDF, avec une fenêtre de contexte d'environ un million de tokens. Concrètement, trois usages reviennent sans cesse.

### Analyser un tableau de données

Joignez votre fichier de chiffres (ventes, dépenses, inscriptions) à une nouvelle discussion, puis guidez l'analyse. La qualité de la réponse dépend surtout de la précision de la demande :

```text
Voici l'export des ventes du premier semestre (une ligne par commande).
1. Décris la structure du fichier : colonnes, période couverte, anomalies.
2. Calcule le chiffre d'affaires par mois et par région.
3. Identifie les trois tendances les plus marquantes, chiffres à l'appui.
4. Signale toute valeur qui te semble incohérente au lieu de la corriger.
```

Notre conseil : demandez toujours à l'assistant de décrire le fichier avant de calculer. S'il se trompe sur le nom d'une colonne ou sur la période, vous le voyez tout de suite, avant de vous fier à une synthèse fausse.

### Lire et interpréter une image

Une capture d'écran de tableau de bord, une photo de tableau blanc, un schéma technique ou un graphique scanné : Muse peut en extraire le contenu et le commenter. Demandez une transcription d'abord (« recopie les chiffres visibles »), puis l'interprétation. Cette séparation limite les erreurs de lecture.

### Analyser et comparer des PDF

C'est l'usage le plus rentable au quotidien : comparer deux devis, deux contrats ou deux offres. Joignez les deux fichiers et imposez une grille :

```text
Compare ces deux devis dans un tableau : prix total HT et TTC, détail des
postes, délais, conditions de paiement, garanties, exclusions.
Indique pour chaque ligne la page où se trouve l'information.
Termine par les points à négocier et les informations manquantes.
```

Exiger la page source de chaque information est un réflexe essentiel : il vous permet de vérifier en quelques secondes les points décisifs. Pour approfondir la rédaction de ce type de consignes, les principes de notre guide sur les [prompts ChatGPT efficaces](https://guides-numeriques.fr/ia/prompt-chatgpt/) s'appliquent tels quels à Muse.

## Muse Code : qu'est-ce que l'agent de code de Meta ?

Muse Code est l'agent de programmation de Meta, pensé pour le terminal et l'intégration continue et optimisé pour les modèles Muse Spark. Lancé dans un dossier de projet, il planifie, modifie les fichiers et exécute des commandes pour mener une tâche à bien, avec un système d'autorisations et un bac à sable du système d'exploitation activés dès le premier lancement.

Ce qui le distingue d'un simple assistant de chat :

- **Il agit dans vos fichiers** : il lit le code, écrit les modifications, lance les tests et le build, lit les erreurs et corrige.
- **Il travaille en équipe d'agents** : Muse Code fait tourner des agents d'observation en arrière-plan et peut confier des sous-tâches à des agents enfants, chacun dans sa propre copie de travail Git si vous l'activez.
- **Il garde une trace** : chaque session est journalisée localement, ce qui permet de reprendre une session interrompue ou de revenir en arrière.
- **Il fonctionne aussi sans interface** : la commande `muse exec` exécute une consigne jusqu'au bout, pour les scripts et la CI.

Le réflexe à adopter est le même qu'avec les autres agents de code : votre rôle devient celui d'un responsable technique qui définit le besoin, valide le plan et relit le résultat.

## Comment installer et utiliser Muse Code : les étapes

Fil rouge : une petite application web de suivi de dépenses, créée de zéro puis enrichie.


**Schéma — Démarrer avec Muse Code en 6 étapes**

1. **Installer** : Script officiel : curl (macOS, Linux) ou irm (Windows)
2. **Se connecter** : Connexion par le navigateur ou clé API Meta
3. **Faire confiance au dossier** : Charge les règles, skills et hooks du projet
4. **Créer AGENTS.md** : muse init, puis vos commandes et conventions
5. **Régler modèle et effort** : /models et /effort selon la tâche
6. **Planifier puis construire** : /plan, validation du plan, puis exécution


### Étape 1 — Installer Muse Code

La [documentation officielle de Muse Code](https://dev.meta.ai/docs/muse-code) fournit un script d'installation par système. Sous macOS et Linux :

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

Sous Windows, dans PowerShell :

```powershell
irm https://dev.meta.ai/install.ps1 | iex
```

Vérifiez ensuite l'installation :

```bash
muse --version
```

N'utilisez que ces commandes issues du domaine de Meta. Des sites aux noms proches imitent les pages officielles : un script d'installation exécuté depuis une source douteuse a accès à toute votre machine.

### Étape 2 — Configurer la connexion

Placez-vous dans le dossier de votre projet et lancez `muse`. Au premier démarrage, Muse Code vous propose deux méthodes d'authentification : une **connexion par le navigateur** ou le **collage d'une clé API** Meta. La commande `/login` rouvre ces options à tout moment, `muse logout` efface les identifiants enregistrés. Pour un serveur d'intégration continue, on fournit plutôt la clé dans la variable d'environnement `META_API_KEY`.

Côté facturation, deux modes coexistent : le paiement au token via un compte Meta Model API, ou un abonnement Muse Code à tarif mensuel fixe, qui nécessite un compte Meta. Attention : les abonnements sont réglés par défaut en **mode Contributor**, qui donne davantage d'utilisation en échange de l'utilisation de vos contenus pour entraîner les modèles de Meta. Sur un code client ou confidentiel, désactivez ce mode dans les réglages avant de travailler.

### Étape 3 — Faire confiance au dossier et régler les autorisations

Muse Code vous demande ensuite si vous faites confiance à ce dossier. Accepter charge les règles, skills et hooks propres au projet ; sur un dépôt récupéré d'une source inconnue, lisez ces fichiers avant d'accepter.

Les autorisations reposent sur des profils. Par défaut, un **relecteur automatique** valide les actions courantes et vous renvoie la décision quand il ne peut pas trancher. Vous pouvez choisir un profil où vous validez tout, un profil en lecture seule pour explorer un projet sans risque, ou un profil sans restriction, à réserver aux environnements isolés. Le bac à sable limite les écritures au dossier de travail et à un dossier temporaire.

### Étape 4 — Intégrer Muse Code dans VS Code

Meta ne documente pas d'extension VS Code officielle pour Muse Code. La méthode fiable consiste à l'utiliser dans le **terminal intégré** de VS Code :

1. Ouvrez le dossier du projet dans VS Code (Fichier > Ouvrir le dossier).
2. Ouvrez le terminal intégré (Affichage > Terminal).
3. Lancez `muse` : l'agent travaille sur le dossier ouvert, et vous voyez les fichiers changer dans l'explorateur.
4. Utilisez la vue Contrôle de code source de VS Code pour relire chaque modification avant de la valider dans Git.

Cette organisation donne le meilleur des deux mondes : l'agent dans le terminal, le code et les différences sous vos yeux. Vous pouvez aussi coller ou glisser une image (maquette, capture d'erreur) dans la zone de saisie de Muse Code : elle est transmise au modèle.

### Étape 5 — Premier lancement et commandes clés

Dans une session, les commandes commencent par une barre oblique. Celles à connaître dès le premier jour :

| Commande | Rôle |
|---|---|
| `/help` | Afficher toutes les commandes disponibles dans votre espace de travail |
| `/new` ou `/clear` | Repartir d'une conversation vierge |
| `/resume` | Reprendre une session précédente |
| `/compact` | Résumer une session devenue longue |
| `/rewind` (ou Échap deux fois) | Revenir à un état antérieur de la conversation |
| `/plan` | Obtenir un plan qui attend votre validation avant toute modification |
| `/goal` | Fixer un objectif que l'agent poursuit sur plusieurs étapes |
| `/models` et `/effort` | Changer de modèle et de niveau d'effort |

La touche Échap interrompt le tour en cours ; Entrée pendant que l'agent travaille injecte une précision dans la tâche en cours, Alt+Entrée la met en file pour le tour suivant.

### Étape 6 — Choisir le modèle et le niveau d'effort

Le **modèle** se change avec `/models` en cours de session, ou avec l'option `--model` au lancement. La documentation de Muse Code indique `muse-spark-1.2` comme modèle par défaut ; Muse Spark 1.3, recommandé par Meta pour les nouveaux travaux, est disponible dans Muse Code. Selon votre abonnement, les modèles Muse Wonder peuvent aussi être proposés.

Le **niveau d'effort** règle la profondeur de raisonnement, au prix d'un temps de réponse plus long. Les niveaux documentés vont de `minimal` à `ultra` en passant par `low`, `medium`, `high` (le niveau par défaut), `xhigh` et `max`. On le change avec `/effort` ou au lancement :

```bash
muse --reasoning-effort medium
```

Notre règle pratique en formation : effort bas ou moyen pour les petites retouches (renommer, corriger un texte, ajouter un champ), effort élevé pour une nouvelle fonctionnalité, effort maximal pour un bug difficile ou une architecture à concevoir. Le sélecteur n'affiche que les niveaux pris en charge par le modèle actif.

### Étape 7 — Créer une première application

Commencez par initialiser Git, puis demandez un plan avant tout code :

```bash
mkdir suivi-depenses && cd suivi-depenses
git init
muse
```

```text
/plan Crée une application web de suivi de dépenses en React + TypeScript
avec Vite. Fonctionnalités : ajouter une dépense (date, montant, catégorie),
afficher la liste, filtrer par mois, total par catégorie. Données enregistrées
dans le navigateur. Interface en français, utilisable sur mobile.
Critère de fin : le build passe et tu m'expliques comment lancer l'application.
```

La skill `/plan` rédige un plan et attend votre accord sans toucher au code. Relisez-le, corrigez ce qui ne correspond pas au besoin, puis validez. Une fois l'application générée, lancez le serveur de développement dans le terminal, testez chaque fonctionnalité et faites un commit. Ensuite seulement, ajoutez la fonctionnalité suivante (export CSV, graphique, catégories personnalisées), une à la fois.

Si vous voulez comparer avec une approche sans installation, dans le navigateur, notre guide du [vibe coding](https://guides-numeriques.fr/ia/vibe-coding/) présente la méthode de l'idée au déploiement.

> **Formation recommandée** : [Guide Complet Muse IA & Muse Code : De l'Analyse au Développement](https://espritacademique.com/formations/guide-complet-muse-ia-muse-code-de-l-analyse-au-developpement/) — 1h30 de vidéo, 39 €.

## Règles et skills : adapter Muse Code à votre façon de travailler

Un agent sans consignes produit un code générique qui ignore vos conventions. Muse Code offre plusieurs mécanismes pour le cadrer, du plus simple au plus avancé.

### Le fichier AGENTS.md : les règles du projet

La commande `muse init` écrit un fichier **AGENTS.md** dans le dossier courant (avec `--dry-run` pour prévisualiser sans rien écrire). Complétez-le avec ce que l'agent doit savoir à chaque session :

```text
Projet : application de suivi de dépenses (React, TypeScript, Vite).

Commandes :
- Installer : npm install
- Développement : npm run dev
- Vérifier avant de terminer : npm run build

Conventions :
- Un composant par fichier dans src/components.
- Textes d'interface en français, code en anglais.
- Aucune nouvelle dépendance sans justification.

Règles :
- Jamais de clé ou de secret dans le code.
- Plus de trois fichiers touchés : proposer un plan d'abord.
```

Muse Code remonte du dossier de travail jusqu'à la racine du dépôt Git et lit à chaque niveau le premier fichier trouvé parmi AGENTS.md, CLAUDE.md, .agents/AGENTS.md et .claude/CLAUDE.md. Les règles du projet l'emportent sur vos règles personnelles, et les fichiers les plus profonds sur les plus hauts. Si votre dépôt contient déjà un CLAUDE.md, Muse Code le prend donc en compte.

### Les skills : des savoir-faire chargés à la demande

Une **skill** est un dossier contenant un fichier `SKILL.md` (et éventuellement des scripts ou des modèles). Les skills de projet se rangent dans `.agents/skills/` et se partagent avec l'équipe via Git ; les skills personnelles restent dans votre configuration utilisateur. Muse Code est livré avec des skills intégrées, dont `/plan`, `/grill` (qui met un plan à l'épreuve) et `/taste` (qui repère les choix visuels trop génériques).

La ligne de commande permet de les gérer :

```bash
muse skills list
muse skills validate ./ma-skill
muse skills import --from claude
```

La différence avec AGENTS.md est la même que chez les autres agents : AGENTS.md contient les règles permanentes, lues à chaque session ; une skill contient une procédure précise (revue de code, création d'un composant, rapport de version), chargée seulement quand elle sert. Votre contexte reste léger.

### Hooks, serveurs MCP et mémoire

- **Hooks** : des commandes exécutées automatiquement à des moments précis (début de session, avant ou après l'utilisation d'un outil). Ceux du projet se déclarent dans `.muse/hooks.json`. Ils s'exécutent hors du bac à sable : n'ajoutez que des hooks dont vous avez lu les commandes.
- **Serveurs MCP** : ils se déclarent dans le fichier de réglages utilisateur (`~/.config/muse/settings.json`) et donnent à l'agent l'accès à des outils externes. Ils ne sont pas confinés par le bac à sable : connectez uniquement des serveurs de confiance. Le protocole est présenté en détail dans notre guide [Claude Code et MCP](https://guides-numeriques.fr/ia/claude-code-mcp/).
- **Mémoire** : Muse Code tient des notes en Markdown, personnelles ou partagées dans le dépôt (`.agents/memory/`), avec un index `MEMORY.md`.

## Les erreurs fréquentes avec Muse Code (et comment les éviter)

| Erreur | Conséquence | Solution |
|---|---|---|
| Installer depuis un site qui imite Meta | Script non vérifié exécuté sur votre machine | Utiliser uniquement les commandes de dev.meta.ai |
| Laisser le mode Contributor sur un code confidentiel | Contenus utilisables pour entraîner les modèles de Meta | Désactiver le mode Contributor dans les réglages |
| Faire confiance à un dépôt inconnu sans le lire | Règles, skills et hooks d'un tiers chargés | Lire AGENTS.md, skills et hooks avant d'accepter |
| Travailler sans Git | Impossible de revenir à une version stable | git init dès le départ, un commit par étape validée |
| Effort maximal pour tout | Réponses lentes et consommation inutile | Adapter l'effort à la difficulté de la tâche |
| Une seule session pour tout le projet | Contexte saturé, réponses moins précises | /new entre deux tâches, /compact si besoin |
| Profil sans restriction sur un projet réel | Commandes exécutées sans contrôle ni bac à sable | Le réserver à un conteneur isolé et jetable |

En formation, l'erreur la plus fréquente est de valider le plan sans le lire. C'est pourtant à ce stade qu'on repère une mauvaise compréhension du besoin, pas après dix fichiers modifiés.

## Muse Code vs Claude Code vs Codex : comparaison

Muse Code arrive sur un terrain déjà occupé par Claude Code et OpenAI Codex. Voici les différences vérifiables à la date de ce guide.

| Critère | Muse Code | Claude Code | OpenAI Codex |
|---|---|---|---|
| Éditeur | Meta | Anthropic | OpenAI |
| Modèles | Muse Spark, Muse Wonder selon l'offre | Claude | Modèles OpenAI |
| Où l'utiliser | Terminal et CI, sous macOS, Linux et Windows | Terminal, extensions IDE, application, web | CLI, extension VS Code, cloud |
| Extension VS Code officielle | Non documentée (terminal intégré) | Oui | Oui |
| Fichier de consignes | AGENTS.md (lit aussi CLAUDE.md) | CLAUDE.md | AGENTS.md |
| Extensions | Skills, hooks, serveurs MCP, plugins | MCP, skills, hooks, plugins, sous-agents | MCP, skills |

Le point le plus original de Muse Code est sa compatibilité avec l'existant : il lit un CLAUDE.md, reconnaît les dossiers de skills de Claude Code et de Codex, et peut importer leurs skills. Passer d'un agent à l'autre ne demande donc pas de tout réécrire.

Pour aller plus loin sur chaque concurrent, consultez nos guides consacrés à [Claude Code et au protocole MCP](https://guides-numeriques.fr/ia/claude-code-mcp/), à [OpenAI Codex](https://guides-numeriques.fr/ia/openai-codex/) et à l'éditeur [Cursor](https://guides-numeriques.fr/ia/cursor-ia/), qui intègre l'IA directement dans l'interface de code.

## Comment apprendre Muse IA et Muse Code ?

La progression que nous recommandons, en tenant compte de la nouveauté des outils :

1. **Muse IA d'abord** (une heure) : dialoguer avec l'agent, analyser un fichier de chiffres, une image, puis comparer deux PDF avec une grille imposée.
2. **Installation de Muse Code** (trente minutes) : script officiel, connexion, mode Contributor, confiance dans le dossier, terminal intégré de VS Code.
3. **Premier projet** (deux heures) : Git, AGENTS.md, plan validé, une fonctionnalité à la fois.
4. **Personnalisation** : modèles, niveaux d'effort, skills et hooks pour vos tâches récurrentes.
5. **Veille** : relire régulièrement le journal des modifications de Muse Code, car les commandes et les réglages évoluent vite.

Pour suivre ce parcours avec un formateur, [la formation vidéo sur Muse IA et Muse Code](https://espritacademique.com/formations/guide-complet-muse-ia-muse-code-de-l-analyse-au-developpement/) d'EspritAcadémique condense l'essentiel en une heure trente, sans prérequis. Elle couvre notamment :

- la découverte de l'assistant Muse et la façon de dialoguer efficacement avec lui ;
- l'analyse d'un tableau de chiffres, la lecture d'images et la comparaison de documents PDF ;
- l'installation de Muse Code, la connexion et son utilisation depuis Visual Studio Code ;
- les commandes essentielles d'une session, puis le choix du modèle et du niveau d'effort ;
- la réalisation complète d'une première application ;
- les règles et les skills pour adapter l'agent à vos propres consignes.

## En résumé

Muse IA et Muse Code couvrent deux usages complémentaires de l'écosystème de Meta : l'agent personnel Muse pour analyser vos données, images et PDF, et Muse Code pour développer dans le terminal, y compris celui de VS Code. Installez Muse Code uniquement depuis les pages de Meta, vérifiez le mode Contributor, versionnez avec Git et exigez un plan avant chaque fonctionnalité. AGENTS.md, le choix du modèle et du niveau d'effort, puis les skills feront ensuite de l'agent un collaborateur adapté à votre façon de travailler.

## Sources et documentation officielle

- [Muse Code overview (Meta Model API docs, Meta)](https://dev.meta.ai/docs/muse-code)
- [Muse Code : configuration and context (Meta Model API docs, Meta)](https://dev.meta.ai/docs/muse-code/configuration)
- [Muse Code : extending and automating (Meta Model API docs, Meta)](https://dev.meta.ai/docs/muse-code/extending)
- [Introducing Muse, personal AI agent (Meta Newsroom)](https://about.fb.com/news/2026/09/introducing-muse)

## Questions fréquentes

### Muse Code est-il gratuit ?

Non. Muse Code consomme des tokens facturés via un compte Meta Model API, ou s'utilise avec un abonnement Muse Code à tarif mensuel fixe. Meta propose quatre formules d'abonnement, de l'usage courant à l'usage maximal. Par défaut, ces abonnements sont en mode Contributor : Meta peut utiliser vos contenus pour entraîner ses modèles, une option désactivable dans les réglages. Consultez la page tarifs officielle de Meta pour les prix à jour.

### Muse IA est-il disponible en France ?

Meta a lancé son agent personnel Muse le 8 septembre 2026 avec un déploiement annoncé d'abord aux États-Unis, sur iOS, Android et le site muse.ai. L'annonce officielle ne donne pas de calendrier pour la France. Vérifiez la disponibilité directement sur muse.ai ou dans votre magasin d'applications. Muse Code, l'outil pour développeurs, est distinct : ses offres et avantages peuvent varier selon la région.

### Quelle différence entre Muse et Meta AI ?

Meta AI est l'assistant conversationnel de Meta, pensé pour poser des questions et créer des images dans ses applications. Muse est présenté par Meta comme un agent personnel : il ne se contente pas de répondre, il réalise des tâches, dans une machine virtuelle dédiée, et demande votre accord avant les actions sensibles comme un envoi d'e-mail ou un achat. Les deux s'appuient sur les modèles Muse Spark.

### Existe-t-il une extension Muse Code pour VS Code ?

La documentation officielle de Meta ne présente pas d'extension VS Code pour Muse Code. L'outil est un agent en ligne de commande : on l'utilise dans le terminal intégré de VS Code, en lançant la commande muse dans le dossier du projet. Méfiez-vous des extensions et des sites qui imitent les pages officielles : installez uniquement depuis les pages de Meta.

### Muse Code fonctionne-t-il sous Windows ?

Oui. Muse Code fonctionne sous macOS, Linux et Windows. Sous Windows, il s'installe depuis PowerShell et les commandes lancées par l'agent utilisent la syntaxe PowerShell. Le bac à sable peut afficher une demande de contrôle de compte d'utilisateur au premier lancement, et la saisie vocale comme la messagerie entre sessions ne sont pas disponibles sur ce système.

### Quelle différence entre Muse Code et Claude Code ?

Les deux sont des agents de code qui travaillent dans votre projet depuis le terminal, avec skills, hooks et serveurs MCP. Muse Code est développé par Meta, utilise les modèles Muse Spark et lit le fichier AGENTS.md. Claude Code est développé par Anthropic, utilise les modèles Claude, lit CLAUDE.md et propose une extension officielle pour VS Code. Muse Code sait aussi lire un CLAUDE.md existant et importer des skills de Claude Code.

### Faut-il savoir programmer pour utiliser Muse Code ?

Non, mais quelques bases aident beaucoup. Muse Code écrit le code à votre place et peut créer une application à partir d'une description. Pour vérifier son travail, il faut toutefois savoir ouvrir un dossier dans VS Code, lancer une commande dans un terminal et utiliser Git pour revenir en arrière. Ces notions s'apprennent en quelques heures de pratique guidée.