JERRY8_22

J’ai passé plus de temps à me pencher sur le protocole Newton, ou NEWT, parce que ce ne ressemble pas à un projet que l’on peut comprendre correctement en un simple coup d’œil, à travers le récit IA qui l’entoure. Au début, il est facile de classer Newton dans la même catégorie que tous les autres projets crypto qui cherchent à se connecter à l’intelligence artificielle. Mais plus j’y réfléchis, plus j’ai l’impression que la véritable histoire ne se résume pas à l’IA. La vraie histoire, c’est le contrôle.
C’est ce qui rend le protocole Newton intéressant à mes yeux. Il ne se contente pas de demander ce que l’IA peut faire dans la crypto. Il pose une question plus pratique : quelle liberté faut-il accorder à un système automatisé lorsqu’il est question d’argent réel ? C’est important, car les utilisateurs de la crypto vivent déjà au quotidien avec l’automatisation. Les traders utilisent des systèmes automatisés, les utilisateurs de DeFi poursuivent le rendement, les protocoles dépendent d’outils d’exécution, et les capitaux se déplacent entre les chaînes plus vite que n’importe quelle personne ne peut les suivre manuellement. Mais la plupart de cette automatisation semble encore grossière, risquée et difficile à faire confiance.

Je regarde Newton avec la prudence que l’on développe en observant des projets crypto promettre une valeur d’infrastructure globale, puis dépendre discrètement d’un groupe d’utilisateurs beaucoup plus restreint que le récit le laisse entendre. Newton a retenu mon attention parce qu’il ne cherche pas vraiment à devenir une autre couche de coffre-fort, un autre tableau de bord, ou un autre token lié à une croissance DeFi généralisée. Le projet est construit autour de quelque chose de plus spécifique : offrir aux gestionnaires de vaults et aux institutions onchain un moyen d’imposer des règles avant qu’une action ne se produise, et non après qu’une décision a déjà été prise, laissant ensuite tout le monde examiner les dégâts.

Je surveille la crypto depuis assez longtemps pour savoir que la plupart des projets me perdent dès qu’ils commencent à parler de l’avenir avec trop de certitude. Newton ne m’a pas marqué parce qu’il promet une couche de sécurité supplémentaire ou parce qu’il utilise un langage autour de l’autorisation. Ce qui m’a fait faire une pause, c’est quelque chose de plus concret : il se penche sur le moment juste avant qu’une transaction n’ait lieu, quand l’utilisateur a encore la possibilité d’éviter une erreur plutôt que de devoir la gérer après coup. En crypto, cette petite fenêtre compte plus que ce que les gens veulent bien admettre.

I’ve been watching crypto long enough to know that the projects worth paying attention to are not always the ones making the most noise. Newton Protocol stood out to me for a quieter reason. It is trying to deal with a problemI’ve been thinking about Newton Protocol lately, especially beyond the usual excitement around AI.
What caught my attention is the question it raises around trust. Automation sounds useful when it is limited to simple tasks, but the moment software starts interacting with real on-chain value, the stakes change. It is no longer just about whether an agent can complete an action quickly or efficiently.
It becomes about whether people understand what that system is allowed to do.
Newton Protocol feels interesting because the bigger challenge is not making automated actions possible. Crypto already has plenty of systems that can execute transactions. The harder part is making those actions understandable, controlled, and accountable.
When users give software permission to act on their behalf, they need more than good performance. They need clear boundaries. They need to know what can happen, what cannot happen, and what remains under their control.
I’m still unsure how comfortable most people will be giving automated systems meaningful authority over assets. That trust will probably take time.
But I think projects like Newton Protocol may matter more for how they approach permissions and accountability than for the AI itself. The technology may improve quickly. Trust usually does not. that has been sitting in front of the industry for years: people want more automation, but they are not comfortable giving software open access to their money, wallets, and decisions. That tension feels more real to me than the usual AI narrative. Most of us do not need another system promising to think for us. We need systems that can act within limits without making us feel as though we have handed over control and hoped for the best.
The longer I spend around crypto, the more I notice how much work the user is expected to do. At first, the idea of having full control over your assets feels freeing. You hold your keys, approve your own transactions, choose your own tools, and do not have to rely on an intermediary. But after a while, that freedom starts to come with a lot of small responsibilities. You have to watch positions, check fees, follow price movements, understand approvals, keep track of transfers, and remember which systems have changed their rules or incentives. None of these things sounds overwhelming on its own, but together they turn basic participation into something that demands constant attention.
That is why automation keeps returning as a major theme. It is not hard to understand why people want help. Most users are not looking for an AI agent to take over their financial life or make bold decisions on their behalf. They want something simpler. They want a system that can handle repetitive tasks, respond to clear conditions, or carry out instructions that have already been defined. The idea is less about replacing human judgment and more about reducing the amount of time people spend watching screens and reacting to every small change.
Newton Protocol seems to be built around that space. The project is focused on creating a way for automated agents to carry out on-chain actions while staying within rules set by the user. Instead of treating an agent like a black box that gets broad access and is expected to behave properly, Newton is trying to make that authority more specific. An agent could be allowed to perform certain actions, use only a limited amount of funds, or operate only under certain conditions. That may sound like a technical detail, but I think it is actually the most important part of the idea.
Crypto already has automated systems. It has had them for a long time. There are programs that monitor prices, move funds, react to market conditions, and carry out transactions based on pre-set rules. The difference with a project like Newton Protocol is not simply that it wants software to execute actions. Software has been doing that for years. The more interesting question is whether that execution can be controlled in a way that users can understand and verify. Can someone see what an agent is allowed to do before giving it access? Can they limit its authority? Can they check whether it acted according to the rules it was given?
Those questions may sound obvious, but crypto has not always handled them well. Too often, users are asked to approve something without really understanding what the approval means. A prompt appears, the user sees technical information, perhaps a large permission request, and then clicks confirm because the interface feels familiar enough. The decision is made in seconds, while the consequences can last much longer. In that environment, a system that makes delegated authority more visible could be useful. But the word “could” matters here. The usefulness will depend on whether the system is simple enough for normal users to understand, not just technically sophisticated enough for developers to appreciate.
I find myself thinking about the difference between automation and trust. People often speak about AI agents as if the main issue is whether they are intelligent enough to make good decisions. I am less interested in that part. A system can be very intelligent and still be unsafe if it has too much freedom. In fact, the more capable an agent becomes, the more carefully its permissions probably need to be designed. An agent that can move funds, change positions, or interact with on-chain systems should not be trusted simply because it is described as smart. It should be trusted only within the boundaries that the user has clearly chosen.
That is where Newton Protocol’s approach feels more grounded than many of the louder AI projects in crypto. It is not just about making agents more capable. It is about trying to make their actions more controlled. There is something almost boring about that, but boring is not always a bad thing in finance. Most people do not need dramatic systems. They need predictable ones. They need software that does exactly what it is supposed to do and nothing more.
At the same time, I do not think the problem is solved simply by adding permissions and proofs. A system can prove that an agent followed a rule, but that does not mean the rule was wise. A user might set up a condition that looks sensible in calm markets and becomes dangerous when prices move quickly. An automated instruction might work well most of the time and fail during the one period when the user needs it most. Crypto has shown again and again that the hardest situations are not the normal ones. They are the moments when liquidity disappears, networks slow down, or prices move in ways that no simple rule can fully account for.
This is why I think projects working on automated execution need to be judged by their failure cases, not just their demos. It is easy to show an agent completing a clean transaction under perfect conditions. It is much harder to show what happens when data is wrong, transfers are delayed, a network becomes congested, or an on-chain system behaves differently than expected. The real value of a system like Newton Protocol may not be in how much it can automate when everything is working. It may be in how safely it behaves when things are not working.
There is also the issue of complexity. Crypto users are already dealing with too much of it. If Newton Protocol requires people to understand a long list of permissions, execution rules, proofs, environments, and technical settings before they can safely use it, then it may end up serving only the users who are already comfortable with that complexity. That does not make the project irrelevant, but it does limit its reach. The real challenge will be turning advanced security controls into something that feels understandable without making it feel simplistic or misleading.
I have seen many crypto projects struggle with that balance. They build something technically strong, but the experience makes people feel like they are agreeing to terms they cannot really interpret. Then the system becomes trusted mostly because people assume someone else has checked it. That is not much different from the systems crypto originally claimed it wanted to move away from. Transparency is useful, but only when people can make sense of what they are looking at. A permission model is only helpful if users can tell what they are giving permission for.
Newton Protocol also brings up a larger question about what role AI should play in on-chain systems. There is a big difference between an agent that helps a user understand options and an agent that can actually move assets. The first feels like assistance. The second feels like delegation. Both can be useful, but they should not be treated as the same thing. I suspect most people will be more comfortable with AI systems that recommend, monitor, or organize information than with systems that act independently. The more financial authority an agent has, the more careful the design needs to be.
That is why I think the strongest use cases for Newton Protocol may not be the flashy ones. Automated trading is always going to get attention because it fits naturally into crypto’s obsession with speed and profit. But the more practical uses may be quieter. A treasury could use controlled automation for routine actions. A user could set limited permissions to avoid missing recurring tasks. A system could manage operational processes without giving any one person too much control. These are not the kinds of use cases that create excitement, but they are closer to the everyday problems that need solving.
Of course, even the quieter use cases come with their own risks. A treasury system can still make a costly mistake. A cross-chain process can still depend on weak infrastructure. A user-defined policy can still be poorly designed. No permission system can fully protect someone from their own bad assumptions. Newton Protocol may be able to reduce some forms of risk, but it cannot remove uncertainty from markets or eliminate the possibility of human error. That is not a flaw unique to the project. It is simply the reality of building anything that touches money, automation, and decentralized systems at the same time.
What I appreciate about Newton Protocol is that it is working around a problem that is likely to become more important, not less. As crypto becomes more complicated, users will want more help managing it. As AI becomes more present in software, people will want agents that can do more than make suggestions. And as those agents become more useful, the question of permission will become impossible to ignore. Who decides what an agent can do? How much access is too much? What happens when something goes wrong? Can the user stop it? Can they understand what happened afterward?
These are not exciting questions, but they are serious ones. They are the kind of questions that usually matter more in the long run than the loudest claims about innovation. Newton Protocol may end up becoming part of the infrastructure that helps answer them, or it may run into the same problems that have slowed down many ambitious crypto projects before it. The technology may be sound, but adoption could still be difficult. The design may be thoughtful, but users may still prefer simpler tools that ask fewer questions. The system may offer better controls, but people may not use those controls carefully.
For now, I see Newton Protocol as an attempt to make automation feel less like surrender. That is probably the right place to start. I do not think most people want software that replaces their decisions. I think they want software that respects the decisions they have already made. The difference is subtle, but it matters. In crypto, where control is supposed to belong to the user, the best kind of automation may not be the kind that acts freely. It may be the kind that knows exactly where its limits are.
$NEWT #Newt @NewtonProtocol

I’ve been watching crypto for years, long enough to know that most projects start sounding familiar after a while. New terms appear, new promises get attached to them, and eventually you realize you have heard a version of the same idea before. Newton Protocol did not immediately feel like that to me. I came across the project while looking into $NEWT after its mainnet beta went live, but I stayed because I wanted to understand what Newton Protocol actually meant by “programmable authorization.” It is one of those phrases that sounds technical enough to ignore, but the more I sat with it, the more it felt connected to a problem crypto keeps creating for itself.
We have built an industry where people can move assets, trade, borrow, lend, stake, and interact with financial systems in a few clicks. That freedom is still one of the reasons crypto feels different from traditional finance. But after spending enough time around it, I have also seen how easily that freedom turns into blind trust. People approve permissions without fully understanding the scope. They hand over access because the process feels routine. They allow automated systems to act because manual decisions feel too slow. Most of the time, it is not a carefully considered choice. It is simply the easiest path in the moment.
That is where Newton Protocol starts to make sense to me. The project is looking at the layer before a transaction happens. Not just whether a transaction can be executed, but whether it should be allowed under certain conditions. That sounds like a small shift, but it is not. In crypto, permissions are often very broad. A wallet either gives access or does not. A transaction either goes through or fails. There is usually very little room for something more specific.
Newton Protocol seems to be trying to create that missing middle ground. Instead of giving a system open-ended authority, the idea is that rules can be attached to what it is allowed to do. A transaction could be limited by amount, timing, asset type, market conditions, or other defined boundaries. That makes the project feel less like it is adding another layer of complexity and more like it is trying to make delegation less reckless.
I keep thinking about how relevant that becomes as automation becomes more common. Crypto is moving toward a future where software can do more on behalf of users. It can react to market changes, manage positions, organize strategies, and carry out tasks faster than someone watching a screen all day. That sounds useful until you ask the obvious question: how much control are you giving away? It is easy to say you want automation. It is harder to decide what that automation should never be allowed to do.
Newton Protocol feels like it is built around that tension. The project is not really asking whether machines can act onchain. We already know they can. It is asking whether their actions can be constrained in a way that still leaves the user with meaningful control. That is a more practical question. Anyone can build something that acts automatically. Building something that has clear limits, predictable behavior, and rules that do not quietly become a black box is much harder.
What makes this interesting is that Newton Protocol is not trying to remove risk. I do not think any honest project in crypto can claim that. It is more about making risk visible and adjustable. There is a big difference between giving a system unlimited permission and giving it permission that only works under specific conditions. The first is trust. The second is closer to a boundary.
Of course, the idea also comes with its own problems. Rules are only as good as the people who design them. Data is only as reliable as the source providing it. A policy that looks reasonable on paper can become frustrating or even unfair when it is applied in a real situation. What happens if the data is wrong? What happens if someone is blocked from a transaction they believe should be allowed? What happens when policies become too complicated for the average person to understand? These are not small questions, and Newton Protocol will have to answer them through real usage, not just technical design.
That is probably the part I find most important. Crypto projects often look cleanest before people start using them. The real test is not whether a system works in theory. It is whether it makes sense when someone is trying to move funds quickly, manage risk during volatility, or understand why an action was denied. A programmable authorization layer may be useful, but it has to remain understandable. If people cannot see what is happening, then the project risks replacing one kind of blind trust with another.
Still, Newton Protocol is working on something that feels more grounded than many of the ideas floating around crypto right now. It is not trying to make finance look futuristic. It is trying to deal with a problem that becomes more serious as onchain activity becomes more automated. How do you let software act without giving it too much power? How do you add control without turning everything into a restrictive system? How do you create rules that protect users without making them feel trapped inside them?
I do not know yet whether Newton Protocol will become a major piece of infrastructure or remain a useful experiment around a difficult idea. But I think the project is worth paying attention to because it is focused on something crypto usually ignores until something goes wrong: permissions, boundaries, and the small decisions that happen before a transaction moves and before a mistake becomes permanent.
The longer I watch this space, the less interested I become in projects that promise to do everything. Newton Protocol is interesting because it is focused on one part of the system that most people barely notice. And maybe that is exactly why it matters. The future of crypto may not depend only on what can happen onchain, but on how carefully we decide what should be allowed to happen in the first place.
#Newt $NEWT @NewtonProtocol

I’ve spent enough years around crypto to notice that the projects that stay with me are rarely the loudest ones. Newton Protocol caught my attention because it is looking at a problem that most of us have learned to ignore until it becomes painful: what exactly happens after we give a contract, bot, or automated system permission to act for us. In decentralized finance, that moment is usually reduced to a simple button press. Approve token spend. Connect wallet. Confirm access. It feels routine because we have repeated it so many times, but the reality underneath is not routine at all. We are often giving systems more freedom than we can comfortably explain, then trusting that the code, the team, and the market behave the way we expect.
That is the part of crypto I find myself thinking about more than ever. We have become very good at building systems that can move money automatically. We are less good at making those permissions understandable. A trading bot can rebalance a wallet, an automated strategy can shift capital, and an agent can execute a plan while the user is asleep. All of that sounds efficient until you stop and ask a basic question: what is that system actually allowed to do once it has access? Not what it says it will do. Not what a dashboard suggests. What it can do.
Newton Protocol is built around that difference. Rather than treating approval as a one-time blanket permission, it is trying to make authorization more specific and more conditional. The project is designed around programmable policies that can sit between a user’s intent and an onchain transaction. In practical terms, that means an action could be checked against certain rules before it goes through. A bot might be allowed to trade only within a certain limit. A wallet might be allowed to send funds only to approved destinations. A treasury might be restricted from moving assets unless a set of conditions is met. The goal is not to remove automation, but to make automation operate inside boundaries that are clearer than the usual approve-and-hope model.
I think that is why the project feels more relevant than many of the conversations around AI agents in crypto. A lot of the attention is focused on what agents will be able to do. They can monitor markets, execute trades, manage liquidity, respond to signals, and handle tasks users do not want to perform manually. That part is easy to imagine. The harder part is deciding how much authority those systems should have. An agent can be useful and still be dangerous if its permissions are too broad. It can follow a strategy exactly as intended and still cause damage if the market changes, the inputs are wrong, or the original assumptions no longer hold.
Newton Protocol seems to be approaching this from the more grounded side of the problem. Instead of asking users to simply trust an automated system, it gives more importance to the conditions under which that system can act. That sounds obvious, but crypto has not always treated it that way. Unlimited approvals became normal because they were convenient. Broad permissions became normal because they made things easier to use. Over time, users were trained to see a wallet popup as a minor obstacle rather than a serious financial decision. Newton Protocol is trying to bring some structure back into that process.
What makes the idea interesting is that it is not limited to one kind of user. A trader could use policies to limit how much a bot is allowed to move. A group managing shared funds could use them to control spending rules. A larger organization could set conditions around who can receive assets or when a transaction is valid. Even a simple wallet could use the same logic to prevent certain actions unless they match a predefined set of rules. The project is not solving every trust problem in crypto, but it is addressing a piece of infrastructure that becomes more important as more actions are delegated to software.
At the same time, I do not think policy-based authorization is automatically simple just because the idea sounds clean. Rules can become complicated quickly. The more detailed the policy, the more likely it is that someone has to understand how all the pieces interact. A limit that makes sense during normal market conditions might fail during a sudden crash. A rule based on external data depends on that data being accurate and available. A system that relies on multiple participants has to deal with disagreement, delays, incentives, and edge cases. None of that makes the project less interesting, but it does mean the real test will be in how it behaves under pressure, not how elegant the concept looks on paper.
I also think Newton Protocol has to solve a human problem, not only a technical one. Most people do not want to write complex policies for every action they take. They want to understand what they are approving without needing to think like a developer or a risk manager. The project will be more useful if it can make those permissions feel readable and practical. A user should be able to understand that a bot can trade only a limited amount, that a payment tool cannot send funds outside a chosen list, or that automated capital cannot move when certain risk conditions are triggered. The underlying infrastructure can be advanced, but the user experience cannot feel like another layer of complexity.
There is something quietly important about the problem Newton Protocol is trying to address. Crypto has always been built around self-custody and control, but in practice, many users trade some of that control away for convenience. They approve contracts they barely understand, use systems they do not monitor every day, and rely on automation because the ecosystem is too fast and too fragmented to manage manually. That tension is only going to grow as agents become more capable. The question is not whether people will delegate more actions to software. They probably will. The question is whether those delegations will come with real limits.
Newton Protocol does not remove the need for trust, and it does not make automated finance risk-free. No protocol can do that. But it is trying to make the boundaries of trust more visible. It is trying to move the conversation away from broad access and toward specific authority. That feels like a healthier direction for crypto, especially at a time when more systems are being asked to act independently with real assets.
I keep coming back to the fact that most risky actions in crypto do not look risky in the moment. They look like normal clicks. They look like a familiar approval screen, a harmless permission request, or a setting that promises to save time. Newton Protocol is interesting because it takes that ordinary moment seriously. It asks whether a user should have to hand over a blank check just to make automation useful. I do not know how widely the project will be adopted, and I do not think the answer is obvious yet. But I do think the question it is asking is one the industry can no longer avoid: when software acts for us, how do we make sure it stays within the limits we actually intended?
#Newt @NewtonProtocol $NEWT

I’ve spent enough time around crypto to know that most projects become easier to understand once you ignore the big slogans and look at the problem they are quietly trying to solve. Newton feels like one of those projects. The more I look at it, the less I see it as another technical layer built for people already comfortable with crypto, and the more I see it as an attempt to deal with something the industry has avoided for years: the fact that moving money onchain is not always supposed to be final in the human sense.
Crypto has always been proud of finality. You send a transaction, it settles, and nobody can interfere. There is a certain appeal in that. No one can suddenly pause your money, question your decision, or make you wait for approval. But after watching this space mature, I have started to feel that finality is often treated like a complete answer when it is really only one side of the equation.
Real payments are rarely as clean as blockchain transactions make them look. People get tricked. A payment is sent to the wrong place. A buyer does not receive what was promised. Someone gains access to an account that was not theirs. A recurring payment continues longer than expected. In those situations, the question is not whether the transaction happened. The question is whether it should have happened in that way at all.
That is where Newton becomes more interesting. It seems to be built around the idea that onchain payments can include rules before they become permanent. Instead of treating every transfer as the same, Newton creates room for conditions around how money moves. A transaction can carry limits, permissions, checks, or restrictions that make the payment feel less like an irreversible command and more like part of a controlled process.
I think that matters because crypto has spent years proving that value can move quickly. That is no longer the difficult part. The harder issue is whether people can use that value in everyday situations without carrying the full burden of every mistake. Fast settlement is useful, but it does not automatically create trust. A payment system becomes more meaningful when it can account for the possibility that something goes wrong.
Newton’s approach seems to focus on that gap. It is not just about sending funds from one place to another. It is about giving the transaction some context. Who is allowed to send? How much can move? Under what conditions should a payment be approved? Should there be limits based on behavior, timing, or risk? These are questions that most people do not think about until they are the ones affected by a bad transaction.
The idea of chargebacks is especially important here, although I do not think it should be understood as simply reversing a payment. A chargeback is really a dispute. It is a process for questioning whether a transaction was legitimate, fair, or properly completed. Sometimes the buyer is right. Sometimes the seller is right. Sometimes the situation is unclear and neither side has a perfect case.
That is exactly why bringing this kind of protection onchain is difficult. A blockchain can show that funds moved, but it cannot naturally understand whether someone was misled, whether a service was delivered properly, or whether a claim is honest. Those are human questions. They involve judgment, evidence, and context. Newton may be able to make the rules around transactions more programmable, but it cannot remove the complexity that comes with real financial disputes.
Still, I think there is value in trying to build around that reality instead of ignoring it. Onchain payments often feel like digital cash. Once you hand it over, the interaction is over. That can be useful in some cases. But many payments are not really like cash. They involve trust between people who do not know each other, expectations around delivery, and the possibility that one side may need protection later.
Newton could make those interactions feel less exposed by allowing payments to carry clearer conditions from the beginning. Some transfers might be final immediately. Others could include a limited period for disputes. Some could require extra approval. Others might have restrictions based on who is receiving the funds or how the payment is being used. The important part is not that every transaction gets the same protection. It is that the rules are visible before the money leaves.
That kind of clarity could be more important than it first appears. In many financial systems, people only discover the rules after something goes wrong. They find out too late whether a payment can be challenged, whether they are protected, or who is responsible for fixing the problem. Newton has the potential to make those conditions more explicit. A user could understand what kind of transaction they are entering before they confirm it.
But that possibility also brings difficult questions. The moment a system can stop, restrict, or reverse a payment, someone has authority. Even when rules are open and visible, they still have to be written by someone. Someone has to decide what counts as suspicious behavior. Someone has to decide which disputes are valid. Someone has to decide how much control is too much.
That is where I remain cautious. The goal of making onchain payments safer can easily turn into building systems that are too restrictive, too complicated, or too difficult for ordinary users to challenge. A person may feel protected until a rule affects them unfairly. A merchant may appreciate fraud prevention until a valid payment is blocked. A user may want reversibility until they become the one waiting for funds to clear.
Newton is working in that uncomfortable space between complete freedom and structured protection. It is not an easy place to build, and it should not be treated as an easy problem. But I find the direction more thoughtful than the usual idea that people should simply accept the consequences of every transaction forever.
The industry has spent years celebrating the idea that users should control their own money. That principle still matters. But control also means responsibility, and responsibility becomes heavy when there is no room for error. Newton seems to be exploring whether onchain payments can remain direct while still allowing for more realistic safeguards around the way people actually use money.
I do not know whether that balance can be achieved cleanly. It may create new forms of control, new disputes, and new questions about who gets to define fairness. But I think Newton is at least looking at a problem that many projects prefer to ignore. Moving money is only one part of a payment system. The harder part is deciding what should happen when the transaction is not as simple as it first appeared.
#Newt @NewtonProtocol $NEWT