Comment interroger efficacement Claude Fable 5 : guide pratique

À 10 $ par million de jetons en entrée et 50 $ par million de jetons en sortie, Claude Fable 5 (identifiant du modèle claude-fable-5) est le moyen le plus onéreux de la gamme Claude pour envoyer une requête vague. C'est aussi, lorsqu'il est bien sollicité, le modèle le plus susceptible de terminer une tâche difficile en un seul tour au lieu de cinq. Cette combinaison change ce que signifie une requête efficace. Dans l'analyse de lancement , j'ai expliqué ce qu'est Fable 5 et quand il justifie son surcoût ; cet article est la suite, pour le jour où vous lui adressez réellement du trafic. Tout ce qui suit est exécutable : briefs complets, balayages d'effort, mise en cache des requêtes, budgets de tâche et solutions de repli en cas de refus, avec le calcul des jetons pour montrer pourquoi chaque élément est rentable.

L'efficacité prend une forme différente sur ce modèle

Sur les générations précédentes de Claude, le travail d'efficacité consistait à ajuster des chiffres : une température par-ci, un budget de réflexion par-là, un plafond max_tokens comme frein improvisé. Fable 5 supprime tout cela. Les paramètres d'échantillonnage renvoient une erreur 400, les budgets de réflexion manuels renvoient une erreur 400, et contrairement à Opus 4.8, vous ne pouvez même pas envoyer un paramètre explicite thinking: {"type": "disabled"} ; la réflexion est simplement toujours active, et le modèle détermine lui-même le temps nécessaire à chaque tâche. Il ne reste que deux leviers : les mots de votre requête et output_config.effort. Cela ressemble à moins de contrôle. En pratique, cela déplace le travail d'efficacité là où il a toujours dû être : la qualité du brief que vous rédigez et une mesure honnête de la profondeur réellement requise par votre tâche.

Rédigez l'intégralité du brief d'emblée

Le plus grand gain d'efficacité ne coûte rien : mettez l'ensemble du travail dans le premier message. Fable 5 est optimisé pour les tours longs et autonomes, et sa planification n'est aussi bonne que la spécification sur laquelle elle s'appuie. Une conversation au compte-gouttes (« maintenant, ajoute aussi les tests », « ah, et garde l'API stable ») oblige le modèle à raisonner à nouveau après chaque correction, et sur les charges de travail interactives, il raisonne intensément après chaque intervention de l'utilisateur. Cinq tours courts coûtent systématiquement plus cher qu'un seul brief complet, et produisent un résultat moins bon. Un brief complet comporte cinq parties : le contexte (pourquoi c'est important), l'objectif, les contraintes, le format de sortie attendu et une définition vérifiable du succès.

# efficient_brief.py
# pip install anthropic
from anthropic import Anthropic

client = Anthropic()  # reads ANTHROPIC_API_KEY from the environment

BRIEF = """Context: I maintain a Laravel blog whose custom search endpoint
has slowed to ~900ms p95 as the posts table passed 50K rows.

Goal: propose and implement the smallest change that gets p95 under 150ms.

Constraints: MySQL 8 only, no new services, migrations must be reversible,
and the public JSON response shape cannot change.

Deliver: the migration, the changed query code, and one paragraph on the
root cause. Definition of done: EXPLAIN shows no full table scan.
"""

with client.messages.stream(
    model="claude-fable-5",
    max_tokens=32000,                    # stream anything this large
    output_config={"effort": "high"},
    # No thinking parameter: on Fable 5 thinking is always on, and an
    # explicit {"type": "disabled"} is rejected with a 400.
    messages=[{"role": "user", "content": BRIEF}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

final = stream.get_final_message()
print(f"\n[stop: {final.stop_reason}, output: {final.usage.output_tokens}]")

Utilisez le constructeur ci-dessous pour assembler un brief de cette forme pour votre propre tâche, puis collez-le directement dans l'API, Claude Code ou claude.ai. La structure compte plus que la formulation.

Balayez l'effort au lieu de le deviner

output_config.effort façonne tout : la profondeur de réflexion du modèle, le nombre d'appels d'outils qu'il effectue, la verbosité de la réponse. La valeur par défaut est high, et l'échelle va de low, medium, high, xhigh, max. Ce qui est contre-intuitif, c'est la puissance du bas de l'échelle. L'effort low sur Fable 5 dépasse souvent ce que les modèles de la génération précédente produisaient à leurs réglages maximums, de sorte que l'extraction, la classification et le résumé de routine relèvent fréquemment de low ou medium, où les réponses sont plus rapides et nettement moins chères. Réservez xhigh et max aux travaux où la justesse prime sur le coût. Ne devinez pas où se situe votre tâche : balayez-la une fois et laissez les chiffres décider.

# effort_sweep.py
# Run one representative prompt at four effort levels and compare.
import time
from anthropic import Anthropic

client = Anthropic()
TASK = open("representative_task.txt").read()  # a real prompt from prod

print(f"{'effort':<8}{'seconds':>9}{'output':>9}  stop")
for effort in ["low", "medium", "high", "xhigh"]:
    t0 = time.monotonic()
    with client.messages.stream(
        model="claude-fable-5",
        max_tokens=64000,
        output_config={"effort": effort},
        messages=[{"role": "user", "content": TASK}],
    ) as stream:
        final = stream.get_final_message()
    took = time.monotonic() - t0
    print(f"{effort:<8}{took:>8.1f}s{final.usage.output_tokens:>9}"
          f"  {final.stop_reason}")

# Judge the four answers (by eye, or with a judge prompt) and keep the
# cheapest effort level that still clears your quality bar.

Le nombre de jetons de sortie d'un balayage se traduit directement en argent. Le bac à sable ci-dessous s'exécute entièrement dans votre navigateur : saisissez vos propres mesures et voyez ce que coûte une journée de trafic à chaque niveau d'effort, avec et sans mise en cache.

Déprescrire les prompts écrits pour les anciens modèles

Voici la surprise de migration que personne ne budgétise : vos meilleurs prompts de l'ère Opus peuvent dégrader Fable 5. Les prompts accumulent des échafaudages, des listes d'étapes numérotées, des règles du type « toujours faire X avant Y », des résumés forcés toutes les quelques actions, parce que les anciens modèles avaient besoin de garde-fous. Fable 5 suit les instructions plus littéralement et planifie mieux que l'échafaudage que vous avez écrit, de sorte que les prompts prescriptifs le contraignent activement. Les conseils de migration d'Anthropic sont directs à ce sujet : énoncez l'objectif et les contraintes, puis testez A/B la charge de travail avec et sans l'échafaudage étape par étape, et conservez la version gagnante. Lors de mes tests, la version déprescrite l'emporte bien plus souvent qu'elle ne perd.

BEFORE (written for an older model, too prescriptive for Fable 5):

  Step 1: Read the ticket. Step 2: List every file that could be involved.
  Step 3: For each file, explain whether it is relevant and why.
  Step 4: Propose exactly three fixes. Step 5: Pick one and implement it.
  Step 6: Summarize what you did in exactly 3 bullet points.

AFTER (goal + constraints, steps left to the model):

  Fix the double-charge described in ticket #4821 (text below).
  Constraints: touch only the billing module, keep the public API stable,
  add a regression test. Deliver a unified diff plus one paragraph on the
  root cause. When you have enough information to act, act; do not
  narrate options you will not pursue.

Mettez le préfixe en cache et payez-le dix fois moins cher

La mise en cache des prompts repose sur une correspondance de préfixe : les requêtes sont rendues sous forme d'outils, puis de système, puis de messages, et tout octet modifié invalide tout ce qui suit. Structurez chaque charge de travail à haut volume de manière à ce que le contenu stable (prompt système, documentation de référence, définitions d'outils) vienne en premier et soit identique octet par octet à chaque appel, la partie volatile (la question réelle de l'utilisateur) étant placée en dernier. Marquez la limite du cache avec cache_control, et notez que sur Fable 5, un préfixe de moins de 2 048 tokens ne sera pas du tout mis en cache, sans avertissement. Les lectures en cache sont facturées à environ un dixième du prix d'entrée ; sur un modèle à 10 $ le million de tokens servant des milliers de requêtes par jour, ce n'est pas une optimisation, c'est la différence entre une fonctionnalité viable et une fonctionnalité morte.

# cached_prefix.py
from anthropic import Anthropic

client = Anthropic()
PLAYBOOK = open("support_playbook.md").read()  # ~9K tokens, never changes

def answer(ticket: str):
    return client.messages.create(
        model="claude-fable-5",
        max_tokens=2048,
        system=[{
            "type": "text",
            "text": PLAYBOOK,                        # stable prefix first
            "cache_control": {"type": "ephemeral"},  # cache boundary here
        }],
        messages=[{"role": "user", "content": ticket}],  # volatile last
    )

first = answer("Customer says the invoice PDF renders blank.")
again = answer("Customer was charged twice for order #8112.")

for label, r in (("first", first), ("again", again)):
    u = r.usage
    print(f"{label}: wrote={u.cache_creation_input_tokens}"
          f" read={u.cache_read_input_tokens} full_price={u.input_tokens}")

# first: wrote=~9000 read=0     -> pays the 1.25x write premium once
# again: wrote=0 read=~9000     -> reads bill at ~0.1x the input price

Budgétez les boucles d'agent et prévoyez des tours longs

Deux habitudes opérationnelles complètent le tableau de l'efficacité. Premièrement, prévoyez du temps : une seule requête Fable 5 avec un effort élevé sur une tâche difficile peut légitimement durer plusieurs minutes pendant qu'elle rassemble le contexte, construit et vérifie son propre travail. Diffusez donc tout en continu et concevez votre UX autour de la progression plutôt que d'une roue d'attente. Deuxièmement, pour les boucles agentiques, utilisez un budget de tâches. Contrairement à max_tokens, qui est une limite stricte que le modèle ne voit jamais, un task_budget donne au modèle un compte à rebours en direct par rapport auquel il s'auto-régule activement, en priorisant le travail important et en concluant proprement au lieu d'être interrompu en pleine réflexion.

# task_budget.py
# Beta: the model sees a live token countdown and paces itself.
from anthropic import Anthropic

client = Anthropic()

with client.beta.messages.stream(
    model="claude-fable-5",
    max_tokens=128000,
    betas=["task-budgets-2026-03-13"],
    output_config={
        "effort": "high",
        "task_budget": {"type": "tokens", "total": 60000},  # min 20,000
    },
    tools=tools,  # your agent's tool definitions
    messages=[{"role": "user", "content": AGENT_BRIEF}],
) as stream:
    final = stream.get_final_message()

Optez pour les solutions de repli en cas de refus dès le premier jour

Fable 5 exécute des classificateurs de sécurité ciblant la biologie de recherche et la plupart des contenus de cybersécurité, et un travail adjacent bénin, un audit d'outillage de sécurité, un pipeline de données en sciences de la vie, peut parfois déclencher un faux positif. Une requête refusée revient sous la forme d'un HTTP 200 réussi avec stop_reason: "refusal" et, avant la sortie, un tableau de contenu vide, de sorte que le code qui lit response.content[0] plantera sans prévenir sur les requêtes auxquelles vous vous attendez le moins. La méthode efficace consiste à activer les solutions de repli côté serveur : indiquez un modèle de secours dans le même appel, et un refus est redirigé de manière transparente vers Opus 4.8, sans que ce refus non facturé ne vous coûte quoi que ce soit.

# refusal_fallback.py
from anthropic import Anthropic

client = Anthropic()

response = client.beta.messages.create(
    model="claude-fable-5",
    max_tokens=2048,
    betas=["server-side-fallback-2026-06-01"],
    fallbacks=[{"model": "claude-opus-4-8"}],  # rescue inside the same call
    messages=[{"role": "user", "content":
               "Audit this nginx config for MIME sniffing issues."}],
)

if response.stop_reason == "refusal":
    print("Whole chain declined:", response.stop_details)
else:
    rescued = any(i.type == "fallback_message"
                  for i in (response.usage.iterations or []))
    print(f"served by {response.model}" + (" (fallback)" if rescued else ""))
    print(response.content[0].text)

La méthode efficace, en un paragraphe

Rédigez un brief complet en expliquant la raison d’être de la tâche, balayez les niveaux d’effort une fois et retenez le moins coûteux qui donne satisfaction, supprimez l’échafaudage accumulé par vos anciennes invites, mettez en cache chaque préfixe stable de plus de 2 048 jetons, donnez aux boucles d’agent un budget qu’elles peuvent consulter et activez les solutions de repli pour que les refus se dégradent au lieu d’échouer. Aucune de ces étapes n’est difficile et, ensemble, elles réduisent couramment de moitié le coût d’une charge de travail Fable 5 tout en améliorant le résultat. Le modèle a supprimé les réglages fins ; ce qu’il offre en retour, c’est un système où la qualité de votre rédaction devient le paramètre de performance.