Mais à mesure que les applications on-chain continuent d’évoluer, un nouveau changement se produit : de plus en plus de systèmes commencent à exécuter des tâches de manière proactive. Les stratégies d’automatisation, les comptes intelligents, les robots on-chain… tout cela passe progressivement d’un simple outil à un véritable acteur. Et lorsque les logiciels commencent à avoir la capacité d’agir, une nouvelle question apparaît aussitôt : qui va gérer leur comportement ?
Auparavant, lorsque nous parlions des contrats intelligents, l’accent était généralement mis sur la question de savoir si le code est fiable. La valeur la plus importante des contrats intelligents, c’est de pouvoir intégrer les règles à l’avance dans le programme, afin que tous les participants appliquent la même logique. Mais à mesure que les applications on-chain deviennent de plus en plus complexes, de nombreuses actions ne relèvent plus uniquement d’un déclenchement par conditions simples. Un système d’automatisation peut avoir besoin d’évaluer en même temps l’état du marché, la répartition des actifs, les limites d’action et si l’objectif d’exécution répond aux exigences prévues. Dans ce cas, compter uniquement sur le contrat intelligent lui-même se heurte à de nouvelles limites. Il peut exécuter du code, mais il ne comprend pas naturellement les règles qui se cachent derrière l’action.
C’est aussi le problème que le protocole Newton cherche à résoudre. Beaucoup de gens, en voyant Newton, pensent d’abord à un Agent IA ou à l’automatisation. Mais d’après l’architecture présentée dans le livre blanc, ce qui intéresse vraiment Newton, c’est la manière d’établir un système de gestion des comportements une fois que les applications on-chain possèdent des capacités d’exécution autonomes. La position centrale de Newton est la Couche d’Authorization (Authorization Layer). Elle ne remplace pas les smart contracts : elle ajoute une couche de décision de politique entre l’application et l’exécution. Dans la logique on-chain traditionnelle, c’est généralement « transaction initiée → exécution du contrat → obtention du résultat ». Newton veut mettre en place « définir des règles → vérifier des conditions → autoriser l’exécution → produire un résultat ».
La partie la plus essentielle est le Policy Framework. Dans les applications traditionnelles, de nombreuses règles restent cachées dans les systèmes en arrière-plan, comme les restrictions de compte, les limites d’opération, les conditions de risque, etc. Ces logiques sont généralement gérées par des services centralisés. Mais dans un environnement on-chain, si ces règles ne peuvent pas être exprimées clairement, il devient difficile de s’adapter à une automatisation à grande échelle. La démarche de conception de Newton consiste à transformer ces règles en politiques programmables, pour que l’application définisse quelles opérations peuvent être exécutées, quelles conditions doivent être remplies, quels types de comportements sont limités, et quelles vérifications doivent être effectuées au cours de l’exécution. Ce n’est pas juste un contrôle d’accès : c’est un cadre logique qui décrit les limites du comportement.
Je pense que c’est extrêmement important, car l’orientation du développement des applications on-chain à l’avenir ne consistera pas seulement à faire exécuter plus de programmes, mais à permettre à davantage de programmes de fonctionner dans des limites clairement définies. C’est aussi le sens de l’Intent d’Automation. Dans le passé, la relation entre l’utilisateur et le système ressemblait davantage à ceci : l’utilisateur dit à la machine, étape par étape, quoi faire ; mais dans des contextes plus complexes, l’utilisateur n’aura peut-être qu’à exprimer un objectif, par exemple : souhaiter que les actifs conservent une certaine configuration, que la stratégie s’ajuste selon les changements du marché, qu’un programme d’automatisation continue d’accomplir une tâche, tandis que le système doit exécuter conformément aux règles définies.
Pour créer un lien fiable entre l’objectif et l’exécution, les technologies TEE et ZK dans l’architecture de Newton jouent aussi un rôle important. Le TEE fournit un environnement d’exécution de confiance, permettant de mener le calcul sous des conditions protégées ; ZK aide le système à prouver que le résultat de l’exécution répond aux exigences, tout en réduisant l’exposition d’informations sensibles. Ensemble, ils permettent non seulement à un système d’automatisation de s’exécuter, mais aussi de prouver que son exécution respecte les règles prédéfinies. À mesure que le système devient plus autonome, ce dont les gens auront vraiment besoin n’est pas une machine plus rapide, mais une machine capable d’expliquer ses propres comportements.
Du point de vue du marché, je pense que la valeur de Newton ne réside pas seulement dans la création d’une nouvelle catégorie d’application, mais dans l’exploration des capacités fondamentales dont les applications on-chain de la prochaine génération ont besoin. Dans le passé, la concurrence dans l’industrie se concentrait davantage sur le nombre d’utilisateurs, le modèle de revenus et les mécaniques de produit ; mais à mesure que la complexité des applications augmente, la concurrence pourrait progressivement se déplacer vers qui est capable de gérer davantage de comportements d’automatisation.
Bien sûr, Newton a encore besoin de temps pour être validé. Toute infrastructure doit, à terme, prouver sa valeur par une utilisation réelle, y compris l’adoption par les développeurs, la croissance de l’écosystème et les effets de fonctionnement du réseau. Pour $NEWT, je ne m’intéresse pas non plus aux fluctuations de prix à court terme, mais à la capacité à devenir un composant de base dans le processus d’exécution d’un plus grand nombre d’applications on-chain.
Si, à l’avenir, le logiciel accomplissait vraiment de plus en plus les tâches de façon proactive, l’infrastructure permettant de gérer ces comportements deviendra probablement une composante essentielle de l’étape suivante. Dans le passé, les smart contracts ont résolu la question de « comment le code s’exécute », tandis que Newton explore : une fois que le code commence à agir de manière autonome, comment les comportements doivent-ils être gérés. Il s’agit d’une étape très clé pour le passage du on-chain de l’automatisation à la mise à l’échelle.
