Anthropic publie FlashProve, un prototype qui produit une preuve cryptographique qu'un modèle donné a bien généré la réponse facturée. Le code est ouvert, les limites aussi, à commencer par un contexte plafonné à 1 024 jetons.
FlashProve, ou la preuve que le modèle facturé a bien répondu
Quand vous payez pour une réponse d'IA, rien ne garantit que le service a utilisé le modèle annoncé. Un intermédiaire peut router votre requête vers une version moins chère, modifier le texte en cours de route, ou servir un modèle qui n'a pas reçu l'aval d'un régulateur. Ces trois scénarios tiennent aujourd'hui parce que le client n'a aucun moyen de vérifier.
FlashProve attaque ce problème avec un zkSNARK, une preuve cryptographique qui convainc un vérificateur sans révéler ce qu'elle contient. Ici, la preuve zkSNARK dit : cet ensemble de poids, engagé à l'avance, a produit exactement ces jetons pour ce prompt. Elle ne dit rien des poids eux-mêmes.
Anthropic a publié le 3 novembre 2026 un article de recherche, un rapport technique, une spécification de protocole, le code du prouveur, deux vérificateurs et des preuves formelles en Lean. Le tout sous licence Apache 2.0.
Comment fonctionne l'inférence vérifiable d'Anthropic, en deux temps
Le dispositif se décompose en deux phases. La première est hors ligne : le fournisseur s'engage sur ses poids et publie une empreinte d'environ 6,5 Mo. Ce calcul prend une fois environ 39 minutes et vaut pour près de 16 millions de requêtes.
La seconde se joue à chaque appel. Le prouveur calcule une preuve que les jetons sortis correspondent bien au modèle engagé et au prompt envoyé. Le client, ou un tiers, vérifie cette preuve sur un processeur ordinaire, sans carte graphique.
Le point important : le vérificateur n'a pas besoin de télécharger les poids. Il lui suffit de l'empreinte et de la preuve. Un fournisseur peut donc prouver ce qu'il sert sans livrer son modèle, ce qui règle un problème commercial autant que technique.
Les chiffres mesurés sur Llama 4 Maverick
Anthropic a testé son prototype sur Llama 4 Maverick, un modèle à mélange d'experts de 400 milliards de paramètres dont environ 17 milliards sont actifs par jeton, avec des poids publics en 4 bits. La machine : un seul H100 accompagné de 24 cœurs de processeur.
Le débit de preuve atteint environ 110 jetons par seconde. Pour une requête de 1 024 jetons, la preuve pèse à peu près 19 Mo. La vérification, elle, demande 17 secondes sur 24 threads et 21 secondes sur un seul.
Ces valeurs dessinent un usage précis. Prouver une conversation longue reste hors de portée. Prouver une requête courte, une classification, une extraction de données ou un appel d'API structuré, oui.
Le facteur 72 de FlashProve qui freine l'adoption
Comparons ce que coûte la preuve à ce que coûte le service. Sur le même lot, la génération de preuves prend environ 72 fois plus de temps GPU que le service vLLM équivalent. Selon les exécutions, le rapport va de 66 à 77. À la charge la plus élevée testée, il monte à 94.
Un service qui répond en une seconde passerait donc, dans le meilleur des cas mesurés par Anthropic, à plus d'une minute de calcul pour la même requête, ce qui change l'économie d'un produit grand public bien plus qu'un problème d'ingénierie.
Combien d'utilisateurs accepteraient ce délai pour une garantie qu'ils ne peuvent pas lire eux-mêmes ?
Le vérificateur, lui, est bon marché. Un processeur suffit, et le temps de contrôle reste dans la seconde pour les petites requêtes.
Anthropic situe son travail face aux tentatives précédentes. VerInf demandait environ 14,3 heures pour 1 000 jetons sur un DGX Spark, avec une preuve de 93,6 Go. zkLLM prouvait un modèle de 13 milliards de paramètres à environ 2,5 jetons par seconde sur une A100. Un système commercial, Attestable, annonce 53 à 77 jetons par seconde sur un modèle dense de 31 milliards, sans publier son code.
Les limites que FlashProve reconnaît lui-même
La liste est longue, et c'est elle qui rend le document lisible. Il s'agit d'un prototype de recherche, pas d'un service.
Les preuves portent sur une version entière des poids, en décodage glouton. Autrement dit, dès qu'un service échantillonne ses réponses ou calcule en virgule flottante, la sortie peut diverger et la preuve cesser de correspondre. Le procédé suppose aussi une architecture à mélange d'experts, et il ne cache pas cette architecture. Les attaques par canal auxiliaire sortent du périmètre.
Le plafond de 1 024 jetons exclut de fait le chat long, le résumé de documents et les agents qui traînent un historique de plusieurs milliers de mots d'un tour à l'autre, c'est-à-dire l'essentiel des usages payants actuels.
Dernier point, plus gênant : le vérificateur rapide en C++ n'est pas formellement vérifié. La version en Lean l'est, mais elle est lente.
Ce que la vérification formelle en Lean couvre vraiment
Anthropic a fait vérifier par machine trois propriétés de sécurité : la complétude, la solidité et le caractère zero-knowledge. C'est plus rare qu'il n'y paraît dans ce domaine, où les preuves de sécurité restent souvent sur le papier.
Reste un écart que l'équipe signale elle-même. Les énoncés formels doivent encore être audités par des humains, et prouver que le code correspond à la spécification est un problème distinct. Une preuve machine dit qu'une implication tient. Elle ne dit pas que l'implication décrit le bon programme.
Pourquoi Anthropic sort ce prototype maintenant
La feuille de route de sûreté d'Anthropic fixait un objectif public : un prototype d'inférence prouvable avant le 30 septembre 2026. L'entreprise affirme l'avoir atteint par un autre projet, qui signe le trafic d'inférence et le recalcule sur un serveur de confiance. FlashProve est une seconde voie, uniquement logicielle.
Pour un développeur, l'intérêt est concret. Une preuve vérifiable rend détectable le remplacement discret d'un modèle par un autre. Elle permet aussi d'imaginer une « preuve d'échec » : la démonstration qu'un modèle a passé au moins un certain nombre de jetons à chercher des bugs sans en trouver.
Pas en production.
Le dépôt, lui, est déjà lisible, et c'est probablement ce qui compte le plus pour une équipe qui veut tester la méthode sur son propre modèle.






