W Shakespeare

Avant de déployer une policy, Newton Protocol exige de passer par trois étapes : des tests unitaires pour la Rego Policy, des tests distincts pour chaque oracle WASM, puis une simulation de l’ensemble de la policy avec des données du monde réel.
Ces étapes ne servent pas simplement à vérifier chaque composant isolément. Elles sont structurées pour réduire progressivement l’incertitude entourant une décision. Après chaque round de validation, le périmètre de ce qui doit encore attendre le déploiement pour être confirmé se réduit de plus en plus.
En général, le déploiement est le moment le plus important pour savoir si une décision fonctionne comme prévu. Même après de nombreux rounds de tests, l’environnement de production reste l’endroit où beaucoup d’équipes acceptent d’apprendre des choses qu’elles ne pouvaient pas savoir à l’avance.
Avec Newton Protocol, la majeure partie de ce processus se déroule directement pendant le développement. La Rego Policy, l’oracle WASM et les données sont assemblés pour simuler l’ensemble de la décision avant que le déploiement n’ait lieu. Cela me fait penser que Newton Protocol vise une architecture de Pre-validated Deployment.
À ce stade, le déploiement devient principalement une étape de publication d’une décision déjà validée, plutôt qu’un moment où le système continue d’apprendre si cette décision est correcte ou non.
Ce qui me semble particulièrement intéressant, c’est que Newton Protocol semble être en train de changer le rôle du Déploiement. Lorsque le Déploiement n’est plus l’endroit où naît la Validation, il n’est plus non plus celui où le système apprend si une Decision est correcte ou incorrecte.
C’est peut-être là le sens de l’architecture Pre-validated Deployment. Pas une procédure de test plus complète, mais un principe architectural qui déplace l’activité de Validation hors de la Production. Je suis assez curieux de savoir si cela ne sera qu’un choix de Newton Protocol, ou si cela deviendra progressivement la manière dont de nombreux systèmes logiciels seront construits à l’avenir ? $EVAA $NEWT #Newt @NewtonProtocol

L’autre jour, je regardais la section « Writing Data Oracles » du protocole Newton et je suis tombé sur quelque chose d’assez intéressant : si un « HTTP Fetch » échoue, l’oracle de données ne doit pas ignorer l’erreur ni renvoyer des données par défaut. À la place, l’oracle renvoie une erreur « namespaced » afin que la « Rego Policy » puisse refuser (deny) immédiatement la décision.
Il semble que le protocole Newton soit en train de déplacer la place du « failure » pendant la génération de la décision. Une erreur n’est plus seulement une information à lire par le développeur une fois le système terminé son exécution. Dès que l’oracle de données renvoie une erreur namespaced, cet état d’échec devient une partie des données que la policy Rego doit évaluer. La décision ne s’arrête pas parce que le système a rencontré une erreur. Elle s’arrête parce que le système vient de recevoir un signal nouveau.
J’ai soudain compris que le protocole Newton choisit une architecture « Fail-Closed ». Cette architecture ne cherche pas à dissimuler ce qui n’est pas encore connu pour continuer l’exécution. Au contraire, elle élargit la notion de « Evidence ». Ce n’est pas uniquement le fait que des données soient collectées avec succès qui leur donne de la valeur. L’impossibilité pour l’oracle de données de confirmer une information devient aussi une forme d’« Evidence » que la policy Rego doit évaluer.
Une fois que le « failure » est considéré comme une « Evidence », la décision ne peut plus se permettre de l’ignorer. Une décision ne peut pas continuer uniquement parce que le reste des données semble, à première vue, cohérent. Elle doit refléter l’ensemble des « Evidence » dont le système dispose, y compris ce qui ne peut pas être confirmé. Si les « Evidence » ne sont pas suffisantes pour étayer une conclusion, la décision n’a pas le droit de compléter elle-même la partie manquante par hypothèse.
Vu sous cet angle, l’architecture « Fail-Closed » du protocole Newton n’est plus seulement un mécanisme de traitement des défaillances. Elle oblige toutes les décisions à être honnêtes vis-à-vis des « Evidence » dont on dispose réellement, plutôt que des « Evidence » que le système espérait avoir. #Newt $LAB $TRIA $NEWT @NewtonProtocol

Le protocole Newton a été développé par Magic Labs, une équipe à l’origine de nombreux produits répondant à des normes d’entreprise telles que la SOC 2 Type II et l’ISO 27001.
Ces normes exigent qu’une organisation dispose d’un processus de développement suffisamment rigoureux pour gérer le changement, évaluer les risques et garantir que toutes les décisions puissent être tracées tout au long du cycle de développement.
Plus important encore, ce processus de développement ne doit pas seulement servir une seule mise en production. Il doit être suffisamment cohérent pour continuer à être utilisé à travers de nombreuses mises en production, quels que soient les changements continus du produit.
À mon avis, lorsque l’équipe de Magic Labs travaille pendant de nombreuses années avec le même processus de développement, celui-ci ne devient plus seulement un workflow interne. Il devient la méthode par défaut pour aborder les problèmes et prendre des décisions. C’est aussi pourquoi je pense que, lors du développement du protocole Newton, ce que Magic Labs a apporté n’est pas seulement des normes d’entreprise, mais plutôt un mindset « Process-First ».
Avec ce mindset, chaque mise en production du protocole Newton peut rester très différente, car elle doit résoudre de nouveaux problèmes. Mais tous les changements reposent sur le même cadre de décision, la même façon d’évaluer les risques et le même processus d’ingénierie.
Cette cohérence ne se situe pas dans chaque mise en production, mais dans la façon dont Newton Protocol est conçu (Engineered). Lorsque @NewtonProtocol continue de s’étendre, les nouvelles fonctionnalités ne deviendront pas des pièces assemblées issues de philosophies d’ingénierie différentes. Elles seront toujours construites à partir de la même base de pensée qui a façonné le protocole dès le départ.
Il est possible que ce que l’équipe de Magic Labs apporte de plus précieux en développant le protocole Newton soit ce mindset « Process-First ». Il permet au protocole Newton de continuer à évoluer et à s’étendre tout en conservant la cohérence dans la manière dont il est conçu.#Newt $LAB $NEWT

Lisez le guide d’intégration du protocole Newton et j’ai remarqué un détail qui me semble assez étrange : le Data Oracle peut être écrit en JavaScript, Rust ou Python. Au début, je pensais que @NewtonProtocol ne faisait que chercher à élargir les choix pour les développeurs.
Mais ce qui est vraiment remarquable n’est pas le langage de programmation. C’est plutôt le fait que, quel que soit le langage utilisé, tout finit par compiler vers la même interface WIT.
C’est à ce moment-là que j’ai compris : JavaScript, Rust ou Python ne sont que des manifestations extérieures. La chose qui évolue le plus vite dans chaque écosystème n’a jamais été le langage de programmation, mais l’innovation. Python voit apparaître en continu de nouveaux packages liés à l’IA. Rust propose des optimisations en performance et en sécurité. JavaScript évolue très rapidement au niveau des applications et des outils. Chaque écosystème a son propre rythme d’évolution, et personne ne sait d’où viendra la prochaine percée.
Si un protocole est trop étroitement lié à un écosystème de langage de programmation, il parie alors, sans le vouloir, que les innovations les plus importantes continueront d’y émerger. Tout ce qui naît ailleurs devra être porté à nouveau, ou ne sera jamais intégré au système.
Le protocole Newton semble avoir choisi de se tenir à l’écart de la course et d’adopter une approche d’Innovation Neutrality. Le protocole Newton ne standardise pas l’endroit où l’innovation est créée. La seule chose qui est standardisée, c’est la manière dont l’innovation arrive au protocole : via une interface commune.
Ainsi, l’évolution du Data Oracle ne dépend pas d’un seul langage de programmation ni d’une seule communauté de développeurs. Une percée née en Python, Rust ou JavaScript peut devenir une partie du protocole Newton. C’est aussi l’avantage de la position Innovation Neutrality. Le protocole Newton n’a pas besoin de parier l’avenir sur un écosystème de langage de programmation quelconque. #Newt $LAB $HMSTR $NEWT

Lisez la section Verifiable Credentials dans la documentation du Newton Protocol, je me suis encore arrêté sur un tout petit détail.
Parmi une multitude de méthodes SDK dédiées à Identity, Verification et Credential Management, @NewtonProtocol réserve quand même entièrement une méthode à unlinkApp().
À première vue, ce n’est qu’une API destinée à révoquer le lien entre un utilisateur et une application.
Mais plus j’y pense, plus je me dis que son existence est peut-être plus intéressante que sa fonction elle-même.
Un système n’a vraiment besoin de unlinkApp() que si, dès le départ, l’équipe a accepté que les utilisateurs aient toujours des Exit Rights.
Si cette hypothèse est correcte, le Newton Protocol poursuit peut-être une stratégie de Voluntary Lock-in.
À première écoute, cela semble contradictoire.
En général, un Lock-in est créé en augmentant progressivement les Switching Costs, rendant de plus en plus difficile le fait de quitter le système. Mais avec un Voluntary Lock-in, la possibilité de partir existe toujours. La seule chose qui retient l’utilisateur, c’est sa propre décision.
Cela signifie aussi que le Newton Protocol renonce presque à l’un des Competitive Moats les plus courants des plateformes Web3.
Quand Exit est toujours préservé, le Newton Protocol ne peut pas compter sur les Switching Costs pour fidéliser les Users.
À mon avis, c’est précisément le point qui mérite réflexion.
Si le Voluntary Lock-in est réellement une option dans la conception produit, alors chaque Active User n’est plus simplement un indicateur de croissance.
Ils deviennent une preuve que, même lorsqu’ils ont toujours le droit de partir, ils choisissent quand même de rester.
Autrement dit, unlinkApp() pourrait ne pas être qu’une simple méthode SDK.
Cela pourrait être un petit signal montrant que le Newton Protocol ne considère pas le Lock-in comme le résultat de barrières, mais comme le résultat de décisions volontaires répétées dans le temps.
#Newt $MAGMA $LAB $NEWT

"Le marché n’existe vraiment que lorsque deux parties commencent à se trouver."
Cette phrase m’est venue à l’esprit quand j’ai appris que Newton Protocol construit un Policy Marketplace.
Au début, je pensais que ce n’était qu’un endroit où les builders peuvent rechercher et intégrer des politiques.
Mais si l’on observe attentivement sous l’angle Platform Economics, je vois que c’est davantage un Two-Sided Market qu’un marketplace ordinaire.
Un côté : l’Offre. Ils emballent la sécurité, la conformité et l’expertise juridique en des Policy-as-Code réutilisables à de nombreuses reprises.
L’autre côté : la Demande. Ils n’achètent pas une politique simplement parce qu’ils l’aiment. Ce dont ils ont besoin, c’est de la confiance et de la conformité, sans avoir à tout reconstruire depuis zéro à chaque fois qu’ils développent un coffre (Vault), un protocole RWA, un Stablecoin ou un Agent IA.
Dans un marché comme celui-ci, la valeur ne réside pas dans le fait d’avoir beaucoup d’Offre ou beaucoup de Demande.
Elle réside dans l’Efficacité de l’appariement (Matching Efficiency).
Si une politique de qualité n’arrive pas jusqu’au builder qui en a réellement besoin, cette expertise ne crée presque aucune valeur économique. À l’inverse, si les builders ne trouvent pas la bonne politique, ils finissent par la construire eux-mêmes, et la Demande ne se transforme jamais en transactions.
Quand l’Efficacité de l’appariement augmente, les comportements des deux parties changent. L’Offre a davantage d’incitations à créer plus de Policy-as-Code, car la probabilité d’utilisation et les revenus sont plus élevés. La Demande a aussi tendance à passer par le marketplace avant de se développer en interne, car les coûts de recherche et d’intégration diminuent de plus en plus.
C’est peut-être cela qui me paraît le plus intéressant dans le Policy Marketplace de Newton Protocol. @NewtonProtocol ne se contente pas de connecter l’Offre et la Demande. Il cherche aussi à optimiser l’Efficacité de l’appariement, pour que la capacité même à relier les deux côtés devienne une source de liquidité et permette au Two-Sided Market tout entier de fonctionner plus efficacement.
#Newt $LAB $NEWT

Au départ, lorsque j’ai appris que Newton Protocol utilise TypeScript pour construire le Newton Vault SDK.
J’ai dû m’exclamer : "Pourquoi ne pas utiliser Python, alors, et plutôt choisir TypeScript ?"
Si l’objectif est de servir des AI Agents, Python est presque le choix le plus évident. Il existe tout un écosystème énorme pour le machine learning, la finance quantitative.... En termes de capacités, c’est presque le choix le plus facile à comprendre.
Mais il est possible que Newton Protocol ne soit pas du tout en compétition sur les capacités.
Ce qu’ils visent, c’est la Technology Half-life.
L’écosystème de l’IA a une durée de vie extrêmement courte. Aujourd’hui tout le monde parle d’un nouveau modèle, quelques mois plus tard un nouveau framework, un nouveau agent framework, ou encore une nouvelle bibliothèque apparaît. Python est toujours au cœur de ces changements.
Pendant ce temps, l’Execution Stack a une Technology Half-life bien plus longue. Wallet, navigateur, signatures et smart contracts sont constamment améliorés, mais sont rarement remplacés.
C’est aussi là que TypeScript règne.
Cela m’a amené à voir le Newton Vault SDK autrement.
Si Newton Protocol choisissait Python, ils devraient vivre au rythme des changements de l’écosystème IA. À chaque fois que le marché se déplace, le SDK subirait une pression pour s’adapter.
Mais en plaçant le Vault SDK sur TypeScript, Newton Protocol s’ancre dans une couche d’infrastructure dont la Technology Half-life est bien plus longue. L’IA peut changer continuellement de cerveau, mais une fois l’autorité accordée et que la transaction est signée, le workflow revient toujours au même environnement d’exécution.
Ce qui est peut-être le plus remarquable chez Newton Protocol, c’est qu’ils ne cherchent pas à se positionner au sommet de la couche technologique à la mise à jour la plus rapide. Au lieu de cela, le Vault SDK est posé sur une Execution Stack dont la Technology Half-life est plus longue. Quand l’écosystème IA change sans cesse, @NewtonProtocol n’a pas besoin de gagner à chaque cycle de l’IA. Ils ont seulement besoin de survivre à ces cycles. #Newt $TAIKO $NEWT

Au début, je pensais que le VaultKit de Newton Protocol était un SDK permettant aux builders de créer des vaults plus rapidement.
Mais avec le même VaultKit, Newton Protocol parle d’Institutional DeFi, d’AI Agents et même de DeFi Whales. Ces trois catégories d’utilisateurs n’ont presque rien en commun.
Puis j’ai compris que ce que Newton Protocol distribue n’a jamais été un vault.
Ce sont des Constraint Boxes.
Une institution a besoin d’une Compliance Box. Les flux de fonds continuent de fonctionner, mais ils ne peuvent pas toucher des adresses sanctionnées, ne peuvent pas contourner le workflow d’approbation et ne peuvent pas non plus sortir du périmètre du mandat d’investissement.
Un AI Agent, lui, a besoin d’une Behavior Box. Il a toujours le droit de trader, mais toutes ses actions sont limitées par des plafonds de dépenses, une whitelist de protocoles et des règles prédéfinies.
Pendant ce temps, un DeFi Whale qui dépose des fonds dans un vault n’a besoin que d’une Trust Box, où le curator ne peut pas modifier silencieusement la strategy ni transférer les actifs vers des endroits auxquels il n’a jamais été engagé.
Ce qui est intéressant, c’est que ces trois Boxes sont totalement différentes, mais elles résolvent le même problème : limiter l’autorité sans perdre l’automatisation.
C’est aussi à ce moment-là que je vois le VaultKit autrement.
Au lieu de vendre une couche de sécurité générique à tout le monde, Newton Protocol encapsule différents Constraint Boxes pour chaque type de capital et chaque modèle de délégation. Chaque flux de capital peut nécessiter une stratégie différente, mais au final, il doit fonctionner au sein d’une Box conçue pour le niveau d’autorité que le propriétaire est prêt à déléguer.
C’est peut-être ça, le plus marquant chez Newton Protocol. Le projet ne cherche pas à créer une Box adaptée à tout le monde. À la place, @NewtonProtocol est en train de construire une infrastructure où chaque type de capital peut définir sa propre Constraint Box avant d’entrer dans l’économie onchain.
#Newt $SYN $NEWT

Au début, je pensais que VaultKit du Newton Protocol avait été conçu pour l’institution.
La policy, le risk control ou la gouvernance, ce sont le langage des fonds, pas celui du retail.
Puis je me suis demandé :
« Si c’est le cas, qu’est-ce que le retail obtient ? »
Le retail n’écrit pas ses propres policies.
Il ne gère pas non plus les vaults.
Mais plus je regarde le mécanisme de VaultKit, plus je me rends compte que je pose la mauvaise question.
Là où je porte mon attention, ce n’est pas la policy.
C’est le fait que chaque action du curator ou de l’AI Agent doit passer par la policy avant d’être exécutée.
Autrement dit, le pouvoir de décider n’est plus synonyme du pouvoir de tout faire.
Cela crée un changement assez intéressant.
Auparavant, quand le retail déposait de l’argent dans un vault, il faisait en réalité confiance au jugement du curator.
Si la personne en charge prenait une mauvaise décision, il n’y avait presque aucune couche pour l’empêcher de se produire.
VaultKit déplace le centre de gravité de la confiance.
« Attendez… »
« Est-ce que je n’ai plus besoin de croire que le curator est aussi compétent ? »
Je n’ai plus besoin de croire à leur expertise : seulement qu’ils ne peuvent pas dépasser des limites définies à l’avance.
Ce mécanisme fait progressivement basculer la confiance, des humains vers la contrainte.
C’est exactement ainsi que l’institution gère le capital.
Personne ne reçoit jamais le droit total.
Le pouvoir va toujours de pair avec des contraintes.
Newton ne fait que transférer cette discipline sur onchain.
Le plus intéressant, c’est que le retail n’a pas besoin de devenir une institution pour en profiter.
Il envoie toujours son argent dans les vaults comme avant.
La seule différence, c’est que la gouvernance de l’institution n’est plus cantonnée au processus interne des fonds.
Elle devient une partie intégrante de VaultKit lui-même.
C’est la chose la plus fascinante que je vois dans VaultKit.
Il apporte la discipline institutionnelle au retail.
C’est peut-être aussi le groupe d’utilisateurs que Newton Protocol a choisi pour étendre sa confiance dans les vaults onchain. $TAC $NEWT #Newt @NewtonProtocol

Quand je vois qu’OpenGradient Chat permet d’acheter des crédits via une carte de crédit/débit, je me dis que ce n’est qu’un moyen de rendre les paiements plus pratiques pour ceux qui n’utilisent pas de crypto.
Mais plus j’y réfléchis, plus je vois qu’OpenGradient abandonne un avantage que possèdent encore beaucoup de produits Web3.
L’immunité Web3.
Quand on paie en crypto, la transaction est presque irréversible.
Une fois l’argent envoyé, la majeure partie des responsabilités se termine aussi au niveau de la transaction.
Les cartes de crédit/débit fonctionnent selon une logique différente.
En rejoignant ce système, OpenGradient doit aussi se conformer aux règles de l’infrastructure de paiement traditionnelle, où la responsabilité du commerçant ne se termine pas lorsque le paiement est effectué.
C’est à ce moment-là que je comprends qu’une transaction réussie ne signifie plus qu’un service est terminé.
Les crédits doivent être délivrés.
L’inférence doit fonctionner.
L’utilisateur doit réellement recevoir le bon service pour lequel il a payé.
C’est l’engagement de niveau de service (Service-Level Commitment) d’OpenGradient.
Un engagement qui ne s’arrête plus au simple traitement du paiement.
Mais qui s’étend jusqu’à ce que la valeur soit réellement livrée à l’utilisateur.
Et je pense que cet engagement de niveau de service a une signification assez importante :
Quand @OpenGradient doit assumer la responsabilité du processus après le paiement, ce qu’ils vendent n’est plus seulement une capacité d’IA.
Ils vendent aussi la livraison.
Peu importe à quel point le modèle est puissant si les crédits ne sont pas délivrés correctement, si l’inférence ne tourne pas de façon stable, ou si l’expérience d’OpenGradient Chat est interrompue.
À ce moment-là, la livraison devient le produit.
Le bouton de paiement par carte de crédit/débit n’ouvre pas seulement une nouvelle méthode de paiement.
Il montre aussi qu’OpenGradient s’impose une norme selon laquelle la valeur d’OpenGradient Chat n’est pas uniquement déterminée par le modèle, mais aussi par sa capacité réelle à livrer ce qui a été promis.
$TAC #OPG $OPG

La dernière fois, j’ai dîné avec Trinh, une amie qui travaille dans le Web3.
Elle m’a raconté qu’une équipe venait de lancer un token, puis que la première chose à faire était de trouver où insérer ce token dans l’application : acheter des passes d’utilisation, activer une fonctionnalité, et obtenir des avantages.
Je lui ai demandé : « L’utilisateur a-t-il besoin du token ici ? »
Elle a répondu : « Peu importe de savoir, tant que le token génère de la demande, c’est suffisant. »
Cette phrase m’a fait penser à OpenGradient Chat.
En y regardant de plus près, il y a un endroit qui pourrait facilement devenir une source de demande pour le token, mais qui n’est pas utilisé de cette manière.
C’est le Crédit.
L’utilisateur achète du Crédit en utilisant l’USDC, puis utilise ce Crédit dans OpenGradient Chat. Le parcours de paiement est assez direct : la stablecoin se transforme en Crédit, puis le Crédit se transforme en usage.
Si l’on voulait créer une nouvelle demande pour le token OPG, le projet pourrait tout à fait permettre d’acheter du Crédit avec le token OPG. Ainsi, le token serait relié à l’endroit où l’utilisateur touche réellement le produit.
Mais OpenGradient ne choisit pas cette approche.
Et du point de vue de l’utilisateur, cette décision est bien plus logique.
Un utilisateur régulier d’OpenGradient Chat a besoin d’un coût d’entrée fixe. Il doit savoir combien il paye, combien de Crédit il reçoit, puis utiliser ces Crédit pour les workflows sans avoir à calculer le prix du token.
Si le token OPG se trouvait à l’étape d’achat du Crédit, l’utilisateur aurait davantage de choses à prendre en compte : quand acheter, le prix du token est-il élevé ou bas...
Autrement dit, le projet pourrait créer plus de demande pour le token, mais le prix se paie en termes d’expérience utilisateur.
C’est la User-First Token Discipline (discipline du token pensée pour l’utilisateur).
OpenGradient ne transfère pas la volatilité, le risque de timing et la friction mentale sur l’utilisateur uniquement pour accroître la demande du token.
Ils veulent construire sur le long terme : rendre les coûts d’OpenGradient Chat assez simples à mesurer, de sorte que l’utilisateur revienne l’utiliser comme une habitude de travail.
Ce qu’il faut regarder, c’est ceci : lorsque $OPG aura besoin de générer plus de demande, est-ce qu’OpenGradient continuera de prioriser l’expérience utilisateur et de maintenir la User-First Token Discipline ? À cette question, je n’ai pas encore de réponse.
$VELVET #OPG @OpenGradient
chat.opengradient.ai