Que se passe-t-il, vraiment, quand vous parlez à une IA ?

Trois idées suffisent pour comprendre — et démystifier — ChatGPT, Claude, Gemini et tous leurs cousins : le jeton, le transformateur, et la fenêtre de contexte. Aucune formule, juste des analogies qui tiennent.

L'IA ne lit pas de mots. Elle lit des jetons.

Première surprise : quand vous écrivez « Bonjour, comment vas-tu ? » à une intelligence artificielle, elle ne voit ni votre phrase, ni vos mots, ni même vos lettres. Elle voit une suite de jetons — un mot anglais qu'on garde en français, tokens — produits par un découpage automatique de votre texte.

Un jeton, ce n'est pas un mot complet ni une lettre seule : c'est un fragment, quelque part entre les deux. En français, un jeton vaut typiquement 3 à 4 caractères, soit environ trois quarts de mot. Le mot fenêtre peut tenir en un seul jeton parce qu'il est fréquent. fenêtres peut se découper en deux (fenêtre + s). Un nom propre rare ou un mot technique peut éclater en quatre ou cinq morceaux.

Pourquoi est-ce important pour vous ? Parce que tout, dans les outils d'IA, se mesure en jetons : la facture si vous payez à l'usage, la longueur maximale d'une conversation, la taille des documents que vous pouvez analyser. Quand un fournisseur annonce « 200 000 jetons de contexte », c'est l'équivalent d'environ 500 pages de livre. Quand vous lui collez un document, il le découpe en jetons avant de le regarder.

Une seule opération, répétée des milliers de fois : prédire le prochain jeton.

Voici l'idée la plus contre-intuitive du domaine, et celle qui change tout : aussi sophistiqué soit-il, un grand modèle de langage ne fait fondamentalement qu'une seule chose. Étant donnée une suite de jetons, prédire celui qui vient ensuite.

Pas de planification globale. Pas de réflexion préalable sur l'ensemble de la réponse. Pas de plan caché. Un jeton à la fois, dans une boucle qui ne s'arrête que quand le modèle décide qu'il a terminé.

Comment fait-il ? L'architecture qui réalise cette prédiction s'appelle un transformateur. Ce qu'il faut retenir, sans entrer dans la machinerie, c'est son principe central — l'attention. Pour chaque jeton à produire, le modèle pèse l'importance relative de tous les jetons déjà présents. Chaque mot regarde tous les autres et décide lesquels comptent. Une sorte de relecture intégrale, à chaque pas.

Cette mécanique a une conséquence pratique étonnante. Quand l'IA vous répond, elle ne sait pas, au moment où elle écrit le premier mot, comment elle finira sa phrase. Elle écrit, mot après mot, en se relisant à chaque pas pour décider du suivant. Ce qui ressemble à de la pensée fluide est une succession de micro-décisions probabilistes. Cela explique pourquoi une IA peut commencer une réponse confiante et finir par une affirmation fausse — elle s'est « laissée porter » par sa propre génération.

La fenêtre de contexte, ou pourquoi votre IA « oublie ».

Si le modèle ne fait que prédire le prochain jeton à partir de ce qui précède, il faut lui définir un horizon — la quantité de jetons qu'il peut « voir » en même temps. Cet horizon s'appelle la fenêtre de contexte.

C'est la notion centrale à intégrer si vous utilisez régulièrement des outils d'IA. La fenêtre est tout à la fois : la zone d'attention du modèle, son champ de vision, et son seul support d'information. Tout ce qui s'y trouve peut influencer sa réponse ; tout ce qui n'y est pas n'existe pas pour lui.

Cette fenêtre a une taille maximale, fixée à la fabrication du modèle, mesurée en jetons. Selon le modèle, on parle de quelques milliers à plusieurs centaines de milliers de jetons. Pour les modèles Claude actuels par exemple, la fenêtre standard est d'environ 200 000 jetons, soit l'équivalent d'un livre de 500 pages. Au-delà, on ne peut plus rien ajouter : il faut retirer du contenu existant pour faire de la place.

Pourquoi votre IA « oublie » au bout d'un moment

Vous avez peut-être déjà eu cette expérience : dans une longue conversation, l'assistant semble oublier ce que vous lui avez dit en début d'échange. Pas un bug. Une conséquence directe de ce qu'on vient de voir. Quand l'historique atteint la limite de la fenêtre, l'application qui pilote le modèle est obligée de couper : soit elle élague les anciens messages, soit elle les remplace par un résumé plus court. Dans les deux cas, le détail original est perdu pour le modèle.

Et pour la même raison, charger un PDF de 800 pages dans une fenêtre de 200 000 jetons peut tout simplement ne pas tenir. Au-delà, l'outil doit ruser — découper le document, n'en charger que des extraits pertinents, ou refuser. Aucune magie.

D'un prédicteur de texte à un assistant qui répond.

Voici la deuxième idée contre-intuitive du domaine. Un transformateur, livré à lui-même, ne « répond » pas aux questions. Il continue du texte. Donnez-lui « La capitale de la France est », il complétera vraisemblablement par « Paris. ». Donnez-lui « Bonjour, comment vas-tu ? », il pourrait tout aussi bien continuer par « demanda Marie en ouvrant la porte. » — parce que c'est aussi une suite plausible dans le corpus de textes qui l'a entraîné.

Pour qu'il se comporte comme un assistant — qu'il réponde au lieu de continuer — il faut lui donner un cadre. Ce cadre s'appelle le system prompt : un texte placé avant la conversation qui définit qui le modèle est, ce qu'il doit faire, comment il doit s'exprimer, et ce qu'il doit refuser. C'est la première chose qu'il « lit » à chaque requête, et tout le reste se construit par-dessus.

Le system prompt est le mécanisme qui anime les produits que vous utilisez — ChatGPT, Claude.ai, Gemini, Copilot, Le Chat. Derrière chaque interface conversationnelle, un texte d'instructions transforme un prédicteur brut en assistant. Voici à quoi ça ressemble en pratique :

Changez le system prompt, vous changez l'assistant. Voici le même modèle, avec une autre identité :

Même cerveau, deux personnalités. Tout est du texte continu — les étiquettes Utilisateur : et Assistant : ne sont rien d'autre que des marqueurs textuels qui aident le modèle à savoir quand son tour de continuer arrive.

Le modèle ne se souvient de rien.

Voici la troisième idée à intégrer, et elle a des implications très concrètes pour vous. Le transformateur est sans état. Entre deux requêtes, il n'a aucun souvenir de ce qui a été dit. Aucun. Pour qu'une conversation paraisse continue, l'application qui parle au modèle doit lui renvoyer la conversation entière à chaque tour.

Quand vous tapez « Et sa population ? » dans une discussion qui parlait du Canada, l'application reconstruit en coulisse tout l'historique et l'envoie au modèle :

Tout est là, dans une seule longue chaîne. Le modèle reçoit ce bloc, voit qu'il se termine par Assistant : avec un curseur, et continue le texte. Sans cette reconstitution intégrale, il n'aurait aucune idée de ce que désigne « sa » dans la dernière question.

Cette absence de mémoire interne a une conséquence très concrète : chaque nouvel échange dans une conversation repaie le coût de tout ce qui précède. Plus la conversation avance, plus chaque tour est cher en jetons et plus la fenêtre se remplit. C'est pour ça que les conversations très longues finissent par se tasser, ralentir, ou démarrer dans un nouveau fil.

Et c'est aussi pour ça qu'on voit apparaître, dans les produits modernes, des fonctions de mémoire persistante — un magasin distinct de la conversation où le système enregistre les faits durables sur vous (préférences, projets, contexte professionnel) pour les ré-injecter quand c'est pertinent. Ce n'est pas le modèle qui se souvient : c'est l'application qui lui rappelle.

Comment une IA peut agir sur le monde.

Si une IA ne fait que prédire des jetons, comment peut-elle « lire un fichier », « chercher sur le web » ou « envoyer un courriel » ? La réponse est élégante : elle ne fait toujours rien d'autre que produire du texte — mais ce texte peut prendre la forme d'une instruction d'action que le programme hôte va reconnaître et exécuter pour elle.

L'astuce tient en deux ingrédients. D'abord, on apprend au modèle, dans son system prompt, qu'il a accès à des outils : lire un fichier, chercher sur le web, exécuter du code, etc. Ensuite, l'application surveille ce que le modèle écrit. Quand il produit une ligne qui ressemble à un appel d'outil — quelque chose comme read_file("/data/rapport.txt") — l'application l'intercepte, exécute réellement l'opération, et injecte le résultat dans la conversation. Du point de vue du modèle, tout reste du texte continu. Du point de vue de l'application, c'est elle qui fait le vrai travail.

Voici à quoi ressemble un cycle complet, en texte continu :

Le modèle demande une action. L'application la fait. Le résultat revient en contexte, le modèle le voit comme s'il l'avait toujours su, et il continue. C'est la mécanique fondamentale des assistants modernes — Claude qui lit votre Google Drive, ChatGPT qui cherche sur le web, GitHub Copilot qui édite votre code. Toujours la même boucle : l'IA demande, l'application exécute, le résultat retourne en contexte.

La conséquence sur la fenêtre

Tout cela laisse une trace dans la fenêtre, et chaque trace coûte des jetons. Lire un fichier de cinquante pages, c'est aussi déposer cinquante pages dans la fenêtre. Faire dix recherches web, c'est ajouter dix pages de résultats. C'est pour ça que les agents modernes — ceux qui enchaînent des actions de leur propre chef — peuvent saturer leur fenêtre étonnamment vite. Et c'est aussi le sujet principal de l'article suivant, pour qui veut aller plus loin.

Trois idées qui suffisent à tout expliquer.

Si vous quittez cette page avec trois choses en tête, qu'elles soient celles-ci. Premièrement — l'IA lit des jetons, pas des mots, et tout ce qu'elle voit doit tenir dans une fenêtre de taille fixe. Deuxièmement — elle ne fait qu'une opération, prédire le prochain jeton, dans une boucle qui relit l'entrée à chaque pas. Troisièmement — elle n'a aucune mémoire entre deux requêtes : c'est l'application autour d'elle qui simule la continuité, en lui renvoyant l'historique à chaque tour, et qui exécute réellement les outils qu'elle réclame.

Avec ces trois idées, vous pouvez expliquer pourquoi votre assistant oublie au bout d'un moment, pourquoi un long document peut « ne pas tenir », pourquoi un même modèle se comporte différemment d'un produit à l'autre, et pourquoi un agent qui consulte beaucoup de sources peut devenir lent ou imprécis. Tout ce que vous lirez ensuite sur le sujet — RAG, MCP, compaction, sous-agents — sera de la variation autour de ces mêmes contraintes.