Claude Mythos : le modèle qui pense en boucles

Claude Mythos ne pense pas une fois puis répond. Il repense. Et encore. Jusqu'à décider que c'est bon.

Tous les modèles d'IA que tu as utilisés fonctionnent pareil : tu poses une question, le modèle la lit une fois, prédit mot par mot, produit une réponse. Un seul passage. Terminé. Claude Mythos fonctionnerait de façon radicalement différente : mêmes poids, tournés en boucle, chaque passe affinant ce que la précédente avait raté. Comme dormir sur un problème difficile, sauf que ça prend 16 siestes en une seconde, toutes invisibles, avant d'écrire un seul mot.

C'est l'hypothèse. En avril 2026, un développeur nommé Kye Gomez a rétroconçu la conception supposée à partir de documents Anthropic divulgués et l'a publiée sur GitHub avant qu'Anthropic ne dise quoi que ce soit publiquement. Ce post explique comment ça fonctionne et comment tu peux le faire tourner toi-même dès aujourd'hui.

Comment fonctionnent vraiment les modèles d'IA classiques

Imagine chaque IA que tu as utilisée comme une ligne droite.

Tu tapes une question. Le modèle la fait passer par la couche 1, puis la couche 2, puis la couche 3. Chaque couche est un ensemble séparé de poids entraînés, utilisés exactement une fois, dans l'ordre. GPT-4 a environ 120 de ces couches. Chaque couche augmente la taille du fichier du modèle, son empreinte mémoire et son coût de calcul. Pour rendre un modèle plus intelligent, tu ajoutes des couches. Plus de couches, plus de paramètres. Plus de paramètres, plus de GPUs pour le faire tourner.

C'est le mur que chaque modèle frontier heurte. Pas "comment pensons-nous mieux ?" mais "comment caser plus de couches ?" Claude Mythos semble conçu autour d'une question entièrement différente : et si une seule couche pouvait faire le travail de beaucoup ?

L'idée centrale : une couche, tournée encore et encore

L'hypothèse Mythos se résume à un seul changement architectural.

Au lieu de 6 couches uniques avec 6 ensembles de poids, le modèle a 1 couche avec 1 ensemble de poids. Cette couche tourne 5 fois (ou autant que l'entrée l'exige). Mêmes poids à chaque passe. La sortie de chaque passe devient l'entrée de la suivante.

Le modèle est moins lourd à stocker. Mais tout aussi profond en termes de nombre d'étapes de traitement que l'entrée traverse.

Cette classe d'architecture s'appelle recurrent-depth. "Récurrent" signifie la même chose que dans les RNNs : un processus qui réinjecte sa sortie comme sa propre entrée. La différence, c'est que Mythos applique cette idée à la couche transformer complète, pas seulement à l'état caché.

La stabilité LTI est ce qui empêche ces passes répétées d'exploser. LTI signifie Linear Time-Invariant, un concept de théorie du contrôle qui décrit des systèmes où la même entrée produit toujours la même sortie, peu importe quand tu l'appliques. Dans un modèle en boucle, sans contraintes de stabilité, les erreurs se cumulent d'une passe à l'autre et les activations explosent. La stabilité LTI l'en empêche. La couche est conçue pour que la tourner à répétition maintienne les valeurs dans une plage bornée plutôt que de partir à l'infini.

Chaque passe affine la réponse

Pense aux passes comme à des brouillons.

La passe 1 est la première pensée brute. Le modèle lit l'entrée et génère une représentation initiale. Elle n'est pas fausse à proprement parler, elle est juste superficielle.

La passe 2 prend cette représentation et la retraite. Elle peut attraper ce que la première a manqué. Les contradictions sont signalées. La réponse commence à se préciser.

Chaque passe suivante applique les mêmes poids sur une représentation du problème de plus en plus affinée. À la passe N, le modèle a eu N occasions de travailler la question. La sortie est le résultat de la passe finale.

C'est ce que le carousel décrit comme "Same brain. Run again." Les poids ne changent pas entre les passes. Ce qui change, c'est la qualité de la représentation sur laquelle ces poids travaillent. Chaque boucle ajoute de la profondeur.

La LoRA par profondeur s'inscrit là-dedans. LoRA (Low-Rank Adaptation) est une technique pour rendre les modèles entraînables avec moins de paramètres en approximant les mises à jour de poids comme le produit de deux matrices plus petites. Dans un modèle recurrent-depth, la LoRA par profondeur ajoute de petits ajustements à chaque passe pour que la même couche de base puisse se comporter légèrement différemment à la passe 2 qu'à la passe 1, même si les poids centraux sont partagés. C'est comment le modèle évite de faire exactement la même chose à chaque boucle.

La MLA attention (Multi-head Latent Attention) est le mécanisme d'attention suspecté de tourner à l'intérieur de chaque passe. L'attention multi-têtes standard est coûteuse : les matrices de clés et valeurs grossissent avec la fenêtre de contexte, et il faut les mettre en cache pour chaque couche. La MLA compresse le cache clé-valeur en le projetant dans un espace latent plus petit. Dans un modèle qui tourne la même couche à répétition, ça compte énormément. Sans compression, les coûts mémoire se multiplient à chaque boucle. La MLA les maintient gérables.

La MoE FFN (Mixture of Experts Feed-Forward Network) gère la partie feed-forward de chaque passe. Dans un transformer standard, chaque token active tous les paramètres du bloc feed-forward. Le MoE utilise un routeur pour n'activer qu'un sous-ensemble de sous-réseaux "experts" pour chaque token. Le modèle peut ainsi avoir un nombre de paramètres total élevé dans le bloc FFN tout en n'utilisant qu'une fraction à chaque passe. Dans le contexte Mythos, le MoE ajoute de la capacité à chaque passe de boucle sans augmenter proportionnellement le coût de calcul.

Les questions difficiles ont plus de boucles

C'est ce qui rend le recurrent-depth vraiment différent de simplement agrandir un modèle.

Un modèle standard fait passer chaque entrée par toutes les couches à chaque fois. Que tu tapes "Salut" ou "Explique les bases thermodynamiques de la flèche du temps", le coût de calcul est identique. Le nombre de couches est fixe.

Dans un modèle recurrent-depth avec halting ACT, ce n'est plus vrai.

ACT signifie Adaptive Computation Time. C'est un mécanisme qui laisse le modèle décider du nombre de passes à effectuer avant de produire sa sortie. À chaque passe, le modèle produit une "probabilité de halting" en parallèle de sa représentation. Quand la probabilité de halting cumulée dépasse un seuil, la boucle s'arrête et la représentation courante devient la sortie.

Le résultat : un modèle qui alloue du calcul en fonction de la difficulté de la question :

Les tokens faciles ont 2 boucles. Les difficiles en ont 10. Rien n'est gaspillé. Le modèle ne passe pas 10 boucles sur "Salut" juste parce que l'architecture le permettrait.

C'est aussi en partie pour ça qu'en moins de 24 heures après l'annonce publique d'Anthropic, le Secrétaire au Trésor américain et le président de la Réserve fédérale ont convoqué une réunion d'urgence à huis clos avec les PDG des grandes banques au sujet des implications cybersécurité de ce modèle. Un modèle qui route son propre calcul et décide de la profondeur de sa réflexion est une classe de système différente de ceux qui tournent toujours le même nombre fixe de passes. La surface de contrôle pour l'alignement et les prédictions de capacité change.

Quelqu'un l'a reconstruit en open source

Anthropic n'a jamais confirmé l'architecture publiquement. Mais Kye Gomez a fait ce qu'il y a de mieux : il a lu les preuves disponibles, déduit le design, et en a rétroconçu une implémentation fonctionnelle.

Le projet c'est kyegomez/OpenMythos sur GitHub, publié en 2026.

L'architecture correspond à tous les indices qui ont fui des recherches d'Anthropic. La fuite du spec modèle début 2026 a exposé des drafts de posts de blog et documents internes faisant référence à des designs de poids bouclés. La fuite de la source map de @anthropic-ai/claude-code version 2.1.88 a exposé des feature flags internes et des notes d'architecture cohérentes avec un raisonnement recurrent-depth. Rien de tout ça n'était un blueprint direct. Kye Gomez a comblé les lacunes.

La communauté l'a livré avant qu'Anthropic ne dise quoi que ce soit publiquement.

Comment faire tourner ta propre version

OpenMythos est le chemin le plus rapide pour faire tourner un modèle recurrent-depth localement. Voici le minimum nécessaire.

Ce qu'il te faut :

• Python 3.10+
• PyTorch 2.1+
• 8 Go+ de VRAM pour de petites configs, 24 Go+ pour une vraie mise à l'échelle
• Git

Cloner et installer :

git clone https://github.com/kyegomez/OpenMythos
cd OpenMythos
pip install -r requirements.txt

La boucle centrale en termes simples. OpenMythos définit un seul bloc transformer, puis l'enroule dans une boucle avec une tête de halting ACT. La tête de halting est une petite couche linéaire qui lit l'état caché courant et produit un scalaire entre 0 et 1. Quand le score de halting cumulé dépasse un seuil (typiquement 0,99), la boucle sort. Voici la forme conceptuelle :

# Simplified recurrent-depth forward pass
hidden = embed(input_tokens)

halt_acc = 0.0
n_steps = 0

while halt_acc < 0.99 and n_steps < max_loops:
    hidden = transformer_block(hidden)          # same weights every pass
    halt_prob = halt_head(hidden).sigmoid()     # how confident to stop?
    halt_acc += halt_prob * (1 - halt_acc)
    n_steps += 1

output = lm_head(hidden)

Le transformer_block tourne les mêmes poids à chaque passe. Le halt_head décide quand s'arrêter. Le modèle ne prend jamais plus de passes que max_loops, tu peux donc plafonner le calcul.

La LoRA par profondeur en pratique. Pour laisser le modèle se comporter différemment à chaque passe sans poids séparés, OpenMythos injecte des embeddings d'index de passe avant le bloc transformer. Chaque passe reçoit un petit décalage appris qui déplace légèrement la représentation. Les poids de base restent partagés ; les décalages donnent à chaque passe son propre caractère :

# Pass index conditioning
pass_embed = self.pass_embeddings(torch.tensor(n_steps))
hidden = hidden + pass_embed
hidden = self.transformer_block(hidden)

C'est une version légère de la LoRA par profondeur. Une implémentation complète utiliserait des adapters low-rank par passe plutôt que des décalages appris, mais le principe est le même.

Entraîner avec ACT. La loss d'entraînement ajoute un terme de régularisation qui pénalise les passes inutiles. Sans ça, le modèle apprendrait à toujours tourner le nombre maximum de boucles quelle que soit la difficulté de l'entrée. Le coût de réflexion le pousse à s'arrêter tôt quand la représentation est déjà assez bonne :

loss = cross_entropy_loss + lambda_ponder * n_steps.float().mean()

Le coefficient lambda_ponder contrôle le compromis entre qualité de réponse et efficacité de calcul. Des valeurs plus élevées produisent des modèles plus rapides et superficiels. Des valeurs plus faibles produisent des penseurs plus profonds qui utilisent plus de passes.

Pourquoi cette architecture est importante

Trois choses changent si le recurrent-depth devient l'approche standard pour les modèles frontier.

De la profondeur sans le volume. Un modèle peut raisonner aussi profondément qu'un autre avec 6 fois plus de couches tout en ne stockant que les poids d'une seule. Fichiers de modèle plus petits, moins de mémoire requise, moins cher à servir. Tu obtiens la qualité de sortie d'un grand modèle au coût de stockage d'un petit.

Du calcul variable par token. Le modèle dépense du calcul là où le problème est vraiment difficile. Un prompt composé à 90% de contexte simple et à 10% de raisonnement difficile ne paie pas le même coût par token qu'un prompt uniformément difficile. Ça change ce que "inférence efficace" signifie.

Un nouvel axe de design pour la capacité. L'approche standard pour rendre les modèles plus intelligents, c'est d'entraîner des modèles plus grands sur plus de données. Le recurrent-depth ajoute un axe différent : la profondeur de raisonnement par passe avant. Un modèle peut devenir "plus intelligent" en autorisant plus de boucles, pas seulement en ajoutant des paramètres. Des boucles, pas des couches.

Si Anthropic a bien fait ça, le playbook pour mettre à l'échelle l'intelligence vient de changer. Pas plus de poids. Plus de passes.

Ce qu'on ne sait pas

Il faut être clair sur ce que c'est et ce que ce n'est pas.

Anthropic n'a pas confirmé publiquement que Claude Mythos utilise une architecture recurrent-depth. Les preuves sont indirectes : documents de spec modèle divulgués, contenu de source maps, comportement sur les benchmarks cohérent avec le calcul adaptatif, et le travail de rétro-ingénierie de Kye Gomez. L'architecture colle. Elle n'a pas été vérifiée.

OpenMythos est une implémentation communautaire d'une conception supposée. Ce n'est pas un produit Anthropic et ça ne reproduit aucun code d'entraînement ni poids réels d'Anthropic.

Le vrai modèle Mythos, s'il existe tel que décrit, est la release la plus restreinte d'Anthropic. Il n'est pas accessible au public. Ce que tu peux faire tourner aujourd'hui, c'est OpenMythos : l'hypothèse architecturale rendue exécutable.

Cette distinction compte. Faire tourner OpenMythos t'apprend comment le recurrent-depth fonctionne. Ça ne te donne pas Claude Mythos.

Où ce pattern s'applique

L'idée recurrent-depth n'est pas unique à la spéculation sur Mythos. La même approche est apparue dans la recherche académique sous différents noms : Universal Transformers (Dehghani et al., 2018), Pondering (Banino et al., 2021), et plus récemment dans des travaux sur l'inférence adaptative en profondeur axée sur l'efficacité.

Ce que représente Mythos, si l'hypothèse est juste, c'est Anthropic appliquant cette direction de recherche à l'échelle frontier avec une ingénierie de qualité production. Ça compte parce que le travail antérieur sur le recurrent-depth restait principalement en labo de recherche. Le mettre à l'échelle jusqu'à un modèle assez capable pour qu'Anthropic en restreigne l'accès, c'est un résultat d'une classe différente.

Le chemin open source existe. Kye Gomez l'a construit. L'architecture est compréhensible. Les pièces (halting ACT, MoE FFN, LoRA par profondeur, MLA attention) sont chacune documentées indépendamment dans la littérature de recherche.

Une boucle à la fois, la représentation s'améliore. C'est toute l'idée.

Publié par @speedy_devv