Claude Fable 5.2 : configuration, prix API et comparaison avec Opus

Essayez Claude Fable 5.2 si Opus 5.5 échoue encore à vos vérifications de code avec un niveau d’effort élevé. Sinon, gardez Opus pour le travail quotidien. Commencez avec medium dans Claude Code ou high dans l’API, selon les recommandations d’Anthropic.

Le paramètre effort règle la profondeur du raisonnement. Comparez le coût des modifications acceptées : un prix par token plus élevé peut malgré tout réduire le coût d’une tâche terminée.

Fable 5.2 est sorti le 9 novembre 2026 et utilise l’identifiant API claude-fable-5-2. Au 2026-11-12, sa fiche technique indique une fenêtre de contexte de 1M tokens et une sortie maximale de 128K.

Sélectionner Fable 5.2 dans Claude Code et vérifier une modification réelle

Utilisez Claude Code 2.1.321 ou une version ultérieure, puis sélectionnez l’identifiant complet du modèle. Le journal officiel des modifications indique que Fable 5.2 a été ajouté dans la version 2.1.321.

Il vous faut un client Claude Code installé et authentifié, ainsi qu’un compte ou un fournisseur autorisant ce modèle. Avant d’envoyer du code privé, vérifiez que votre organisation approuve les règles de traitement des données Covered Models applicables à Fable.

Pour une installation native, exécutez ces commandes dans Bash :

claude update
claude --version

Pour une installation via un gestionnaire de paquets, suivez les instructions de mise à jour correspondantes. Vérifiez que la version affichée est au moins 2.1.321. Ne supposez pas qu’une ancienne installation a bien été mise à jour.

Dans une session existante, exécutez :

/model claude-fable-5-2

L’expression « modèle Fable par défaut » ne signifie pas que Fable devient le modèle par défaut de tous les utilisateurs. La référence de configuration des modèles précise qu’aucun modèle Fable n’est le choix par défaut associé à un type de compte.

Pour isoler le test, créez un répertoire temporaire avec Bash et Python 3 :

workdir="$(mktemp -d)"
cd "$workdir"

cat > clamp.py <<'PY'
def clamp(value, low, high):
    return min(low, max(value, high))
PY

cat > test_clamp.py <<'PY'
from clamp import clamp

assert clamp(-2, 0, 10) == 0
assert clamp(5, 0, 10) == 5
assert clamp(12, 0, 10) == 10
print("3 checks passed")
PY

claude --model claude-fable-5-2 --effort medium

Ces options de la CLI sélectionnent le modèle et le niveau d’effort de la session. Vérifiez /model avant de commencer. Si le niveau diffère, contrôlez CLAUDE_CODE_EFFORT_LEVEL : cette variable d’environnement est prioritaire sur l’option de lancement.

Donnez la tâche suivante à Claude Code. Elle demande de corriger la fonction sans modifier les tests ni utiliser de sous-agents :

Read clamp.py and test_clamp.py.
Fix clamp.py so all existing assertions pass.
Do not edit test_clamp.py.
Run python3 test_clamp.py and report the exact result.
Do not use subagents.

Gardez les contrôles d’autorisation activés. N’approuvez que les opérations sur les fichiers et les commandes adaptées à ce répertoire.

Une fois le travail de l’agent terminé, quittez Claude Code et exécutez vous-même :

python3 test_clamp.py

Le résultat attendu est 3 checks passed, sans modification du fichier de tests. Un correctif proposé ne suffit pas : il doit être appliqué et le test doit réussir. Ce contrôle vérifie le fonctionnement des outils, pas la supériorité de Fable sur un autre modèle.

Envoyer une première requête API à claude-fable-5-2

Utilisez d’abord l’API Messages directe d’Anthropic pour distinguer le comportement du modèle de la configuration d’une passerelle. Cet exemple nécessite Bash, curl avec --fail-with-body, jq et une clé API émise par Anthropic.

Créez votre propre clé en suivant les instructions de la Console, puis choisissez un espace de travail précis. Une clé limitée à cet espace permet d’omettre anthropic-workspace-id dans cet exemple, comme le précise la documentation d’authentification de l’API.

Collez la clé quand read attend une saisie, puis appuyez sur Entrée :

read -rs ANTHROPIC_API_KEY && export ANTHROPIC_API_KEY

Envoyez une requête synchrone :

curl --silent --show-error --fail-with-body \
  https://api.anthropic.com/v1/messages \
  --header "Authorization: Bearer ${ANTHROPIC_API_KEY}" \
  --header "anthropic-version: 2026-10-21" \
  --header "content-type: application/json" \
  --data '{
    "model": "claude-fable-5-2",
    "max_tokens": 4096,
    "output_config": {
      "effort": "high"
    },
    "messages": [
      {
        "role": "user",
        "content": "Fix this Python function and return the corrected function plus three assertions: def clamp(value, low, high): return min(low, max(value, high))"
      }
    ]
  }' \
  --output fable-response.json &&
jq '{
  model,
  stop_reason,
  usage,
  text: [.content[] | select(.type == "text") | .text]
}' fable-response.json

La requête utilise l’en-tête de version actuel de l’API et le champ documenté output_config.effort. Elle omet thinking, car Fable 5.2 utilise déjà le raisonnement adaptatif.

Vérifiez le modèle renvoyé, la présence de texte non vide, usage et stop_reason. Une réponse terminée naturellement renvoie généralement end_turn ; max_tokens indique que la sortie a atteint la limite fixée. Suivez le guide des motifs d’arrêt et augmentez la limite de sortie avant de considérer une réponse tronquée comme un défaut de qualité.

Si la requête HTTP échoue, consultez l’erreur enregistrée :

jq '.error' fable-response.json

Cette requête renvoie du code sous forme de texte. Elle ne lit pas les fichiers locaux et n’exécute pas les assertions. Examinez le code reçu avant de l’exécuter.

BetterToken répertorie également claude-fable-5-2 au 2026-11-12. Son intégration avec Claude Code utilise la Base URL https://bettertoken.ai. Suivez séparément les instructions d’authentification de cette voie d’accès. La présence du modèle au catalogue ne confirme pas la prise en charge de tous les paramètres d’effort ou du mode rapide.

Comparer le prix des tokens au coût d’une tâche terminée

Aux tarifs standard de l’API, Fable 5.2 coûte moins cher par token que Fable 5.1, mais deux fois plus qu’Opus 5.5. Voici les prix publiés par Anthropic au 2026-11-12, en USD par million de tokens.

Modèle, vitesse standard	Entrée hors cache	Sortie
Claude Fable 5.1	$10	$50
Claude Fable 5.2	$8	$40
Claude Opus 5.5	$4	$20
Claude Sonnet 5.5	$2	$10

Entre Fable 5.1 et 5.2, les tarifs d’entrée et de sortie baissent chacun de 20%. C’est une réduction du prix unitaire. Elle ne garantit pas une facture de session inférieure de 20%.

À vitesse standard, les écritures en cache de Fable 5.2 coûtent $10 pour une conservation de cinq minutes et $16 pour une heure. Les lectures coûtent $0.20. Chaque tarif s’applique à un million de tokens.

Les tarifs d’entrée/sortie de Batch, qui fonctionne de manière asynchrone, sont de $4/$20. Ils ne correspondent pas à l’utilisation interactive de Claude Code.

Pour une charge estimée à 100,000 tokens d’entrée hors cache et 20,000 tokens de sortie facturés :

Fable 5.2: 0.1 × $8 + 0.02 × $40 = $1.60
Opus 5.5: 0.1 × $4 + 0.02 × $20 = $0.80

Ce calcul suppose la vitesse standard et les tarifs globaux, sans opérations de cache, outils payants ni remise Batch. Il exclut les taxes applicables. Le nombre de tokens est identique pour les deux modèles, ce qui n’est souvent pas le cas dans les sessions réelles d’agents.

L’annonce FrontierCode 2.0 d’Anthropic compare une autre mesure. Fable 5.2 au niveau High obtient 45.3%, contre le meilleur score d’Opus 5.5 de 45.5%. Selon les résultats publiés, le coût par tâche de Fable est environ la moitié de celui d’Opus.

Cette comparaison oppose Fable High à Opus Max. Elle ne repose ni sur un volume de tokens identique ni sur un même niveau d’effort.

Les résultats actuels de CursorBench 4.0 montrent pourquoi la conclusion dépend des tâches évaluées. Fable 5.2 High atteint 56.9% pour un coût publié de $9.70, tandis qu’Opus 5.5 High obtient 56.0% pour $3.97. Fable 5.2 Max atteint 60.0% pour $32.79.

Ce sont les résultats d’évaluation de leurs éditeurs, pas des tarifs d’abonnement ni des mesures sur votre dépôt. Cursor étiquette la ligne à 56.9% High, et non Medium, le réglage par défaut de Claude Code.

Utilisez le guide d’évaluation du coût par tâche pour inclure les nouvelles tentatives, les échecs et les paramètres d’exécution de l’agent.

Activer le mode rapide seulement si la vitesse de sortie compte

Activez le mode rapide, ou fast mode, pour les tâches sensibles à la latence, après la réussite de la requête standard. Anthropic annonce une génération de tokens jusqu’à 2.5 fois plus rapide. Cela ne garantit pas qu’une tâche complète de programmation se termine 2.5 fois plus vite.

Avec l’API Messages directe, gardez claude-fable-5-2 et ajoutez ce champ au premier niveau du corps de la requête :

"speed": "fast"

Aucun en-tête bêta propre au mode rapide n’est nécessaire. Après une requête réussie, vérifiez que usage.speed vaut "fast", comme l’explique le guide du mode rapide pour l’API.

Au 2026-11-12, les tarifs d’entrée/sortie de Fable 5.2 en mode rapide sont de $16/$80 par million de tokens. Les limites par défaut documentées pour ce mode s’appliquent aux niveaux d’usage Start, Build et Scale.

Si vous dépassez une limite de débit du mode rapide, l’API renvoie 429 avec retry-after. Respectez le délai indiqué. Vous pouvez aussi retirer explicitement speed, puis réessayer à vitesse standard.

Dans Claude Code, sélectionnez Fable 5.2 et exécutez /fast. Avec un abonnement, le mode rapide consomme directement les crédits d’usage, même s’il reste de l’usage inclus dans le forfait. Consultez les conditions de Claude Code avant de l’activer.

L’accès via Vertex/Agent Platform de Google Cloud exige Claude Code 2.1.322 ou une version ultérieure pour le mode rapide. Les régions prises en charge sont global, us et eu. Suivez les instructions propres à ce fournisseur.

La configuration cURL ci-dessus vise l’API directe d’Anthropic. Ne la réutilisez pas telle quelle avec le point de terminaison d’un autre fournisseur cloud.

Éviter les erreurs 400 lors de la migration

Vérifiez les paramètres des requêtes et l’historique de conversation avant de basculer le trafic de production. Le raisonnement adaptatif toujours actif et l’interdiction des appels d’outils forcés s’appliquaient déjà à Fable 5.1 et à Opus 5.5. Ce ne sont pas de nouvelles restrictions de Fable 5.2.

Le guide de compatibilité de Fable 5.2 décrit ces erreurs :

Paramètres de la requête	Résultat	Correction
thinking: {"type": "enabled"} avec budget_tokens	400	Omettez thinking ou utilisez {"type": "adaptive"}. Réglez la profondeur avec effort.
thinking: {"type": "disabled"}	400	Supprimez ce paramètre. Le raisonnement adaptatif ne peut pas être désactivé.
tool_choice: {"type": "any"}	400 invalid_request_error	Utilisez {"type": "auto"} et prévoyez la possibilité d’une réponse textuelle.
tool_choice: {"type": "tool", "name": "..."}	400 invalid_request_error	Supprimez le choix forcé et gérez la sélection des outils dans votre application.

Pour obtenir des arguments d’outil conformes au schéma, utilisez strict: true avec le choix automatique lorsque cette fonction est disponible. Le mode strict contraint les arguments, mais ne force pas l’appel. Les sorties JSON sont une autre option.

Dans les organisations utilisant des clés de chiffrement gérées par le client, Fable 5.2 ne prend en charge ni les appels d’outils stricts ni les sorties JSON. Validez alors les sorties dans le code de l’application.

Un changement important concerne la vérification plus stricte du préfixe de conversation. Fable 5.2 l’applique à tous les comptes, y compris les anciens dont les requêtes à Fable 5.1 passaient auparavant.

Le message d’erreur contient cette phrase :

The block is bound to a different conversation.

Elle peut apparaître si vous renvoyez un bloc de raisonnement après avoir modifié le prompt system, tools ou le contenu antérieur de la conversation. Répéter la même requête ne corrige pas l’incohérence.

Respectez les règles de conservation du raisonnement. Gardez le préfixe existant intact, ajoutez les nouveaux messages à la fin et renvoyez les tableaux de contenu de l’assistant exactement tels que reçus. Pour une intégration simple, ouvrez une nouvelle conversation lorsque vous remplacez le prompt système initial ou les définitions d’outils.

Les applications utilisant computer use ou les outils advisor doivent aussi consulter le guide complet de migration avant le déploiement.

Ajuster effort et vérifier la fin des tâches longues

Contrôlez le raisonnement avec le réglage effort plutôt qu’avec la formulation du prompt. Selon Anthropic, demander de répondre sans délibérer ne supprime pas le raisonnement de Fable 5.2 à partir de medium.

Le guide de prompts propre au modèle décrit aussi des arrêts prématurés dans les tâches à plusieurs étapes, surtout avec low et medium. Une réponse end_turn signifie que le tour est terminé. Vos vérifications d’acceptation doivent encore déterminer si tout le travail est achevé.

Pour une tâche de dépôt au périmètre défini, précisez les conditions de fin. Le prompt suivant demande de terminer la modification et les tests, mais de s’arrêter si un accès manque, qu’une action destructive s’impose ou que le périmètre doit changer :

Complete the requested change and run the relevant tests.
Do not stop after a plan or a list of remaining steps.
Continue through ordinary implementation failures within the approved scope.
Stop and report the blocker if you need unavailable credentials,
destructive actions, or a decision that changes the requested scope.
Do not start subagents for this trial.

Pour les longues tâches de programmation, comparez high à votre résultat de référence avec medium. N’essayez xhigh que si les gains mesurés justifient le travail supplémentaire. Réservez max aux mesures du plafond de capacité ou aux tâches dont l’échec serait particulièrement coûteux.

La délégation modifie aussi le coût. Selon Anthropic, Fable délègue volontiers lorsque le système d’agents qui l’entoure l’y invite. Les sous-agents peuvent consommer une grande part du budget d’une session. Notez leurs modèles et leur consommation avant d’attribuer toute la facture au modèle principal.

Quel modèle garder au quotidien ?

Gardez Sonnet 5.5 pour des modifications ciblées avec des tests clairs, tant que ses résultats répondent à vos besoins. Ses tarifs par token plus faibles en font un premier essai raisonnable pour les modifications répétitives. Passez à un modèle plus capable si la revue révèle des dépendances oubliées ou plusieurs tentatives de correction.

Gardez Opus 5.5 pour le travail courant sur les dépôts, sauf si Fable apporte une amélioration mesurable. Le guide de sélection d’Opus explique comment revenir à ce modèle et conserver ce choix.

Testez Fable 5.2 sur les diagnostics difficiles, les modifications de plusieurs fichiers et les longues migrations qu’Opus rate encore avec un effort élevé. Choisissez-le lorsque l’amélioration des modifications acceptées ou du coût total de réalisation compense ses tarifs par token plus élevés.

Après avoir vérifié la configuration, comparez les modèles depuis le même commit initial et avec les mêmes tests d’acceptation. Notez effort, le temps écoulé, l’usage du cache, la consommation des sous-agents et toutes les tentatives échouées. Gardez la configuration la moins chère qui passe vos propres vérifications ; un score de benchmark ne doit pas remplacer cette décision.