CoinBella

#newt $NEWT Quelque chose à propos de quoi je me suis mis à trop y penser.

Les passionnés de cryptomonnaies sont obsédés par la création d’agents intelligents. Chaque mise à jour produit promet un raisonnement plus “intelligent”, de meilleures décisions et des vitesses d’exécution plus rapides. Tout cela est très bien !

Mais est-ce qu’on ne peut pas programmer des agents intelligents pour faire très bien la mauvaise chose ?

La finance est un monde impitoyable.

Parfois, la foudre tombe et transforme des décennies de gains en poussière. Quand des milliards de dollars sont en jeu, je ne suis pas sûr que l’intelligence soit ce qui compte le plus. Je pense que la prévisibilité est plus importante.

C’est pour ça que Newton Protocol m’intrigue.

New Protocol ne se limite pas à exécuter des smart contracts qui valident des transactions en fonction de LEUR validité. Il pose une autre question : LA question qui compte bien plus.

FAUT-il autoriser cette transaction à s’exécuter ?

Ce mot-clé — UN seul — a changé quelque chose en moi.

Et si un agent ne pouvait dépenser qu’un montant X ? Et si un autre agent ne pouvait interagir qu’avec 5 protocoles approuvés ? Et si les autorisations d’un agent étaient révoquées à la fin de son action, plutôt que d’exister de manière éternelle ?

Même agent. Règles différentes.

Ça se tient.

Ce que je n’ai pas entendu assez, c’est ceci : nous laissons déjà des logiciels contrôler nos actifs. Bientôt, nous allons laisser l’IA prendre des décisions pour nous. Ce n’est pas la même chose. Et à mesure que l’IA deviendra plus intelligente, je pense qu’il deviendra ENCORE plus crucial de définir des garde-fous clairs sur ce que ces agents DOIVENT et NE DOIVENT PAS faire.

C’est ce que j’aime dans Newton. Toutes ces règles d’autorisation sont programmables, visibles et appliquées. Personne n’a besoin de croire sur parole : l’IA “vous fait confiance” ou sait “faire la bonne chose”. Les garde-fous existent avant l’exécution.

Peut-être que Web3 ne devrait pas revenir à l’agent le plus intelligent.

Peut-être que ça devrait revenir à l’agent le plus prévisible.

#Newt @NewtonProtocol $NEWT

#newt $NEWT
Plus l’IA devient performante, plus je me demande si notre plus grande erreur ne serait pas de faire confiance à des logiciels défectueux, mais plutôt de faire un peu trop confiance aux bons logiciels.

L’automatisation est censée supprimer les frictions. C’est l’idée même. Mais la friction n’est pas toujours l’ennemie. Parfois, c’est elle qui vous arrête et vous pousse à vous demander : « Cette transaction devrait-elle vraiment avoir lieu ? »

Je commence à penser que cette question devient plus importante que jamais.

C’est d’ailleurs l’une des raisons pour lesquelles le protocole Newton a retenu mon attention.

Au lieu de supposer que chaque transaction valide mérite d’être exécutée, Newton introduit une couche d’autorisation programmable qui vérifie d’abord si une action correspond réellement aux règles que vous avez définies. Pas après coup. Avant l’exécution.

Cela change la conversation.

Peut-être qu’un agent IA a une limite de dépenses. Peut-être que ses autorisations disparaissent après une seule session. Peut-être qu’il ne peut interagir qu’avec des protocoles approuvés, tandis qu’un autre agent suit un ensemble de règles totalement différent.

Des agents différents.

Des limites différentes.

Voici ce que j’aime le plus : les règles ne sont pas dissimulées derrière un backend qui se contente de vous demander de lui faire confiance. Elles sont transparentes, vérifiables et applicables. Et tandis que les agents IA commencent à fonctionner sur plusieurs chaînes, conserver la cohérence de ces règles d’autorisation devient bien plus important que de distribuer des approbations permanentes de portefeuille et d’espérer que tout se passera bien.

Pour moi, le vrai risque n’est pas l’automatisation.

C’est une automatisation qui, petit à petit, nous convainc d’arrêter de remettre en question ses décisions.

C’est exactement pour cela que je pense que vérifier l’intention compte autant que vérifier le code.

$NEWT @NewtonProtocol #Newt

#newt $NEWT
Plus j’y pense, et plus je réalise que, dans l’IA en Web3, « valide » ne veut pas toujours dire « autorisé ».
Un agent IA peut signer la bonne transaction, interagir avec des contrats intelligents audités et passer tous les contrôles de consensus… tout en effectuant pourtant une action qui sort des autorisations prévues par le propriétaire.
C’est précisément ce que Newton Protocol essaie de résoudre.
Au lieu de supposer que chaque transaction valide mérite d’être exécutée, Newton ajoute une couche d’autorisation programmable qui pose d’abord une question différente :
Cette action doit-elle être autorisée avant l’exécution ?
Peut-être qu’un agent IA reçoit une limite de dépenses.
Peut-être qu’un autre ne parle qu’à des protocoles approuvés.
Peut-être qu’une clé de session disparaît après une heure.
Des agents différents.
Des limites différentes.
Voici la partie que les gens passent généralement sous silence.
Ce n’est pas vraiment question d’ajouter une autre couche de sécurité.
Il s’agit de rendre les règles visibles.
Vous pouvez voir ce à quoi un agent a le droit.
Vous pouvez le vérifier.
Vous pouvez l’imposer. C’est bien plus sain que d’approuver tout et d’espérer le meilleur.
Et si ces mêmes règles d’autorisation vous suivent sur différentes chaînes, vous n’avez pas à reconstruire votre modèle de confiance à chaque fois que vos actifs se déplacent.
Ça a simplement du sens.
Je ne pense pas que la prochaine défaillance systémique en crypto vienne d’un code cassé.
Elle vient d’un logiciel qui fait exactement ce qu’il était autorisé à faire… tout en manquant totalement ce que son propriétaire voulait vraiment.
Pour moi, vérifier le code était un problème d’hier.
Vérifier l’autorisation avant l’exécution est là que commence le véritable changement.
@NewtonProtocol #Newt $NEWT

#newt $NEWT
Plus je vois l’IA s’infiltrer dans la crypto, moins je suis convaincu que notre ancien modèle de sécurité survivra à ce qui arrive.
Pendant des années, la sécurité semblait simple. Si une transaction avait une signature valide, le smart contract était audité, et le réseau parvenait à un consensus : c’était suffisant. J’y croyais aussi.
Et maintenant ? Pas vraiment.
Les agents IA n’exécutent plus seulement des transactions. Ils décident aussi quelles transactions ont le droit d’avoir lieu.
C’est un problème différent.
C’est pourquoi le protocole Newton a attiré mon attention.
Ce n’est pas intéressant parce qu’il ajoute une couche de sécurité supplémentaire. Ce qui est intéressant, c’est l’endroit où cette couche se place. Avant qu’une action n’arrive dans un smart contract, Newton pose une question simple : cette action doit-elle même être autorisée ?
L’autorisation passe en premier.
L’exécution vient ensuite.
Grosse différence.
Le point le plus fou, c’est que nous continuons à délivrer des autorisations de portefeuille illimitées et à espérer que rien ne tournera mal des mois plus tard. Newton remplace cela par des autorisations programmables.
Peut-être que vous voulez un plafond de dépenses.
Ou un accès temporaire qui disparaît après une seule session.
Ou des règles qui n’autorisent que des protocoles approuvés.
Peut-être que votre bot de trading reçoit une politique, tandis que votre automatisation de trésorerie en reçoit une autre.
C’est logique.
Ce qui a changé ma façon de voir, c’est que Newton n’essaie pas de rendre l’IA plus intelligente. Il s’assure que l’intelligence ne devienne jamais automatiquement de l’autorité.
Ses politiques d’autorisation sont programmables, transparentes et applicables, offrant aux utilisateurs un contrôle vérifiable plutôt qu’une confiance aveugle.
Pour moi, Newton ne fait pas seulement mieux la sécurité de la blockchain. Il redéfinit la confiance elle-même en prouvant que les actions sont autorisées, et pas seulement valides.

#Newt @NewtonProtocol $NEWT

#newt $NEWT Je me demande toujours si les développeurs demandent réellement une nouvelle couche d’infrastructure, ou s’ils se contentent encore d’intégrer chaque règle dans des smart contracts.

Au début, l’architecture de Newton m’a semblé ajouter de la complexité. Au lieu d’envoyer directement une transaction à un contrat, elle passe d’abord par une couche d’autorisation où des politiques programmables sont évaluées avant l’exécution. Sur le papier, cela ressemblait à une autre fonctionnalité technique à la recherche d’un cas d’usage.

Plus j’y pensais, plus je me rendais compte que Newton ne cherche pas à rendre les smart contracts plus intelligents. Il cherche à les empêcher d’assumer des responsabilités pour lesquelles ils n’ont jamais été conçus.

Les utilisateurs particuliers ne verront probablement pas la différence. Si un échange réussit et que les frais restent faibles, c’est suffisant pour la plupart des gens. Les développeurs et les institutions, eux, voient autre chose. Ils doivent gérer des plafonds de dépense, des autorisations déléguées, des règles de conformité, des validations internes et des politiques opérationnelles qui évoluent beaucoup plus vite que le code des smart contracts.

C’est là que la séparation commence à avoir du sens.

Au lieu de réécrire les contrats à chaque changement de règles métier, la couche d’autorisation permet aux politiques d’évoluer indépendamment, tandis que l’exécution reste la même.

Cela dit, une bonne architecture ne garantit pas l’adoption.

Les équipes doivent intégrer une couche de plus. Les flux de travail existants doivent évoluer. Les organisations doivent croire que les bénéfices opérationnels l’emportent sur la complexité supplémentaire. C’est un obstacle plus important que d’écrire un meilleur code.

Un autre point m’a également marqué. Le modèle de Newton dépend de plus que les smart contracts. L’évaluation des politiques, la coordination des opérateurs et des données de politique fiables deviennent eux aussi partie du système. Si ces éléments ne mûrissent pas en même temps que le protocole, la conception peut être techniquement solide, mais plus lente à gagner du terrain.

Peut-être que la vraie question n’est pas de savoir si les smart contracts devaient devenir plus intelligents.

Peut-être que la question est de savoir si le marché est prêt, dès le départ, à séparer l’autorisation de l’exécution.

@NewtonProtocol $NEWT #Newt

#newt $NEWT Un détail ne me quitte pas à mesure que davantage de systèmes deviennent automatisés.

Tout le monde parle de montée en charge. Plus d’utilisateurs. Plus de transactions.

Plus d’agents IA.

Presque personne ne parle de ce qui se passe quand quelque chose se passe mal.

Pas sur le plan technique.

Mais sur le plan opérationnel.

Qui a approuvé cette transaction ?

Qui a vérifié la politique ?

Qui en prend la responsabilité ?

Plus le système est vaste, plus il devient facile de se cacher derrière le système lui-même.

Tout semble valide. La transaction s’est exécutée.

Les journaux existent.

La blockchain est parvenue à un consensus.

Cela ne me dit toutefois toujours pas qui a réellement décidé que cette action devait avoir lieu.

En lisant le protocole Newton, j’ai commencé à envisager ce problème différemment.

Le protocole ne se contente pas de vérifier qu’une transaction peut s’exécuter.

Il met en place un processus d’autorisation avant exécution,

dans lequel des opérateurs décentralisés évaluent des politiques programmables et produisent des attestations cryptographiques.

Ces décisions ne sont pas invisibles.

Elles sont appuyées par des signatures, peuvent être contestées et entraînent des conséquences économiques si elles sont erronées.

Cela ressemble à une manière de penser très différente de l’infrastructure.

Peut-être que la montée en charge n’est pas uniquement une question de capacité à traiter davantage de transactions.

Peut-être s’agit-il plutôt de veiller à ce que la responsabilité ne disparaisse pas à mesure que le système grandit.

J’ai remarqué que nous traitons souvent l’exécution réussie comme une preuve que tout a fonctionné.

Je ne suis pas sûr que ce soit suffisant désormais. Une transaction peut être techniquement correcte et soulever malgré tout une question simple que la blockchain ne répond pas elle-même :

Qui l’a approuvée ?

Peut-être que la chose la plus difficile à mettre à l’échelle n’est pas

le calcul. C’est la responsabilisation.

@NewtonProtocol $NEWT #Newt

#newt $NEWT La transaction la plus dangereuse est celle qui respecte toutes les règles.

La plupart des gens pensent que la transaction dangereuse est celle qui échoue.

Mauvaise signature. Solde invalide. Erreur de contrat intelligent.

C’est ce que je pensais aussi.

Puis j’ai passé un peu de temps à lire le protocole Newton, et je me suis retrouvé bloqué sur une idée différente.

Et si la transaction la plus dangereuse était en fait celle qui suit toutes les règles techniques ?

Réfléchissez-y.

La signature est valide.

La blockchain l’accepte.

Le contrat intelligent exécute exactement ce qui est écrit.

Rien ne semble suspect.

Puis vous réalisez que le portefeuille n’était jamais censé effectuer ce transfert en premier lieu.

Ce n’est pas un échec de la blockchain.

C’est un échec d’autorisation.

Je ne pense pas qu’on en parle assez.

Nous sommes devenus vraiment bons pour prouver qu’une transaction peut avoir lieu.

Nous ne consacrons pas autant de temps à se demander si elle devrait avoir lieu.

C’est la partie qui m’a marqué dans Newton.

Le protocole vérifie les politiques programmables avant l’exécution.

Limites de dépenses. Permissions déléguées. Exigences d’identité.

Quelles que soient les règles qu’une application veut appliquer.

Une transaction peut réussir tous les contrôles de la blockchain et échouer tout de même à l’autorisation.

Cela a changé ma façon de penser la sécurité.

Peut-être que la sécurité ne consiste pas seulement à bloquer les transactions invalides, désormais.

Peut-être qu’il s’agit d’empêcher des transactions parfaitement valides qui franchissent discrètement une limite que personne n’a vérifiée.

La blockchain prouve que la transaction est réelle.

L’autorisation prouve qu’elle appartient.

Ces deux garanties semblent vraiment très différentes.

#Newt @NewtonProtocol $NEWT

#newt $NEWT La plupart des gens qui parlent des risques liés à l’IA semblent être obsédés par une seule chose.
Et si le modèle prenait la mauvaise décision ?
Je pensais aussi que c’était le problème principal.
Puis j’ai passé un peu de temps à lire le protocole Newton, et je me suis retrouvé coincé sur une question différente.

Et si l’IA prenait la bonne décision... mais qu’elle n’était tout simplement pas censée prendre cette décision à la base ?

Honnêtement, ça ressemble à un scénario d’échec beaucoup plus réaliste.
Une IA peut générer la transaction correcte. Elle peut trouver le meilleur itinéraire. Elle peut tout optimiser parfaitement.
Mais rien de tout cela ne répond à une seule question.

Qui lui a réellement donné la permission ?

Je pense que les gens confondent tout le temps intelligence et autorité.
Ce n’est pas la même chose.
Un modèle peut être incroyablement intelligent et ne pas pour autant avoir le droit de toucher un portefeuille en particulier, de déplacer un actif spécifique, ou d’approuver une transaction donnée.

C’est ce qui m’a marqué en lisant le protocole Newton.
Le protocole ne suppose pas que toute transaction techniquement valide doit être exécutée. Il vérifie si l’action correspond aux politiques définies au préalable. Limites de dépenses. Permissions déléguées. Exigences d’identité. Quelles que soient les règles que l’application choisit d’appliquer.

L’autorisation précède l’exécution.
C’est à ce moment-là que ma façon de penser a changé.
Peut-être que le vrai défi n’est pas de construire une IA qui ne se trompe jamais.

Bonne chance avec ça.

Peut-être qu’il s’agit plutôt de s’assurer qu’une IA ne peut pas agir en dehors de l’autorité qui lui a été accordée — même lorsqu’elle est techniquement capable de le faire.
Une chose me revenait sans cesse en lisant la documentation.

L’intelligence répond : « Est-ce que je peux faire ça ? »

L’autorisation répond : « Ai-je le droit de faire ça ? »

Ce ne sont pas les mêmes questions.

Je me trompe peut-être, mais si l’IA doit gérer de l’argent réel, je voudrais que
la permission soit vérifiée avant l’intelligence, à chaque fois.

#Newt @NewtonProtocol $NEWT

#newt $NEWT Tout le monde répète que la décentralisation résout la question de la confiance. Je n’y crois pas vraiment. La décentralisation ne prend pas les décisions.

À un moment donné, il faut quand même que quelqu’un approuve quelque chose avant qu’une transaction ne passe.

C’est pour ça que @NewtonProtocol a attiré mon attention.

Beaucoup de projets crypto s’appuient sur l’idée que des incitations corrigent tout. Peut-être que oui, peut-être que non. Newton semble adopter une approche plus directe.

Si vous êtes opérateur, vous mettez votre propre capital en jeu. Vous examinez les transactions, vérifiez les règles, et vous les validez.

Si vous continuez à bien faire le travail, vous continuez à gagner. C’est un accord assez simple.

Maintenant, imaginez que quelqu’un décide de tricher le système. Approuver quelque chose qu’il ne devrait pas.

Ignorer un contrôle de conformité. Espérer que personne ne s’en rende compte. Oui… ils peuvent essayer. Mais si quelqu’un conteste cette décision et prouve qu’elle était erronée, la mise est alors amputée.

De l’argent réel. Pas des excuses publiques. Pas des gens qui vous tombent dessus sur X pendant une journée. Vous perdez réellement quelque chose que vous avez travaillé pour obtenir.

Ça change la façon dont je le vois. Ce n’est pas vraiment une question de faire confiance aux opérateurs.

Il s’agit plutôt de rendre le coût de la triche suffisamment élevé pour que ça ne devienne plus rentable.

Un autre état d’esprit. Et j’ai remarqué autre chose… on n’attend pas seulement des opérateurs qu’ils disent : « Faites-moi confiance, je l’ai vérifié. »

Chaque validation laisse une preuve cryptographique, des signatures, des justificatifs de conformité. S’il y a des questions plus tard, il y a quelque chose à examiner au lieu de deux personnes qui se disputent sur ce qui s’est passé.

Je vois souvent les gens utiliser l’expression « système sans confiance ». Je ne sais pas… je pense que « système dont la triche coûte cher » le décrit mieux.

Les gens ne se réveillent pas honnêtes juste parce qu’il y a une blockchain.

Ils restent honnêtes lorsque tricher peut effacer des mois, voire des années de récompenses à cause d’une seule mauvaise décision.

C’est vraiment la partie que j’aime.

Le protocole ne demande pas aux gens d’être des saints. Il fait simplement en sorte que la cupidité aille dans le même sens que le réseau.

#Newt @NewtonProtocol $NEWT