Actualités IA · 13 min de lecture

Votre routeur API a-t-il remplacé le modèle ? Ce que FlashProve d'Anthropic peut prouver

FlashProve d'Anthropic utilise des preuves à divulgation nulle pour identifier le modèle qui a répondu. Voici ses possibilités et ses limites.

Illustration d'un modèle d'IA envoyant une réponse par un routeur, avec un bouclier de vérification lumineux sur le flux de données

FlashProve est le prototype de recherche open source d’Anthropic pour l’inférence vérifiable. Il permet à un fournisseur de modèle de produire une preuve cryptographique qu’une réponse provient d’un ensemble précis de poids fixé par un engagement, sans révéler ces poids. Publié en novembre 2026 et présenté sur Llama 4 Maverick de Meta, il ne peut pas encore être activé pour le trafic de l’API Claude ou les routeurs tiers.

Un routeur API peut-il remplacer votre modèle en secret ?

Oui. Un service de routage tiers ou un revendeur peut substituer en coulisses un modèle moins cher ou plus petit, et la lecture des réponses ne permet pas à elle seule de détecter ce remplacement de façon fiable.

Quand on consulte un comparatif des prix officiels des API d’IA, l’attrait des routeurs API à prix réduit et des points d’accès proxy revendus est évident. Les modèles de pointe coûtent cher à fort volume, et un intermédiaire qui promet le même identifiant de modèle avec une forte remise tente tout développeur ou responsable d’équipe surveillant sa facture mensuelle.

Le problème est que le champ model d’une réponse API n’est qu’une chaîne renvoyée par le serveur. Dans son article de recherche du 2 novembre 2026, la Frontier Red Team d’Anthropic a exposé clairement le problème : une personne interrogeant aujourd’hui un modèle ne peut pas vérifier que les réponses proviennent bien du modèle précis que le développeur dit utiliser, plutôt que d’un modèle « secrètement substitué par un service de routage pour des raisons de coût, ou même par un attaquant ayant altéré le flux de tokens ». Le rapport technique d’Anthropic ajoute qu’un fournisseur pourrait utiliser un modèle plus petit ou moins performant, ou même changer de modèle entre les requêtes.

Beaucoup de développeurs pensent remarquer une baisse de gamme grâce à leur impression générale ou à des tests ponctuels de prompts. Anthropic prévient explicitement que juger uniquement à partir des résultats du modèle n’est pas fiable, même lorsque les réponses semblent de grande qualité. Les petits modèles et les variantes quantifiées traitent souvent assez bien les prompts courants pour passer un contrôle superficiel, tout en échouant sur des cas limites plus difficiles que l’on ne remarque qu’en production.

Qu’est-ce que FlashProve ?

FlashProve est un système cryptographique purement logiciel qui utilise un argument de connaissance succinct à divulgation nulle de connaissance (zkSNARK) pour prouver qu’un modèle précis, fixé par un engagement, a produit une séquence donnée de tokens de sortie.

Au lieu de dépendre d’enclaves matérielles de confiance, qu’Anthropic considère comme complémentaires de la cryptographie, FlashProve repose sur les mathématiques. Le processus met en jeu deux parties, le fournisseur du modèle (le prouveur) et l’utilisateur (le vérificateur), et comporte trois étapes :

  1. Commit (hors ligne) : Avant de traiter les requêtes, le fournisseur calcule et publie un engagement cryptographique portant sur les poids du modèle. On peut voir cet engagement comme une empreinte courte et infalsifiable qui fixe un ensemble exact de poids tout en gardant ces poids secrets.
  2. Prove (en ligne, a posteriori) : Après avoir généré les tokens de sortie pour un prompt, le fournisseur exécute le prouveur pour créer un fichier de preuve montrant que l’évaluation du modèle engagé sur ce prompt produit exactement ces tokens. Les preuves sont générées par lots après coup, et non en continu pendant l’envoi des tokens à l’utilisateur.
  3. Verify : Toute personne disposant de l’engagement, du prompt et de la réponse peut exécuter un programme de vérification léger sur un processeur ordinaire pour contrôler la preuve en quelques secondes, sans jamais voir les poids du modèle.

Pour les développeurs qui ne sont pas cryptographes, un zkSNARK offre quatre garanties pratiques soulignées par Anthropic lors de sa publication :

  • Complétude : Si le fournisseur a réellement exécuté le modèle engagé comme annoncé, une preuve honnête passera la vérification.
  • Solidité : Un fournisseur ne peut pas falsifier une preuve acceptée pour un autre modèle sans mettre en défaut des hypothèses cryptographiques largement admises.
  • Divulgation nulle de connaissance : Le vérificateur n’apprend rien sur les poids secrets, les activations intermédiaires ou même les experts précis exécutés dans un modèle à mélange d’experts. (L’architecture générale du modèle n’est toutefois pas cachée.)
  • Concision : La preuve est assez petite pour être téléchargée facilement et rapide à vérifier, comparativement à la réexécution d’un modèle massif par ses propres moyens.

Anthropic a publié sur GitHub cinq éléments sous licence Apache 2.0 (anthropics/FlashProve, version 0.16.0) : l’article de recherche, le rapport technique, une spécification du protocole rédigée par Claude, la base de code (comprenant un prouveur CUDA, un vérificateur C++ rapide nommé cp_verify et un vérificateur Lean dont la correction est démontrée), ainsi que des preuves formelles Lean accompagnées d’un outil de visualisation interactif. Anthropic précise que Claude a produit les améliorations zkSNARK sous-jacentes et que l’équipe a utilisé des énoncés formels dans l’assistant de preuve Lean pour rendre auditables les décisions de conception complexes de Claude.

Quelle est la vitesse de FlashProve et quelle taille font les preuves ?

Au 4 novembre 2026, Anthropic indique que FlashProve peut générer des preuves pour un modèle à mélange d’experts de 400 milliards de paramètres à environ 110 tokens par seconde sur un seul GPU NVIDIA H100. Les preuves font moins de 19 MB et se vérifient en 17 secondes sur un processeur.

Anthropic a évalué FlashProve sur Llama 4 Maverick de Meta, un exemple notable parmi les modèles à poids ouverts, qui utilise 400B paramètres au total, dont environ 17B actifs par token (environ 232 GB de poids publics quantifiés sur 4 bits). Voici les chiffres exacts communiqués par Anthropic le 2 novembre 2026 :

Mesure Résultat Anthropic FlashProve (Llama 4 Maverick)
Modèle testé Meta Llama 4 Maverick (400B au total, ~17B actifs/token, poids 4 bits, ~232 GB)
Matériel du prouveur 1× GPU NVIDIA H100 + 24 cœurs CPU
Temps d’engagement hors ligne ~39 minutes une fois par modèle (valable pour ~16 millions de requêtes avant renouvellement)
Vitesse de preuve ~223 secondes pour un lot de 24 requêtes (~110 tokens/seconde)
Taille de la preuve 18.78 MB par requête (~19 MB pour une requête de 1,024 tokens)
Téléchargement de l’engagement par le client ~6.5 MB au total
Temps de vérification (CPU uniquement) 17 secondes sur 24 threads CPU (21 secondes sur un seul thread)
Surcoût de calcul par rapport à vLLM ~72× le temps par GPU (66–77× selon les essais) ; ~94× à la charge maximale testée de vLLM (plage ~70–95×)
Limite de longueur de contexte Jusqu’à 1,024 tokens

Pour mettre ces chiffres en perspective, Anthropic a comparé FlashProve à l’état de l’art open source antérieur (VerInf) sur le même modèle Llama 4 Maverick. Selon Anthropic, VerInf atteignait environ 0.02 token par seconde : il fallait 14.3 heures pour prouver 1,000 tokens, la preuve faisait 93.6 GB et sa vérification demandait presque une journée entière. Réduire une preuve de 93.6 GB à 18.78 MB fait passer la vérification cryptographique de l’inférence de la théorie mathématique à un résultat qu’une machine cliente peut effectivement télécharger et vérifier.

Un surcoût de calcul de 70× à 95× par rapport au service vLLM standard explique néanmoins pourquoi les preuves sont produites a posteriori par lots, au lieu d’être jointes gratuitement à chaque réponse de chat en direct.

Ce que FlashProve ne prouve pas

FlashProve est un prototype de recherche non maintenu, soumis à des contraintes techniques strictes. Une vérification réussie ne garantit donc ni l’équivalence en virgule flottante, ni la couverture d’une conversation entière, ni une sécurité de production auditée.

Dans les guides known-limits.md et what-is-proved.md du dépôt, l’équipe expose avec une franchise appréciable les limites au 4 novembre 2026 :

  • Modèle entier et décodage glouton uniquement : La preuve concerne une version quantifiée du modèle en nombres entiers à virgule fixe, utilisant un décodage glouton (qui choisit toujours le seul token ayant le meilleur score). Les API réelles utilisent généralement l’arithmétique en virgule flottante et un échantillonnage aléatoire avec température. Anthropic indique que, lors d’une mesure, le meilleur token différait à 6.81% des positions entre le modèle entier et une implémentation en virgule flottante.
  • Politique d’acceptation « clipped-gap » plus souple : Les systèmes de service pouvant légèrement diverger de la référence entière, le vérificateur prend en charge une politique plus souple qui renvoie WITHIN LIMITS. Anthropic prévient qu’une acceptation selon cette politique ne prouve pas à elle seule que la réponse vient du modèle ; si vous ne pouvez pas évaluer indépendamment ces limites de tolérance, n’acceptez qu’une correspondance exacte.
  • Limite de contexte courte : Les preuves prennent actuellement en charge des contextes allant jusqu’à 1,024 tokens, ce qu’Anthropic juge « assez court » par rapport aux sessions normales de programmation ou de chat.
  • Architectures MoE uniquement : L’implémentation actuelle ne prend en charge que les architectures à mélange d’experts ; elle ne cache pas l’architecture du modèle et ne protège pas contre les canaux auxiliaires tels que les attaques temporelles.
  • Portée au niveau des tokens sans métadonnées : Une preuve valide ne couvre que les tokens précis vérifiés et n’intègre ni identité du client ni horodatage.
  • Aucun audit de sécurité indépendant : Bien que la solidité du vérificateur de référence écrit en Lean soit formellement démontrée, le vérificateur C++ rapide (cp_verify), le prouveur CUDA et le composant d’engagement ne bénéficient pas de garanties formelles : cp_verify est simplement testé par rapport au vérificateur Lean. Anthropic précise en outre que les programmes et les preuves n’ont fait l’objet d’aucun audit de sécurité indépendant et que le dépôt est publié comme un artefact de recherche qui n’est ni maintenu ni ouvert aux contributions.

Pourquoi l’identifiant d’engagement compte plus que la preuve

Une preuve FlashProve valide confirme seulement qu’une réponse provient des poids, quels qu’ils soient, qui correspondent à l’identifiant d’engagement. Un routeur malhonnête pourrait donc s’engager sur un modèle bon marché et vous remettre une preuve mathématiquement valide pour le mauvais modèle.

C’est le point essentiel pour toute personne préoccupée par les routeurs API tiers. Dans le guide « Known limits » du dépôt, sous le titre The provider chooses the model, Anthropic écrit : « Un oui ne dit pas à qui appartiennent les poids… Un fournisseur peut s’engager sur le modèle de son choix, y compris un modèle petit ou dégénéré. »

Imaginez que vous payez un routeur API peu fiable pour accéder à un modèle de pointe de 400B paramètres. Pour économiser, le routeur exécute secrètement un modèle bon marché de 8B. S’il crée son propre engagement FlashProve pour ce modèle 8B, y exécute votre prompt et vous envoie la réponse avec la preuve et son fichier d’engagement, le vérificateur C++ de votre ordinateur portable indiquera une réussite. Les mathématiques sont parfaitement valides : le modèle 8B a bien produit ces tokens.

C’est pourquoi Anthropic donne une règle opérationnelle stricte : « Obtenez l’identifiant d’engagement auprès d’une partie de confiance, jamais auprès du serveur que vous vérifiez ni dans des fichiers envoyés avec une preuve. »

Pour que l’inférence vérifiable détecte un routeur malhonnête, le créateur initial du modèle (comme Anthropic ou Meta) ou un auditeur indépendant de confiance doit publier l’identifiant d’engagement officiel des véritables poids. Ce n’est qu’en vérifiant la preuve du routeur avec l’identifiant officiel du propriétaire que la cryptographie révèle une substitution de modèle.

Ce que cela signifie pour les routeurs, revendeurs et évaluateurs

Si les créateurs de modèles publient un jour des identifiants d’engagement officiels et prennent en charge l’inférence vérifiable, les routeurs tiers et hébergeurs cloud pourront prouver qu’ils ont fourni exactement les poids pour lesquels vous avez payé, sans exposer les fichiers propriétaires du modèle.

Dans ses annonces des 2 et 3 novembre 2026, Anthropic a présenté plusieurs groupes susceptibles d’en bénéficier à mesure que cette technologie mûrit :

  • Clients de routeurs API : Les équipes acheminant leur trafic par des fournisseurs d’inférence tiers pourraient auditer a posteriori un échantillon de leurs requêtes avec l’identifiant d’engagement publié par le créateur du modèle ; une baisse de gamme silencieuse échouerait à la vérification.
  • Évaluateurs indépendants de la sécurité : Les évaluateurs avant et après publication peuvent vérifier que le modèle dont ils testent la sécurité est exactement celui qui sera ensuite fourni aux clients.
  • Équipes de sécurité surveillant les flux altérés : Comme la preuve lie le prompt et les tokens de sortie aux poids engagés, Anthropic indique qu’elle complique la prise de contrôle d’un chat ou la modification du flux de tokens en transit par des attaquants présents sur des serveurs compromis. Cette préoccupation est liée aux menaces applicatives comme l’injection de prompt.
  • Régulateurs et contrôles de provenance : Anthropic évoque aussi le « pacing » matériel (vérifier que le calcul sert à l’inférence plutôt qu’à un entraînement non autorisé), la provenance des textes (prouver qu’un modèle précis a écrit ou relu un document) et l’application des règles d’approbation des modèles.

Qu’en est-il du trafic Claude d’Anthropic ? Dans son article du 2 novembre 2026, Anthropic précise que sa Frontier Safety Roadmap visait à développer un prototype d’inférence vérifiable (qu’Anthropic appelle « inference verification » depuis une mise à jour du 19 octobre 2026) avant le 30 septembre 2026. Anthropic affirme avoir respecté cette échéance de septembre grâce à un projet connexe distinct, qui signe cryptographiquement son trafic d’inférence et recalcule l’inférence sur un serveur de confiance. FlashProve poursuit le même objectif de vérification par une cryptographie à divulgation nulle, plutôt que par un recalcul de confiance.

Ce que je ferais aujourd’hui en achetant un accès à un modèle auprès d’un tiers

Au 4 novembre 2026, aucune API commerciale ni aucun routeur ne joint de preuves FlashProve au trafic en direct. Votre seule défense fiable aujourd’hui contre la substitution de modèle consiste donc à acheter directement auprès des fournisseurs d’origine ou de partenaires vérifiés en qui vous avez contractuellement confiance.

Si vous êtes développeur ou responsable technique et envisagez actuellement un proxy à prix réduit ou un routeur tiers, voici comment je procéderais :

  1. Considérez la chaîne model dans une réponse tierce comme une affirmation non vérifiée. Ne supposez pas qu’un revendeur fournit le modèle de pointe simplement parce que la charge utile JSON l’indique.
  2. Ne comptez pas sur des tests ponctuels de prompts pour détecter une substitution. Prenez au sérieux l’avertissement d’Anthropic : les seuls contrôles de qualité des sorties ne distinguent pas de manière fiable un modèle de pointe d’un substitut moins cher sur les prompts quotidiens.
  3. Gardez les charges de travail critiques sur les API des fournisseurs d’origine ou les grands hébergeurs cloud. Si la précision, la sécurité ou la conformité de votre produit dépend d’un modèle de pointe précis, payez le tarif officiel ou utilisez un partenaire cloud officiel avec des accords de niveau de service contraignants.
  4. Sachez comment vérifier si les preuves sont déployées plus tard. Si votre fournisseur d’inférence adopte un jour FlashProve ou un système zkSNARK similaire, n’utilisez jamais le fichier d’engagement joint à sa réponse. Obtenez l’identifiant directement auprès du créateur du modèle, compilez vous-même le vérificateur, contrôlez les tokens couverts et exigez une correspondance exacte, sauf si vous pouvez évaluer vous-même les limites de tolérance numérique.

Questions fréquentes

FlashProve peut-il vérifier les réponses de l’API Claude aujourd’hui ?

Non. Au 4 novembre 2026, FlashProve est un prototype de recherche open source présenté sur Llama 4 Maverick, le modèle à poids ouverts de Meta. Ni l’API Claude, ni OpenAI, ni les routeurs API commerciaux ne joignent aujourd’hui de preuves FlashProve aux réponses. Anthropic a indiqué séparément avoir atteint son objectif interne du 30 septembre 2026 pour la vérification de l’inférence grâce à un autre projet qui signe le trafic et recalcule l’inférence sur un serveur de confiance.

FlashProve révèle-t-il les poids secrets du modèle ?

Non. FlashProve utilise une preuve à divulgation nulle de connaissance (zkSNARK), qui garantit que le vérificateur n’apprend rien sur les poids secrets du modèle, les valeurs des couches intermédiaires ou les experts précis activés pendant l’inférence. L’architecture générale du modèle n’est pas cachée et les canaux auxiliaires temporels sont hors périmètre, mais les poids propriétaires restent entièrement confidentiels tout en permettant à chacun de vérifier le calcul sur un CPU.

Puis-je exécuter moi-même le vérificateur FlashProve ?

Oui. Anthropic a publié le code sur GitHub sous licence Apache 2.0 (anthropics/FlashProve). Vous pouvez compiler le vérificateur C++ rapide (cp_verify) sur Linux et vérifier les preuves sur un CPU ordinaire sans GPU ni poids du modèle. Le dépôt comprend un exemple enregistré utilisant un petit modèle synthétique afin que les développeurs puissent tester localement le processus Commit → Prove → Verify.

L’inférence vérifiable est-elle identique à une signature numérique ?

Non. Une signature numérique classique prouve uniquement qui a envoyé un message ; vous devez donc faire confiance à l’expéditeur pour avoir exécuté honnêtement le bon modèle. L’inférence vérifiable avec FlashProve prouve quels poids engagés ont calculé les tokens de sortie. Même dans ce cas, vous devez obtenir l’identifiant d’engagement auprès d’une partie de confiance, car un serveur malhonnête pourrait sinon s’engager sur un modèle bon marché et générer des preuves valides pour celui-ci.

Détails vérifiés pour la dernière fois le 4 novembre 2026. Prochaine vérification : 4 décembre 2026.

Sources

Écrit par

Chunyu Cai

Chunyu Cai est le directeur général de Lotook, LLC et un entrepreneur qui écrit sur les modèles d’IA, les agents et leur influence sur le travail au quotidien. Chunyu Cai est titulaire d’un master de l’établissement Imperial College London.