Anthropic a mis un prix net sur l’autonomie de frontière : Claude Fable 5 est affiché à 10 $ par million de tokens en entrée et 50 $ par million de tokens en sortie sur la Claude API, tandis que Sonnet 4.6 est à 3 $/15 $ et Opus 4.8 à 5 $/25 $ (Fable, Sonnet, Opus). Cet écart, c’est toute la décision produit.
Si vous envoyez chaque prompt de code à Fable, vous ne faites pas du “frontier”. Vous sautez l’architecture.
Au 16 juin 2026, il y a aussi une subtilité côté disponibilité : la page Fable d’Anthropic indique que Fable 5 est actuellement indisponible, et Anthropic dit avoir suspendu l’accès le 12 juin après une directive du gouvernement américain couvrant Fable 5 et Mythos 5 (déclaration d’Anthropic). Ça ne rend pas la couche de routage moins utile. Ça la rend plus urgente. Votre app devrait déjà savoir se replier de Fable vers Opus ou Sonnet sans réveiller un ingénieur.
Ce guide construit cette couche : Sonnet par défaut, Opus pour le travail de production à fort enjeu, Fable uniquement pour les jobs d’agents longs où la valeur d’un bon résultat dépasse la facture de tokens.
La Règle De Routage : Fable Est Un Spécialiste, Pas Un Choix Par Défaut
Commençons par un tableau sans détour.
| Modèle | ID du modèle API | Prix entrée / sortie | À utiliser pour |
|---|---|---|---|
| Claude Sonnet 4.6 | claude-sonnet-4-6 | 3 $ / 15 $ par 1M de tokens | code courant, revue, support, extraction, la plupart des agents |
| Claude Opus 4.8 | claude-opus-4-8 | 5 $ / 25 $ par 1M de tokens | code de qualité production, revues complexes, étapes d’agent qui demandent du jugement |
| Claude Fable 5 | claude-fable-5 | 10 $ / 50 $ par 1M de tokens | travail d’agent long, à forte valeur, avec un vrai potentiel de gain |
Le positionnement d’Anthropic colle à ce découpage. Sonnet 4.6 est présenté comme le modèle polyvalent du quotidien pour le code, les agents et les workflows professionnels, avec une fenêtre de contexte de 1M de tokens actuellement en bêta API (Anthropic Sonnet). Opus 4.8 vise le code sérieux, les workflows agentiques et les tâches d’entreprise à fort enjeu (Anthropic Opus). Fable 5 est décrit comme un modèle de niveau Mythos pour des projets ambitieux et longs, ainsi que des agents capables de planifier par étapes, déléguer et vérifier leur propre travail (Anthropic Fable).
Ce qui donne une politique propre :
- Sonnet par défaut. La plupart des prompts ne méritent pas un modèle à 50 $/M en sortie.
- Montez vers Opus quand l’échec coûte cher. Pensez migrations de schéma, revue de PR sensible à la sécurité, analyse financière et refactors multi-fichiers.
- Utilisez Fable seulement quand la tâche est vaste, ambiguë et justifie une facture plus élevée. Runs d’agents sur plusieurs jours, modernisation de codebase, dossiers de recherche profonds et workflows “amène ce projet jusqu’au bout”.
Le débat dans la communauté porte surtout sur ce troisième panier. Le thread HN sur la suspension du 12 juin par Anthropic a généré plus d’un millier de commentaires selon des récapitulatifs HN indexés, et la discussion s’est vite divisée entre sécurité, géopolitique et la question de savoir si quelqu’un peut réellement se permettre un usage agentique à ces prix (thread HN, référence de récap). Les threads Reddit étaient plus directs : des développeurs se plaignaient des sessions Claude Code gourmandes en tokens, des quotas d’abonnement, et se demandaient si 50 $/M en sortie ne poussait pas Fable dans un territoire réservé aux entreprises (discussion ClaudeCode, discussion subreddit ChatGPT).
La réponse pratique qui manque dans la plupart des discussions : ne débattez pas d’un “meilleur modèle” global. Routez selon la valeur attendue.
Étape 1 : Utiliser OneHop Comme Couche D’Accès Drop-In
Si vous voulez le chemin le plus court, utilisez OneHop comme couche fournisseur et gardez votre code applicatif neutre vis-à-vis du provider. La page Fable de OneHop liste anthropic/claude-fable-5, affiche les tarifs officiels à côté des tarifs OneHop, et indique que les nouveaux comptes reçoivent 10 $ gratuits sans carte requise (OneHop Fable 5). La page actuelle liste le support Anthropic Messages sur https://api.onehop.ai/anthropic ; utilisez-le pour l’Anthropic SDK.
Installez le SDK :
pip install anthropic
export ONEHOP_API_KEY="your_key_here"Appel minimal :
from anthropic import Anthropic
client = Anthropic(
api_key=os.environ["ONEHOP_API_KEY"],
base_url="https://api.onehop.ai/anthropic",
)
message = client.messages.create(
model="anthropic/claude-fable-5",
max_tokens=1024,
messages=[{"role": "user", "content": "Plan a safe Rails 6 to Rails 8 migration."}],
)
print(message.content[0].text)C’est le point d’intégration. Votre couche de routage doit se placer au-dessus et décider quelle chaîne de modèle envoyer.
La valeur de OneHop ici est ennuyeuse dans le meilleur sens du terme : un compte, une page modèle claire, et un changement de base URL au lieu de réécrire votre application. Si Fable est en pause ou indisponible, le même routeur peut orienter les tâches haut de gamme vers Opus et garder le produit en vie.
Commencez ici si vous voulez simplement l’accès et les crédits : Claude Fable 5 sur OneHop, puis démarrez avec 10 $ gratuits.
Étape 2 : Construire Un Routeur Sensible Au Budget
Voici un routeur Python compact que vous pouvez lancer. Il estime le coût de la requête, applique un plafond par appel, se replie quand Fable est indisponible, et garde Sonnet comme option par défaut.
import os
from dataclasses import dataclass
from anthropic import Anthropic, APIError, RateLimitError
PRICES = {
"sonnet": {"model": "claude-sonnet-4-6", "in": 3.00, "out": 15.00},
"opus": {"model": "claude-opus-4-8", "in": 5.00, "out": 25.00},
"fable": {"model": "anthropic/claude-fable-5", "in": 10.00, "out": 50.00},
}
@dataclass
class Task:
kind: str
prompt: str
max_output_tokens: int = 2000
budget_usd: float = 0.25
high_value: bool = False
long_running: bool = False
production_risk: bool = False
def rough_tokens(text: str) -> int:
return max(1, len(text) // 4)
def estimate_cost_usd(model_key: str, input_tokens: int, output_tokens: int) -> float:
price = PRICES[model_key]
return (input_tokens / 1_000_000 * price["in"]) + (output_tokens / 1_000_000 * price["out"])
def choose_model(task: Task) -> str:
if task.high_value and task.long_running:
return "fable"
if task.production_risk or task.kind in {"migration", "security_review", "architecture"}:
return "opus"
return "sonnet"
def route_with_budget(task: Task) -> list[str]:
first = choose_model(task)
fallbacks = {
"fable": ["fable", "opus", "sonnet"],
"opus": ["opus", "sonnet"],
"sonnet": ["sonnet"],
}[first]
input_tokens = rough_tokens(task.prompt)
return [
key for key in fallbacks
if estimate_cost_usd(key, input_tokens, task.max_output_tokens) <= task.budget_usd
] or ["sonnet"]
def run(task: Task) -> str:
client = Anthropic(
api_key=os.environ["ONEHOP_API_KEY"],
base_url="https://api.onehop.ai/anthropic",
)
last_error = None
for key in route_with_budget(task):
try:
response = client.messages.create(
model=PRICES[key]["model"],
max_tokens=task.max_output_tokens,
messages=[{"role": "user", "content": task.prompt}],
)
return response.content[0].text
except (APIError, RateLimitError) as exc:
last_error = exc
continue
raise RuntimeError(f"All model routes failed: {last_error}")
if __name__ == "__main__":
task = Task(
kind="migration",
prompt="Create a step-by-step plan to migrate a 200k-line Django app from 3.2 to 5.x.",
max_output_tokens=3000,
budget_usd=0.20,
production_risk=True,
)
print(run(task))Le point important n’est pas l’estimateur de tokens. C’est la frontière de politique produit. Il vous faut un endroit dans votre codebase où le produit dit : “Cette tâche a le droit de coûter plus cher parce que le résultat compte.”
Étape 3 : Ajouter Des Plafonds Qui Collent Au Vrai Comportement Des Agents
Les coûts des agents sont irréguliers. Une complétion de chat est facile à chiffrer. Un agent de code peut inspecter des fichiers, appeler des outils, réécrire, tester, réessayer et résumer. Un thread Reddit affirmait qu’un run Fable avait brûlé des millions de tokens en une heure ; prenez ça comme une anecdote, mais le schéma est bien réel : les agents de long horizon multiplient l’usage de tokens par leurs boucles (Reddit).
Ajoutez trois plafonds :
- Plafond par appel : refusez ou rétrogradez si le coût estimé dépasse le budget de la requête.
- Plafond par tâche : arrêtez l’agent après une limite en dollars, même si chaque appel pris séparément est valide.
- Plafond par utilisateur ou par workspace : empêchez une équipe de brûler tout le compte partagé.
En production, stockez les dépenses dans une table de base de données indexée par workspace_id, task_id et model. Ne vous reposez pas seulement sur les tableaux de bord des fournisseurs. Ils servent au rapprochement de facturation, pas au contrôle produit en direct.
Utilisez aussi le prompt caching de façon agressive. Anthropic dit que Fable conserve la remise existante de 90 % sur les tokens d’entrée via le prompt caching, et les pages Sonnet et Opus annoncent également jusqu’à 90 % d’économies avec le prompt caching (Fable, Sonnet, Opus). Mettez en cache les parties stables : carte du repo, standards de code, docs API, résumés de schéma et longues specs produit. Ne mettez pas en cache les instructions utilisateur volatiles.
Une bonne couche de routage devrait journaliser ces champs à chaque appel :
{
"task_kind": "migration",
"chosen_model": "opus",
"fallback_from": "fable",
"estimated_cost_usd": 0.18,
"budget_usd": 0.20,
"input_tokens": 12000,
"max_output_tokens": 3000
}Ce log, c’est ce qui vous permet de répondre au CFO, au staff engineer et à l’utilisateur qui demande pourquoi l’agent s’est arrêté.
Étape 4 : Traiter Le Fallback Comme Un Comportement Produit
Fable a deux types de fallback à prévoir.
Le premier est le fallback d’infrastructure classique : modèle indisponible, rate limit, timeout, problème fournisseur. Le statut actuel de Fable prouve que ça compte. Anthropic dit que l’accès aux autres modèles n’a pas été affecté par la directive du 12 juin (Anthropic), donc une bonne app doit continuer à fonctionner via Opus ou Sonnet.
Le second est le fallback de sécurité. Anthropic dit que Fable redirige certaines requêtes signalées en cybersécurité et en biologie vers Opus 4.8, et que les utilisateurs ne sont pas facturés aux prix de Fable pour les requêtes reroutées (Anthropic Fable). Le billet de lancement indique que ces garde-fous se déclenchent dans moins de 5 % des sessions en moyenne, avec quelques faux positifs attendus (lancement Anthropic).
Ne le cachez pas aux utilisateurs. Si votre produit de revue sécurité demande Fable et obtient un comportement Opus, l’UI devrait dire quelque chose comme :
“Cette requête a utilisé la route de fallback plus sûre pour la portion signalée. Les résultats peuvent être moins exhaustifs. L’impact budgétaire a été ajusté.”
C’est mieux que de faire semblant que toutes les réponses viennent du même modèle. Ça protège aussi vos evals. Si vous benchmarkez Fable mais que la moitié de votre jeu de test déclenche le fallback, vous mesurez autant le chemin de votre classifieur que le modèle.
Ce Qu’il Faut Livrer Cette Semaine
Livrez le routeur avant de livrer le feature flag Fable.
Pour la plupart des produits développeurs, mes réglages par défaut recommandés sont simples :
- Explication de code, petites corrections, tests, docs : Sonnet 4.6.
- Revue de PR, bugs de production, choix d’architecture : Opus 4.8.
- Travail d’agent sur plusieurs heures ou plusieurs jours avec un bénéfice business clair : Fable 5 quand disponible, avec fallback Opus.
- Tout ce qui est non borné : pas de Fable tant que l’utilisateur n’a pas fixé de budget.
- Tout ce qui se répète chez beaucoup d’utilisateurs : mettez en cache le long contexte ou traitez-le par lots.
Le but n’est pas de vénérer le modèle du haut de gamme. Le but est de dépenser les tokens de frontière là où ils changent vraiment le résultat.
Fable 5 est peut-être le modèle qui fait débattre HN cette semaine. Sonnet reste là où la plupart du trafic de production devrait commencer. Opus est le milieu fiable. L’implémentation gagnante, c’est un routeur ennuyeux avec des plafonds stricts, un fallback honnête et des logs assez bons pour déboguer à la fois la qualité et le coût.
Si vous voulez tester la configuration au plus vite, ouvrez Claude Fable 5 sur OneHop, créez un compte, et démarrez avec 10 $ gratuits. Ensuite, branchez le routeur ci-dessus dans un workflow, pas dans tout votre produit. Mesurez le coût par résultat accepté. Ce chiffre compte plus que n’importe quel benchmark de semaine de lancement.
