GPT-4o vs Claude & Grok : Les LLMs à l’épreuve des échecs

Les modèles de langage de grande taille (LLMs) tels que GPT-4o, Claude 3.5/3.7 ou encore Grok 3.0, sont aujourd'hui capables de répondre à une variété de requêtes complexes, couvrant des domaines aussi divers que la programmation, la logique, la rédaction ou le raisonnement stratégique. Toutefois, leur capacité à respecter des règles strictes et bien définies sur une longue durée reste un champ d'exploration pertinent.

Les échecs, jeu régi par un ensemble de règles formelles et codifiées (FIDE), offrent un cadre d'expérimentation idéal pour tester la robustesse des LLMs. Contrairement aux moteurs spécialisés comme Stockfish ou Leela, les LLMs n'ont pas d'évaluation de position intégrée ni de mécanisme de validation interne de la légalité des coups. Leur performance repose uniquement sur leur compréhension prédictive du langage et des structures logiques sous-jacentes.

Ce papier propose une méthodologie simple mais rigoureuse pour confronter plusieurs LLMs à une partie d'échecs complète, dans un format texte, où l'humain joue le rôle d'intermédiaire. L'objectif est double :

1. Tester la capacité de ces modèles à gérer la mémoire contextuelle sur la durée via le suivi FEN (Forsyth-Edwards Notation).
2. Identifier les situations dans lesquelles un modèle propose un coup illégal ou perd le fil de la partie.

Les résultats sont surprenants : certains modèles hallucinent rapidement ou perdent le contexte très rapidement, tandis que d'autres, comme GPT-4o, montrent une maîtrise absolue des contraintes imposées.

Nous détaillerons dans ce travail le processus mis en œuvre, les prompts utilisés, les erreurs rencontrées, ainsi que les perspectives de tests futurs intégrant les fonctionnalités avancées comme les "projets" ou le raisonnement pas à pas (CoT).

Contexte et motivation

En tant que passionné par les LLM, je connais les fondements de leur fonctionnement sans être l’expert de pointe : apprentissage par prédiction de token, absence de mémoire d’état interne persistante, tendance à l’hallucination sous contrainte d’ambiguïté, etc. Pourtant, c’est précisément ce qui rend fascinant le fait de confronter ces modèles à un système rigide, normatif, sans ambiguïté possible : les échecs.

Le jeu d’échecs repose sur un ensemble de règles strictes (celles de la FIDE), universellement comprises et vérifiables. Il n’y a pas de place pour l’improvisation syntaxique, les interprétations subjectives ou la créativité non encadrée. Soit un coup est légal, soit il ne l’est pas. Ce cadre formel devient donc un excellent terrain d’expérimentation pour tester non pas la “créativité” des IA, mais leur capacité à raisonner dans un système formel fermé, à suivre des instructions précises, et à s’autocontraindre sur la durée d’une partie.

Ce travail n’a donc pas pour but de prouver que “les LLMs peuvent jouer aux échecs”, car ce n’est pas leur finalité première, mais plutôt d’évaluer leur comportement cognitif sous contraintes strictes. C’est aussi un bon stress test du prompt engineering dans un cadre normatif : que se passe-t-il lorsqu’on les oblige, via consignes simples, à se comporter comme des entités rationnelles, sans anticipation, sans raccourcis, sans erreur ?

Certains experts IA pourraient juger cet usage “hors sujet” mais c’est précisément cette mise à l’épreuve qui en dit long sur la robustesse réelle d’un modèle. Si un LLM échoue à respecter un système formel bien défini, que peut-on réellement espérer dans des contextes ambigus, comme la santé, la justice ou l’éducation ?

📖 Avant cette lecture pour les curieux, je vous incite à lire :

→ Comment construire un système agentic en 2025

→ Architecture agents IA en 2025

Méthodologie expérimentale

Pour tester la capacité des LLMs à respecter les règles officielles des échecs et à jouer dans un cadre strict, j’ai mis en place un processus simple, en m’appuyant uniquement sur les interfaces web des modèles testés, sans API ni moteur tiers pour rester aligné avec l’usage basique qu’un utilisateur lambda utilisera.

Cadre expérimental

Chaque IA est invitée à jouer comme un joueur d’échecs professionnel. Elle reçoit un prompt initial explicite, qui impose :

• le respect strict des règles FIDE,
• l’interdiction absolue de proposer des coups illégaux,
• l’obligation de répondre uniquement au coup précédent, sans anticiper les suivants.

Prompt initial (extrait) :

« Tu es un joueur d’échecs professionnel. […] Tu dois respecter strictement les règles officielles du jeu d’échecs (FIDE). Tu ne dois jamais tricher ou proposer un coup illégal. […] »

À chaque tour, l’IA reçoit l’état exact du plateau via la notation FEN, ainsi que le dernier coup joué par l’adversaire. Elle doit répondre par un unique coup en notation algébrique, avec optionnellement une brève justification.

Exemple de consigne :

Voici l'état actuel de l'échiquier : FEN : rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq - 0 1 ; Le dernier coup de ton adversaire : e4 ; C'est à toi de jouer (noir). Donne ton prochain coup (notation algébrique), et précise s'il y a une prise, un échec ou une promotion si besoin.

Le processus suit une boucle de dialogue humaine (l’intermédiaire humain jouant les coups, et relayant la position et le contexte à chaque tour).

Modèles testés

Trois grands modèles de langage ont été mis à l’épreuve, dans des versions actualisées au moment des tests (avril 2025) :

• GPT-4o (OpenAI) – testé systématiquement comme joueur blanc.
• Claude 3.5 & Claude 3.7 (Anthropic) – comme adversaires noirs.
• Grok 3.0 (xAI) – également comme adversaire noir.

Chaque confrontation a été jouée jusqu’à une position claire de victoire ou d’abandon implicite (modèle n’ayant plus de coup pertinent, ou position théoriquement perdue).

Objectifs

Ce protocole vise à observer trois éléments principaux :

1. Le respect des règles de jeu : coups légaux uniquement, pas d’oubli ou d’invention.
2. La stabilité de réponse : pas de retour incohérent par rapport à la position fournie.
3. L’autonomie stratégique : capacité à prendre des décisions pertinentes dans un cadre tactique.

Pourquoi ce cadre ? (choix du prompt et de la boucle FIDE)

Le choix d’un prompt strict, centré sur les règles FIDE, ne relève pas d’un simple formalisme. Il est motivé par deux constats importants dans le comportement des modèles de langage :

1. Les LLM ne “savent pas” jouer aux échecs en tant que tels: Ils n’ont pas de moteur de validation interne (contrairement à un vrai moteur d’échecs), ils génèrent du texte à partir de probabilité conditionnelle. Cela signifie que, par défaut, un coup comme Nf3 peut être “probable” sans être valide dans la position donnée.

2. L’interaction multi-tour est essentielle: Fournir uniquement la FEN ou uniquement le dernier coup mène souvent à des hallucinations ou à des erreurs de continuité. La présentation combinée (FEN + dernier coup joué + instruction explicite) limite ces biais.

3. L’alignement seul n’est pas suffisant: Même les modèles “alignés” (notamment Claude ou Grok) proposent parfois des coups illégaux. Ce n’est pas uniquement un problème d’intention, mais de représentation de la règle de validité dans le contexte positionnel. Le prompt vise donc à forcer une attention au cadre.

4. Tester les LLM dans des conditions “utilisateur final”: L’objectif est aussi de se rapprocher d’un usage courant : que se passe-t-il si un utilisateur lambda joue aux échecs avec un LLM avancé en passant par l’interface web, sans outil annexe pour vérifier les coups ? On veut simuler cet usage grand public tout en conservant un protocole rigoureux.

Résultats globaux

Sur les trois parties jouées, opposant systématiquement GPT-4o (côté blanc) à un autre LLM (côté noir), le constat est sans appel :

✅ GPT-4o n’a jamais proposé un seul coup illégal

Peu importe la profondeur de la partie, la complexité de la position ou la phase de jeu (ouverture, milieu, finale), chaque réponse de GPT-4o était valide, cohérente avec la FEN, respectueuse des règles FIDE et contextuellement logique. Ce modèle est donc parfaitement utilisable comme moteur de dialogue d’échecs, dans les limites textuelles du protocole choisi.

❌ Claude 3.5 et Claude 3.7 ont proposé plusieurs coups illégaux

Les deux versions testées de Claude ont commis des erreurs à des moments critiques :

• Claude 3.5 a proposé des déplacements impossibles, notamment avec des pièces déjà capturées.
• Claude 3.7, bien que plus stable, a lui aussi halluciné des positions, oubliant des pièces ou en générant là où il n’y en avait pas.

⚠️ Grok 3.0 a mieux résisté mais hallucine par instabilité

Le modèle de xAI a montré une meilleure compréhension tactique dans certains cas… mais a aussi produit des séquences où la position ne suivait plus. Il reste donc intéressant mais peu fiable dans ce protocole.

📊 Comparaison synthétique

Voici les trois vidéos courtes des parties (shorts Youtube) :

Claude 3.7 : https://youtube.com/shorts/kSWPfE42PxE

Claude 3.5 : https://youtube.com/shorts/BK-RAFPHSEY

Grok 3.0 : https://youtube.com/shorts/JsO2WDJCnME

Analyse modèle par modèle

🧠 GPT-4o (OpenAI)

Statut : Référence / baseline

Couleur : Blancs dans toutes les parties

Comportement observé :

• Aucune hallucination.
• Respect strict des règles FIDE, même en finale complexe.
• A donné des coups valables même lorsque l’adversaire proposait un coup illégal (sans s’écarter du protocole).
• Bonne compréhension des motifs classiques (pression sur le centre, domination des colonnes ouvertes, clouages).
• Petite note : GPT-4o ne propose pas de variantes ou d’analyse poussée dans ce protocole, mais reste extrêmement rigoureux dans la production du coup unique demandé.

Conclusion :

Un candidat sérieux pour jouer aux échecs dans un protocole FEN + dialogue texte. Son comportement est parfaitement aligné aux règles sans nécessiter d’ajustement. Le fait qu’il n’ait jamais proposé de coup illégal témoigne d’une excellente gestion du contexte.

🤖 Claude 3.5 (Anthropic)

Statut : Ancienne génération Claude

Couleur : Noirs (contre GPT-4o)

Comportement observé :

• Rapidement Claude à fait des propositions de coups impossibles : déplacement de pièces déjà capturées, ou accès à des cases occupées par ses propres pièces.
• Confusions récurrentes entre les couleurs, surtout dans les échanges.
• Ne semble pas bien intégrer les contraintes de la FEN.

Hypothèse :

Le modèle semble s’appuyer sur une logique d’inférence floue, probablement basée sur des patterns appris plus que sur une modélisation stricte du plateau. Cela rend son comportement peu fiable dans des contextes structurés comme les échecs.

🤖 Claude 3.7 (Anthropic) — Dégradation par rapport à 3.5

Statut : Version plus récente

Couleur : Noirs

Comportement observé :

Contrairement aux attentes, Claude 3.7 se comporte moins bien Il propose bien plus rapidement des coups illégaux, confond les couleurs (ex. : tenter de déplacer des pions adverses), et montre un affaiblissement général de la stabilité contextuelle.

Hypothèse :

La logique de Claude 3.7 est plus “linguistique” que “mécanique”. Il comprend bien le langage, mais pas toujours les implications spatiales d’un jeu comme les échecs.

🦾 Grok 3.0 (xAI)

Statut : Modèle multimodal d’Elon Musk

Couleur : Noirs

Comportement observé :

• Très bon début de partie.
• Capacité à répondre avec des coups cohérents.
• Mais hallucinations progressives, coup joué dans une position qui n’existe pas (probable décalage FEN mal géré).
• N’a pas été aussi fautif que Claude, mais largement moins stable que GPT-4o.

Hypothèse :

La gestion du contexte est souvent bonne, mais la mémoire contextuelle s’effrite sur la longueur de la partie. Le modèle semble avoir du mal à “maintenir une partie stable” sans perdre la cohérence.

⚙️ Processus de test et d’évaluation

🔍 Objectif du protocole

L’idée n’est pas de simuler une partie classique entre deux moteurs d’échecs optimisés.

Le but est de tester la stabilité contextuelle des LLMs dans un scénario contraint :

“Répondre à un coup d’échecs en respectant les règles FIDE à partir d’une position donnée via FEN.”

Cela nous permet de mesurer leur capacité à :

• Intégrer un état du jeu explicité textuellement.
• Respecter des règles strictes dans un univers logique.
• Réagir uniquement à l’information transmise, sans halluciner ou anticiper.

🧪 Protocole appliqué

Chaque partie suit ce protocole précis :

1. Initialisation par message système : Le modèle reçoit un prompt d’initialisation qui le transforme en joueur d’échecs professionnel, en lui rappelant les règles et les limites de son rôle (pas d’anticipation, un seul coup, notation algébrique).

2. Tour par tour :

   • On envoie la FEN (représentation formelle de la position).
   • On précise le dernier coup joué par l’adversaire.
   • On demande une réponse unique (ex : Nf3, dxe6, O-O), avec éventuellement une courte justification.

3. Évaluation automatique et manuelle :

   • Tous les coups sont contrôlés manuellement (et parfois via un moteur comme Stockfish) pour valider leur légalité.
   • Chaque erreur est documentée : coup impossible, pièce absente, règle ignorée (ex : roque interdit, mauvaise capture…).

📊 Métriques d’évaluation

Nous avons retenu trois critères principaux :

👉 Dans tous les cas, GPT-4o n’a commis aucune infraction. Les autres modèles ont chuté sur le premier critère dès la moitié de partie.

🧭 Prochaine phase de test : Mode “Projet” & modèles orientés raisonnement

🧱 Pourquoi changer de cadre ?

Si le test par interface directe (chat web) est révélateur de la stabilité brute d’un LLM face à des consignes structurées, il ne reflète pas l’intégralité du potentiel des modèles.

En particulier, il omet :

• L’utilisation prolongée d’un contexte mémoire persistante.
• La possibilité d’un cadrage initial plus poussé, via les outils comme les “projects” ou “system instructions étendues”.
• L’intégration dans une architecture agentisée, où le modèle est guidé par une logique de décision explicite, une mémoire structurée et des modules de validation ou d’outillage.

🧪 Phase 2 : Intégration du mode “Projet”

✅ Objectif

Explorer si la persistance de contexte et l’encapsulation conversationnelle permettent :

• D’améliorer la cohérence des réponses.
• D’éviter certains décrochages constatés sur Claude ou Grok en session longue.
• D’approcher un comportement proche d’un moteur d’analyse basique mais juridiquement propre (zéro coup illégal).

🔄 Méthodologie

• Utilisation de sessions OpenAI Projects ou Claude “Workbench”.
• Mise en place d’un cadre système enrichi :
  • Règles FIDE injectées de manière persistante.
  • Historique de partie structuré et compressé (FEN + PGN partiel).
• Comparaison directe avec les performances obtenues en mode interface.

🧠 Extension : tester des modèles à forte composante “reasoning”

Certains modèles sont spécifiquement conçus pour maintenir une cohérence logique sur des tâches structurées :

• OpenAI o4-mini : une version compacte et performante intégrant des mécanismes de raisonnement avancés, adaptée aux environnements contraints tout en conservant une forte capacité d’analyse.
• Claude avec l’usage de l’option reasoning.

📌 Hypothèse à tester (semi lol)

L’intégration d’un contexte structuré et persistant améliore drastiquement la qualité, la cohérence et la légalité des coups proposés par les LLMs sur une séquence longue.

🧠 Interlude pédagogique : comprendre les erreurs typiques des LLMs aux échecs

⚠️ Types d’erreurs identifiés

1. Coup illégal
   • Exemples : jouer une pièce qui n’existe pas sur l’échiquier, ou bouger un roi en échec sans défense légale.
   • Modèles concernés : Claude 3.7 et 3.5 (plus rarement Grok 3.0).
   • ✅ Jamais observé chez GPT-4o.
2. Coup incohérent avec la FEN
   • Le LLM donne un coup valide sur un plateau… mais ce coup n’est pas possible dans la position donnée.
   • Cela trahit souvent un oubli de la mémoire positionnelle, ou une hallucination structurelle.
3. Confusion de notation
   • Le modèle mélange parfois notation figurée (♘xf6+) et notation algébrique (Nxf6+), ou propose des notations hybrides incorrectes.
4. Réponse partiellement correcte mais incomplète
   • Ex : une promotion non spécifiée (e8 au lieu de e8=Q) ou un échec non signalé (Qf6 au lieu de Qf6+).
   • Ce type d’erreur est critique dans un cadre de test strict, car il introduit de l’ambiguïté ou empêche l’analyse automatique.

🔍 Causes profondes (techniques)

1. Manque de raisonnement positionnel stable
   • Contrairement à un moteur d’échecs, un LLM ne “voit” pas le plateau : il déduit une position à partir du contexte texte, ce qui crée un flou cumulatif.
2. Pas de moteur de validation interne
   • Aucun de ces modèles n’a, par défaut, une vérification légale des coups. Tout repose sur l’attention au contexte.
   • GPT-4o semble néanmoins bénéficier d’un meilleur encodage positionnel, probablement lié à son entraînement multimodal.
3. Mémoire contextuelle limitée
   • Les coups précédents, s’ils ne sont pas résumés ou rappelés efficacement (via FEN par exemple), s’effacent progressivement de la “vue” du modèle.
4. Alignement non spécifique
   • Ces IA sont alignées pour la vérité, la cohérence, la sécurité… mais pas pour les règles strictes d’un jeu comme les échecs, sauf si explicitement encadrées par des instructions ou prompts dédiés.

💡 Implications pour les utilisateurs

• Claude & Grok peuvent être utiles pour discuter stratégie ou rejouer une position connue.
• Mais pour une partie tour par tour, seul GPT-4o a montré une fiabilité sans faille à ce jour, sans le moindre coup illégal, y compris après 35 coups.
• Cela suggère une meilleure généralisation de GPT-4o à des tâches logiques sous contrainte stricte.

🧮 Synthèse des résultats par confrontation

Afin de rendre compte de manière claire des performances observées, voici un résumé détaillé des trois matchs joués, opposant systématiquement GPT-4o (blancs) à un autre LLM (noirs).

1. GPT-4o vs Claude 3.7 (50 demi-coups)

https://youtu.be/Mwg0OyJjiGg

• Statut de la partie : victoire blanche par abandon implicite.
• Moment critique : Claude 3.7 propose un coup illégal, en tentant de déplacer une pièce inexistante.
• Observation : Claude 3.7 perd le fil encore plus tôt que Claude 3.5, avec des erreurs critiques : déplacements de pièces adverses, coups impossibles, instabilité croissante.

2. GPT-4o vs Claude 3.5 (53 demi-coups)

https://youtu.be/Kq3pK8qymbk

• Statut : victoire blanche par submersion tactique.
• Moment critique : Claude 3.5 joue un cavalier déjà capturé, perdant ainsi le fil complet de la position.
• Observation : Claude 3.5 semble moins apte à intégrer la FEN comme état de vérité. GPT-4o déroule une attaque méthodique après l’erreur adverse.

3. GPT-4o vs Grok 3.0 (69 demi-coups)

https://youtube.com/live/NKULhJ5Ud1c

• Statut : victoire blanche par promotion forcée.
• Moment critique : Grok résiste jusqu’à la fin, mais commet des erreurs de continuité dans certains coups (perte de repère positionnel).
• Observation : malgré quelques hallucinations, Grok est le seul modèle à offrir une résistance plus prolongée. GPT-4o reste parfait.

📈 Tableau comparatif des confrontations

⚠️ Limites du protocole actuel & pistes d’amélioration

Bien que la méthodologie proposée permette de tester la capacité des LLMs à suivre des règles strictes dans un cadre normatif, certaines limites doivent être reconnues afin de nuancer les résultats et guider les améliorations futures.

1. Absence de feedback automatique

Le protocole repose sur un contrôle manuel de la légalité et de la cohérence des coups à chaque tour. Cela implique :

• Un effort humain important, surtout sur des parties longues.
• Un risque d’erreur d’évaluation ou d’oubli de micro-irrégularités.

2. Format uniquement textuel (interface web)

L’expérience se limite ici à des sessions dans les interfaces web des LLMs testés (chat.openai.com, claude.ai, x.ai). Cela signifie :

• Pas de mémoire de session avancée ni de système externe d’aide à la décision.
• Aucune correction automatique ni rappel des règles en cas de coup illégal. (Dans la mesure du possible car souvent une obligation totale d’ouvrir un nouveau chat car boucle continue)

🔧 Piste d’amélioration : “projet”

• La mémoire de session persistante.
• Un prompt système enrichi en arrière-plan.
• L’ajout de validateurs logiques ou d’historiques compressés.

3. Absence de raisonnement intermédiaire (no chain-of-thought)

Le protocole impose une réponse directe à chaque coup sans justification intermédiaire structurée. Bien que cela permette de tester la rigueur brute, cela ne tire pas parti du raisonnement pas à pas (chain-of-thought) dont certains modèles sont capables.

🔧 Piste d’amélioration

• Tester des modèles spécialisés en raisonnement.
• Injecter une consigne permettant une décomposition du raisonnement, à condition que cela respecte toujours la contrainte de réponse unique finale.
• Exemple : “Réfléchis pour valider la légalité du coup, puis donne le coup final.”

4. Parties toujours jouées contre un autre LLM (et non un moteur ou un humain)

Les adversaires sont également des LLMs, donc potentiellement eux-mêmes sources d’erreurs. Cela introduit un biais dans l’analyse comparative :

• Un modèle peut sembler “meilleur” simplement car l’autre s’est effondré plus vite.
• Certaines positions illogiques ou non naturelles peuvent émerger, ce qui biaise l’interprétation.

🔧 Piste d’amélioration

• Créer une série de parties jouées uniquement par le LLM contre Stockfish (avec validation stricte).
• Ou alors, faire jouer un LLM contre lui-même, mais avec différentes variantes de prompts ou d’historique.

🔬 Implications pour la recherche sur les LLMs

Ce protocole, bien qu’artisanal et limité à un usage web, soulève des questions fondamentales sur la robustesse des LLMs en environnement structuré.

1. La légalité comme indicateur de “compréhension”

Un coup illégal en contexte FEN n’est pas simplement une erreur de syntaxe : c’est un symptôme d’un manque de représentation mentale cohérente. Cela révèle :

• Un défaut dans la capacité à maintenir un état interne structuré (plateau + règles).
• L’absence d’un module interne de validation (contrairement aux moteurs d’échecs).
• Une difficulté pour certains modèles à s’aligner non pas sur l’intention, mais sur l’exactitude mécanique d’un système normatif.

Ce type de test pourrait donc servir de stress test générique, bien au-delà des échecs, pour tout domaine à règles strictes : droit procédural, sécurité, architecture réseau, etc.

2. Les échecs comme banc d’essai de raisonnement sous contraintes

Les échecs ne sont pas seulement un jeu complexe, ce sont une structure fermée à logique pure, ce qui en fait un outil idéal pour :

• Tester les modèles sur leur capacité à intégrer un système complet de règles.
• Évaluer leur stabilité en interaction longue.
• Analyser les mécanismes d’erreurs internes sans ambiguïté d’interprétation.

Contrairement à des tâches comme la rédaction ou la traduction, ici, la vérité est binaire : coup légal ou illégal, cohérent ou non.

3. Différences significatives entre les familles de modèles

Les résultats obtenus illustrent très clairement que tous les LLMs ne sont pas équivalents :

• GPT-4o démontre une rigueur contextuelle exceptionnelle, possiblement liée à son architecture multimodale ou à un pré-entraînement renforcé sur des structures logiques.
• Claude 3.5/3.7, pourtant réputés pour leur alignement, échouent sur des règles objectives.
• Grok 3.0 montre une promesse, mais son instabilité empêche une confiance sur la durée.

Ces écarts indiquent que le “reasoning structurel” est un axe de différenciation majeur à venir dans l’évolution des modèles.

🧾 Conclusion

Ce travail visait à tester une idée simple : peut-on faire jouer une IA généraliste aux échecs, uniquement via texte, sans qu’elle triche, hallucine ou sorte du cadre ?

La réponse est oui… mais pas avec tous les modèles.

• GPT-4o a montré une rigueur impressionnante : aucun coup illégal, pas de rupture contextuelle, un respect strict des règles même après de nombreux coups.
• Claude et Grok en revanche ont démontré les limites de leur architecture ou de leur encodage du cadre formel : coups illégaux, confusion de position, perte du fil.

L’intérêt de cette recherche n’est pas de dire “quel modèle joue mieux”, mais de souligner les capacités différentielles de représentation et de stabilité dans un système fermé. Les échecs, comme tout domaine strictement normé, deviennent un miroir parfait des forces et des failles de ces modèles.

Les prochaines étapes, avec un passage en mode “projet”, l’introduction de mémoire persistante, ou le test de modèles spécialisés en raisonnement, permettront d’aller plus loin encore dans notre compréhension et avoir conscience des limites des modèles via un usage normal.

En attendant, GPT-4o reste le seul à pouvoir jouer une partie complète sans jamais sortir du cadre.