Claude Haiku 5.5 : le vrai coût d'un petit modèle dans un agent ou un RAG Java

Claude Haiku 5.5, c'est quoi et combien ça coûte ?

Claude Haiku 5.5 est le petit modèle d'Anthropic, sorti le 7 octobre 2026 sous l'identifiant claude-haiku-5-5. Il coûte 0,10 $ par million de tokens en entrée et 0,50 $ en sortie, tant que le prompt reste sous 100 000 tokens. Au-delà, les prix sont multipliés par cinq.

La documentation donne un contexte de 1 million de tokens et jusqu'à 128 000 tokens de sortie (300 000 en bêta sur la Batch API). La réflexion est adaptative, avec un effort réglable (medium par défaut).

L'identifiant est fixe : pas de suffixe de date, pas d'alias séparé. Le modèle est disponible sur l'API Claude, Amazon Bedrock, Google Cloud et Microsoft Foundry.

L'annonce d'Anthropic le destine aux tâches à fort volume : résumés, compaction de contexte, classification, requêtes en base. Elle le présente aussi comme un sous-agent de Sonnet 5.5 ou d'Opus 5.5 sur du code.

Sauf mention contraire, les chiffres qui suivent viennent des pages d'Anthropic, relevées le 13 octobre 2026. Je n'ai mesuré aucun benchmark.

Une grille à deux paliers : le seuil des 100 000 tokens

Haiku 5.5 est le seul modèle actuel d'Anthropic facturé selon la longueur du prompt. Les autres facturent leur million de tokens de contexte au même tarif. Voici la grille de la page Pricing, en dollars par million de tokens :

	Haiku 5.5 (≤ 100K)	Haiku 5.5 (> 100K)	Sonnet 5.5	Opus 5.5
Entrée	0,10	0,50	2	4
Sortie	0,50	2,50	10	20
Écriture de cache (5 min)	0,125	0,625	2,50	5
Lecture de cache	0,01	0,05	0,10	0,20

La règle du seuil a un piège. Le compte inclut tout le prompt, lectures et écritures de cache comprises. Une requête de 120 000 tokens, dont 100 000 en cache, paie donc le tarif haut sur tout.

En chiffres, sans cache : 100 000 tokens d'entrée coûtent 0,01 $. 120 000 tokens coûtent 0,06 $, et la sortie passe à 2,50 $ le million.

La Batch API (traitement asynchrone, résultats différés) retire 50 % sur l'entrée et la sortie : 0,05 $ et 0,25 $ sous le seuil. La doc précise que cette remise se cumule avec les tarifs du cache.

Reste le « 75 % moins cher » que reprennent les médias. C'est une moyenne calculée par Anthropic.

Selon l'éditeur, le prix baisse de 90 % par rapport à Haiku 4.5 sous 100 000 tokens, et de 50 % au-dessus. Sur Haiku 4.5, 90 % des requêtes restaient sous ce seuil. Le calcul intègre aussi le nouveau tokenizer, précise la note de l'annonce.

Ce que coûte une requête RAG, prix publics à l'appui

Prenons une requête de RAG (génération augmentée par recherche documentaire) ordinaire. Elle contient 3 000 tokens d'instructions lus en cache, 6 000 tokens de passages retrouvés et la question, puis 500 tokens de réponse. C'est un calcul sur les prix publiés, pas une mesure.

• Haiku 5.5 : 0,00003 $ de cache, 0,0006 $ d'entrée, 0,00025 $ de sortie. Soit 0,88 $ les 1 000 requêtes.
• Sonnet 5.5 : 0,0003 $ de cache, 0,012 $ d'entrée, 0,005 $ de sortie. Soit 17,30 $ les 1 000 requêtes.

Le calcul omet deux choses. D'abord la réflexion : elle est active par défaut, et ses tokens sont facturés en sortie.

Ensuite le tokenizer (le découpage du texte en tokens). D'après le guide de migration, le même texte compte environ 30 % de tokens de plus que sur Haiku 4.5.

Une estimation faite sur les comptes de Haiku 4.5 est donc à refaire. Elle sous-estime le coût, et elle peut placer sous le seuil un prompt qui le dépasse. Pour un RAG, je plafonne le contexte récupéré bien en dessous de 100 000 tokens, comptés avec le modèle 5.5.

Le cache de prompt dans LangChain4j 1.22 et Spring AI

Le cache de prompt réutilise le début d'une requête déjà traité. Sur Haiku 5.5, il ne s'applique qu'à partir de 512 tokens, et il vit 5 minutes par défaut. Chaque lecture le prolonge sans frais.

LangChain4j 1.22.0, publié le 8 octobre, ajoute le cache automatique d'Anthropic. Anthropic place alors le point de cache sur le dernier bloc de chaque requête et l'avance avec la conversation.

Deux options arrivent sur AnthropicChatModel, sa version streaming et AnthropicBatchChatModel : cacheAutomatically et cacheTtl ("5m" ou "1h"). Les deux sont désactivées par défaut.

ChatModel model = AnthropicChatModel.builder()
    .apiKey(System.getenv("ANTHROPIC_API_KEY"))
    .modelName("claude-haiku-5-5")
    .cacheSystemMessages(true)  // instructions stables
    .cacheTools(true)           // définitions des outils
    .cacheAutomatically(true)   // historique qui grandit
    .build();

Ce bloc reprend les méthodes du code source au tag 1.22.0. Je ne l'ai ni compilé ni exécuté.

Le cache automatique ne convient pas à tout. L'auteur de la demande de fusion #6598 a mesuré le coût d'entrée sur Opus 5.5, pas sur Haiku.

Avec cacheAutomatically seul, sur une boucle d'agent à trois outils qui garde l'historique, l'entrée tombe à environ 21 % du coût sans cache. Sur des appels indépendants, elle monte à environ 125 %.

La doc d'Anthropic donne la raison. Si le dernier bloc change à chaque requête, on paie une écriture de cache sans jamais la relire. C'est le cas d'un RAG, dont les passages changent à chaque question.

Pour un RAG, je garde donc cacheSystemMessages et je réserve cacheAutomatically aux conversations qui s'allongent.

Côté Spring AI 2.0.1, le cache passe par spring.ai.anthropic.chat.cache-options.strategy. Sa valeur par défaut est NONE ; SYSTEM_AND_TOOLS convient au RAG. Le modèle par défaut de la propriété spring.ai.anthropic.chat.model est encore claude-haiku-4-5 : changez-le explicitement.

Haiku 5.5, Sonnet 5.5 ou Opus 5.5 : quand le petit modèle suffit-il ?

Anthropic répond elle-même. Selon l'annonce, Sonnet 5.5 et Opus 5.5 restent de meilleurs choix pour le code agentique complexe. Haiku 5.5 convient aux tâches étroites : compaction, résumé, sous-agent, et selon la doc classification, extraction, routage.

Les benchmarks publiés par l'éditeur vont dans ce sens. Sur Terminal-Bench 4.0 (tâches en ligne de commande), Anthropic annonce 39,2 % pour Haiku 5.5 et 70,6 % pour Sonnet 5.5. Sur OSWorld 2.1 (pilotage d'un ordinateur, sous-ensemble hors ligne), elle annonce 72,4 % contre 83,9 %.

Ces chiffres viennent des tests d'Anthropic, détaillés dans sa system card.

Une mesure indépendante existe. Artificial Analysis donne 43 à Haiku 5.5 en effort maximal sur son indice d'intelligence. Sa fiche le classe 2e sur 175 modèles de sa gamme de prix, pas de tout le marché. Elle le juge aussi très verbeux : 440 millions de tokens générés pour l'évaluation, contre une médiane de 95 millions dans cette gamme. Pour le coût, c'est un chiffre à surveiller autant que le prix unitaire.

En pratique, je découpe l'agent. Un modèle fort planifie et écrit le code. Haiku 5.5 trie, extrait des champs, résume, choisit l'outil à appeler.

Chaque tâche confiée à Haiku doit avoir une sortie vérifiable par le code : une classe, un JSON validé, un identifiant.

Ce qui casse en passant de Haiku 4.5 à Haiku 5.5

Changer l'identifiant ne suffit pas. Le guide de migration liste plusieurs changements, dont des erreurs 400 nouvelles :

• temperature, top_p et top_k : à retirer, une temperature autre que 1 est refusée. Vérifiez vos propriétés Spring AI et vos builders LangChain4j.
• Le prefill (un dernier message assistant que le modèle continue) : refusé, même sans réflexion. Pour forcer un format, passez aux structured outputs, ou à un outil à champ enum pour une classification. Sur Bedrock, les structured outputs ne sont pas disponibles pour Haiku 5.5.
• budget_tokens : la réflexion se règle par l'effort, plus par un budget.
• max_tokens : les tokens de réflexion comptent dedans. Un plafond bas réglé pour Haiku 4.5 peut couper la réponse avant le texte.

Gérez aussi stop_reason: "refusal", car le modèle peut décliner une requête. Enfin, une conversation qui renvoie des blocs de réflexion doit rester en ajout seul. Renvoyer un bloc de réflexion après avoir modifié le prompt système, les outils ou un message antérieur provoque une erreur 400. C'est le cas sur les comptes créés depuis le 31 août 2026.

Que faire cette semaine si vous avez un agent ou un RAG Java ?

Mon avis : Haiku 5.5 change l'économie des tâches répétitives, à condition de rester sous 100 000 tokens. Au-dessus, la baisse tombe à 50 % au tarif, avant le surcoût du tokenizer.

Trois actions :

1. Recompter vos prompts avec claude-haiku-5-5, et repérer ceux qui approchent le seuil.
2. Activer le cache sur la partie stable : instructions et outils. Le cache automatique de LangChain4j 1.22 sert aux conversations qui grandissent, pas aux requêtes indépendantes.
3. Migrer en branche : retirer temperature et le prefill, relever max_tokens, puis comparer les sorties à celles de Haiku 4.5 sur vos propres cas.

Si vous suivez aussi Spring AI, le jalon Spring AI 2.1 prépare d'autres changements côté messages. Et pour une classification pure, le DecisionModel de LangChain4j 1.21 répond sans générer de texte, avec une probabilité par réponse.

Vous voulez chiffrer ce que coûterait votre agent ou votre RAG Java sur Haiku 5.5, Sonnet 5.5 ou Opus 5.5 ? Je développe sur cette stack depuis 2015. Réserver un appel découverte de 30 minutes.