Le premier test n'a pas départagé les modèles. Le deuxième a montré que les modèles qui vérifient leur propre travail sont ceux qui atterrissent. Pour le troisième, j'ai choisi un problème où une réponse erronée est impossible à cacher — le chaos déterministe, avec l'arbitre intégré au fichier — et j'ai observé ce que les modèles faisaient quand la correction n'était plus ce qui les séparait.
L'histoire jusqu'ici
Le test 01 était un visualiseur de Fourier dans un seul fichier HTML, avec un affichage d'erreur en direct comme arbitre intégré. Quatre modèles, invite identique, premier jet seulement. Les quatre ont produit des maths fonctionnelles avec une erreur d'arrondi près. La seule chose qui variait, c'était la facture, d'environ 200×. La conclusion étroite et honnête : pour une tâche bien spécifiée avec une réponse vérifiable, le choix du modèle cesse d'être la variable qui compte.
Le test 02 était un Lunar Lander jouable avec deux arbitres — une physique de chute libre exacte, et un pilote automatique ouvert qui devait piloter le propre jeu du modèle. La physique est à nouveau à égalité. Le pilote automatique, non : 20/20, 18/20, 5/20, 0/20. Et ce qui prédisait la différence n'était pas le nom ou le prix du modèle — c'était de savoir si le modèle testait son propre travail avant de dire que c'était fini.
Donc pour le test 03, je voulais une tâche qui soit entièrement vérifiable — pas de moitié ouverte cette fois — mais où la réponse vérifiable est vraiment difficile à falsifier. Si la thèse « le modèle n'a pas d'importance » est réelle, c'est ici qu'elle devrait être la plus forte. Et je voulais voir ce qui reste pour séparer quatre modèles quand même la correction converge.
La réponse s'est avérée être : le chaos.
trace de double pendule en pose longue
Le test : un arbitre avec lequel on ne peut pas discuter
Mêmes règles que d'habitude. Une invite, collée dans quatre interfaces en ligne de commande à la fois, quatre dossiers, premier jet seulement, terminaux enregistrés.
L'invite : un double pendule dans un seul fichier HTML autonome. Constantes fixes (deux masses de 1 kg, deux tiges de 1 m, g = 9,81), position de départ fixe (les deux bras à 120°, lâchés depuis le repos), les équations non linéaires complètes du mouvement, RK4 avec un pas de temps de 1/2000 s. Le dessiner, tracer la masse inférieure, et — le point crucial — évaluer sa propre physique en direct, à l'écran, de deux façons :
- Dérive énergétique. Un double pendule sans frottement conserve l'énergie mécanique totale exactement. Donc l'application calcule sa propre énergie à chaque image et indique à quel point elle a dérivé de la valeur de départ. Toute dérive est une pure erreur d'intégrateur. Il existe une réponse analytique correcte, et c'est zéro. C'est l'arbitre avec lequel on ne peut pas discuter.
- L'exposant de Lyapunov. L'application exécute un pendule jumeau caché, identique sauf que son premier angle est décalé d'une partie par milliard (10⁻⁹). Il mesure la vitesse à laquelle les deux divergent, ajuste l'exponentielle, et rapporte le taux de croissance λ. Un λ positif est la signature mathématique du chaos déterministe — la preuve que le mouvement sauvage à l'écran est une vraie sensibilité aux conditions initiales, pas un artefact numérique.
Un bouton exécute les deux vérifications sans interface sur 60 secondes simulées et affiche le verdict.
Pourquoi un double pendule ? Parce que c'est l'exemple le plus net d'un système qui est
complètement déterministe et complètement imprévisible en même temps
. Les équations n'ont pas d'aléatoire. Exécutez-les deux fois depuis le même départ et vous obtenez le même mouvement à chaque fois. Décalez le départ d'un milliardième de radian et en quinze secondes les deux font des choses totalement différentes. C'est le test de stress parfait pour la thèse : la physique est exactement vérifiable, mais le comportement est impossible à évaluer à l'œil.
doubles pendules
Pour noter les correcteurs, j'ai construit le mien
Il y a un piège dans un test auto-évalué : et si les quatre applications s'accordent sur un nombre qui est simplement faux ? Un bug partagé ressemblerait à un consensus.
Donc avant la course, j'ai écrit ma propre simulation de double pendule à partir de zéro — mêmes constantes, même RK4, mêmes 60 secondes — comme corrigé indépendant. Il indique : énergie initiale 14,715 J, dérive maximale sur 60 secondes 6,6×10⁻⁸ % (c'est un cheveu d'arrondi près de la perfection), plus grand exposant de Lyapunov ≈1,4 par seconde, et les trajectoires jumelles divergent d'un radian complet à ≈14,5 secondes.
Voilà la vérité terrain à laquelle chaque application ci-dessous est mesurée. Pas « les modèles étaient d'accord entre eux » — mais « les modèles étaient d'accord avec une simulation indépendante que je contrôle ».
La course
Quatre terminaux, quatre outils différents : Sonnet 5 dans Claude Code, Grok 4.5 et Composer 2.5 via l'interface Grok CLI, DeepSeek V4 Pro dans opencode.
Deux d'entre eux ont traité ça comme un sprint. Composer 2.5 a terminé premier, en 1 minute 43 secondes — a écrit le fichier, a imprimé un joli tableau « résultats headless vérifiés », terminé. Grok 4.5 a suivi en avec le compte-rendu le plus complet des quatre : l'équation énergétique la plus propre, et deux métriques de séparation là où tout le monde n'en rapportait qu'une.
Les deux autres ont traité ça comme un examen qu'ils devaient remettre. Sonnet 5 a écrit le fichier le plus compact du lot, puis a ouvert un vrai navigateur — quinze fois — pour exécuter réellement son propre arbitre. En cours de route, il a remarqué que l'onglet d'automatisation était ralenti par Chrome en arrière-plan, a raisonné à voix haute que sa vérification headless ne dépendait pas de l'animation, l'a exécutée quand même, et seulement alors a déclaré la tâche terminée, en . DeepSeek V4 Pro a fait la même chose via un outil différent — a piloté un Chrome headless, a cliqué sur son propre bouton Run Referee, a pris une capture d'écran du panneau pour confirmer — et a terminé en , ayant dépensé la somme de huit centimes.
quatre terminaux, quatre agents IA
Voici le détail révélateur, et il inverse le test 02. Composer et Grok ont rapporté des nombres d'arbitre corrects sans jamais ouvrir le fichier. D'après l'enregistrement, ils ont affirmé leurs résultats « validés » à partir du seul raisonnement. Sonnet et DeepSeek ont rapporté des nombres corrects parce qu'ils ont exécuté la chose et lu le panneau
Peut-être que la prochaine fois, je devrai forcer playwright ou un test e2e Chrome.
Les résultats, d'après l'arbitre de chaque application
Arbitre #1 — la dérive énergétique, la moitié exacte. Vérité terrain : 6,6×10⁻⁸ %.
Modèle
Dérive énergétique maximale (auto-déclarée)
Verdict
Sonnet 5
6,57×10⁻⁸ %
RÉUSSI
Grok 4.5
≈6,6×10⁻⁸ %
RÉUSSI
Composer 2.5
6,6×10⁻⁸ %
RÉUSSI
DeepSeek V4 Pro
4,94×10⁻⁸ % *
RÉUSSI
Convergence. Une troisième fois. Les quatre tombent sur la même réponse à huit décimales que ma simulation indépendante. Personne n'a falsifié l'intégrateur — c'est impossible à falsifier, c'est tout le principe, et cette fois personne n'a même essayé. (* DeepSeek lit un peu plus bas seulement parce que sa vérification headless échantillonne l'énergie tous les 100 pas au lieu de chaque pas — le vérificateur le moins précis des quatre, mais il réussit quand même confortablement.)
Arbitre #2 — l'exposant de Lyapunov, la moitié chaotique. Vérité terrain : ≈1,4 par seconde, positif.
Modèle
λ ajusté
Divergence d'un radian
Sonnet 5
1,634 /s
14,85 s
DeepSeek V4 Pro
1,535 /s (R² = 0,964)
14,50 s
Composer 2.5
1,47 /s
14,5 s
Grok 4.5
1,45 /s
14,85 s
Tous positifs. Tous dans la fenêtre que chaque modèle a choisie pour l'ajustement. Le chaos est réel, mesuré de quatre façons indépendantes, et il correspond au corrigé.
dérive énergétique
Alors, qu'est-ce qui les a réellement séparés ?
Lisez les deux tableaux et la réponse honnête est : sur ce que le test mesure, rien ne les a séparés. Les quatre sont corrects. C'est la plus forte apparence de la thèse « le modèle n'a pas d'importance » depuis trois tests — la tâche était entièrement vérifiable, vraiment difficile, et chaque modèle a réussi.
Mais le test 02 m'a appris à regarder la colonne qui n'est pas le score. La dernière fois, c'était le pilote automatique. Cette fois, c'est l'horloge, et le navigateur.
- Les deux modèles rapides (Composer 1:43, Grok 3:58) ont livré des fichiers corrects qu'ils n'ont jamais exécutés.
- Les deux modèles lents (Sonnet 9:07, DeepSeek 9:15) ont livré des fichiers corrects parce qu'ils les ont exécutés.
Voici la surprise par rapport au test 02. La dernière fois, les modèles qui n'ont pas vérifié ont échoué — le pilote automatique de Grok a planté 15 atterrissages sur 20. Cette fois, les modèles qui n'ont pas vérifié ont réussi quand même. Composer et Grok avaient raison sans vérifier.
Ce qui affine la leçon au lieu de la répéter : la vérification n'est pas ce qui rend la sortie correcte. C'est ce qui vous permet de savoir qu'elle est correcte avant de la livrer. Sur une tâche entièrement vérifiable, un modèle assez bon peut sauter la vérification et avoir quand même raison. Il ne peut simplement pas savoir qu'il a raison. Composer et Grok y sont arrivés en un quart du temps — et ont livré en aveugle. Sonnet et DeepSeek ont payé cinq minutes et huit centimes à deux dollars pour quelque chose que les sprinteurs n'ont pas acheté : la certitude.
Que cet échange en vaille la peine dépend entièrement du coût d'une erreur. Pour une visualisation jetable, livrez en aveugle et économisez les minutes. Pour tout ce où un bug d'intégrateur silencieux atteint la production, le modèle qui ouvre le navigateur est celui que vous voulez — et DeepSeek a prouvé que cette habitude coûte quatre centimes, pas deux dollars.
Mode aveugle : là où ce test montre ses dents
Il y a une raison pour laquelle j'ai choisi le chaos. Mettez les quatre pendules côte à côte et laissez-les tourner. En quinze secondes, chaque trace est un gribouillis imprévisible différent — et vous ne pouvez pas dire quel modèle a écrit lequel. Le style maison, les noms de variables, les petites fioritures d'interface disparaissent tous dès que la physique prend le dessus. Quatre implémentations correctes d'un système chaotique sont, à l'œil, indiscernables.
Ce n'est pas un défaut du test. C'est la conclusion, rendue sous forme d'image : quand la tâche est entièrement spécifiée et correctement résolue, l'empreinte du modèle disparaît. Essayez le mode aveugle et voyez si vous pouvez battre un pile ou face. Je n'ai pas pu.
quatre traces de double pendule
Ce que la facture a acheté
- DeepSeek V4 Pro : 0,0432 $, détaillé par jeton. C'était aussi l'un des deux qui ont piloté un vrai navigateur pour s'auto-évaluer. Le moins cher et le plus assidu — le meilleur rapport qualité-prix, encore une fois, par deux ordres de grandeur.
- Sonnet 5 : ~2,02 $, mesuré en jetons (il fonctionnait sur un forfait, donc c'est mon nombre de jetons × prix publié). La majeure partie est allée dans la boucle de vérification en quinze appels qui a produit la validation la plus minutieuse du lot.
- Grok 4.5 et Composer 2.5 : abonnement fixe via l'interface Grok CLI, pas de prix par jeton — donc pas de chiffre en dollars honnête, et pas de barre sur mon graphique.
Les réserves, avant que vous ne me citiez
Un seul essai par modèle. Les quatre interfaces en ligne de commande ont été lancées à une ou deux minutes d'intervalle, donc les chronomètres dans la vidéo sont le temps réel de chaque modèle d'après ses propres journaux, pas un coup de pistolet synchronisé — les durées sont honnêtes, la « ligne de départ » est décalée, et je préfère vous le dire plutôt que de simuler un départ propre. L'arbitre headless de DeepSeek sous-échantillonne, ce qui explique pourquoi son nombre de dérive est le plus bas ; je considère cela comme une imprécision mineure, pas une erreur, car son panneau en direct échantillonne chaque image et mon exécution indépendante confirme la valeur réelle. Et « la vérification achète la confiance, pas la correction » est une affirmation concernant cette tâche, où la réponse était entièrement vérifiable — sur une tâche ouverte (voir le test 02), la vérification achetait aussi la correction.
Tout est publié et fonctionne en direct. Vous n'êtes pas obligé de croire un nombre dans cet article — appuyez vous-même sur le bouton.
https://x.com/0xBakeer/status/2077442955934101680
Essayez-le
Les quatre fichiers intacts s'exécutent dans votre navigateur. Appuyez sur Play pour regarder le chaos, appuyez sur Run Referee pour reproduire chaque nombre ci-dessus :
- Le test : https://khaledbakeer.github.io/One-Prompt/tests/double-pendulum/index.html
- L'arène (les quatre, côte à côte) : https://khaledbakeer.github.io/One-Prompt/tests/double-pendulum/arena.html
- Mode aveugle — devinez qui a construit quoi : https://khaledbakeer.github.io/One-Prompt/tests/double-pendulum/blind.html
- Test 02, le round Lunar Lander : https://khaledbakeer.github.io/One-Prompt/tests/lunar-lander/index.html
- Test 01, le round Fourier : https://khaledbakeer.github.io/One-Prompt/tests/fourier-epicycles/index.html
- Données brutes, invite incluse : https://khaledbakeer.github.io/One-Prompt/data/double-pendulum.json
Le tableau de l'énergie est le groupe de contrôle — il est censé être à égalité, et il l'est. L'horloge est l'expérience. Et le mode aveugle est la chute : quatre réponses correctes à un problème chaotique se ressemblent exactement.
— Khaled
