Elowen 洞察

J’ai suivi un problème discret qui va devenir très bruyant. Les agents autonomes passent au multi-chaîne. Un optimiseur de rendement qui démarre sur Ethereum repère désormais des opportunités sur Arbitrum, Optimism et Polygon. Un gestionnaire de trésorerie rééquilibre entre plusieurs L2 en une seule session. L’agent lui-même est transportable… son code peut être déployé n’importe où. Mais ses limites d’autorisation ? Elles restent derrière, verrouillées à la chaîne sur laquelle vous les avez définies pour la première fois.
Cela crée, selon moi, une fragmentation de l’autorisation inter-chaîne. Vous définissez votre politique de risque sur Ethereum — plafonds de slippage, contrats autorisés, plafonds de volatilité. L’agent les respecte parfaitement sur le mainnet. Puis il bridge vers une L2 pour viser des rendements plus élevés, et soudain, ces limites ne l’accompagnent plus. Le moteur de politique qui appliquait vos règles sur une chaîne n’a aucune juridiction sur une autre. Il ne vous reste plus qu’à faire confiance à l’agent pour qu’il se comporte correctement, alors même que les contraintes que vous avez définies sont techniquement absentes.

J’ai passé beaucoup de temps à réfléchir à la raison pour laquelle les DAO ont du mal à déployer leurs trésoreries de manière autonome. Ce n’est pas un manque de capital. Certaines DAO disposent de millions en stablecoins et en actifs volatils, et recherchent activement du rendement ou des déploiements stratégiques. Le goulot d’étranglement n’est pas l’opportunité. C’est la confiance. À l’heure actuelle, une DAO qui souhaite automatiser la gestion de trésorerie se heurte à un arbitrage douloureux. Elle peut utiliser des multi-signatures… lents, dépendants des humains, et impossibles à faire évoluer quand les opportunités exigent des réactions à la minute. Ou elle peut déléguer une autorité large à un agent ou à une équipe de stratégie, en acceptant le risque qu’une seule erreur de jugement, un seul écart par rapport à l’appétit de risque de la communauté, puisse coûter des millions. Aucune des deux options ne correspond à la réalité de la façon dont une organisation mature devrait fonctionner. Ce dont les DAO ont réellement besoin, c’est d’une constitution fiscale. Un ensemble de règles onchain qui définissent précisément comment les fonds de trésorerie peuvent être dépensés, déplacés ou investis… appliquées automatiquement, sans attendre des votes humains, et sans faire confiance à un seul opérateur pour rester dans les limites. <c-20/> est le plus proche de ce que j’ai vu pour rendre cela possible. La couche d’autorisation programmable de Newton n’est pas seulement destinée aux utilisateurs particuliers qui déploient des agents personnels. C’est une infrastructure que toute entité autonome, y compris une DAO, peut utiliser pour encoder sa politique fiscale directement dans le chemin de transaction. Avant qu’un seul satoshi ne quitte la trésorerie, l’action proposée doit passer par un moteur de politique qui la vérifie par rapport aux règles que la DAO a déjà ratifiées. Limites de slippage. Listes d’actifs autorisés. Listes des protocoles autorisés. Exposition maximale par stratégie. Périodes de refroidissement entre les rééquilibrages. Des plafonds de vélocité de dépenses qui empêchent de vider les fonds trop rapidement, même si chaque transaction individuelle semble anodine. Cela change entièrement le modèle de confiance. Dans le système actuel, une DAO vote une proposition, transfère les fonds vers une multi-signature, puis espère que les signataires agiront de bonne foi dans le mandat général qui leur a été donné. La politique fiscale vit dans des publications de forum et le consensus social, pas dans le code. Avec Newton, la politique fiscale vit onchain sous forme de contraintes cryptographiques. La multi-signature peut toujours initier des transactions, mais ces transactions seront bloquées si elles violent la constitution de la DAO encodée. La confiance passe des personnes à la mathématique. La trésorerie de la DAO devient réellement autonome… non pas parce que les humains sont supprimés, mais parce que leur marge de manœuvre est bornée de façon vérifiable. Ce qui m’enthousiasme dans cette approche, c’est à quel point elle prolonge naturellement la promesse initiale des DAO. Nous avons créé des organisations décentralisées pour supprimer les points de défaillance uniques. Mais, avec le temps, la gestion de trésorerie a silencieusement réintroduit ces points de défaillance via des signataires humains et une délégation opaque. Newton rétablit la décentralisation là où elle compte le plus : au moment de la dépense. Chaque mouvement de jeton peut être vérifié par n’importe qui, onchain, en temps réel, par rapport à la politique fiscale déclarée par la DAO. $NEWT joue un rôle essentiel ici. Le jeton n’est pas seulement un actif spéculatif. C’est le carburant économique qui alimente cette couche fiscale programmable. Les vérifications de politique ont un coût de calcul. Les contrôles historiques pour les périodes de refroidissement ou la vélocité de dépenses nécessitent du gaz et le travail des validateurs. Le jeton aligne les incitations pour maintenir l’application décentralisée… de sorte qu’une constitution fiscale de DAO ne soit pas appliquée par le serveur d’une seule entreprise, mais par un réseau sans autorisation qui gagne $NEWT pour une application honnête. Pour les contributeurs de DAO, cela signifie qu’il n’y a plus de confiance aveugle envers les gestionnaires de trésorerie. Pour les délégués, cela signifie un mandat clair : vous pouvez autoriser des stratégies, mais ces stratégies doivent toujours passer la constitution fiscale. Pour les régulateurs qui observent le secteur, cela apporte quelque chose que les multi-signatures ne peuvent jamais offrir : une trace vérifiable et audit-able prouvant que chaque action de trésorerie respectait les règles que la DAO s’est fixées. Mon avis sincère est que nous allons regarder l’ère de la gestion de trésorerie par pure multi-signature comme on regarde aujourd’hui le partage de mots de passe. Fonctionnel pendant un temps, mais fondamentalement insuffisant pour un capital sérieux. La prochaine génération de DAO ne se contentera pas de voter sur l’endroit où va l’argent. Elles encoderont leur appétit pour le risque dans une infrastructure qui rend impossible que l’argent aille ailleurs.

Je me souviens avoir appris très tôt dans ma carrière la différence entre la programmation déclarative et impérative. L’impératif est pas à pas : « Ouvrez le fichier, lisez la première ligne, vérifiez le solde, puis signez la transaction. » Le déclaratif se concentre sur le résultat : « Je veux que mon portefeuille soit rééquilibré avec ces limites. Faites-le. » Depuis des années, la sécurité DeFi est en mode impératif. Auditez ce contrat. Ajoutez un multisig. Mettez en place de la surveillance. Mettez le protocole en pause si quelque chose casse. Chaque étape est une instruction manuelle. Chaque garde-fou est un processus. Et le résultat est un système fragile, lent et réactif. Vous êtes toujours à une étape oubliée du désastre. C’est pourquoi le protocole Newton ($NEWT ) a retenu mon attention. Non pas parce que c’est un autre outil de sécurité, mais parce qu’il représente un passage de la sécurité impérative à la sécurité déclarative. Au lieu d’indiquer au système comment vous protéger, vous lui dites ce que vous voulez autoriser. Ensuite, il impose automatiquement ces limites. Regardez la différence. La sécurité impérative dit : « Auditez le code de mon agent pour trouver des failles. » La sécurité déclarative dit : « Mon agent ne peut interagir qu’avec ces cinq contrats, avec cette limite de slippage, et jamais plus de 2 ETH par transaction. Faites respecter cela onchain. » La première approche essaie de détecter chaque bug. La seconde rend les bugs sans importance en cloisonnant ce que l’agent peut faire. La couche d’autorisation programmable de Newton est déclarative par design. Vous écrivez une politique, un ensemble de règles, et le moteur de politique les applique de manière cryptographique avant que toute transaction n’atteigne la chaîne. Plafonds de slippage. Plafonds de volatilité. Adresses whitelistées. Limites de valeur par session. Vous n’auditez pas la logique interne de l’agent. Vous contraignez son comportement externe. Et cette contrainte est vérifiable, onchain, et automatique. Pour moi, c’est la pièce manquante qui explique pourquoi tant de protocoles « sécurisés » continuent d’échouer. La sécurité impérative dépend de la rigueur humaine et d’un code parfait. La sécurité déclarative ne suppose ni l’un ni l’autre, et construit des garde-fous qui fonctionnent quand même. L’une est un bouclier que vous tenez. L’autre est une cage que vous verrouillez autour de l’agent. Les boucliers se fissurent. Les cages tiennent. $NEWT fournit cette couche de sécurité déclarative. Les contrôles de politique ne sont pas gratuits. La vérification consomme du gas. Les validateurs ont besoin d’incitations. Le token aligne l’économie de façon à ce que l’exécution déclarative puisse s’étendre sans opérateur central. À mesure que davantage de protocoles exigent une autorisation avant l’exécution, $NEWT devient l’actif natif d’une nouvelle économie de la sécurité : un monde où vous déclarez vos limites une fois et le réseau les applique partout. Cela change aussi la façon dont les développeurs réfléchissent. Au lieu de corriger des bugs après une exploitation, ils conçoivent des agents dans un environnement déclaratif dès le départ. « Qu’est-ce qui peut mal tourner ? » devient « Qu’est-ce que je n’autoriserai pas mon agent à faire ? » C’est un état d’esprit plus sain pour une industrie qui gère des milliards de valeur. Alors voici la question honnête que je vous laisse. Quand vous sécurisez votre stratégie DeFi aujourd’hui, donnez-vous encore des instructions pas à pas à un système qui les suivra aveuglément ? Ou bien déclarez-vous vos limites et laissez-vous l’infrastructure les faire respecter ? Newton Protocol parie que l’avenir appartient à la sécurité déclarative et $NEWT est la clé qui fait que cela fonctionne. @NewtonProtocol #newt

Je pensais qu’une fois que je définissais des règles pour mon agent, je serais en sécurité. J’ai fixé une limite de glissement (slippage). J’ai choisi quelques contrats de confiance. J’ai lancé le déploiement. C’est fait. Puis j’ai commencé à observer les agents de près. J’ai vu quelque chose qui m’a inquiété. Un agent peut respecter chaque règle et pourtant dériver vers le danger. Pas parce qu’il a été piraté. Pas parce que le code a cassé. Mais parce que le marché a changé. De nouveaux protocoles sont apparus. L’agent a commencé à commettre de petites erreurs qui s’accumulaient avec le temps. Une règle statique ne voit pas les schémas. Elle ne vérifie qu’une seule transaction à la fois. Elle n’apprend jamais. Elle ne vous avertit jamais que les ennuis se préparent avant qu’il ne soit trop tard. C’est à ce moment-là que j’ai compris la vraie puissance du Newton Protocol $NEWT . Newton vous permet déjà de mettre vos règles onchain. Avant qu’une transaction n’ait lieu, il vérifie vos limites : slippage, volatilité, listes blanches de contrats. Mais la grande idée qui me trotte dans la tête, c’est ceci : et si ces règles pouvaient aussi apprendre du comportement passé de l’agent ?Imaginez une règle qui dit : si l’agent s’approche cinq fois de suite de ma limite de slippage en une semaine, resserrez automatiquement la limite. Ou : si un contrat est signalé sur une liste communautaire de risques, supprimez-le de la liste blanche instantanément, sans attendre que je me réveille. C’est ce que j’appelle l’autorisation adaptative. Elle transforme une règle figée en filet de sécurité vivant. Un garde-fou normal ne fait que vous arrêter quand vous le touchez. Un garde-fou adaptatif vous voit vous approcher trop près et vous ramène avant le crash. Le moteur de politiques de Newton est programmable. Donc ces règles intelligentes, conscientes de l’historique, ne sont pas un rêve. C’est un design qui demande à voir le jour. Et $NEWT <e powers all of thIs.> Les vérifications de politiques nécessitent un calcul. Le suivi de l’historique nécessite du gas. Les validateurs doivent être récompensés. Le token fait tourner le tout équitablement, sans patron central. Ce qui m’enthousiasme le plus, c’est le passage d’une sécurité réactive à un contrôle proactif. On passe tellement de temps à se demander si notre agent est intelligent. Newton nous pousse à poser une meilleure question : mes règles sont-elles assez intelligentes pour évoluer avec mon agent ? Parce que, dans un monde dirigé par des agents, la phrase la plus effrayante n’est pas « le code avait un bug ». C’est « le code a suivi toutes les règles que je lui ai données, mais mes règles étaient trop aveugles pour voir le danger arriver ». L’autorisation adaptative, alimentée par $NEWT , veille à ce que vos règles restent en avance.@NewtonProtocol $NEWT $VANRY #Newt #newt

J’ai assisté en silence à quelque chose qui se déroule progressivement dans la DeFi et qui est rarement évoqué. On appelle ces entités des « agents autonomes », mais si l’on regarde de près la façon dont ils fonctionnent réellement, beaucoup d’entre eux sont centralisés au niveau du contrôle, dépendants de scripts hors chaîne, de bots sur un seul serveur, ou de quelques clés contrôlées par des développeurs. L’agent lui-même est sans permission, mais la décision d’autoriser une transaction reste entre les mains d’une partie centrale. Ce n’est pas de l’autonomie. C’est de l’automatisation sous la pression de quelqu’un d’autre. Plus j’observais, plus je réalisais que cette centralisation invisible est le véritable goulot d’étranglement. Un agent peut proposer un échange à la vitesse de la machine, mais si un opérateur humain doit donner son feu vert, si un cron hors chaîne doit déclencher l’étape suivante, ou si une clé privée détenue par une seule équipe peut mettre en pause ou réorienter l’ensemble de la stratégie, alors le système n’est décentralisé qu’à hauteur de ce point de contrôle unique. Vu de l’extérieur, l’agent semble autonome, mais à l’intérieur, le modèle d’autorisation est entièrement centralisé.

Les portefeuilles multisignature font partie des primitives de sécurité crypto les plus anciennes et les plus fiables. Ils ont remplacé les points de défaillance uniques par une prise de décision collective. Pour les DAOs, les trésoreries et les mises à niveau de protocole, ils restent indispensables. Mais voici la vérité inconfortable que j'ai comprise seulement après avoir observé des agents autonomes fonctionner à la vitesse des machines : les multisigs ont été conçus pour des décisions dictées par l'humain, pas pour l'exécution à la vitesse des agents. Et ce décalage crée un fossé de contrôle croissant que la plupart de la DeFi n'a pas encore pris en compte.

« Le code, c’est la loi » est la constitution officieuse de la cryptomonnaie depuis des années. L’expression traduit une idée puissante : que les smart contracts exécutent exactement ce qui est écrit, sans biais humain, sans intervention et sans possibilité de remise en cause. C’est un principe qui nous a donné la DeFi sans confiance (Trustless), des protocoles immuables, et un système financier qui fonctionne avec des mathématiques plutôt qu’avec des promesses.
Mais il y a un problème discret avec « le code, c’est la loi » que J’ai mis longtemps à voir. Il ne se demande pas si le code aurait dû faire ce qu’il vient de faire.
Un smart contract peut exécuter une transaction avec une précision parfaite. La blockchain la validera sans hésitation. Mais ni le contrat, ni la chaîne ne vérifie si cette transaction correspondait à l’intention réelle de l’utilisateur. Le code s’est exécuté exactement comme il a été écrit. Cela ne veut pas dire qu’il a exécuté Ce que l’utilisateur voulait réellement. Cela signifie simplement que les règles encodées dans le contrat ont été respectées sur le plan technique.

Tout le monde parle de rendre les Agents IA plus intelligents. Peu de gens parlent de les rendre compatibles. Mais voici le vrai goulot d'étranglement que la plupart des gens manquent : même si chaque agent opère parfaitement dans son propre mandat, ils ne peuvent toujours pas interagir en toute sécurité avec d'autres agents sans une norme partagée définissant ce qui est autorisé.
En ce moment, votre bot de trading ne peut pas automatiquement immobiliser des fonds inactifs dans un vault de rendement géré par une autre IA, parce qu'il n'existe pas de langage commun d'autorisation. Chaque agent a sa propre logique de risque hors chaîne, ses propres limites sur mesure, son propre modèle d'autorisation opaque. La coordination entre agents nécessite une configuration manuelle, des intégrations personnalisées et une confiance aveugle dans le fait que l'autre Agent ne s'écartera pas des limites promises. Ce n'est pas une base pour une économie d'agents. C'est un bac à sable.

Pendant des années, je croyais que les vaults onchain échouaient parce que quelqu’un avait choisi la mauvaise ferme de rendement ou mal calculé les ratios de collatéral. Mais après avoir regardé suffisamment de vaults dériver silencieusement hors mandat, pendant que la blockchain validait consciencieusement chaque transaction, le défaut le plus profond a fini par se révéler : personne n’a jamais demandé à la transaction, « Est-ce que tu as même l’autorisation de faire ça ? ». Un gestionnaire de vault ou un agent autonome peut Exécuter un mouvement parfaitement valide qui passe pourtant droit devant toutes les limites de risque que vous n’aviez jamais codées. Le code fonctionnait, la chaîne approuvait, mais votre capital s’est retrouvé à un endroit que vous n’aviez jamais prévu. Ce n’est pas un problème de stratégie. C’est un écart d’autorisation... et c’est bien plus courant que personne ne l’admet.