newt

I almost delegated my wallet permissions to an AI agent last week. Then I stopped and asked myself something simple... what actually happens if that agent makes one wrong call? Not a hack, not an exploit, just a bad decision executed perfectly. That question is what led me into Newton Protocol's verifiable automation layer, and I'm still not sure I like all the answers I found 🤔
So I went down the rabbit hole. Newton is built by Magic Labs, the same team behind that embedded wallet infra a lot of apps quietly run on. Their pitch is basically "let AI agents handle your onchain stuff, but make every action cryptographically checkable." No more blind trust in some bot running in the background. Every move gets wrapped in a proof you (or anyone) can go verify later. Sounds clean on paper, ngl.
But here's where my question actually got harder to answer, not easier. Newton uses two things to pull this off... Trusted Execution Environments and zero knowledge proofs. TEEs are basically a locked box where code runs untouched, and it spits out a receipt saying "yes this ran exactly as intended." ZK proofs let the network confirm a rule was followed without exposing the private details behind it. Stack those together and you get what they call "verifiable automation." A policy engine sits in front of transactions and checks them against rules before anything executes.
Okay but that's the part that kept bugging me. A policy engine can stop a transaction that breaks a rule. It cannot stop an agent from following every rule perfectly and still making a call you would've said no to. My original fear wasn't "will this get hacked," it was "will this do something dumb but technically valid." And after reading through their docs and a few breakdowns, I don't think verification was ever meant to solve that problem. It solves a different one... compliance, auditability, proving after the fact that nothing shady happened.
That's actually useful, don't get me wrong. If you're an institution issuing a stablecoin or running RWA products, having a public explorer where every automated action is checkable is a real unlock. It removes a genuine adoption blocker. But somewhere in my reading I noticed the framing kept drifting toward "institutions" and "compliance," not really toward "should I personally hand my wallet to a bot." Those are two different products wearing the same token, kind of.
So now I'm sitting with a weird mix of respect and hesitation. The tech is legit, TEEs plus ZK isn't some vague buzzword combo, it's a real architecture choice with tradeoffs I can actually point to. But "verifiable" and "safe to trust with my funds" aren't the same sentence, even if the marketing wants them to blend together 💭
I still haven't flipped that switch on delegating permissions. Not because I think Newton is broken, but because my original question never really got answered, it just got redirected into a better question. If an agent's action can be proven correct after the fact, does that actually change how comfortable I should feel handing over control before the fact...
Genuinely asking, not rhetorical. If you've used any agent-based automation on Newton or elsewhere, I'd want to know if that hesitation goes away with use or if it just moves somewhere else...
@NewtonProtocol #Newt
$NVDAB
$MSFTB
$NEWT

One thing crypto has taught me is that expensive losses don't always come from bad investments.
Sometimes they come from a single click.
Sending funds to the wrong address.
Approving a contract without checking the permissions.
Signing a transaction too quickly because you're in a hurry.
I've never liked the fact that blockchains don't ask questions. If the signature is valid, the transaction goes through. That's exactly how the technology is supposed to work, but it also means there's very little room for second chances.
The more I think about it, the more I believe the next step for wallet security isn't just better encryption. It's better decision-making before a transaction is approved.
That's one reason @NewtonProtocol caught my attention.
From what I've learned, it's exploring programmable authorization. Instead of treating every transaction the same, users can define rules for actions that carry more risk.
For example, you could require an extra approval before moving a large amount of funds. An AI agent could handle routine tasks but still be blocked from making high-value transfers on its own. Even biometric verification could be required for sensitive actions.
$NEWT
To me, that feels less like adding friction and more like adding common sense.
Of course, no system can eliminate human error completely. People will still make mistakes, and attackers will keep looking for new ways to exploit them.
But if wallets become better at recognizing risky actions before they happen, even preventing a small number of costly mistakes could make a real difference.
I'm interested to see whether developers adopt this approach and whether users find it practical in everyday use.
If they do, authorization could become just as important as the transaction itself.
What do you think would prevent more crypto losses?
#Newt #newt $ZEC #NEWT

#newt $NEWT The next major evolution in decentralized compliance and verifiable on-chain automation is officially here. As decentralized finance (DeFi) continues to mature, protocols, DAOs, and autonomous AI agents require robust, programmable safety frameworks that go beyond simple identity checks. This is precisely where @NewtonProtocol fills the critical infrastructure gap with the rollout of the Newton Mainnet Beta.
​Real-Time, Pre-Transaction Policy Enforcement
​Unlike traditional methods that rely on background monitoring or deposit-side identity screening, @NewtonProtocol operates as an active authorization layer. It evaluates custom rules written in declarative policy code before a transaction settles. If a transaction fails to meet the compliance or risk criteria set by the smart contract curator, it is blocked or liquidated instantly at the transaction level, producing a verifiable cryptographic attestation.
​The Power of the Mainnet Beta Stack
​The launch of the Mainnet Beta introduces Vaults—dynamic, policy-gated liquidity pools. To ensure these policies are backed by foolproof data, the protocol has established critical launch data partnerships:
​RedStone Oracles: Supplying reliable, manipulation-resistant price feeds and asset-specific data.​Credora: Injecting real-time, model-driven risk ratings directly into the policy infrastructure.
​By blending market pricing and risk intelligence into a unified, enforceable decision engine, @NewtonProtocol allows curators to police risk with institutional-grade precision.
​The Utility of $NEWT
​At the heart of this ecosystem is the $NEWT native utility token. It plays a foundational role in powering the decentralized Actively Validated Service (AVS) network, secured via restaking. The token is built to drive the network through:
​Compute Fees: Paying for the compliance and policy execution layer.​Operator Incentives: Rewarding node operators who execute policies inside secure Trusted Execution Environments (TEEs).​Governance: Giving holders the power to shape future rule frameworks.
​As the ecosystem scales up its operations, keeping an eye on the infrastructure developments coming out of the Newton Mainnet Beta will be crucial for the future of composable on-chain security.
​#Newt

I've been trying to spend less time chasing whatever token is trending for a few hours and more time understanding what projects are actually building. That approach has saved me from making a few bad decisions recently, and it's also the reason I ended up reading more about Newton Protocol (NEWT). At first, I honestly thought it was just another project trying to ride the AI narrative because that's been the easiest way to grab attention lately. After spending some time researching it, I realized there's a bit more going on than I expected.
One thing I've noticed in crypto is that every bull market creates a new buzzword. A few years ago it was NFTs, then it became the metaverse, then liquid staking, and now almost everything seems to have AI attached to it. The problem is that many projects stop at the marketing. They talk about artificial intelligence but never explain how it actually helps users. That's why I usually lose interest pretty quickly. Newton Protocol felt different because the focus isn't on replacing traders with AI. The idea is to build an environment where AI agents can safely perform blockchain tasks while following rules that users approve in advance.
That part actually made sense to me. I don't mind automation, but I don't like giving complete control to software that I don't fully understand. I learned that lesson after trying a trading bot a while back. It looked great when the market was moving up, but once volatility increased, the results became much worse than I expected. Since then I've been skeptical whenever I hear words like "automated trading." Newton Protocol seems to recognize that trust is the biggest issue. Instead of asking users to blindly trust an AI, it aims to create a secure system where every action happens within clear limits. I think that's a much smarter direction than simply promising that AI will magically outperform everyone.
Another thing I found interesting is that the project isn't only thinking about traders. The marketplace for AI developers could become one of its biggest strengths if it attracts enough builders. I like the idea that developers can create useful AI agents while users choose the ones that fit their needs instead of everyone trying to build everything from scratch. Crypto has always rewarded open ecosystems, and this feels closer to that model than a closed platform controlled by one company.
What keeps me interested isn't the token price. To be honest, I've reached a point where price alone doesn't excite me anymore. I've watched too many new listings explode during the first few days and then slowly lose momentum as the hype disappeared. Those experiences taught me that attention can create temporary demand, but it can't replace real adoption. If people aren't actually using the product, the excitement eventually fades. That's why I'm paying more attention to whether developers are building on Newton Protocol and whether users find value in those AI tools than whether the chart is green on a particular day.
I also think the timing of this project is worth mentioning. Blockchain is becoming more complicated every year. There are dozens of networks, countless DeFi protocols, bridges, staking options, lending platforms and yield strategies. Even someone who spends hours following crypto news can struggle to keep up with everything. I can easily imagine a future where trusted AI handles repetitive tasks like managing liquidity, rebalancing portfolios or executing predefined trading strategies while the user stays in control. That feels more realistic than expecting AI to predict every market move perfectly.
Of course, none of this means the project is guaranteed to succeed. Crypto has never worked that way. Good technology doesn't always win, and weak projects sometimes survive much longer than anyone expects. Competition in the AI sector is becoming intense, and Newton Protocol will need to prove that its ecosystem can attract both developers and everyday users. Without real activity, even impressive technology can become irrelevant over time.
I'm also paying attention to token economics because that's something I ignored when I first entered crypto. Back then I only looked at charts and social media excitement. Now I spend more time checking supply schedules, future unlocks and whether demand is actually growing alongside circulation. I've learned that those details matter much more over the long run than a single green candle.
What I appreciate most is that Newton Protocol isn't trying to sell the dream that AI will make everyone rich overnight. At least from what I've researched, the project is trying to solve a practical problem. Crypto is becoming increasingly complex, and automation will probably become a normal part of how people interact with blockchains. The challenge isn't building smarter AI. The challenge is building AI that people can actually trust with their digital assets.
I'm not rushing to call NEWT the next big winner because I've been around this market long enough to know how unpredictable it can be. New narratives appear every few months, and investors move quickly from one trend to another. Still, I think Newton Protocol has enough substance to deserve attention beyond the usual social media hype. That's why I've added it to the list of projects I'm following closely instead of simply watching the daily price chart.
Maybe Newton Protocol becomes one of the important pieces connecting AI and blockchain, or maybe another project eventually does it better. Either way, I believe the direction is becoming clearer. The future of crypto probably won't be about doing everything manually. It will be about giving intelligent tools permission to handle routine tasks without giving up security or control. If Newton Protocol can deliver on that vision instead of only talking about it, then I think it has a much better chance of staying relevant long after the current AI hype cycle fades.
#OilPriceFalls #SolanaGains7%InSevenDays
$NEWT #Newt @NewtonProtocol
$LITEB
$NES

I've been digging into Newton Protocol lately, and honestly, what caught my eye wasn't the usual AI hype.
Every week there's a new project claiming artificial intelligence will change finance forever, but after reading through Newton's design, I came away with a different impression. It isn't trying to build the smartest AI.
It's trying to solve a much more practical problem that almost everyone in crypto eventually runs into: how do you let software help you without handing over complete control of your wallet?
That might not sound exciting at first, but it's one of the biggest problems in the space.
As DeFi grows more complex, people are looking for intent-centric architecture instead of manually approving every action themselves. The idea sounds great, but it only works if users stay in control.
Too many projects focus on making AI more powerful while ignoring the risks that come with giving software access to your funds.
If you've spent enough time around blockchain, you already know the routine.
You keep checking prices, moving assets, claiming rewards, approving transactions, and watching markets because you're worried about missing something. These aren't difficult tasks. They're just repetitive. Naturally, people started looking for better ways to automate them, whether it's automated yield farming or DCA loops. The problem is that many existing solutions still ask users to trust software with far more wallet access than they should.
We've all felt that pit in our stomach after clicking "Approve" on a shady dApp, praying our MetaMask doesn't get wiped out.
That's a feeling almost every experienced crypto user understands. Newton is trying to fix this blind-signing problem by letting users lock down exactly what an application or AI agent can do using zkPermissions and Session Keys. Instead of unlimited permissions, you decide the rules first. An agent might be allowed to buy a certain asset every month, move idle funds into a predefined strategy, or spend only within a limit that you have already approved. If those conditions aren't met, nothing happens.
This is probably the biggest reason Newton stood out during my research. It doesn't ask users to blindly trust artificial intelligence. It assumes AI can make mistakes, and then builds limits around it. That's a much healthier approach. In finance, I don't care how intelligent software claims to be. I care whether it stays inside the boundaries I set.
The project also rethinks how wallets themselves should work. Traditional wallets are simple, but they're also rigid. One signature often means complete authority over everything inside. That model made sense years ago, but today's users expect something better. Newton leans toward Account Abstraction (ERC-4337), allowing permissions to become far more granular without giving away ownership of your assets.
Users can define spending limits, approved contracts, timing rules, and other conditions before any AI agent starts working. To me, this feels less like reinventing finance and more like finally bringing common-sense security into crypto. Traditional financial systems have relied on layered permissions for decades. Blockchain is only now beginning to catch up.
Privacy is another area where Newton takes a practical approach. Financial strategies are valuable because they're private. If an AI bot is executing your trading strategy publicly on-chain, MEV bots will front-run your orders and eat your margins. Newton's selective disclosure, powered by TEEs (Trusted Execution Environments), is crucial here to keep your strategy hidden while executing it safely. That's an underrated problem that many people outside active trading don't think about until it costs them money.
I also like that Newton isn't trying to build every application itself. Instead, it wants developers to create specialized AI agents for different financial tasks. Some might focus on portfolio management, while others could handle treasury operations or recurring investment strategies. The interesting part isn't any single application. It's the possibility of building an ecosystem where developers create useful tools on top of shared infrastructure instead of everyone reinventing the wheel.
Of course, there are still questions. Building reliable infrastructure takes time, and good ideas don't automatically lead to widespread adoption. The biggest challenge for Newton probably isn't the technology. It's convincing developers and users that this permission model is worth building around. That's something only real-world usage can prove.
Even so, the project has continued making steady progress. Recent development has focused on improving programmable account architecture, strengthening permission management, and preparing the infrastructure needed for broader AI-driven execution. None of these updates feel flashy, but infrastructure rarely is. The strongest foundations are usually the ones people barely notice until everything else depends on them.
But let's be real—how does the $NEWT token actually capture value here? If transaction costs or ecosystem incentives don't make economic sense, developers could simply build similar infrastructure elsewhere. That's a question Newton will eventually have to answer. Strong technology alone doesn't guarantee that a token becomes valuable over the long term. The tokenomics need to create lasting incentives. While the idea of staking NEWT as operator collateral and slashing bad operators sounds good on paper, Newton still needs to prove that this model creates sustainable value for builders, users, validators, and long-term holders.
After looking at the project from different angles, I don't see Newton Protocol as another AI narrative. I see it as an attempt to fix one of blockchain's weakest points. Smarter software is useful, but smarter permissions are probably even more important. If AI is going to become part of everyday crypto, users need infrastructure that keeps them in control instead of asking for blind trust.
Whether Newton becomes that standard is still an open question, but it's asking the right questions—and sometimes, that's where meaningful infrastructure begins.
@NewtonProtocol #Newt $NEWT

As artificial intelligence and blockchain continue to converge, a new wave of projects is emerging to power autonomous AI agents. Among them, NEWT has attracted attention due to a growing narrative that positions it as the "SOL of AI Agents." While such comparisons are ambitious, they reflect the market's search for the next high-performance infrastructure capable of supporting scalable AI applications. But what exactly does this narrative mean, and does it have merit?
Understanding the "SOL of AI Agents" Comparison
When people refer to a project as the "SOL of AI Agents," they are drawing a parallel to Solana's reputation for high throughput, low transaction costs, and a developer-friendly ecosystem. Solana became one of the most popular blockchain platforms by enabling applications that required speed and efficiency.
Supporters of NEWT argue that it could play a similar role in the AI ecosystem by providing the infrastructure needed for AI agents to communicate, transact, and operate autonomously. Instead of focusing solely on decentralized finance or NFTs, the emphasis is on enabling intelligent software agents to perform real-world tasks efficiently.
Why AI Agents Need Specialized Infrastructure
AI agents are becoming increasingly capable of making decisions, executing workflows, and interacting with digital services without constant human intervention. As these agents evolve, they require infrastructure that can support:
Fast and secure transactions
Identity verification
Data exchange
Cross-platform communication
Scalable computation
Traditional blockchain networks may struggle to meet these requirements at scale. This has created demand for purpose-built ecosystems that prioritize AI-native applications, and this is where projects like $NEWT aim to establish themselves.
What Makes NEWT Stand Out?
Although the project is still developing its ecosystem, several factors contribute to the growing interest around $NEWT :
AI-First Vision
Rather than treating AI as an additional feature, NEWT appears to focus on building infrastructure specifically designed for autonomous AI systems. This aligns with one of the fastest-growing sectors in Web3.
Scalability Potential
For AI agents to operate continuously, networks must process a large number of interactions with minimal latency. Investors following the project believe $NEWT is targeting this challenge through efficient architecture and optimized performance.
Growing Community Narrative
In crypto markets, narratives often drive early adoption. The phrase "SOL of AI Agents" has gained traction because it provides investors with an easy framework for understanding the project's potential positioning within the broader AI ecosystem.
Opportunities and Risks
Like every emerging crypto project, NEWT presents both opportunities and uncertainties.
Potential opportunities include:
Exposure to the expanding AI blockchain sector.
Early participation in a developing ecosystem.
Increasing demand for AI-native infrastructure.
However, investors should also consider the risks:
The technology is still evolving.
Competition among AI blockchain projects is intense.
Market narratives do not always translate into long-term adoption.
Execution and developer adoption remain critical factors.
Can NEWT Live Up to the Narrative?
Whether NEWT ultimately becomes the "SOL of AI Agents" depends on far more than marketing. The project must demonstrate reliable technology, attract developers, build a thriving ecosystem, and support real-world AI applications. Strong infrastructure, active community engagement, and meaningful partnerships will all play essential roles in determining its future.
Crypto history has shown that compelling narratives can create momentum, but sustainable success is driven by consistent development and genuine utility.
Conclusion
The idea of NEWT becoming the "SOL of AI Agents" is an exciting narrative that reflects the growing intersection of artificial intelligence and blockchain technology. While the comparison highlights the project's ambitions to become foundational infrastructure for AI-powered applications, it remains an early-stage thesis rather than an established reality.
Investors and enthusiasts should view the narrative with balanced optimism—recognizing both the significant potential of AI-driven blockchain ecosystems and the execution challenges that every emerging project must overcome. If $NEWT successfully delivers on its vision, it could become an important player in the next generation of decentralized AI infrastructure.
#newt @NewtonProtocol

想象一个场景：你管理的资产分布在 Arbitrum、Optimism、Polygon 和 Base 四条链上，每发起一笔转账都需要做制裁筛查、KYC 核验和资金来源评估。传统做法是什么？在每一条链上分别部署一套合规逻辑，分别维护数据源的接入协议，分别生成独立的审计记录，分别应对不同链上合约语言的差异。这个成本不是翻倍，是按链的数量指数增长，而且随着多链生态的持续扩展，它只会更重。
我关注这个问题很久了，但这个痛点在整个行业讨论里严重被低估，因为大多数人把注意力放在了「跨链资产移动」上，而不是「跨链合规执行」上。前者有桥接协议，有 LayerZero，有各种互操作性基础设施在卷；后者基本还是空白——机构要么在每条链上各自建一遍，要么干脆只玩一条链，不跨链。
Newton 的跨链架构从设计层面直接对准了这个问题。它的运营商网络在以太坊主链上注册、质押和管理，这套注册状态通过 BLS 签名的 Merkle 根同步到所有目标链，目标链上的验证合约只需核对这个聚合签名就能确认运营商集合的有效性，整个过程不需要中心化桥接，也不需要在每条目标链上重新建立信任锚点。一套策略写好，在所有 Newton 支持的链上通用，合规凭证也统一格式落链，监管审计不需要同时访问四个不同的链上系统。
这个架构的意义我认为需要放在更大的背景里才能看清楚。GENIUS Act 在去年七月落地，香港稳定币条例八月生效，欧洲 MiCA 的执行要求也在持续细化，这些框架有一个共同指向：监管机构要求的不是事后的合规记录，而是交易执行层面的可验证控制。机构如果要进入 DeFi，需要能向监管机构证明每一笔链上交易在发生之前都经过了符合要求的策略审查，且这个证明本身是密码学级别的，不依赖任何中间人出具证明文件。Newton 的跨链统一授权层，正好踩在这个需求的交叉点上。
当然我也不会把这件事想得过于简单。不同司法管辖区对「合规充分性」的认定标准目前还没有统一，机构要在多链环境下真正落地这套体系，除了技术对接，还需要法律团队逐个司法区评估链上凭证的法律效力。这块不会是短期内解决的问题，但技术架构先于监管认可跑通，在这个赛道里几乎是标配路径。
我目前最关注的，是 Newton 在真实机构客户层面的落地速度。基础设施层的叙事需要真实用量来支撑，等第一批机构把这套体系跑通并公开披露之后，我对它的判断会更有底气。
你们觉得链上合规的「监管认可」这道坎，大概还需要多久才能跨过去？
@NewtonProtocol $NEWT #Newt #newt

Me and three friends had a small bet running last weekend on where BTC would close Sunday night. Nothing big, just bragging rights and a round of chai on the loser. When the moment came to actually check, we all pulled out our phones at once. Mine showed one number, my friend's Binance app was a few dollars off because his had lagged for a second, and a third guy was looking at a completely different exchange. We spent almost ten minutes arguing about whose number counted before somebody just said screw it, we'll all refresh together and use that one.
That memory came right back to me reading Newton's Prepare/Evaluate section this week.
My first assumption was the obvious one, more operators independently checking a sanctions list or a price feed sounds like extra safety, more eyes catching more problems. Turns out that's only half the story, and the part I missed is actually the harder engineering problem. If every operator fetches live data on its own, through its own network path, at its own moment, they will almost never get the exact same number back. Prices tick constantly. A feed updates mid request. That's just what independent fetching looks like in practice, my little bet proved that with four phones in the same room.
Here's where it gets serious though. Newton's attestations rely on BLS signature aggregation, and that only works if every signer is signing the literal same message. Not a similar message, not a close enough number, the identical bytes. So if five operators each evaluated a policy against their own slightly different price or sanctions snapshot, you'd get five different results and five signatures that can never combine into one valid attestation. The whole system would just stall out.
Once that clicked, the two phase split stopped looking like extra complexity and started looking like the only way this could actually work.
Prepare phase is where the independence happens. Every operator runs its own sandboxed data fetch, on its own path, no one waiting on the slowest node, streaming answers back as they finish. Then the Gateway takes all those independent numbers and runs a median across them, producing one canonical dataset. Evaluate phase is where agreement happens. That single canonical dataset goes back out, operators pull the actual Rego policy off IPFS by its content hash so they're all running the exact same rule file, evaluate against the exact same data, and only then sign. Same policy plus same data equals identical digest, and that's what makes the signatures aggregate cleanly. The aggregator doesn't even wait for everyone, it stops the moment enough stake weighted operators clear quorum.
Small detail I liked, not every transaction needs the full two step dance. If the policy data is already fixed or cached, Newton skips straight to evaluation in one round trip instead of two.
Where I'm still a bit stuck is who I'd trust to compute that median honestly. The Gateway is the one producing the canonical number in between the two phases, and the paper is clear the Gateway can't forge a signature or alter a result without operators catching it, since each one already attested to what it personally observed in the Prepare phase. What I couldn't find spelled out is whether operators actually cross check that median against those original attestations before signing in Evaluate, or whether they just trust what gets republished to them. Maybe that's in the technical whitepaper and I just haven't gone through it properly yet.
The real test for NEWT isn't whether the two phase design works on a whiteboard, it's whether that median step stays honest and fast enough once the data being fetched moves in milliseconds, not something you can settle with a chai bet and a reload.
Anyone else had a group argument over whose app had the "real" price before settling something? Curious how you all ended up picking one number.
@NewtonProtocol #Newt $NEWT
$SYN
$LAB