Larssen Consulting
Agents et outils

Thread côté serveur

Conversation state

Le thread côté serveur est un mécanisme d’API dans lequel le fournisseur du modèle conserve l’historique d’une conversation sous un identifiant, pour que chaque nouvelle requête n’envoie que les derniers messages, ce qui allège les échanges et réduit la latence des agents qui travaillent longtemps.

  • Lecture : 5 minutes
  • Mis à jour le 12 novembre 2026
  • 4 sources

En clair

Quand on appelle un service client, il y a deux façons de reprendre un dossier. Soit on réexplique toute l’affaire depuis le début à chaque appel, soit on donne son numéro de dossier et le conseiller retrouve l’historique sur son écran. Les modèles de langage fonctionnent par défaut de la première façon : ils ne gardent rien d’une requête à l’autre, et l’application doit leur renvoyer toute la conversation à chaque fois.

Pour un échange de trois messages, c’est sans importance. Pour un agent qui travaille des heures et accumule des centaines de milliers de tokens d’historique, chaque étape oblige à retransmettre un énorme dossier, que le serveur doit recevoir, vérifier et découper à nouveau avant même de commencer à réfléchir. Le thread côté serveur, c’est le numéro de dossier : le fournisseur garde l’historique, et l’application n’envoie que le dernier message en citant la réponse précédente.

Il faut bien comprendre ce que cela change et ce que cela ne change pas. Les requêtes sont plus petites et la réponse démarre plus vite. Mais le modèle, lui, relit toujours l’intégralité de la conversation pour répondre, et la facture en tokens reste la même. Le thread est un raccourci de transport, pas une mémoire.

Un exemple

Une équipe de développement fait tourner un agent de revue de code qui analyse de grosses branches pendant plusieurs heures. Au fil de la journée, l’historique dépasse plusieurs centaines de milliers de tokens et les développeurs se plaignent d’attendre de longues secondes avant chaque réponse. L’équipe active un thread côté serveur : la première requête transmet tout, les suivantes n’envoient que le dernier résultat d’outil.

Le délai avant la première réponse baisse sensiblement, mais la facture mensuelle ne bouge pas, ce que l’équipe avait anticipé. Elle garde par ailleurs sa propre copie de chaque message, car le thread expire après quelques minutes d’inactivité, pendant les pauses déjeuner par exemple : son code renvoie alors l’historique complet pour recréer un thread, sans intervention humaine.

Niveau technique

Comment ça marche

OpenAI a popularisé le principe avec les threads de son Assistants API, qui stockaient côté serveur les messages d’une conversation. Cette API a été arrêtée le 26 août 2026 et remplacée par les conversations de la Responses API, qui stockent non seulement les messages mais aussi les appels et résultats d’outils 1. On peut y chaîner les réponses avec le paramètre previous_response_id ou les rattacher à un objet conversation durable ; la documentation précise que tous les tokens d’entrée des réponses précédentes de la chaîne restent facturés comme des tokens d’entrée, et que les réponses sont conservées 30 jours par défaut, sauf si l’on désactive le stockage 2.

  1. CréationLa première requête envoie tout l’historique, le prompt système et les outils ; le fournisseur ouvre un thread.
  2. ContinuationChaque requête suivante n’envoie que les nouveaux messages, en citant l’identifiant de la réponse précédente.
  3. Lecture complèteLe fournisseur reconstitue la conversation et le modèle la relit en entier pour répondre ; les tokens restent facturés.
  4. Expiration et repriseAprès quelques minutes d’inactivité, le thread disparaît ; l’application renvoie alors sa copie complète pour en ouvrir un nouveau.

Anthropic propose depuis le 2 novembre 2026 des message threads en bêta publique dans sa Messages API 4, avec l’en-tête message-threads-2026-08-12 : la première requête crée le thread avec tout l’historique, le prompt système et les outils, puis chaque requête suivante n’envoie que les nouveaux messages en citant l’identifiant de la réponse précédente 3. Le thread est conservé « au mieux » : il expire cinq minutes après sa dernière requête et il est supprimé au plus tard une heure après sa dernière utilisation ; l’application doit rester la source de vérité et garder sa copie pour pouvoir tout renvoyer si le thread a disparu. Il ne s’ajoute qu’en fin, la compaction à la demande n’y est pas disponible, il n’est pas éligible à la non-conservation des données, et il ne modifie ni les prix ni les limites de débit 3. Anthropic annonce une baisse d’environ 35 % du temps médian avant le premier token sur les requêtes de Claude Code de 500 000 à un million de tokens, où la fonction est activée par défaut pour la plupart des utilisateurs 4.

Le thread côté serveur se distingue du prompt caching, qui réduit le prix de relecture d’un préfixe identique : un thread ne met rien en cache par lui-même, et les deux se combinent 3. Il ne change pas non plus la fenêtre de contexte, dont la limite s’applique toujours à l’historique entier, et ne remplace pas la compaction de contexte, qui le résume. Il rappelle enfin la sticky session, mais l’état est ici conservé par le fournisseur d’API, et non par un serveur de l’application.

Ce que ça change pour une entreprise

Pour les agents qui travaillent longtemps sur de gros volumes, le thread côté serveur apporte surtout de la réactivité : des requêtes plus légères et un premier token plus rapide, sans réécrire l’agent 4. Il ne fait pas baisser la facture : chez OpenAI comme chez Anthropic, l’historique relu reste facturé 2 3. Les économies, elles, viennent du prompt caching et d’un contexte mieux tenu.

Le choix engage la gestion des données. L’historique est confié au fournisseur, pour une heure au plus chez Anthropic 3 ou trente jours par défaut chez OpenAI hors conversations durables 2, ce qui doit être vérifié au regard des exigences de conservation et de confidentialité ; la fonction d’Anthropic n’est pas éligible à la non-conservation des données 3. Il crée aussi une dépendance technique : la façon d’ouvrir, de reprendre et de recréer un thread diffère d’un fournisseur à l’autre, et l’application doit garder sa propre copie pour ne pas perdre le fil.

Idées reçues

  • « Puisqu’on n’envoie plus que le dernier message, on ne paie plus que lui. »

    Le modèle relit toute la conversation : les tokens de l’historique restent facturés comme des tokens d’entrée [2] [3].

  • « Le fournisseur garde la conversation, on peut supprimer sa propre copie. »

    Le thread peut expirer après quelques minutes ; l’application doit rester la source de vérité pour tout renvoyer si besoin [3].

  • « Un thread côté serveur donne une mémoire illimitée à l’agent. »

    C’est un raccourci de transport : le modèle relit tout l’historique à chaque tour [3], qui reste donc soumis à la limite de la fenêtre de contexte.

Sources

  1. OpenAI, « Assistants migration guide », documentation, 2026
  2. OpenAI, « Conversation state », documentation, 2026
  3. Anthropic, « Message threads », documentation, 2026
  4. Paul Lefizelier, « Anthropic message threads speed long Claude Code sessions », Idlen, 2026

Voir aussi