Quebec.IA

Et si l’écart d’efficacité entre les machines et les enfants n’était pas seulement un problème de scaling ?

Et si c’était un problème d’objectif d’apprentissage ?

Un preprint remarquable de Daniel J. Korchinski, Alessandro Favero et Matthieu Wyart propose une théorie de sample complexity pour ce basculement :

Learn from your own latents and not from tokens.

Le problème est connu :

les modèles génératifs modernes sont extraordinaires, mais brutalement gourmands en données.

Les LLMs sont entraînés sur 10¹³–10¹⁴ tokens.

Les enfants, non.

La vraie question n’est donc pas seulement :

comment scaler les modèles ?

Mais :

que leur demande-t-on de prédire ?

La plupart de l’IA moderne apprend à partir de la surface visible :

tokens suivants
tokens masqués
pixels
bruit
patches

Cela fonctionne.

Mais ce n’est peut-être pas le chemin statistiquement efficace vers la hiérarchie.

Les auteurs étudient une grammaire hiérarchique où les tokens visibles sont générés par un arbre latent caché de profondeur L — un modèle stylisé de la structure compositionnelle du langage et des images.

Le résultat est profond :

l’apprentissage au niveau des tokens requiert un nombre d’échantillons exponentiel en L pour retrouver l’arbre latent.

La prédiction de latents y parvient avec une complexité essentiellement constante en L, à des facteurs logarithmiques près.

En clair :

prédire les tokens force le modèle à reconstruire la hiérarchie par les feuilles.

prédire ses propres latents lui permet de remonter l’arbre.

Une fois un niveau d’abstraction appris, il devient le support pour apprendre le suivant.

C’est pourquoi les objectifs de type data2vec et JEPA sont si importants.

Ils ne demandent pas seulement au modèle de reconstruire l’entrée.

Ils lui demandent de prédire sa propre représentation latente d’une autre vue ou d’une région masquée.

La cible n’est plus la surface.

La cible est l’abstraction que le modèle commence déjà à former.

Le papier valide cette théorie de trois façons :

un algorithme de clustering hiérarchique

une architecture neuronale end-to-end entraînée par gradient descent

une analyse de data2vec montrant qu’il effectue implicitement une prédiction hiérarchique de latents

Une implication est particulièrement provocante :

si data2vec découvre déjà la hiérarchie implicitement, des empilements explicites comme H-JEPA pourraient être en partie redondants.

Ce n’est pas “la prédiction du prochain token est morte”.

La prédiction de tokens a construit l’ère actuelle.

Mais si l’objectif est une IA beaucoup plus efficace en données, la reconstruction de surface pourrait être le chemin coûteux.

La frontière stratégique pourrait être la self-prediction latente :

des modèles qui apprennent non seulement de ce qu’ils voient,

mais des abstractions qu’ils sont déjà en train de former.

Crédit complet aux auteurs :
Daniel J. Korchinski, Alessandro Favero, Matthieu Wyart.

Paper :
Learn from your own latents and not from tokens: A sample-complexity theory
https://arxiv.org/abs/2605.27734

J’attache la première page, car l’abstract mérite une lecture attentive.

Le futur de l’IA data-efficient ne sera peut-être pas plus de tokens.

Ce sera peut-être de meilleures cibles.

L’automatisation de la recherche franchit un seuil.

Mais la vraie question n’est plus :

l’IA peut-elle produire des articles ?

Elle le peut.

La question difficile est :

peut-elle préserver la substance de la science ?

Un nouveau papier de l’Awesome AI Auto-Research Team propose l’une des cartes les plus utiles de ce territoire :

AI for Auto-Research: Roadmap & User Guide

Le papier analyse l’IA sur tout le cycle de vie de la recherche :

Création.
Écriture.
Validation.
Diffusion.

La recherche n’est pas une tâche unique.

C’est une chaîne épistémique.

Si une erreur entre tôt, l’automatisation peut l’amplifier jusqu’à produire un artefact plausible… mais scientifiquement fragile.

C’est la tension centrale :

l’IA devient excellente pour produire des objets qui ressemblent à de la recherche.

Mais elle reste beaucoup moins fiable pour juger s’ils sont nouveaux, fidèles, exécutables, reproductibles et scientifiquement significatifs.

Le papier trace une frontière nette.

L’IA performe le mieux quand les tâches sont structurées, ancrées dans des sources, médiées par des outils et vérifiables de l’extérieur.

Elle devient fragile quand il faut générer de vraies idées nouvelles, mener des expériences de niveau recherche, juger la nouveauté, ou porter une responsabilité scientifique de bout en bout.

Le futur crédible n’est donc pas “l’IA scientifique autonome” par défaut.

C’est la collaboration gouvernée par l’humain :

l’IA pour accélérer la mécanique.

l’humain pour le jugement, l’interprétation, la responsabilité et la propriété cognitive du travail scientifique.

La phrase à retenir :

la génération d’artefacts dépasse la vérification scientifique.

Les systèmes les plus dangereux ne seront pas ceux qui échouent visiblement, mais ceux qui produisent des papiers, reviews, rebuttals et figures plausibles tout en perdant la provenance, la preuve et la responsabilité.

Ce papier donne une taxonomie, une carte des benchmarks, un inventaire d’outils, un modèle de risque par étape et un playbook pour construire des systèmes d’auto-research sans confondre productivité et découverte.

Crédit complet aux auteurs :
Lingdong Kong, Xian Sun, Wei Chow, Linfeng Li, Kevin Qinghong Lin, Xuan Billy Zhang, Song Wang, Rong Li, Qing Wu, Wei Gao, Yingshuo Wang, Shaoyuan Xie, Jiachen Liu, Leigang Qu, Shijie Li, Lai Xing Ng, Benoit R. Cottereau, Ziwei Liu, Tat-Seng Chua, Wei Tsang Ooi.

Article :
https://arxiv.org/abs/2605.18661

J’attache la première page, car la Figure 1 devrait être étudiée par toute personne qui construit des agents de recherche.

Le futur de la science ne sera pas décidé par ceux qui automatisent le plus.

Il sera décidé par ceux qui automatisent sans perdre la vérité.

L’un des objets les plus importants de l’IA agentique pourrait être un simple fichier Markdown.

Pas les poids.
Pas seulement le prompt.

Le document de compétence.

Nouveau papier :

SkillOpt: Executive Strategy for Self-Evolving Agent Skills

La thèse est nette :

si la procédure d’un agent doit s’adapter, alors cette procédure doit pouvoir être entraînée.

Une “skill” est une mémoire procédurale portable : chercher l’information, appeler les outils, respecter les formats, suivre les conventions du domaine, éviter les modes d’échec.

Aujourd’hui, ces compétences sont souvent écrites à la main, générées une seule fois, ou révisées par auto-réflexion peu contrôlée.

SkillOpt change la logique.

Le modèle cible reste gelé.
Le skill document devient l’état externe à optimiser.
Un modèle optimiseur transforme les rollouts notés en éditions contrôlées : ajouter, supprimer, remplacer.
Une édition n’est acceptée que si elle améliore strictement une validation held-out.

C’est le passage :

du prompt engineering
à l’entraînement de compétences

de la révision ad hoc
à l’optimisation contrôlée en espace texte

L’analogie avec le deep learning est opérationnelle :

rollouts = batches
erreurs = signaux d’update
budget d’édition = learning rate textuel
validation gate = validation
éditions rejetées = feedback négatif
slow/meta update = stabilité

Le résultat déployé est un best_skill.md compact.

Aucun changement de poids.
Aucun appel supplémentaire à l’inférence.
Aucune “amélioration” acceptée sur impression subjective.

Chaque modification doit survivre à la validation.

Les résultats sont difficiles à ignorer.

Sur six benchmarks, sept modèles cibles et trois environnements — direct chat, Codex, Claude Code — SkillOpt est meilleur ou ex aequo sur les 52 cellules évaluées.

Sur GPT-5.5, il améliore l’accuracy sans skill de :

+23.5 points en direct chat
+24.8 dans la boucle agentique Codex
+19.1 dans Claude Code

Le transfert est tout aussi important : les skills optimisées gardent de la valeur entre tailles de modèles, entre Codex et Claude Code, et vers un benchmark mathématique proche sans ré-optimisation.

C’est une vraie couche d’adaptation :

portable
auditable
réutilisable
agnostique au modèle

La prochaine génération d’agents ne se jouera peut-être pas seulement dans le fine-tuning ou le scaling.

Elle se jouera aussi dans l’optimisation des procédures autour des modèles.

Pas des poids.
Pas seulement des prompts.

Du savoir opérationnel entraîné.

Crédit aux auteurs :
Yifan Yang, Ziyang Gong, Weiquan Huang, Qihao Yang, Ziwei Zhou, Zisu Huang, Yan Li, Xuemei Gao, Qi Dai, Bei Liu, Kai Qiu, Yuqing Yang, Dongdong Chen, Xue Yang, Chong Luo.

Paper:
https://arxiv.org/abs/2605.23904

Code:
https://microsoft.github.io/SkillOpt/

J’attache la première page parce que l’abstract vaut vraiment la lecture.

Les agents de demain n’apprendront peut-être pas seulement quoi répondre.

Ils apprendront comment opérer.

Les mathématiques entrent peut-être dans un nouveau régime :

non pas une IA que l’on croit,

une IA que l’on vérifie.

Un article majeur de Google DeepMind présente AlphaProof Nexus, un cadre de recherche de preuves formelles piloté par l’IA dans Lean.

Le point important n’est pas qu’un LLM puisse produire un raisonnement mathématique convaincant.

Le point important est que le système doit produire du code de preuve qui survit à un vérificateur formel.

Les LLMs génèrent.
Lean vérifie.
La recherche continue.
Seules les preuves vérifiées restent.

Cela change le contrat épistémique.

Dans les mathématiques informelles, une preuve générée par IA peut paraître élégante tout en cachant une faille fatale.

Dans Lean, chaque étape doit compiler.

Pas de rhétorique.
Pas de “ça semble vrai”.

Les résultats sont frappants.

L’agent le plus capable a résolu de façon autonome 9 des 353 problèmes ouverts d’Erdős testés, dont deux questions ouvertes depuis 56 ans, pour un coût d’inférence de quelques centaines de dollars par problème.

Il a aussi prouvé 44 des 492 conjectures OEIS évaluées, et le système est déjà déployé en combinatoire, optimisation, théorie des graphes, géométrie algébrique et optique quantique.

L’architecture est fascinante.

Un mathématicien fournit une formalisation Lean.
L’agent raffine des esquisses de preuve.
Des sous-agents LLM proposent lemmes, décompositions, constructions et corrections.
Lean rejette les étapes invalides.
AlphaProof peut être appelé comme prouveur spécialisé.
Une population évolutive d’esquisses est classée et réutilisée.
La sortie finale est une preuve Lean sans “sorry”.

Ce n’est pas “un chatbot qui fait des maths”.

C’est un nouvel instrument de recherche :

un moteur de recherche dans l’espace des preuves formelles,
guidé par des modèles génératifs,
ancré par un compilateur,
et audité par les mathématiques elles-mêmes.

La leçon dépasse les mathématiques :

les systèmes d’IA deviennent beaucoup plus puissants quand une génération faillible est enveloppée dans une vérification fiable.

Pour les autres domaines, la grande question devient :

quel est l’équivalent d’un compilateur pour la vérité ?

Crédit complet aux auteurs :
George Tsoukalas, Anton Kovsharov, Sergey Shirobokov, Anja Surina, Moritz Firsching, Gergely Bérczi, Francisco J. R. Ruiz, Arun Suggala, Adam Zsolt Wagner, Eric Wieser, Lei Yu, Aja Huang, Miklós Z. Horváth, Andrew Ferrauiolo, Henryk Michalewski, Codrut Grosu, Thomas Hubert, Matej Balog, Pushmeet Kohli, Swarat Chaudhuri.

Article :
Advancing Mathematics Research with AI-Driven Formal Proof Search
https://arxiv.org/abs/2605.22763

J’attache la première page, car l’abstract mérite une lecture attentive.

Le futur de l’IA en mathématiques ne sera peut-être pas composé de modèles que l’on croit.

Mais d’agents dont le travail peut être vérifié.

Le prochain verrou des agents de code n’est peut-être pas le code.

C’est l’expérience.

Un nouveau papier ICML 2026 de Yuxiang Wei, Zhiqing Sun, Emily McMilin, Jonas Gehring, David Zhang, Gabriel Synnaeve, Daniel Fried, Lingming Zhang et Sida Wang introduit Self-play SWE-RL (SSR) :

Toward Training Superintelligent Software Agents through Self-Play SWE-RL

La question est décisive :

Comment entraîner des agents logiciels quand les issues GitHub, les tests, les pull requests et les benchmarks annotés par des humains deviennent le goulot d’étranglement ?

Aujourd’hui, la plupart des agents SWE apprennent encore à partir de traces humaines :

des issues rédigées par des développeurs
des tests existants
des commandes de test connues
des PRs historiques
des environnements soigneusement curés

C’est utile.

Mais c’est aussi un plafond.

SSR propose autre chose :

un agent qui construit sa propre expérience d’apprentissage dans de vrais dépôts logiciels.

Le setup est remarquablement minimal.

On donne à l’agent un dépôt sandboxé avec son code source et ses dépendances.

Pas d’issue annotée.
Pas de commande de test fournie.
Pas de description du bug en langage naturel.

Le même LLM joue ensuite deux rôles :

Injecteur : comprendre le dépôt, créer un bug réaliste, et le spécifier par des tests.

Réparateur : diagnostiquer et corriger le code cassé.

Le détail important :

le bug n’est pas décrit en anglais.

Il est spécifié par un patch de tests.

L’agent n’apprend donc pas seulement à imiter la manière dont les humains décrivent les bugs.

Il apprend la structure opérationnelle du logiciel :

comment un système se casse
comment les tests révèlent le comportement attendu
comment une réparation restaure la cohérence

Encore plus intéressant : les échecs de réparation deviennent des bugs de second ordre, créant un curriculum évolutif de défaillances plus proches du développement réel.

C’est le déplacement AlphaZero appliqué au software engineering :

ne plus dépendre uniquement des parties humaines
générer de l’expérience ancrée dans l’environnement lui-même

Les résultats sont préliminaires, mais importants.

Sur SWE-bench Verified et SWE-Bench Pro, SSR rapporte une auto-amélioration de +10.4 et +7.8 points, et surpasse le baseline RL entraîné sur données humaines tout au long de l’entraînement.

Le signal le plus fort :

SSR est évalué sur des issues en langage naturel, alors qu’il n’a pas été entraîné sur des descriptions d’issues en langage naturel.

Autrement dit, le modèle n’apprend pas seulement la rhétorique des tickets GitHub.

Il apprend à comprendre, casser et réparer des systèmes exécutables.

C’est une trajectoire majeure pour les agents logiciels :

moins de dépendance aux traces humaines
plus d’apprentissage autonome
des curricula qui évoluent avec le modèle
des agents qui récoltent leur propre expérience dans de vrais codebases

Crédit complet aux auteurs :
Yuxiang Wei, Zhiqing Sun, Emily McMilin, Jonas Gehring, David Zhang, Gabriel Synnaeve, Daniel Fried, Lingming Zhang, Sida Wang.

Paper :
Toward Training Superintelligent Software Agents through Self-Play SWE-RL
https://arxiv.org/abs/2512.18552

J’attache la première page, parce que l’abstract mérite d’être lu attentivement.

Le prochain saut des agents logiciels ne viendra peut-être pas de plus de bugs annotés.

Il viendra peut-être d’agents capables de générer les bugs dont ils ont besoin pour apprendre à les dépasser.

La confiance en l’IA ne viendra peut-être pas d’une omniscience impossible.

Elle viendra d’une honnêteté épistémique.

Un nouveau papier de Gal Yona, Mor Geva et Yossi Matias propose l’un des cadrages les plus nets sur les hallucinations des LLMs :

Hallucinations Undermine Trust; Metacognition is a Way Forward

Le point clé :

Une hallucination n’est pas seulement une erreur.

C’est une erreur confiante.

Si le modèle se trompe mais exprime correctement son incertitude, la réponse peut rester utile : une hypothèse, pas une affirmation.

S’il se trompe avec assurance, la confiance s’effondre.

Les auteurs soutiennent que la plupart des progrès en factualité viennent surtout de l’élargissement de la frontière de connaissance du modèle : plus de faits encodés par l’échelle, les données et l’entraînement.

Mais le problème le plus difficile est ailleurs :

Le modèle sait-il quand il arrive à la limite de ce qu’il sait ?

C’est là que le papier devient important.

La calibration n’est pas la discrimination.

Un modèle peut être bien calibré en moyenne, tout en restant incapable de distinguer quelle réponse précise est probablement fausse.

Cela crée le piège classique :

Répondre davantage → préserver l’utilité, mais risquer des erreurs confiantes.
S’abstenir davantage → réduire les erreurs, mais perdre des réponses correctes utiles.

La sortie proposée : l’incertitude fidèle.

Aligner l’incertitude linguistique avec l’incertitude intrinsèque.

Pas du hedging partout.
Pas une clause de non-responsabilité.
Pas “je peux me tromper” à la fin de chaque phrase.

Un modèle fidèle dit :

Je sais ceci.
Je suis incertain sur cela.
Voici ma meilleure hypothèse.
Ici, je devrais vérifier.

C’est cela, la métacognition : être conscient de son incertitude et agir en conséquence.

Pour les chatbots, cela signifie communiquer honnêtement l’incertitude.

Pour les agents, cela devient la couche de contrôle :

quand chercher
quand vérifier
quand faire confiance au contexte
quand ignorer une mauvaise source
quand s’arrêter

Les outils résolvent le problème du stockage.

La métacognition résout le problème du contrôle.

Un modèle avec accès au web peut encore échouer s’il ne sait pas quand chercher, quoi croire, ni comment réagir quand une source contredit ses propres croyances.

La précision finale ne suffit plus.

Il faut évaluer le contrôle épistémique du processus.

Ce papier déplace l’objectif de “ne jamais se tromper” vers quelque chose de plus scientifique :

représenter fidèlement son état épistémique.

Crédit complet aux auteurs :
Gal Yona, Mor Geva, Yossi Matias.

Paper:
Hallucinations Undermine Trust; Metacognition is a Way Forward
https://arxiv.org/abs/2605.01428v1

J’attache la première page, car la Figure 1 résume magnifiquement le dilemme.

La prochaine percée en IA fiable ne sera peut-être pas un modèle qui sait tout.

Ce sera peut-être un modèle qui sait quand il ne sait pas.