_CryptoNova

les quatre domaines d’application dans le Newton Vault SDK m’ont vraiment surpris lorsque je les ai cartographiés ce matin, car ils couvrent davantage de terrain que ne le suggère le titre.

la conformité est la plus évidente. filtrage OFAC, contrôles des sanctions, la couche réglementaire que chaque institution doit pouvoir démontrer. l’identité s’y ajoute : la vérification et l’admissibilité, pour s’assurer que les bonnes parties interagissent avec les bons protocoles. rien que ces deux éléments constitueraient déjà un produit utile.

la sécurité est là que les choses deviennent plus intéressantes. blocage des menaces en temps réel. un type de protection qui ne se contente pas de vérifier qui vous êtes, mais surveille ce qui se passe avec le protocole au moment de la transaction : signalement des fonds entrants en provenance d’adresses compromises, blocage de l’interaction avec des contrats sur liste noire, détection des signatures de failles connues avant qu’elles ne s’exécutent.
et le risque est le quatrième domaine d0main.$VANRY

risque de contrepartie, intégrité de l’APY, limites de levier, santé de l’oracle. des paramètres qui déterminent si une transaction est sûre à exécuter compte tenu des conditions de marché actuelles, et pas seulement si les parties impliquées sont conformes…....$LAB

ce qui m’a frappé dans cette façon de cadrer les choses, c’est que la plupart des systèmes gèrent un ou deux de ces domaines et considèrent les autres comme le problème de quelqu’un d’autre. regrouper les quatre dans une seule couche d’application onchain signifie qu’un vault qui déploie Newton obtient la vue d’ensemble dès qu’une transaction est soumise, plutôt que de la reconstituer à partir de quatre sources distinctes après coup.

la question de conception à surveiller est de savoir si ces quatre domaines, réunis dans une seule couche, restent cohérents à mesure que la complexité des politiques à l’intérieur de chaque domaine augmente… ??

#VitalikOutlinesLeanEthereumRoadmap
@NewtonProtocol $NEWT

Policy-driven execution feels less like another blockchain feature and more like missing infrastructure for trustworthy automation.
If applications consistently need enforceable rules, this layer could become as essential as smart contracts themselves.

The signed attestation is what changes compliance from a promise into verifiable evidence that anyone can audit.
Proof, not just enforcement, is what gives Newton's authorization layer long-term credibility.

Je suis repassé ce matin par la section RWA du livre blanc de Newton, et le modèle de menace contre lequel ils construisent est plus précis que ce à quoi je m’attendais.
Les titres tokenisés, l’immobilier et les produits de crédit présentent trois surfaces d’attaque distinctes que les smart contracts standard ne peuvent pas traiter/

La compromission de la clé admin : un attaquant qui contrôle la clé contourne entièrement tous les contrôles d’accès. Manipulation de la NAV et de l’oracle : mauvaise évaluation des actifs pour permettre des rachats non autorisés ou un minting gonflé. Modifications d’état non autorisées : minting sans autorisation, ou modification des restrictions de transfert en cours de route.

Ce que Newton apporte aux protocoles RWA, c’est un ensemble de contraintes de politique qui fonctionnent comme des invariants d’exécution. Ce ne sont pas des règles qui peuvent être contournées si quelqu’un met la main sur la clé admin..... Elles sont imposées au niveau de la transaction via des exigences d’attestation. Les garde-fous de mint et de rachat garantissent que seuls les investisseurs éligibles peuvent participer. Les contrôles d’intégrité de la NAV recoupent les prix de l’oracle avec des limites de tolérance. Les contrôles de transfert limitent l’activité sur le marché secondaire à des parties qualifiées....

Le cadrage qui m’est resté en tête, c’est que ces politiques opèrent comme des contraintes impossibles à contourner, quelle que soit la personne qui détient la clé admin. Pour les institutions qui tokenisent des actifs réels sur des blockchains publiques, le risque lié à la clé admin fait partie des problèmes les plus difficiles à résoudre. Transformer un risque lié à une clé unique en autorisation distribuée grâce à l’application de politiques, c’est une réponse structurellement différente à ce problème,,,

Je trouve que c’est le cas d’usage le plus convaincant pour une adoption institutionnelle. Pas parce que les autres ne sont pas réels. Mais parce que l’alternative, pour les protocoles RWA, consiste actuellement à accepter le risque de clé admin comme une exposition connue.
Pour les institutions qui tokenisent des actifs, auront-elles besoin de ce niveau d’application on-chain avant de déployer, ou bien le traiteront-elles comme une infrastructure optionnelle ? C’est la question qui mérite d’être suivie??

$NEWT #Newt

@NewtonProtocol

Les stablecoins traitent désormais davantage de valeur chaque mois que bon nombre de réseaux de paiement traditionnels. Cette phrase du livre blanc de Newton m’a arrêté ce matin, parce que l’infrastructure de conformité qui soutient ce volume présente encore un manque fondamental.

Ce manque, c’est l’application au niveau du transfert. Les émetteurs de stablecoins font face à une tension réelle : la proposition de valeur réside dans des transferts mondiaux instantanés et sans permission, mais les cadres réglementaires exigent un filtrage des sanctions, une vérification de l’identité et une surveillance des transactions exactement au moment où le transfert a lieu. Pas au moment de l’onboarding. Pas après coup. Au moment même du transfert.

La plupart des approches existantes gèrent cela au niveau de l’interface utilisateur. Une interface de filtrage des sanctions bloque un utilisateur signalé. Ensuite, cet utilisateur interagit directement avec le contrat intelligent sous-jacent, et le blocage ne sert à rien. La frontière d’application et la frontière d’exécution sont déconnectées.

Newton contrôle le transfert lui-même. Chaque transfert de stablecoin peut nécessiter une attestation de Newton qui vérifie que le filtrage des sanctions a été validé, que les contrôles de juridiction sont passés et que l’attribution au titre de la Travel Rule est satisfaite. Le contrat intelligent ne s’exécute pas sans une attestation valide. L’émetteur définit la politique.... Newton l’applique. La blockchain enregistre la preuve.

Je trouve

le mécanisme de reçu de conformité particulièrement important ici. L’émetteur conserve une preuve cryptographique indiquant que la politique a été appliquée à chaque transfert. Pas des journaux qui montrent que la surveillance a été effectuée. Une preuve que l’application a eu lieu.

Qu’ils adoptent cela avant que les régulateurs ne l’exigent, ou après, reste la question qui détermine à quelle vitesse ce marché se développe.

#Newt @NewtonProtocol $NEWT

Je réfléchis au problème des agents IA depuis ce matin, et je pense que c’est le cas d’usage qui rend l’architecture Newton la plus urgente, en ce moment.

Les agents autonomes opérant sur des rails crypto peuvent initier des transactions à la vitesse de la machine. Les échanges, les mouvements de fonds, les interactions avec des protocoles se produisent sans qu’une personne ne révise chaque opération. Les cadres de conformité qui existent aujourd’hui ont été conçus pour des humains prenant des décisions.

iIs supposent qu’il y a quelqu’un dans la boucle. Les agents suppriment cette hypothèse entièrement.
t Le problème n’est pas que les agents soient dangereux par défaut. Le problème, c’est que la couche d’autorisation de ce qu’ils peuvent faire n’existe pas encore sous une forme vérifiable. Un agent disposant d’un accès au portefeuille peut exécuter dans des juridictions sanctionnées, interagir avec des adresses sur liste noire, dépasser des limites de vélocité, le tout avant qu’un système de surveillance ne rattrape son retard/

Newton résout cela en traitant les transactions initiées par des agents exactement comme celles initiées par des humains. L’agent soumet une intention à la Gateway, l’évaluation de la politique s’exécute, puis une attestation revient. L’agent ne peut exécuter que ce que l’attestation autorise. Les limites de dépense, les contreparties autorisées, les protocoles permis sont tous appliqués de manière programmatique à la vitesse de la machine, plutôt que via une file d’approbation humaine qui ne peut pas suivre...

Je trouve que c’est le bon cadrage. La couche d’autorisation pour la finance agentique ne peut pas être un processus humain. Elle doit être programmatique, temps réel et vérifiable...

Que le cadre de politique pour les agents IA évolue assez vite pour correspondre à la rapidité avec laquelle les agents eux-mêmes sont déployés, c’est la partie qui me fait rester particulièrement attentif.

#Newt @NewtonProtocol $NEWT

il existe une catégorie de risque DeFi spécifique dont on parle trop peu, et ça me dérange à chaque fois que j’y pense.
les vaults curatés, qui détiennent des milliards d’actifs, gèrent leurs limites de risque via des processus hors chaîne.

des tableurs, des revues manuelles, des outils fragmentés qui vivent entièrement en dehors du protocole. les règles existent. elles ne vivent juste pas là où les transactions ont lieu. une règle dans un document hors chaîne et une règle appliquée au niveau du smart contract ne sont pas la même chose, et l’écart entre les deux est là où l’exposition se situe réellement.

ce que Newton fait avec l’exécution des vaults, c’est placer les règles là où se trouvent les transactions. l’évaluation de la politique se fait en chaîne,,, avant le règlement. le vault ne peut pas exécuter une transaction qui enfreint ses propres paramètres de risque

parce que l’attestation qui autorise l’exécution ne sera pas produite si la politique échoue.
la différence entre une limite de risque qui peut être contournée et une limite qui ne le peut pas est toute la raison d’être...
je trouve ce cadrage vraiment éclairant. ce n’est pas une simple amélioration du monitoring. c’est un changement structurel de l’endroit où l’application des règles existe réellement.

que les opérateurs de vault adopteront volontairement l’application de politiques on-chain avant un incident majeur… c’est la question à laquelle je reviens sans cesse????

#Newt @NewtonProtocol $NEWT

Je viens d’apprendre que le SDK Vault @NewtonProtocol est un produit d’expédition réel, et pas une promesse de feuille de route future — et honnêtement, ça a changé ma façon de penser tout le protocole.

la plupart des infrastructures de vault gèrent la conformité, la sécurité et le risque comme trois problèmes distincts. vous ajoutez une vérification de sanctions ici, un coupe-circuit là, un modèle de risque ailleurs. rien ne parle avec le reste. le SDK regroupe tout cela dans une seule couche d’application d’enforcement onchain au lieu de tout séparer.......

c’est une approche vraiment significativement différente. un vault qui utilise ça n’a pas besoin d’assembler sa propre stack de conformité depuis zéro. la logique d’application est intégrée d’origine, et elle est appliquée au niveau du protocole plutôt que de vivre dans un processus offchain qui peut être contourné ou mal configuré.

des vaults DeFi sélectionnés détiennent actuellement des milliards, et ce chiffre continue d’augmenter. la plupart de ces vaults gèrent encore leurs limites de risque via des processus offchain fragmentés. le SDK vise directement ce manque.

j’aime le fait que ce n’est pas une infrastructure abstraite. c’est un produit concret, avec des partenaires de lancement.

que le SDK devienne la façon par défaut de construire de nouveaux vaults, ou qu’il reste une option parmi plusieurs, c’est la partie qu’il vaut la peine de surveiller au fur et à mesure que l’adoption se déploie ??

#Newt @NewtonProtocol $NEWT

passé ce matin à tout relire ce que j’ai écrit à propos de @OpenGradient au cours des deux dernières semaines et j’ai réalisé que je n’avais jamais réellement expliqué ce que $OPG fait mécaniquement. alors voilà.

$OPG n’est pas un token à usage unique. il se trouve à la base de trois fonctions distinctes à la fois. le règlement du réseau : pour chaque requête d’inférence, pour chaque exécution de modèle, pour chaque ressource de calcul consommée sur la plateforme, tout est payé en $OPG , et les opérateurs de nœuds sont récompensés en OPG pour le traitement de ces tâches. c’est l’unité réelle d’activité économique qui circule dans le réseau,,,

la deuxième fonction, c’est l’accès. le fait d’uploader et d’héberger un modèle sur le Model Hub nécessite $OPG .... il fonctionne comme une clé, pas seulement comme un moyen de paiement.

la troisième, c’est la sécurité et la gouvernance combinées. les validateurs doivent miser de l’OPG pour participer au consensus Proof of Stake qui sécurise le réseau.

et les détenteurs de tokens peuvent voter sur les mises à niveau du protocole et sur le registre du code d’enclave approuvé : le même registre de hash de code que le système de vérification TEE contrôle avant qu’un nœud puisse traiter une requête..

la dernière partie m’a vraiment surpris quand je l’ai connectée. la gouvernance sur l’OPG n’est pas abstraite. elle est directement liée au code autorisé à s’exécuter à l’intérieur de l’infrastructure de confidentialité dont toute la plateforme dépend.....

trois fonctions, un token,,,tout est lié à l’utilisation réelle du réseau plutôt qu’à une chose séparée de celui-ci.

la question de long terme vaut vraiment la peine d’être suivie : la participation à la gouvernance par les détenteurs de tokens restera-t-elle suffisamment active pour maintenir correctement ce registre de code à mesure que le réseau grandit ??

chat.opengradient.ai

#OPG @OpenGradient $OPG

Quelque chose à propos de l’hébergement centralisé de modèles d’IA me tracasse depuis un moment, et j’ai finalement une façon claire d’exprimer ça.

Quand un modèle vit sur un serveur centralisé, sa disponibilité est une décision de politique. L’entreprise qui fait tourner le serveur décide quels modèles restent en ligne, lesquels sont retirés, lesquels sont modifiés entre les versions sans préavis, et lesquels disparaissent totalement quand la logique de l’entreprise change....

J’ai vu des modèles que je construisais pour des workflows se faire déprécier, être mis à jour discrètement, ou simplement supprimés. Vous le découvrez quand votre application casse....

Le <0-9>@OpenGradient </0-9> Model Hub est construit sur le stockage décentralisé Walrus. Chaque modèle reçoit un identifiant de Blob adressé par contenu. Cet identifiant est une empreinte cryptographique du modèle lui-même, pas un pointeur vers un emplacement susceptible de changer, mais une référence au contenu exact. Si le contenu change, l’ID change. Vous savez toujours ce que vous exécutez...

Et comme le stockage est décentralisé, aucune partie unique ne peut retirer un modèle de la disponibilité.

La résistance à la censure n’est pas une fonctionnalité ajoutée par-dessus. C’est une propriété de l’architecture de stockage sous-jacente. Un modèle qui existe sur Walrus avec un Blob ID vérifié enregistré sur la chaîne est accessible de façon permanente tant que le réseau existe....

Le réseau héberge actuellement plus de 2 000 modèles. Ce n’est pas un chiffre de démo. C’est un dépôt vivant.

Je trouve que la mécanique de l’adressage par contenu est vraiment importante pour toute personne qui construit des applications de production sur de l’infrastructure IA. La reproductibilité et la disponibilité ne sont pas des choses sur lesquelles vous devriez avoir à faire confiance...

La question opérationnelle vaut-elle d’être suivie : est-ce que la couche de stockage décentralisée restera suffisamment performante face à une forte demande de téléchargement de modèles à mesure que le réseau se développe ?

chat.opengradient.ai

#OPG @OpenGradient $OPG

J’ai lu hier soir la section Twin.fun du livre blanc et c’est la partie de l’écosystim @OpenGradient que je ne m’attendais pas à trouver intéressante. mais ça m’a fait continuer à lire plus longtemps que prévu.

le concept est un marché de jumeaux numériques. vous créez une représentation numérique de vous-même ou de n’importe quel persona, personnage,,, ou base de connaissances et vous la déployez en tant qu’agent IA sur le réseau. d’autres utilisateurs interagissent avec votre jumeau. vous gagnez grâce à ces interactions.

les économies sont la partie qu’il faut comprendre spécifiquement... les créateurs de jumeaux gagnent à partir de l’activité d’inférence que génèrent leurs jumeaux. chaque conversation, chaque requête transmise via votre jumeau produit une activité réseau qui se règle on-chain...

le créateur se trouve tout en haut de cette chaîne. à mesure que votre jumeau est davantage utilisé, les gains se cumulent sans nécessiter votre implication active à chaque interaction....

Et la couche de vérification en dessous rend cela significatif d’une manière qu’un marché centralisé de jumeaux ne pourrait pas reproduire. les interactions avec votre jumeau passent par la même infrastructure TEE et ZKML que le reste du réseau. les sorties sont vérifiables. l’activité est on-chain. un jumeau qui produit des sorties vérifiables est fondamentalement un produit différent de celui qui tourne sur une infrastructure que vous ne pouvez pas inspecter.....

Je trouve vraiment l’angle “économie des créateurs” ici intéressant. construire une représentation IA persistante de vous-même qui gagne de manière autonome tout en conservant les mêmes garanties de confidentialité et de vérification que le reste de la plateforme, c’est une combinaison qui n’existe nulle part ailleurs pour le moment....

que Twin.fun développe suffisamment de base d’utilisateurs pour rendre l’économie des créateurs significative à grande échelle, ou reste un marché de niche, c’est la partie que je veux surveiller au cours des prochains mois?????

chat.opengradient.ai

#OPG @OpenGradient $OPG

Il y a un problème avec les outils d’IA que je n’ai jamais vu quelqu’un résoudre proprement, et ça me dérange à chaque fois que j’y suis confronté.

Vous avez une conversation. Vous construisez un contexte. Le modèle comprend votre projet, vos préférences, votre historique avec un problème particulier.

Puis la session se termine. Vous revenez le lendemain et vous repartez de zéro. Chaque élément de contexte que vous avez construit doit être recréé depuis le début. Le modèle ne se souvient pas de vous. Il ne l’a jamais fait. Chaque session est une page blanche, quelle que soit la quantité de travail que vous avez fournie dans celle d’avant...

MemSync est l’élément d’infrastructure <t-2/> @OpenGradient conçu spécifiquement pour corriger cela. Il offre une mémoire persistante aux agents IA au fil des sessions. Pas seulement l’historique de conversation stocké dans un fichier que vous collez manuellement. Une véritable infrastructure de mémoire à long terme qui maintient le contexte et les données historiques à travers différentes interactions afin que le modèle puisse se comporter de manière cohérente dans le temps.

L’implication pratique pour toute personne qui lance des workflows en continu est considérable. Un agent IA qui se souvient des décisions prises la semaine dernière, des données qu’il a traitées le mois dernier… des préférences et des contraintes établies au cours de dizaines de sessions, c’est fondamentalement un outil différent de celui qui se réinitialise à chaque fois.

Et pour les cas d’utilisation des agents en particulier, la mémoire persistante n’est pas un simple “bonus”. Un agent qui perd le contexte entre les sessions n’est pas vraiment un agent. C’est une série de requêtes ponctuelles déconnectées, qui utilisent simplement le même modèle...

La mémoire de MemSync persiste-t-elle avec les mêmes garanties de confidentialité que celles qui s’appliquent à l’inférence du reste de la plateforme ? C’est la question à laquelle je veux une réponse avant de construire quoi que ce soit de sérieux par-dessus.

chat.opengradient.ai

#OPG @OpenGradient $OPG

Je consulte la documentation du moteur PIPE depuis hier matin, et c’est, selon moi, la partie @OpenGradient qui va le plus compter pour les développeurs une fois que les gens comprendront réellement ce qu’elle fait.

Le problème qu’elle résout est spécifique. Aujourd’hui, les applications on-chain ne peuvent pas appeler nativement un modèle d’IA et utiliser le résultat dans la même transaction. La manière dont la plupart des équipes gèrent cela consiste à utiliser des oracles : l’inférence se fait quelque part 0ff chain, puis le résultat est renvoyé, et au moment où la transaction s’exécute, le résultat d’inférence est déjà périmé.

Il y a donc un écart. Un délai oracle se place entre ce que le modèle calcule et ce que le contrat fait réellement avec ces informations....

PIPE supprime entièrement cet écart. Lorsqu’une transaction contenant une demande d’inférence entre dans le mempool, le moteur extrait toutes les demandes d’inférence en attente et les envoie au réseau d’inférence en parallèle avant que le bloc ne soit finalisé. Au moment où la transaction s’exécute on-chain, les résultats d’inférence ont déjà été pré-calculés et sont prêts. La sortie du modèle et l’exécution du contrat se produisent de manière atomique. Dans la même transaction. Aucun délai d’oracle. Aucune obsolescence.

Le mécanisme de mise à l’échelle est la partie qui m’a réellement impressionné. Des centaines de transactions en attente peuvent faire l’objet de demandes d’inférence envoyées simultanément. Le calcul ML coûteux ne se retrouve pas dans le chemin critique de la production des blocs. Il tourne en parallèle.

Et ce que cela débloque, c’est une catégorie d’applications qui n’existe pas vraiment encore : des smart contracts qui réagissent à des sorties d’IA en direct, en temps réel, sans qu’aucun flux de données externe ne soit intercalé.

La question de performance est de savoir si le réseau d’inférence peut maintenir une latence d’envoi en parallèle suffisamment basse à mesure que le volume des transactions augmente... jusqu’où cela ira-t-il????

chat.opengradient.ai

#OPG @OpenGradient $OPG

le choix de conception qui revient constamment à moi concernant @OpenGradient est celui qui semble simple mais qui est en réalité assez rare dans la pratique...

toutes les inférences d'IA n'ont pas besoin du même niveau de confiance. au lieu de choisir un standard de vérification et de forcer chaque charge de travail à passer à travers, peu importe l'adéquation, @OpenGradient expose trois méthodes et laisse le développeur choisir en fonction du profil de risque réel.
ZKML pour les situations où la certitude mathématique vaut le surcoût de calcul. TEE pour les charges de travail de production où un surcoût négligeable compte et l'attestation matérielle est suffisante. Vanilla pour le prototypage, l'analyse, les inférences à faible enjeu où la performance est la priorité et la confiance dans le nœud est acceptable...

la partie qui m'a vraiment surpris quand j'ai lu le livre blanc attentivement est que ces méthodes peuvent être mélangées au sein d'une seule transaction. pas seulement choisies par application, mais mélangées par appel d'inférence à l'intérieur d'une seule opération atomique. TEE pour l'étape de raisonnement LLM, ZKML pour un modèle de risque fonctionnant dans la même transaction, Vanilla pour des analyses se déroulant aux côtés des deux. chaque inférence obtient le niveau de vérification qui correspond à ses conséquences spécifiques, et non le niveau de vérification qui se trouve être le défaut du système.

c'est une architecture sensiblement différente de tout ce qui applique un modèle de confiance uniformément à tout...

Et l'implication pratique est réelle. un agent DeFi prenant des décisions financières peut appliquer ZKML aux résultats du modèle qui déplacent réellement de l'argent tout en exécutant une vérification moins coûteuse partout ailleurs dans le même pipeline.

que les développeurs utiliseront réellement cette granularité en pratique ou se contenteront d'une méthode pour la simplicité est la question d'adoption qu'il vaut la peine de suivre??

chat.opengradient.ai

#OPG @OpenGradient $OPG