Muse Ember pour sous-agents de code : tarifs et configuration

Testez Muse Ember pour des sous-agents de programmation aux tâches bien délimitées, avec un modèle plus capable pour planifier et effectuer la revue finale. Gardez si possible l’entrée de chaque sous-agent sous 200K tokens : au-delà, Meta triple les tarifs de toute la requête. Ne remplacez pas votre modèle principal de développement sur la seule base d’un score de benchmark.

Au 2026-11-12, Meta propose muse-ember-1.0 via Model API et Muse Code. Le modèle a été lancé le 9 novembre. Il vise les appels répétés aux outils, les sous-tâches de programmation, le routage et l’extraction d’informations.

Quelles tâches confier à Muse Ember ?

Donnez à Ember une tâche précise, le contexte nécessaire et un résultat vérifiable. Laissez les exigences ambiguës, les décisions d’architecture et l’acceptation finale au modèle chargé de la planification.

Le guide du modèle de Meta recommande d’associer Ember à Muse Spark ou Muse Wonder. Le grand modèle planifie, tandis qu’Ember prend en charge les exécutions répétées. Pour commencer, demandez-lui de trouver des fonctions pertinentes, de lire la configuration d’un paquet ou d’extraire les échecs de tests. Une petite modification assortie de tests d’acceptation explicites constitue une autre tâche possible.

Meta recommande plutôt Spark ou Wonder pour les problèmes difficiles à résoudre en une seule réponse et les questions exigeant des connaissances approfondies. Cette distinction compte lorsqu’il faut découvrir la bonne approche, et non simplement suivre des consignes claires.

L’API directe annonce une fenêtre de contexte de 1,048,576 tokens et une sortie maximale de 524,288 tokens. Ces limites ne déterminent pas ce qu’un client de programmation acceptera. L’effort de raisonnement par défaut d’Ember est max, avec des réglages de minimal à max.

Commencez par une investigation en lecture seule. Accordez des droits de modification lorsque le sous-agent fournit régulièrement des références correctes aux fichiers et des conclusions utiles.

Que montrent les benchmarks de programmation ?

Les résultats du lancement justifient un essai d’Ember comme sous-agent. Ils ne démontrent pas qu’il s’agit du meilleur modèle pour produire des modifications prêtes à être intégrées.

La comparaison publiée par Meta le 9 novembre présente ces résultats avec l’effort de raisonnement maximal :

Évaluation	Muse Ember	Claude Haiku 5.5	GPT-6 Luna
Terminal-Bench 4.0, meilleure configuration d’agent publiée	40.9	39.2	16.4
Artificial Analysis Coding Agent Index	46	37	31
FrontierCode 2.0-AA	27.2	34.9	25.2

Le tableau du lancement et ses notes distinguent les configurations de test. Terminal-Bench utilise mini-swe-agent pour Ember, Claude Code pour Haiku et Codex pour Luna. La comparaison porte sur chaque modèle avec le logiciel qui orchestre ses actions et ses outils. Ce n’est pas un test contrôlé où seul le modèle change dans un même outil.

Artificial Analysis publie aussi indépendamment les résultats du Coding Agent Index. Ember dans Muse Code obtient 46 points, contre 37 pour Haiku dans Claude Code et 31 pour Luna dans Codex.

Artificial Analysis indique également un score de 32.8 pour Haiku sur Terminal-Bench dans ses évaluations de l’Intelligence Index. Ne remplacez pas sans explication le résultat de 39.2 cité par Meta pour la meilleure configuration publiée. Ces chiffres proviennent de séries d’évaluation différentes.

La faiblesse pertinente reste la même : Ember est derrière Haiku sur FrontierCode, qui évalue si des modifications de code peuvent être intégrées au projet. Testez d’abord Ember pour l’investigation et l’exécution de tâches ciblées. Conservez Haiku ou votre sous-agent actuel plus capable lorsque les modifications acceptées comptent davantage que le faible coût du travail intermédiaire.

Notre guide du coût par tâche dans le Coding Agent Index explique comment comparer des configurations complètes d’agents. Leurs scores ne mesurent pas uniquement les modèles.

Quel est l’effet du seuil de 200K sur la facture ?

Calculez votre budget selon la longueur d’entrée, et non selon la capacité de contexte annoncée. Dans l’API directe de Meta, l’entrée en cache et l’historique conservé comptent pour le seuil de 200K.

Ces tarifs publics des API directes sont ceux du 2026-11-12. Tous les montants sont en USD par 1M tokens. Le tableau présente le traitement standard lorsqu’il s’applique. Il exclut les majorations régionales, les remises sur les traitements par lots et les frais des outils hébergés côté serveur.

Modèle et tranche d’entrée	Entrée hors cache	Entrée en cache	Sortie
Muse Ember, jusqu’à 200K en entrée	$0.10	$0.004	$0.50
Muse Ember, au-delà de 200K en entrée	$0.30	$0.012	$1.50
Claude Haiku 5.5, jusqu’à 100K en entrée	$0.10	$0.01	$0.50
GPT-6 Luna, jusqu’à 272K en entrée	$0.10	$0.01	$0.50
DeepSeek V4.1 Flash 1017, heures creuses	$0.15	$0.003	$0.60
DeepSeek V4.1 Flash 1017, heures de pointe	$0.30	$0.006	$1.20

Sources : tarifs de Meta, tarifs d’Anthropic, tarifs de GPT-6 Luna et tarifs de DeepSeek.

Les tarifs de Haiku sont multipliés par cinq au-delà de 100,000 tokens d’entrée. Au-delà de 272K tokens d’entrée, Luna double ses tarifs d’entrée et de cache, et multiplie son tarif de sortie par 1.5. Les deux modèles facturent séparément l’écriture en cache. Le prix d’une lecture en cache ne représente donc pas le coût complet de sa création et de sa réutilisation.

L’identifiant deepseek-flash de DeepSeek correspond actuellement à V4.1 Flash 1017. Les heures de pointe sont 01:00–04:00 et 06:00–10:00 UTC, du lundi au vendredi, hors jours fériés officiels chinois. Les autres périodes utilisent les tarifs des heures creuses.

Pour Ember, notez U l’entrée hors cache, C l’entrée en cache et O la sortie facturée. Choisissez la tranche selon U + C, puis calculez :

Token cost = (U × input_rate + C × cache_rate + O × output_rate) / 1,000,000

Voici deux estimations pour des requêtes à l’API directe. Elles supposent l’absence de lecture en cache et d’outils payants côté serveur :

199,000 input + 10,000 output:
(199,000 × $0.10 + 10,000 × $0.50) / 1,000,000 = $0.0249

201,000 input + 10,000 output:
(201,000 × $0.30 + 10,000 × $1.50) / 1,000,000 = $0.0753

La deuxième requête ne paie pas la majoration uniquement sur ses derniers 1,000 tokens d’entrée. Toute son entrée et toute sa sortie utilisent les tarifs supérieurs.

Meta compte aussi comme entrée la conversation référencée par previous_response_id. Un nouveau message court peut donc déclencher les tarifs de contexte long. Donnez des consignes ciblées aux sous-agents plutôt que de transmettre toute la conversation du modèle chargé de la planification.

Les résultats d’Artificial Analysis du 9 novembre donnent à Ember 36 points pour environ $0.14 par tâche de l’Intelligence Index. Haiku atteint 36 points pour $0.41 ; DeepSeek V4.1 Flash 1017 atteint 33 points pour $0.60. Ce sont des moyennes de benchmark, pas des devis pour votre dépôt ni des garanties de réussite équivalente.

Pour comparer avec DeepSeek, utilisez les distinctions entre le modèle Flash actuel et ses tarifs, plutôt que les prix d’une ancienne version V4.

Connecter Meta API et vérifier une réponse

Choisissez Responses pour une nouvelle intégration. Conservez Chat Completions pour du code existant qui utilise un tableau de messages, ou Messages pour un client au format Anthropic.

Meta documente trois formats d’API :

Format	Point de terminaison de la requête
Responses	POST https://api.meta.ai/v1/responses
Chat Completions	POST https://api.meta.ai/v1/chat/completions
Messages	POST https://api.meta.ai/v1/messages

Les trois utilisent l’authentification Bearer. Leurs formats de requête diffèrent : changer uniquement l’URL ne convertit pas le corps de la requête.

Créez une clé dans le tableau de bord Meta Model API, sous API keys → Create API key. Le guide de démarrage documente cette étape de configuration du compte.

Avec curl et jq installés, exécutez ce test de connexion dans Bash :

set -o pipefail
read -rs MODEL_API_KEY && export MODEL_API_KEY

curl --fail-with-body --silent --show-error \
  "https://api.meta.ai/v1/responses" \
  -H "Authorization: Bearer $MODEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "muse-ember-1.0",
    "input": "Classify this ticket as bug, billing, or feature. Return only the label: The parser unit test now fails.",
    "reasoning": {"effort": "minimal"},
    "max_output_tokens": 1024,
    "store": false
  }' |
jq '{
  status,
  model,
  text: (
    [.output[]?
      | select(.type == "message")
      | .content[]?
      | select(.type == "output_text")
      | .text]
    | join("\n")
  ),
  usage
}'

Vérifiez la présence de status: "completed", de l’identifiant du modèle Ember, de la classification bug et d’un objet usage renseigné. Ces champs suivent la structure de réponse de Responses documentée.

Ce test utilise volontairement l’effort minimal. Les résultats publiés des benchmarks utilisent max ; ce test de connexion ne les reproduit pas. La limite de sortie inclut le raisonnement et la sortie visible.

Si la requête échoue, examinez l’erreur renvoyée avant d’ajouter des outils. Revérifiez la clé, le point de terminaison et l’identifiant exact du modèle. Si la sortie est incomplète, examinez sa limite et réessayez avec une valeur adaptée.

Une classification correcte vérifie la connexion à l’API. Elle ne vérifie ni l’accès au dépôt ni l’exécution des outils.

Confier une sous-tâche ciblée de Claude Code à Ember

Utilisez l’intégration Messages documentée par Meta pour tester concrètement un modèle planificateur associé à un sous-agent. Cette configuration exécute des modèles Meta dans Claude Code. Elle ne conserve pas un modèle Claude comme planificateur derrière le même point de terminaison Meta.

Installez Claude Code et conservez MODEL_API_KEY de l’étape précédente. Depuis un projet JavaScript de test jetable contenant package.json, exécutez ceci dans Bash :

(
  unset ANTHROPIC_API_KEY
  export 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-ember-1.0"
  export CLAUDE_CODE_SUBAGENT_MODEL="muse-ember-1.0"
  claude
)

Le sous-shell empêche ces modifications d’affecter les sessions de shell suivantes. Les instructions de Meta pour les agents de programmation précisent l’hôte de base sans /v1. Elles utilisent l’authentification Bearer via ANTHROPIC_AUTH_TOKEN.

Le modèle principal est Wonder. L’alias haiku et le modèle par défaut des sous-agents pointent vers Ember. Toutefois, la configuration actuelle des modèles de Claude Code permet aux paramètres d’appel et aux définitions d’agents de remplacer ce choix par défaut.

Utilisez cette consigne de test explicite :

Use one general-purpose subagent with the haiku model to read package.json.
Return the package name and scripts.test value, or say which field is absent.
Do not edit files or execute commands. Then stop.

Elle demande à un seul sous-agent généraliste utilisant haiku de lire package.json. Il doit renvoyer le nom du paquet et la valeur de scripts.test, ou signaler les champs absents. La consigne interdit de modifier les fichiers et d’exécuter des commandes.

Pendant l’exécution du sous-agent, consultez /tasks. Claude Code v2.1.242 et les versions suivantes y affichent le modèle du sous-agent. Confirmez qu’il utilise muse-ember-1.0, qu’un outil de lecture a réellement été exécuté et que son rapport correspond à package.json.

Gardez les approbations habituelles des outils activées. Une consigne de lecture seule ne constitue pas une restriction technique des permissions.

Si le mauvais modèle s’exécute, examinez l’appel et la définition de l’agent avant de mettre en cause le fournisseur. Pour conserver des modèles Anthropic partout, suivez le guide de configuration et de vérification des sous-agents Haiku en lecture seule.

Configurer OpenRouter ou Cline sans supposer un réglage réservé aux sous-agents

Utilisez OpenRouter si votre application s’y connecte déjà, mais choisissez son identifiant de modèle plutôt que celui de l’API directe de Meta.

La fiche du modèle sur OpenRouter utilise meta/muse-ember. Son guide de démarrage Responses cible https://openrouter.ai/api/v1/responses avec une clé d’API OpenRouter, et non une clé Meta.

Au 2026-11-12, la fiche affiche $0.10 en entrée et $0.50 en sortie par 1M tokens. Son catalogue de modèles répertorie aussi des tarifs de lecture et d’écriture en cache. Confirmez la facturation du contexte long auprès du fournisseur sélectionné avant d’envoyer plus de 200K tokens d’entrée. Les tarifs mis en avant ne prouvent pas qu’un prix uniforme s’applique à toute la fenêtre de contexte.

Pour Cline, suivez la configuration du fournisseur OpenRouter. Ouvrez Settings, choisissez OpenRouter sous API Provider, puis saisissez votre clé d’API OpenRouter. Sélectionnez meta/muse-ember dans le sélecteur de modèles. Laissez vide le champ facultatif d’URL de base personnalisée pour la connexion standard à OpenRouter.

Exécutez la même tâche de lecture de fichier avant de demander des modifications. Vérifiez qu’un outil a réellement été appelé et comparez les valeurs renvoyées au fichier.

Choisir Ember dans le sélecteur de modèles du fournisseur ne prouve pas que seuls les sous-agents l’utiliseront. La documentation des sous-agents natifs de Cline couvre actuellement CLI et Desktop, pas les extensions VS Code ou JetBrains. Pour l’essai explicite avec différents modèles décrit ici, utilisez la configuration Claude Code précédente.

Vérifier les restrictions régionales et les paramètres de données

Consultez les conditions de la voie d’accès choisie avant d’envoyer le contenu d’un dépôt. La présence d’un modèle chez un agrégateur ne prouve pas que votre localisation ou votre déploiement sont autorisés.

La Geographic Use Policy de Meta, consultée au 2026-11-12, inclut la Russie, la Biélorussie et l’Iran parmi les territoires restreints. Les restrictions concernent l’accès et le fait de permettre sciemment l’accès à des produits intégrés aux utilisateurs situés dans ces territoires. La politique interdit aussi de contourner les contrôles géographiques par des moyens techniques.

Sur Model API, Ember fonctionne uniquement en mode Standard, sans variante Contributor. Meta indique que le contenu du mode Standard ne sert pas à entraîner ses modèles.

Cela ne garantit pas une absence de conservation des données. Zero Data Retention nécessite une activation distincte, et sa prise en charge peut varier selon le modèle.

Les abonnements Muse Code suivent une autre règle : ils utilisent le mode Contributor par défaut. Vérifiez ce réglage avant de travailler sur un dépôt avec un abonnement. Pour le désactiver, ouvrez /settings, sélectionnez la ligne Contributor mode et désactivez-la. Le réglage est propre à chaque appareil : vérifiez-le donc sur chaque ordinateur.

Décider après un essai limité

Comparez Ember à votre sous-agent actuel sur un ensemble fixe de tâches représentatives avant de modifier le routage de toute l’équipe.

Par exemple, sélectionnez 20 tâches issues de travaux récents. Gardez les mêmes versions du dépôt, permissions des outils, contrôles d’acceptation et règles de cache. Notez le modèle réellement utilisé, l’effort de raisonnement, la longueur d’entrée, les nouvelles tentatives, le temps écoulé et l’acceptation de chaque résultat.

Calculez le coût par tâche acceptée en incluant la planification, le sous-agent, les nouvelles tentatives et la revue effectuée par un modèle :

Cost per accepted task =
(planner cost + worker cost + retry cost + model-review cost)
÷ accepted tasks

Mesurez séparément le temps de revue humaine. Élargissez les tâches d’Ember uniquement si le coût par tâche acceptée diminue sans perte de qualité inacceptable. Conservez le sous-agent précédent pour les tâches où les nouvelles tentatives ou les modifications rejetées d’Ember annulent les économies.