Izhan Ahmad

Every now and then when reading docs about Newton Protocol I can't stop thinking about this one. Many of us is very excited about AI on-chain, but what if we could also pose another question – "who is the gate keeper that validates if this AI is following all of its rules"?
Today blockchain networks are very good at verifying that a transaction happened once it's signed – that a certain wallet signed for a certain instruction and it's legitimate, but not what is the underlying reason, what is the intent. When AI's are able to hold funds, trade and initiate transactions with smart contracts – this difference gets much more crucial.
One specific technical aspect that interested me is Newton's usage of programmable policies prior to execution. So instead of believing any message that arrives, the system with its programmable rules checks first whether the transaction conditions are satisfied or not – be it the spending amount limits, approved counterparties, need for multi signature for specific kind of transactions etc.
My thought – this move, slightly but still, from the security post-action reactive to the pre-action preventive. Could become the main subject in the coming times when AI would take a bigger piece of financial world.
Of course – this brings in new concerns. Who set up policies? When will they need to be changed? Will they be too restrictive for the innovation to flow?
This is just a single architecture idea I found in Newton Protocol which got my attention while reading its docs. I don't claim this is the end solution for AI security in Web3, but rather just one idea. Let's see how it works when adopted.
Perhaps, the next phase of blockchain security will be not on strengthened wallets but in making sure that AI has followed its rules before it will actually signed any transactions.
What do you think – Should AI agents have 100% freedom on chain, or should they play by pre defined, programmable rules?
@NewtonProtocol $NEWT $LAB $TLM
#Newt #NewtonProtocol #AI #Web3 #blockchain #crypto #BinanceSquare

While reading through Newton Protocol's documentation, one idea kept pulling my attention. We spend a lot of time discussing decentralization, self-custody, and security, but very little time discussing permissions.
In Web3, once a wallet signs a transaction, the blockchain simply executes it. It doesn't ask whether the action makes sense or whether the wallet owner intended it. That works well when humans are making every decision. But what happens when AI agents begin managing wallets, treasury operations, or automated investment strategies?
This made me think that the next challenge for Web3 may not be transaction speed or lower fees—it could be smarter authorization.
Instead of treating every signed transaction as equally trustworthy, Newton Protocol introduces an authorization layer where predefined policies can evaluate requests before they are executed. These policies can define spending limits, approved applications, trusted counterparties, or additional approval requirements for sensitive actions.
What I found interesting is that this isn't about reducing decentralization. It's about adding programmable decision-making before execution, especially as AI becomes more involved in on-chain activity.
One question I'm still thinking about is whether authorization layers could eventually become as common as multi-signature wallets. If autonomous software is going to manage digital assets, should permission policies become a standard security practice rather than an optional feature?
Maybe this is one of those infrastructure ideas that isn't very noticeable today but becomes essential as AI-driven finance grows.
I'm still watching how Newton Protocol develops this approach, because the conversation around AI in crypto may soon shift from "What can AI do?" to "What should AI be allowed to do?"
What do you think? Should programmable permissions become a standard feature for every AI-controlled crypto wallet?
@NewtonProtocol $NEWT $ARPA $THE
#Newt #NewtonProtocol #Web3 #AI #blockchain #crypto #BinanceSquare

Imagine waking up at 3 AM and seeing multiple notifications from your crypto wallet. An AI agent that was supposed to manage your portfolio has just transferred thousands of dollars to an unfamiliar address. The worst part? The transaction was technically valid, so the blockchain executed it without hesitation.
As AI becomes more involved in Web3, this scenario doesn't feel impossible anymore.
AI agents can already analyze markets, automate trades, and manage digital assets. But intelligence alone isn't enough. Every AI system also needs clear boundaries that define what it can and cannot do.
This is one reason I started paying attention to @NewtonProtocol .
Instead of giving AI unlimited authority over on-chain assets, Newton introduces an authorization layer that checks transactions against predefined policies before execution. Imagine setting rules like "Never send funds above a certain amount," "Only interact with trusted protocols," or "Require my approval for high-value transfers." If a transaction violates those rules, it simply doesn't move forward.
What I find interesting is that this isn't about slowing AI down—it's about making automation more trustworthy.
The goal isn't to replace autonomous finance, but to ensure AI operates within limits chosen by the user.
As AI continues to shape the future of crypto, I believe the conversation shouldn't only focus on what AI can do. We should also ask what AI should be allowed to do.
That shift—from unlimited permissions to programmable authorization—could become one of the most important building blocks of the next generation of Web3.
What do you think? Would you trust an AI agent with your entire crypto portfolio if there were no rules controlling its actions? @NewtonProtocol #Newt
$NEWT
$TLM
$BIRB
#DenzoTM #defi #DelistingAlert #TrendingTopic

The crypto industry is becoming increasingly excited about AI agents. @NewtonProtocol
We imagine AI trading for us, managing treasuries, moving liquidity, paying subscriptions, and even running entire businesses without human intervention.
But there is one question I don't see enough people asking:
What happens when an AI makes a bad financial decision?
Traditional finance assumes humans are responsible for every transaction.
AI changes that assumption completely.
An autonomous agent can operate at machine speed, execute hundreds of transactions in seconds, and interact with protocols across multiple chains without ever asking for permission again.
That creates an entirely new risk model.
An AI wallet could accidentally interact with a malicious contract.
It could exceed spending limits.
It could send funds into restricted jurisdictions.
It could even make decisions that technically follow instructions while completely violating the original intent.
The more I studied Newton Protocol, the more I felt that crypto doesn't simply need smarter AI.
It needs smarter boundaries for AI.
Newton introduces programmable authorization rules that sit between intention and execution.
Instead of asking humans to manually approve every action, users define the rules once:
• Maximum spending limits
• Approved counterparties
• Allowed protocols
• Transaction frequency restrictions
• Escalation rules for large transfers
The AI remains autonomous, but it operates inside predefined guardrails.
That idea feels important.
Because the future of finance probably isn't humans competing against AI.
It's humans defining the rules while AI handles the execution.
And if AI becomes the new user of blockchain networks, authorization may become just as important as intelligence itself.
@NewtonProtocol
$NEWT $DYDX $BASED
#Newt #OilPriceFalls #BinanceSquare #crypto #Write2Earn

Blockchain has changed the way we transfer value, but one important question remains: should every valid transaction be executed automatically? As crypto grows with AI, stablecoins, and institutional adoption, authorization before execution is becoming more important than ever.
This is where @NewtonProtocol introduces a fresh approach. Rather than building another blockchain, Newton focuses on becoming the authorization layer for on-chain transactions. Before a transaction is executed, it can be checked against programmable policies such as identity verification, spending limits, sanctions screening, and risk management.
A simple way to understand this is by comparing it to traditional finance. When you pay with a bank card, the payment is authorized before it is settled. Newton aims to bring that same concept to Web3 while keeping the process decentralized, transparent, and verifiable through cryptographic proofs instead of relying on a single trusted intermediary.
One of the most exciting use cases is AI-powered finance. As AI agents begin managing wallets, executing trades, and making payments, they need clear boundaries. Newton allows developers to create programmable rules that define what AI agents can and cannot do. This helps reduce risks while allowing automation to operate efficiently.
Privacy is another major advantage. Instead of exposing sensitive user information on-chain, Newton uses verifiable credentials and cryptographic proofs to confirm compliance while protecting personal data. Users maintain greater control over their information without sacrificing security.
The protocol is also designed for multiple blockchain ecosystems, making it easier for developers and institutions to apply the same authorization standards across different networks.
In my opinion, the future of blockchain isn't only about faster transactions—it's about smarter and safer transactions. As Web3 continues to evolve, an authorization layer could become just as important as the settlement layer itself.
@NewtonProtocol is building infrastructure that could help make decentralized finance more secure, AI-friendly, and institution-ready.
@NewtonProtocol $NEWT $SYN $HEI
#Newt #NewtonProtocol #Write2Earn #Write2Earn!