Actualités IA · 10 min de lecture

Claude API Message Threads : ce qui change pour les longues sessions d'agents

La Messages API d'Anthropic garde une conversation temporaire sur le serveur. Découvrez les gains de latence et la facturation des tokens.

Illustration de courts échanges ajoutés à une chronologie lumineuse de conversation conservée sur le serveur, au lieu de renvoyer tout l'historique.

Les Claude API Message Threads permettent à la Messages API de conserver temporairement une conversation sur le serveur : chaque échange suivant n’envoie ainsi que les nouveaux messages au lieu de renvoyer tout l’historique. Annoncée en bêta publique début novembre 2026, cette fonctionnalité réduit la taille des requêtes et le temps jusqu’au premier token lors des longues exécutions d’agents, mais votre consommation de tokens facturée reste exactement la même.

Si vous avez créé un assistant de programmation ou une boucle d’outils à plusieurs étapes, vous connaissez le problème au 40e échange. Chaque fois que le modèle exécute une commande ou examine une capture d’écran, votre client rassemble tous les prompts, réponses et résultats d’outils précédents et renvoie le tout sur le réseau. Message Threads est la solution d’Anthropic à ce goulot d’étranglement de transport et de validation, avec quelques règles strictes concernant l’expiration après cinq minutes, le prompt caching et la conservation des données, à prendre en compte avant l’activation.

Que sont les Claude API Message Threads ?

Les Message Threads constituent un cache de conversation côté serveur pour la Claude Messages API, activé en bêta avec l’en-tête message-threads-2026-08-12. Au lieu de traiter chaque appel API comme un nouveau départ nécessitant tout votre historique de chat, le serveur conserve la conversation en mémoire entre les échanges : votre client ne transmet donc que les changements depuis la dernière réponse.

Selon les notes de version et la documentation d’Anthropic du 2 novembre 2026, cette fonction est distincte des fils de session de Claude Managed Agents. Elle fonctionne directement sur /v1/messages avec tous les modèles en bêta et est disponible sur la Claude API directe, Claude Platform on AWS, Claude Models on Google Cloud (géré par Anthropic) et Claude in Microsoft Foundry.

Entre les échanges, Anthropic conserve le fil en mémoire serveur, chiffré avec une clé gérée par le serveur, et ne l’écrit jamais sur un stockage disque durable.

Que permet d’économiser Message Threads, et que ne change-t-il pas ?

Message Threads réduit le volume envoyé sur le réseau et le temps jusqu’au premier token (TTFT) lors des longues conversations, mais ne réduit pas le nombre de tokens facturés et ne modifie pas vos limites de débit.

Lorsqu’une session d’agent atteint des centaines de milliers de tokens, ce qui est fréquent quand une boucle de programmation lit de gros fichiers ou qu’un agent utilisant un ordinateur échange des captures d’écran, renvoyer et valider cette charge à chaque échange ajoute un délai perceptible avant même que le modèle commence à générer. Anthropic indique que Message Threads est activé par défaut pour la plupart des utilisateurs de Claude Code et que, pour les requêtes de 500k à 1M tokens, le TTFT médian baisse d’environ 35%.

Votre facture, elle, ne change pas. Même si votre requête HTTP ne contient que le dernier message utilisateur ou résultat d’outil, Claude lit toujours toute la conversation à chaque échange. Les tarifs standard des tokens s’appliquent : en novembre 2026, Claude Opus 5.5 est affiché à $4 par million de tokens d’entrée ($0.20 en cache) et $20 par million de tokens de sortie, tandis que Sonnet 5.5 coûte $2 en entrée ($0.10 en cache) et $10 en sortie (consultez notre comparatif des prix des API d’IA et notre guide Claude Opus 5.5 vs. Sonnet 5.5 pour comparer ces tarifs).

Ce qui change avec Message Threads Ce qui reste identique
Charges utiles HTTP plus petites pour les échanges suivants Tokens de toute la conversation lus et facturés à chaque échange
Temps jusqu’au premier token réduit (baisse médiane du TTFT d’environ 35% sur les requêtes de 500k–1M tokens dans Claude Code, selon Anthropic) Tarifs standard des tokens API et limites de débit existantes
system et tools envoyés une fois à la création du fil Votre application reste la source de référence pour l’historique des messages

Comment créer et poursuivre un fil ?

Vous démarrez un fil en envoyant une requête /v1/messages normale avec "thread": {"type": "create"} et l’en-tête bêta message-threads-2026-08-12, puis vous le poursuivez à l’échange suivant en transmettant l’id de la réponse comme previous_message_id. Si vous utilisez les SDK d’Anthropic, l’utilitaire client.beta.messages.thread(...) gère la création et la poursuite et ajoute automatiquement l’en-tête bêta.

Lors de l’appel create initial, incluez toute votre conversation jusqu’à ce point ainsi que system et tools :

{
  "model": "claude-sonnet-5-5",
  "max_tokens": 2048,
  "system": "You are a careful repository refactoring assistant.",
  "tools": [
    {
      "name": "run_tests",
      "description": "Run the project test suite",
      "input_schema": { "type": "object", "properties": {} }
    }
  ],
  "thread": {
    "type": "create"
  },
  "messages": [
    { "role": "user", "content": "Check why the auth test is failing." }
  ]
}

L’API renvoie une réponse de message standard avec un id (par exemple msg_01XYZ...) représentant la conversation enregistrée, réponse de Claude comprise. À l’échange suivant, vous n’envoyez que les nouveaux messages, comme un tool_result ou le prompt suivant de l’utilisateur, et faites référence à cet id :

{
  "model": "claude-sonnet-5-5",
  "max_tokens": 2048,
  "thread": {
    "type": "continue",
    "previous_message_id": "msg_01XYZ..."
  },
  "messages": [
    {
      "role": "user",
      "content": [
        {
          "type": "tool_result",
          "tool_use_id": "toolu_01ABC...",
          "content": "FAIL src/auth.test.ts: expected 200, got 401"
        }
      ]
    }
  ]
}

Les règles qui risquent de vous piéger si vous sautez la documentation

Anthropic impose une stricte cohérence pendant toute la durée de vie d’un fil :

  • Champs réservés à la création : Vous devez omettre system et tools dans chaque requête continue. Les renvoyer entraîne une erreur 400.
  • Champs fixes : Vos valeurs de model, tool_choice, thinking, mcp_servers (sauf le jeton d’authentification de chaque serveur), context_management, output_config, les skills de conteneur, cache_control au niveau supérieur et l’ensemble exact des valeurs d’en-tête anthropic-beta doivent correspondre à l’appel create initial. Toute modification déclenche une erreur 400 thread_fingerprint_mismatch.
  • Champs par échange : Vous restez libre de modifier max_tokens, stop_sequences, stream, metadata et service_tier d’un échange à l’autre.
  • Historique limité aux ajouts : Chaque id de réponse ne peut être poursuivi qu’une fois, et vous devez toujours poursuivre à partir du dernier id de réponse. Pour modifier un message antérieur ou créer une branche de conversation, vous devez démarrer un nouveau fil avec create.

Combien de temps dure un Message Thread ?

Un Message Thread expire 5 minutes après sa dernière requête et est définitivement supprimé de la mémoire du serveur au plus tard 1 heure après sa dernière utilisation. Chaque réponse enregistrée avec succès réinitialise le minuteur de 5 minutes.

Les fils étant conservés en mémoire volatile comme cache sans garantie, la réponse de l’API ne vous indique jamais à l’avance si un échange précis a été enregistré. Vous ne le découvrez qu’au prochain appel continue. Si le délai de 5 minutes est écoulé ou si le serveur a évincé le fil plus tôt, l’API renvoie une erreur 404.

Lorsque votre client reçoit une erreur 404, la récupération est simple : renvoyez tout l’historique de la conversation (avec system et tools) dans une nouvelle requête "thread": {"type": "create"}. Votre application doit rester la source de référence et conserver sa propre copie complète de chaque message et résultat d’outil.

Comment les Message Threads fonctionnent-ils avec le prompt caching ?

Message Threads et le prompt caching résolvent différentes parties du problème des longs contextes, et le prompt caching n’est pas automatique lorsque vous activez les fils. Message Threads réduit les octets que vous envoyez et validez sur le réseau ; le prompt caching réduit le prix des tokens d’entrée répétés (par exemple, de $2 à $0.10 par million de tokens d’entrée Sonnet 5.5, comme détaillé dans notre comparatif des prix des API d’IA).

Pour obtenir à la fois un TTFT plus rapide et des coûts de tokens d’entrée plus bas, vous devez activer les deux. Pour mettre chaque échange d’un fil en cache, incluez cache_control au niveau supérieur dans la requête create initiale et continuez à envoyer le même cache_control au niveau supérieur dans chaque requête continue (rappelez-vous que cache_control au niveau supérieur est l’un des champs fixes qui doivent correspondre dans tout le fil). Anthropic autorise au maximum 4 points d’arrêt cache_control lorsque thread est défini.

Qui devrait activer Message Threads ?

Les équipes qui exécutent de longues boucles de programmation, des workflows utilisant un ordinateur ou des agents multi-échanges traitant beaucoup de documents en tireront le bénéfice le plus net, tandis que celles soumises à des exigences strictes de conformité ou utilisant des pipelines batch devront peut-être s’en passer. Si vous découvrez la différence entre les boucles utilisant des outils et les chatbots ordinaires, notre guide sur ce qu’est un agent IA en présente les bases.

Les cas où Message Threads convient le mieux :

  • Agents de programmation : Des boucles qui lisent des fichiers, exécutent des compilateurs et itèrent sur des dizaines d’échanges rapides pendant la fenêtre active de 5 minutes. (Anthropic l’a déjà activé par défaut pour la plupart des utilisateurs de Claude Code.)
  • Agents utilisant un ordinateur : Des workflows où chaque échange joint une nouvelle capture d’écran du bureau ou du navigateur ; conserver les captures précédentes sur le serveur évite de renvoyer des mégaoctets d’images en base64 à chaque étape.
  • Chats riches en documents et en images : Des sessions interactives où un utilisateur envoie de gros PDF ou des ensembles d’images et pose rapidement des questions de suivi. Même si votre agent orchestre des pipelines multimédias externes, par exemple en rédigeant des scripts et en lançant des rendus dans un outil comme AI Studio, garder le contexte de planification volumineux et les images de référence dans un fil côté serveur rend la boucle de coordination plus réactive.

Cas bloqués ou non pris en charge en novembre 2026 :

  • Organisations Zero Data Retention (ZDR) et HIPAA : Les Message Threads ne sont pas éligibles à ZDR, et les organisations ayant activé la préparation HIPAA ne peuvent pas les utiliser.
  • Fonctionnalités API non prises en charge : Vous ne pouvez pas utiliser thread avec Message Batches, les requêtes de comptage de tokens contenant thread, la compaction à la demande, la plupart des stratégies de modification du contexte (sauf clear_thinking_20251015 avec keep: "all"), ou les organisations ayant activé les Inference hooks.

Ce que je ferais concrètement

Si vous maintenez une infrastructure d’agent sur la Claude Messages API, j’activerais Message Threads partout où une tâche dépasse régulièrement 100k tokens et où les échanges sont espacés de moins de cinq minutes, à condition que vos exigences de conformité le permettent. Voici la liste de déploiement que je suivrais :

  1. Gardez votre stockage local des conversations intact. Considérez les fils sur le serveur uniquement comme un accélérateur de transport, jamais comme votre base de données. Enregistrez localement chaque échange utilisateur, réponse de l’assistant et résultat d’outil comme aujourd’hui.
  2. Entourez continue d’un mécanisme de secours automatique pour 404. Lorsqu’un appel continue renvoie 404 (après 5 minutes d’inactivité ou une éviction du cache sans garantie), interceptez l’erreur et rejouez immédiatement tout l’historique local avec "thread": {"type": "create"}, system et tools.
  3. Associez-le à cache_control au niveau supérieur. N’activez jamais Message Threads en espérant réduire votre facture. Placez cache_control au niveau supérieur dans vos appels create et continue pour obtenir la réduction de 90%+ sur les entrées en cache en plus du gain de TTFT. Consultez notre comparatif des prix des API d’IA pour estimer les coûts d’entrée avec et sans cache à 500k tokens.
  4. Fixez la configuration du fil dès sa création. Vérifiez que votre boucle d’agent ne modifie pas dynamiquement les en-têtes tools, system, thinking ou anthropic-beta en cours de tâche, sous peine d’obtenir des erreurs 400 thread_fingerprint_mismatch.
  5. Vérifiez d’abord les paramètres ZDR et HIPAA. Si votre espace de travail dépend de Zero Data Retention ou de la préparation HIPAA, laissez Message Threads désactivé : la bêta n’est éligible à aucun des deux.

Questions fréquentes

Message Threads réduit-il le coût de mes tokens Claude API ?

Non. Même si chaque requête HTTP suivante ne transporte que les nouveaux messages, Claude lit toujours tout l’historique à chaque échange. La totalité des tokens d’entrée et de sortie est facturée aux tarifs Claude standard, et les limites de débit existantes restent applicables. Pour réduire votre facture de tokens d’entrée sur un contexte répété, combinez Message Threads et prompt caching.

Ai-je encore besoin du prompt caching si j’utilise les Message Threads ?

Oui. Message Threads conserve simplement la conversation en mémoire serveur pour vous éviter de renvoyer et de revalider les anciens messages sur le réseau. Il n’active pas automatiquement le prompt caching. Pour obtenir le tarif des entrées en cache à chaque échange, envoyez cache_control au niveau supérieur dans la requête create initiale et chaque requête continue suivante (jusqu’à 4 points d’arrêt au total).

Que se passe-t-il après 5 minutes d’inactivité ?

Un Message Thread expire 5 minutes après sa dernière requête (et est supprimé de la mémoire au plus tard 1 heure après sa dernière utilisation). Si vous envoyez une requête continue après son expiration, l’API renvoie un code d’état 404. Votre client doit intercepter ce 404 et renvoyer toute la conversation avec "thread": {"type": "create"} pour démarrer un nouveau fil.

Message Threads est-il disponible sur AWS, Azure et Google Cloud ?

Oui. Selon les notes de version d’Anthropic du 2 novembre 2026, la bêta publique (message-threads-2026-08-12) est disponible sur la Claude API directe, Claude Platform on AWS, Claude Models on Google Cloud (géré par Anthropic) et Claude in Microsoft Foundry.

Claude Code utilise-t-il déjà les Message Threads ?

Oui. Anthropic indique que les Message Threads sont activés par défaut pour la plupart des utilisateurs de Claude Code, avec une réduction médiane d’environ 35% du temps jusqu’au premier token pour les requêtes de 500k à 1M tokens.

Détails de la fonctionnalité vérifiés pour la dernière fois le 3 novembre 2026. Prochaine vérification : 3 décembre 2026.

Sources

Écrit par

Chunyu Cai

Chunyu Cai est le directeur général de Lotook, LLC et un entrepreneur qui écrit sur les modèles d’IA, les agents et leur influence sur le travail au quotidien. Chunyu Cai est titulaire d’un master de l’établissement Imperial College London.