Guide de l'API Claude Fable 5

Pour appeler Claude Fable 5, utilise l'ID de modèle claude-fable-5 et active la réflexion avec thinking: {"type": "adaptive"}. Voilà tout le chemin heureux. Les pièges, c'est tout ce qu'il y a autour : des paramètres de sampling qui marchaient avant renvoient maintenant un 400, et un paramètre qui passe sur Opus 4.8 va casser ta requête sur Fable 5.

Fable 5 est sorti le 9 juin 2026 comme le modèle le plus capable d'Anthropic, un cran au-dessus d'Opus. Il a une fenêtre de contexte d'1M et un plafond de sortie de 128K, et il coûte $10 par million de tokens en entrée et $50 par million en sortie. C'est le double du tarif d'Opus 4.8, donc c'est un modèle que tu pointes sur les problèmes durs, pas sur le travail de routine.

C'est le guide pratique. Comment faire l'appel, quels 400 et pourquoi, comment régler l'effort et les budgets, comment le caching change, et l'unique étape Bedrock qui va te bloquer si tu la sautes.

L'appel minimal qui marche

Commence ici. C'est le plus petit appel qui fonctionne, en Python avec le SDK officiel d'Anthropic. Le client lit ta clé ANTHROPIC_API_KEY depuis l'environnement, choisit le modèle, active la réflexion adaptative, et met l'effort à xhigh parce que c'est le bon réglage pour le code et le travail agentique.

import anthropic

client = anthropic.Anthropic()

message = client.messages.create(
    model="claude-fable-5",
    max_tokens=16000,
    thinking={"type": "adaptive"},
    output_config={"effort": "xhigh"},
    messages=[{"role": "user", "content": "Explain what a row-level security policy does."}],
)

print(message.content[0].text)

L'ID du modèle est la chaîne exacte claude-fable-5. Il n'y a pas de suffixe de date. Si tu en ajoutes un, tu te prends un 404.

Si tu ne veux pas de réflexion du tout, tu enlèves la ligne thinking. Tu ne la mets pas à disabled. Cette distinction est le plus gros piège de ce modèle, et elle a droit à sa propre section plus bas.

Les pièges du 400

Fable 5 a laissé tomber tout un jeu de paramètres que les modèles précédents acceptaient. En envoyer un seul renvoie un HTTP 400 (invalid_request_error). Voici le tableau complet de ce qui casse et comment le corriger.

Un prefill, c'est quand ton tableau messages se termine par un tour role: "assistant" que tu as commencé à écrire pour que le modèle le continue. Ce motif renvoie un 400 sur Fable 5. Si tu t'en servais pour forcer du JSON, passe aux sorties structurées, montrées plus bas.

Pourquoi la réflexion désactivée renvoie un 400

C'est le piège qui casse les mises à niveau « drop-in », donc ça vaut le coup d'être précis.

Sur Opus 4.8 et Opus 4.7, deux choses font tourner une requête sans réflexion : omettre le champ thinking, ou mettre thinking: {"type": "disabled"}. Elles sont interchangeables.

Sur Fable 5, elles ne le sont pas. Un thinking: {"type": "disabled"} explicite renvoie un 400. Seule l'omission du champ tourne sans réflexion. Donc du code qui marchait hier sur Opus et qui mettait explicitement disabled va commencer à planter à l'instant où tu changes l'ID du modèle.

Ce snippet montre la version cassée et la version qui marche côte à côte. La première fait un 400 sur Fable 5. La seconde tourne sans réflexion, ce que la première essayait de faire.

# WRONG on Fable 5 - returns a 400
message = client.messages.create(
    model="claude-fable-5",
    max_tokens=4096,
    thinking={"type": "disabled"},
    messages=[{"role": "user", "content": "Classify this ticket as bug or feature."}],
)

# RIGHT - omit the thinking param to run without thinking
message = client.messages.create(
    model="claude-fable-5",
    max_tokens=4096,
    messages=[{"role": "user", "content": "Classify this ticket as bug or feature."}],
)

La correction est une suppression, pas un changement de valeur. Enlève la ligne. N'essaie pas de trouver une autre valeur pour type.

Un autre changement de comportement à connaître : avec la réflexion coupée, Fable 5 écrit parfois un raisonnement plus long dans la réponse visible. Si tu as besoin de réponses courtes et rapides, la correction la plus propre est de laisser la réflexion adaptative active, ce qui garde le raisonnement hors du texte final. Si tu dois absolument tourner sans réflexion, ajoute une instruction système qui dit au modèle de répondre uniquement avec sa réponse finale.

Réglage de l'effort

L'effort contrôle à quel point le modèle réfléchit et agit dur. Tu le mets dans output_config, pas au niveau racine. Le défaut est high.

Cet appel fixe l'effort explicitement. Des valeurs plus basses veulent dire moins d'appels d'outils, moins de préambule et une sortie plus terse. Des valeurs plus hautes veulent dire un raisonnement plus profond et plus de minutie, à un coût en tokens plus élevé.

message = client.messages.create(
    model="claude-fable-5",
    max_tokens=16000,
    thinking={"type": "adaptive"},
    output_config={"effort": "high"},  # low | medium | high | xhigh | max
    messages=[{"role": "user", "content": "Refactor this module for testability."}],
)

Voici comment choisir un niveau.

L'effort compte plus sur Fable 5 que sur n'importe quel Opus précédent. Si tu migres, re-règle-le par route au lieu de supposer que l'ancien réglage colle encore. Pour les tâches agentiques longue durée, donne toute la spec de la tâche d'un coup en un seul tour et tourne en high ou xhigh. En xhigh ou max, donne à max_tokens une vraie marge (commence à 64K) pour que le modèle ait de la place pour réfléchir et agir à travers les appels d'outils.

Budgets de tâche

Un budget de tâche dit au modèle combien de tokens il a pour toute une boucle agentique, en comptant la réflexion, les appels d'outils et la sortie finale. Le modèle voit un compte à rebours et se cale dessus, en bouclant proprement à mesure que le budget descend.

C'est différent de max_tokens. max_tokens est un plafond dur que le modèle ne voit pas. Un budget de tâche est une suggestion dont le modèle est conscient et autour de laquelle il planifie. Sers-toi du budget pour faire s'auto-modérer le modèle, et garde max_tokens comme plafond appliqué.

Les budgets de tâche sont en bêta, donc tu passes un header bêta et tu appelles via le namespace bêta. Le budget minimum est de 20 000 tokens.

message = client.beta.messages.create(
    betas=["task-budgets-2026-03-13"],
    model="claude-fable-5",
    max_tokens=64000,
    thinking={"type": "adaptive"},
    output_config={
        "effort": "high",
        "task_budget": {"type": "tokens", "total": 128000},
    },
    messages=[{"role": "user", "content": "Migrate the auth module off the deprecated API."}],
)

Mets un budget généreux pour les runs agentiques ouverts et un plus serré pour les tâches sensibles à la latence. Si le budget est trop petit pour le travail, le modèle finit de façon moins minutieuse et te dit que le budget était la contrainte.

Notes sur le caching

Le prompt caching marche comme sur tous les modèles Claude : c'est un match de préfixe, donc le moindre changement d'octet n'importe où dans le préfixe caché invalide tout ce qui vient après. Garde le contenu stable en premier et mets le contenu volatil (horodatages, IDs de requête, la question propre à chaque requête) après ton dernier point de rupture.

Deux chiffres sont différents sur Fable 5. Le préfixe minimum cachable est de 2048 tokens, contre 4096 sur Opus 4.8. Donc un prompt de 3K tokens qui n'arrivait pas à se cacher en silence sur Opus 4.8 va se cacher sur Fable 5. Les lectures de cache coûtent environ 0,1x le tarif d'entrée de base, et les écritures environ 1,25x avec la fenêtre par défaut de cinq minutes.

Cet appel cache un gros prompt système stable. Le marqueur cache_control va sur le bloc système. La question propre à la requête dans le tour utilisateur reste non cachée, ce qui est exactement ce que tu veux.

message = client.messages.create(
    model="claude-fable-5",
    max_tokens=16000,
    system=[
        {
            "type": "text",
            "text": LARGE_STABLE_SYSTEM_PROMPT,
            "cache_control": {"type": "ephemeral"},
        }
    ],
    messages=[{"role": "user", "content": "Summarize the key risks in section 4."}],
)

Pour confirmer une lecture de cache, lis message.usage.cache_read_input_tokens. Si ça reste à zéro sur des requêtes répétées avec le même préfixe, c'est que quelque chose dans le préfixe change à chaque appel. Les coupables habituels sont un horodatage dans le prompt système, du JSON sérialisé sans clés triées, ou un jeu d'outils qui varie d'une requête à l'autre.

Streaming pour les grosses sorties

Fable 5 peut produire jusqu'à 128K tokens de sortie, mais le SDK va se prendre un timeout HTTP sur une requête non-streamée qui demande une grosse sortie. La règle empirique : streame tout ce qui dépasse environ 16K max_tokens.

Ceci streame la réponse et collecte le message final à la fin, donc tu obtiens à la fois les tokens en direct et un objet de résultat complet.

with client.messages.stream(
    model="claude-fable-5",
    max_tokens=64000,
    thinking={"type": "adaptive"},
    output_config={"effort": "xhigh"},
    messages=[{"role": "user", "content": "Write the full migration plan."}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)
    final = stream.get_final_message()

Une note de streaming propre à Fable 5 : les blocs de réflexion streament, mais leur texte est vide par défaut. Si tu affiches le raisonnement aux utilisateurs, ce défaut ressemble à une longue pause silencieuse avant que la réponse ne commence. Pour restaurer une progression visible, demande une réflexion résumée avec thinking={"type": "adaptive", "display": "summarized"}.

Fable 5 sur Amazon Bedrock

Bedrock a une étape qui va bloquer toutes tes requêtes tant que tu ne l'as pas faite : tu dois consentir au partage de données avant de pouvoir invoquer Fable 5. Il n'y a pas d'UI console pour ça au lancement, donc c'est facile à louper et l'erreur que ça produit n'est pas évidente.

Tu consens via l'API Data Retention en mettant le mode à provider_data_share. Cet appel curl le fait pour le moteur bedrock-mantle, celui que tu utilises avec l'API Anthropic Messages. Lance-le une fois par compte avant ton premier appel de modèle.

curl -X PUT https://bedrock-mantle.us-east-1.api.aws/v1/data_retention \
  -H "x-api-key: <your-bedrock-api-key>" \
  -H "Content-Type: application/json" \
  -d '{ "mode": "provider_data_share" }'

Si tu appelles plutôt l'API Converse ou Invoke sur le moteur bedrock-runtime, l'endpoint et l'auth diffèrent. Voici le consentement équivalent pour ce moteur.

curl -X PUT https://bedrock.us-east-1.amazonaws.com/data-retention \
  -H "Authorization: Bearer <your_bearer_token>" \
  -H "Content-Type: application/json" \
  -d '{ "mode": "provider_data_share" }'

Consentir veut dire qu'Anthropic conserve tes entrées et sorties pendant 30 jours. Les données ne sont pas utilisées pour l'entraînement, tout accès humain est journalisé, et elles sont supprimées au bout de 30 jours. C'est une obligation pour tout le trafic de classe Mythos, et une fois que tu consens, tes données sortent de la frontière de sécurité d'AWS. Décide si c'est acceptable pour ta charge avant de basculer.

Une fois consentant, pointe le SDK Anthropic vers l'endpoint Bedrock. L'ID du modèle sur l'API Messages est anthropic.claude-fable-5, avec le préfixe anthropic.. Cet appel Python tourne contre bedrock-mantle.

import anthropic

client = anthropic.Anthropic(
    base_url="https://bedrock-mantle.us-east-1.api.aws/anthropic",
    api_key="<your-bedrock-api-key>",
)

message = client.messages.create(
    model="anthropic.claude-fable-5",
    max_tokens=4096,
    messages=[{"role": "user", "content": "Design a multi-region architecture for 100k requests per second."}],
)

print(message.content[0].text)

Si tu préfères l'API Converse via boto3, l'ID du modèle change pour global.anthropic.claude-fable-5 et tu appelles bedrock-runtime. Voici la même requête sous cette forme.

import boto3

bedrock_runtime = boto3.client("bedrock-runtime", region_name="us-east-1")

response = bedrock_runtime.converse(
    modelId="global.anthropic.claude-fable-5",
    messages=[{"role": "user", "content": [{"text": "Design a multi-region architecture for 100k RPS."}]}],
    inferenceConfig={"maxTokens": 4096},
)

print(response["output"]["message"]["content"][0]["text"])

Au lancement, Bedrock sert Fable 5 dans US East (N. Virginia) et Europe (Stockholm). L'accès s'étend progressivement à travers les comptes AWS ; si le tien n'est pas encore activé, contacte le support AWS pour aller plus vite.

Une surprise de facturation à anticiper

Fable 5 est livré avec des protections conservatrices. Les requêtes sur le cyber, le bio, la chimie et les sujets de santé basculent vers une réponse d'Opus 4.8 à la place, et l'utilisateur est prévenu. Ça se déclenche dans moins de 5 % des sessions en moyenne.

La partie qui affecte ton code, c'est la facturation. Les réponses de bascule sont facturées aux tarifs Opus, pas aux tarifs Fable. Sur Bedrock, si une requête est bloquée en cours de conversation, les tokens initiaux sont facturés aux tarifs Fable et le reste aux tarifs Opus. Donc certaines réponses seront moins chères que ce que ton sélecteur de modèle laisse penser et porteront une note disant qu'elles ont été répondues par Opus 4.8. Construis ton modèle de coût pour le prévoir au lieu de traiter chaque appel Fable comme une charge Fable forfaitaire.

Migrer depuis Opus 4.8 ou 4.7

Si ton code Opus existant est déjà propre, passer à Fable 5 est un simple changement d'ID de modèle, et rien d'autre. « Propre » veut dire pas de paramètres de sampling, pas de budget_tokens, et pas de thinking: {"type": "disabled"} explicite.

Voici la checklist.

• Change l'ID du modèle en claude-fable-5.
• Supprime tout thinking: {"type": "disabled"}. Ça fait un 400 sur Fable 5. Omets le champ à la place.
• Enlève temperature, top_p et top_k. Ils font déjà un 400 sur Opus 4.7 et 4.8, et ici aussi.
• Remplace budget_tokens par thinking: {"type": "adaptive"}.
• Remplace tout prefill de dernier tour assistant par output_config: {"format": {...}}.
• Re-règle effort par route. Il pèse plus lourd sur Fable 5.
• Mets thinking.display à "summarized" si tu affiches le raisonnement aux utilisateurs.
• Re-cale tes dashboards de max_tokens et de coût, puisque Fable tourne au double du prix d'Opus.

Si tu viens d'Opus 4.6 ou plus ancien, applique d'abord toute la migration vers la réflexion adaptative, puis les deltas Fable 5 ci-dessus.

Le seul changement vraiment nouveau et cassant par rapport à Opus 4.8 et 4.7, c'est le 400 explicite sur la réflexion désactivée. Tout le reste de cette liste s'appliquait déjà aux modèles Opus récents. C'est pour ça que les gens appellent Fable 5 « presque drop-in ». Le mot qui fait le boulot, c'est « presque ».

Foire aux questions

Quel est l'ID du modèle Claude Fable 5 ?

L'ID de modèle direct est la chaîne exacte claude-fable-5, sans suffixe de date. Sur Amazon Bedrock, il porte un préfixe anthropic. : anthropic.claude-fable-5 sur l'API Messages (bedrock-mantle), et global.anthropic.claude-fable-5 sur l'API Converse ou Invoke (bedrock-runtime).

Pourquoi la réflexion désactivée renvoie-t-elle un 400 sur Fable 5 ?

Sur Fable 5, un thinking: {"type": "disabled"} explicite n'est pas accepté et renvoie un 400. C'est propre à Fable 5 ; Opus 4.8 et 4.7 l'acceptent. Pour faire tourner une requête sans réflexion, omets entièrement le paramètre thinking au lieu de le mettre à disabled.

Comment utiliser Fable 5 sur Bedrock ?

D'abord, consens au partage de données en mettant le mode de l'API Data Retention à provider_data_share. Il n'y a pas d'UI console pour ça au lancement, donc tu le fais avec un appel curl vers l'endpoint de rétention de données. Ensuite, pointe le SDK Anthropic vers la base URL de Bedrock et utilise l'ID de modèle anthropic.claude-fable-5, ou utilise l'API Converse de boto3 avec global.anthropic.claude-fable-5.

Combien coûte Claude Fable 5 ?

$10 par million de tokens en entrée et $50 par million en sortie. C'est le double des $5 et $25 d'Opus 4.8. Les réponses qui touchent les protections et basculent vers Opus 4.8 sont facturées aux tarifs Opus à la place, donc certains appels coûtent moins que le tarif Fable affiché.

Comment couper la réflexion sur Fable 5 sans erreur ?

Enlève le champ thinking de ta requête. Une requête sans champ thinking tourne sans réflexion. Ne mets pas thinking: {"type": "disabled"}, qui renvoie un 400. Si tu trouves que le modèle écrit un long raisonnement dans la réponse visible avec la réflexion coupée, soit tu laisses la réflexion adaptative active, soit tu ajoutes une instruction système pour répondre uniquement avec la réponse finale.

Le prompt caching change-t-il sur Fable 5 ?

La mécanique est la même, mais le préfixe minimum cachable est plus bas : 2048 tokens sur Fable 5 contre 4096 sur Opus 4.8. Donc un prompt de taille moyenne qui ne se cacherait pas sur Opus 4.8 se cachera sur Fable 5. Vérifie les lectures avec usage.cache_read_input_tokens.

Sources

• Claude Fable 5 et Claude Mythos 5
• Claude Fable 5 d'Anthropic sur AWS (AWS News Blog)
• Vue d'ensemble des modèles (docs API)
• Guide de migration des modèles (docs API)
• Construire avec la réflexion étendue (docs API)
• Model card de Claude Fable 5 (Amazon Bedrock)
• Pratiques de rétention de données pour les modèles de classe Mythos

Pages liées

• Antisèche Opus 4.8
• Les modèles de Claude Code
• Claude Mythos et OpenMythos