Ruoxi 若曦

@NewtonProtocol I’ll Be Honest… The first time I joined an onchain campaign, I thought every wallet represented a real person. It didn’t take long to realize how wrong I was. One user could create dozens of wallets, bots could flood reward programs in minutes, and communities had no reliable way to separate genuine contributors from disposable accounts.
Honestly, that’s one of the biggest problems Web3 still hasn’t fully solved.
We often celebrate decentralization, but decentralization without trust creates its own challenges. AI agents are becoming more capable, DeFi is becoming more automated, and blockchain applications are handling more value than ever. Yet many protocols still struggle with one simple question: Who should be allowed to interact before a transaction happens?
While reading through the Newton Protocol whitepaper and developer documentation, I came across its integration with Neynar, and I think it addresses this problem in a surprisingly practical way. Instead of building another identity platform, Newton introduces a Farcaster Data Oracle that allows applications to verify reputation and identity signals through programmable policies before any onchain action is executed.
That idea immediately made sense to me.
Newton Protocol isn’t trying to replace Ethereum or compete with existing blockchains. Its goal is different. It’s a decentralized policy engine designed to authorize onchain transactions using real-world context that smart contracts normally can’t access. According to the protocol documentation, developers can define, verify, and enforce policies for AI agents, DeFi protocols, RWAs, stablecoins, and automated applications without relying on centralized backend checks.
What makes the Neynar integration interesting is that it brings Farcaster reputation directly into those policies.
If you’ve spent time around Farcaster, you’ve probably heard of Neynar. It’s one of the core developer infrastructure providers for the ecosystem, offering APIs that expose verified wallet addresses, user profiles, reputation scores, follower counts, account badges, social graphs, and authenticated identity information. Much of the Farcaster ecosystem already relies on its infrastructure.
Newton turns those social signals into programmable decision-making.
Imagine building an airdrop today.
Normally, projects check whether a wallet exists or whether it meets a few simple requirements.
With Newton’s Neynar Data Oracle, developers can instead create policies that require a minimum Farcaster reputation score, verified external wallet addresses, and a healthy follower count before rewards are distributed.
If the policy isn’t satisfied, the transaction simply doesn’t execute.
I think that’s much cleaner than embedding every verification rule inside smart contracts.
One detail I genuinely appreciated is that the logic doesn’t live inside the contracts themselves.
It lives inside Newton’s policy layer.
That means developers can adjust reputation thresholds, update participation rules, or introduce new requirements without redeploying contracts or rewriting application logic. Crypto moves incredibly fast, and having flexible policy management feels much more practical than constantly modifying contract code.
From what I’ve seen, the real value goes beyond Farcaster.
The same policy framework can help protect AI agents from interacting with suspicious wallets, reduce Sybil attacks in DeFi incentive programs, improve DAO governance participation, and create more reliable reward systems.
Instead of cleaning up abuse after funds have already moved, applications gain the ability to stop risky interactions before they happen.
That feels like a meaningful shift.
Another reason I like Newton’s design is that Neynar isn’t treated as the only source of truth.
Developers can combine Farcaster identity with other Newton Data Oracles depending on their needs. Identity verification from Veriff or Persona, gas fee information from Etherscan, treasury and market signals from Massive or Vaults.fyi, and wallet authentication through Magic Labs can all become part of the same programmable policy. Rather than relying on one reputation score, trust becomes the result of multiple independent signals working together.
To me, that’s a much healthier model for decentralized infrastructure.
Real trust rarely comes from one metric.
It usually comes from several pieces of evidence pointing in the same direction.
Of course, I don’t think this completely solves digital identity.
Not every legitimate crypto user has a Farcaster account. Reputation systems evolve, social metrics can sometimes be manipulated, and follower counts don’t always reflect genuine participation. If developers depended only on Farcaster reputation, they could accidentally exclude real users.
Fortunately, Newton’s architecture doesn’t require that.
The protocol encourages developers to combine multiple data sources, allowing each application to define trust differently depending on its purpose. That flexibility is probably one of its biggest strengths.
After spending time researching this integration, I don’t really see it as a social media feature anymore.
I see it as infrastructure.
As AI agents become more autonomous and blockchain applications continue automating financial decisions, programmable trust may become just as important as scalability, low fees, or transaction speed.
Fast blockchains are impressive.
Smart contracts changed finance.
But giving developers a decentralized way to decide who should interact before value moves onchain might end up being one of the most useful building blocks Web3 creates over the next few years.
#Newt $NEWT
$AA
$T

@NewtonProtocol For a long time, I thought stablecoins were just the “boring” side of crypto. They don’t pump 100% overnight, they rarely dominate headlines, and most people only mention them when markets get shaky.
Then I started paying closer attention to how money actually moves on-chain.
That’s when I realized something interesting. The real innovation isn’t the stablecoin itself anymore. It’s everything that happens before a payment is approved, while it’s moving, and after it settles.
And that’s exactly where Newton Protocol caught my attention.
From what I’ve seen, crypto has already solved one huge problem: moving value anywhere in the world within minutes. Billions of dollars flow through stablecoins every day. Yet if you ask a bank, a payment company, or even a regulated business to use those rails, they’ll usually point to the same concern.
“What happens if the payment breaks compliance rules?”
That’s the missing piece.
Newton Protocol isn’t trying to build another stablecoin. It isn’t competing with payment networks either. Instead, it’s building what feels like an authorization layer for blockchain payments—a decentralized policy engine that checks whether a transaction should be allowed before it reaches the blockchain. Rather than relying on manual reviews or centralized approval systems, policies are evaluated by decentralized operators, cryptographically verified, and enforced directly during transaction execution.
I actually think this approach is smarter than chasing another payment token.
Stablecoins already work.
What’s missing is trust at scale.
Imagine a company paying salaries in USDC across several countries. Every payment may need sanctions screening, identity verification, jurisdiction checks, spending limits, or internal business rules. Today those checks often happen outside the blockchain, creating extra friction and new points of failure.
Newton moves those rules closer to the transaction itself.
That’s a subtle change, but a meaningful one.
The project describes this as programmable compliance. Policies can combine on-chain and off-chain information, while a decentralized network running Trusted Execution Environments evaluates those rules and produces proofs that anyone can verify. The idea is to keep compliance transparent without sacrificing decentralization.
Honestly, I think AI makes this even more relevant.
Everyone talks about AI agents trading, investing, or paying for services automatically. That sounds exciting until you ask one simple question.
Who makes sure the AI doesn’t send money somewhere it shouldn’t?
Without guardrails, autonomous finance becomes risky very quickly.
Newton is designed with that future in mind. Instead of simply allowing AI agents to execute transactions, it lets developers define spending limits, approved counterparties, jurisdiction restrictions, and other programmable rules before those transactions ever happen. That feels much more practical than simply giving an AI wallet unlimited freedom.
What I also appreciate is that Newton isn’t asking DeFi to abandon decentralization.
Many institutional solutions end up creating permissioned ecosystems that isolate liquidity from the broader crypto market. Newton tries a different path by making policies composable with existing smart contracts, stablecoins, DeFi vaults, RWAs, and cross-chain applications instead of forcing everyone into closed systems.
That’s important because infrastructure rarely gets attention until it disappears.
People notice wallets.
People notice exchanges.
People notice token prices.
Very few notice the invisible systems deciding whether trillions of dollars can move safely.
Infrastructure isn’t exciting until it becomes essential.
The NEWT token also fits naturally into that infrastructure story. It isn’t presented as another speculative asset with endless promises. Its utility revolves around paying for policy computation, rewarding network operators, supporting delegated staking, and participating in governance as the protocol evolves.
That said, I don’t think Newton solves every problem overnight.
Regulation changes constantly, and compliance requirements differ from one country to another. Convincing financial institutions, DeFi protocols, and developers to adopt a shared policy layer won’t happen instantly. The technology can be elegant, but adoption is still the hardest challenge for almost every Web3 infrastructure project.
There’s also the balancing act between privacy and transparency. Users want decentralized finance to stay open, while institutions need stronger guarantees around risk management. Finding that middle ground won’t always be easy.
Still, this feels like the kind of project that becomes more valuable as the blockchain industry matures.
For years we’ve focused on making payments faster.
Now the conversation is shifting toward making payments trustworthy, programmable, and suitable for both humans and AI.
Personally, I think that’s where the next wave of blockchain infrastructure will be built.
Stablecoins may carry the value, but protocols like Newton could quietly decide how that value moves, who can move it, and whether every transaction follows the rules without sacrificing the openness that made crypto worth building in the first place.
#Newt $NEWT
$BEE
$SXT

@NewtonProtocol I’ll Be Honest… A few months ago, if someone had asked me what was missing from blockchain infrastructure, I probably would’ve talked about faster transactions, cheaper gas fees, or better scalability. Those are obvious answers. But after spending time reading through Newton Protocol’s whitepaper and developer documentation, I realized there’s another problem that doesn’t get enough attention.
Blockchains are incredibly good at executing transactions.
They’re not very good at deciding whether those transactions should happen in the first place.
That difference sounds small, but I honestly think it’s becoming one of the biggest challenges for Web3 as AI agents, DeFi automation, tokenized real-world assets, and institutional capital continue moving on-chain.
Newton Protocol approaches this from a completely different angle.
Instead of creating another blockchain or another DeFi protocol, Newton acts as a decentralized policy engine built on EigenLayer AVS. Rather than asking, “Can this transaction execute?” it asks, “Does this transaction satisfy the rules before execution?”
The more I thought about it, the more it reminded me of how card payments work.
When you swipe your card, money doesn’t instantly move. Networks like Visa first check fraud rules, spending limits, and authorization before settlement happens.
Newton brings that same authorization mindset to blockchain.
Except instead of trusting one company, the decision is verified by a decentralized operator network using cryptographic proofs.
Everything starts with something called a Policy.
Despite the technical name, it’s simply a collection of rules written by developers. Those rules might define daily spending limits, wallet allowlists, jurisdiction restrictions, KYC requirements, or risk controls for an AI trading strategy. Newton stores these reusable policies on IPFS, while allowing them to reference configurable parameters and trusted external data when needed.
When a user wants to perform an action, Newton creates what’s known as an Intent.
I like thinking of it as a draft transaction.
It contains the sender, receiver, amount, calldata, target chain, and function being called. Nothing mysterious—just all the information describing what someone wants the blockchain to do.
That intent is then paired with its policy to create a Task.
This task becomes the basic unit Newton evaluates.
Here’s where things become interesting.
The task doesn’t go straight to the blockchain.
Instead, it’s submitted through the Newton Gateway, where decentralized AVS operators independently evaluate whether the proposed transaction satisfies every policy rule. If those rules depend on outside information—like market prices, sanctions lists, proof of reserves, or KYC status—Newton can fetch that data through PolicyData WASM oracles before making a decision.
Every operator performs the evaluation separately.
Once enough operators agree, their BLS signatures are aggregated into a single Attestation.
That attestation isn’t just another approval message.
It’s cryptographic proof that decentralized validators reached consensus on the policy outcome. It includes information like the task ID, policy ID, evaluation result, and expiration block, giving smart contracts something they can verify instead of simply trusting.
The final piece is the PolicyClient.
This is the contract developers integrate into their applications.
Before executing a sensitive function, the contract validates Newton’s attestation using either the standard verification method—which automatically resolves configuration but costs a bit more gas—or a direct validation method that saves gas while requiring developers to manage policy references themselves.
What I appreciate is how logical the entire evaluation lifecycle feels.
Developers publish a reusable policy.
A PolicyClient is configured with thresholds or parameters.
A user submits an intent.
Operators evaluate the task.
Consensus is reached.
A cryptographic attestation is returned.
The smart contract verifies that proof before allowing execution.
Each step has a clear purpose instead of adding complexity for the sake of sounding innovative.
From my perspective, this becomes much more valuable once AI enters the picture.
AI agents are getting better at making decisions, managing portfolios, and interacting directly with smart contracts.
But intelligence without guardrails can become expensive very quickly.
Giving autonomous systems programmable policies that every transaction must satisfy feels like a practical layer of protection rather than another buzzword.
The same applies to DeFi.
Imagine automated vaults that won’t exceed predefined risk limits.
Stablecoins that automatically enforce jurisdictional rules.
Institutional funds that can participate in decentralized finance while still following compliance requirements.
Those ideas stop feeling theoretical when policy enforcement becomes part of transaction execution itself instead of relying on centralized dashboards or frontend restrictions.
That said, I don’t think Newton solves everything.
Policies are only as effective as the people writing them. A poorly designed rule could accidentally reject legitimate users or create unnecessary friction. External data sources also introduce another dependency, even if Newton’s decentralized consensus is designed to reduce trust assumptions. Long-term adoption will depend not only on the technology but also on how reliable developers, operators, and policy libraries become over time.
Still, after digging into Newton’s architecture, I came away with one simple thought.
Maybe the future of blockchain isn’t just about executing transactions faster.
Maybe it’s about proving that every important transaction was authorized for the right reasons before it ever reached the chain. And if AI, DeFi, and institutional finance keep growing the way they are, that kind of programmable trust could become just as important as the blockchain itself.
#Newt $NEWT
$B
$MMT

@NewtonProtocol I’ll Be Honest… A few years ago, if someone told me that a simple Twitter/X follower count could become a cryptographically verified input for a blockchain policy, I’d probably have laughed. Social media numbers felt too easy to fake—screenshots, edited profiles, purchased followers, you name it. But after digging into Newton Protocol’s zkTLS Twitter example, I realized the interesting part isn’t the follower count itself. It’s the way the data gets verified before it ever reaches a smart contract.
That changed how I think about Web3 infrastructure.
Newton Protocol isn’t trying to turn every website into a blockchain. From what I’ve seen in the whitepaper and developer documentation, it’s solving a different problem. Smart contracts are deterministic, but the real world isn’t. Contracts can’t naturally verify whether someone passed KYC, owns a verified social account, or satisfies an off-chain condition. Newton acts as a decentralized authorization layer that evaluates trusted external data before an on-chain action is approved.
The zkTLS Twitter/X example is a surprisingly practical demonstration of this idea.
Instead of trusting a screenshot or a centralized API response, the user opens a browser integrated with a TLSNotary-compatible extension. During the HTTPS session with a TLSNotary proof is generated. What’s clever here is that the proof doesn’t simply say, “Trust me, I have 10,000 followers.” It proves that the response genuinely came from Twitter’s servers while allowing selective disclosure of only the information the policy actually needs. That’s one of the biggest strengths of zkTLS—verifiable data without exposing everything else.
I actually think this is where blockchain starts becoming useful beyond token transfers.
The flow itself is pretty straightforward once you understand the moving parts.
The browser communicates with the TLSNotary extension, which creates an attester session through Newton’s zkTLS sidecar. After retrieving the follower count from Twitter/X, a cryptographic proof is generated instead of a screenshot. That proof is stored, producing a Content Identifier (CID), and Newton receives a task containing the proofCid, policy-specific wasmArgs, and a transaction intent.
The decentralized operator network can then evaluate whether the account satisfies the configured follower threshold before returning the authorization result.
No guessing.
No manual verification.
No trusting whoever submitted the claim.
One implementation detail I genuinely appreciate is the proof integrity verification.
Before accepting any proof, the SDK retrieves the proof bytes using the CID and independently recalculates the multihash. If the bytes don’t reproduce the exact CID, the request fails immediately. The client also performs this verification immediately after storing the proof, ensuring the gateway didn’t substitute different content behind the same reference. Only SHA2-256 multihashes are accepted, reducing ambiguity and preventing unsupported hashing algorithms from entering the workflow.
Honestly, this sounds like a small engineering detail, but it’s exactly these boring safeguards that usually separate production infrastructure from flashy demos.
Another thing I found interesting is that Newton deliberately keeps the proof storage interface stable even though the backend is expected to migrate from IPFS-backed storage toward gateway-managed PostgreSQL persistence. Developers continue interacting with the same store() and retrieve() APIs while the infrastructure evolves underneath.
That’s good protocol design.
Applications don’t need to be rewritten every time backend architecture changes.
The future roadmap also hints at something much bigger than follower verification.
Newton plans to bind zkTLS proofs with encrypted identity records. Instead of submitting only a proof CID, developers could attach encrypted identity references, allowing policies to simultaneously validate proof freshness, identity domains, jurisdiction, and even chain-specific requirements before authorizing execution.
Imagine combining verified identity, jurisdiction rules, sanctions screening, and web proofs into one authorization decision.
That’s no longer just an oracle.
That’s programmable trust.
And AI agents immediately come to mind.
Everyone talks about autonomous AI managing wallets or executing DeFi strategies, but very few discuss authorization. AI making decisions is exciting until it accidentally signs something it shouldn’t.
Newton’s policy engine feels like a guardrail.
Instead of blindly allowing every transaction, policies can ask questions first.
Does this wallet belong to a verified identity?
Does the submitted proof still meet freshness requirements?
Does this action exceed spending limits?
Does this transaction satisfy compliance policies?
Only after every condition passes does the transaction move forward.
For DeFi, that could mean automated vaults enforcing real-world constraints instead of relying entirely on frontend interfaces.
For stablecoins, payment networks, or tokenized assets, it introduces something that traditional finance has relied on for decades—authorization before settlement.
I also like that Newton doesn’t force developers into a single use case.
The Twitter example happens to verify follower counts, but the underlying pattern works almost anywhere trusted web data exists.
Subscription status.
Bank confirmations.
Employment verification.
Age checks.
Identity attributes.
Any HTTPS response that can be proven through zkTLS could theoretically become policy input.
That’s much broader than social verification.
That said, I don’t think this solves every trust problem overnight.
zkTLS still depends on trusted notaries participating in the verification process. The cryptography is powerful, but users still place trust in the verifier infrastructure rather than magically eliminating trust altogether. That’s an important distinction that sometimes gets lost in crypto conversations. Even the TLSNotary team emphasizes that zkTLS is publicly verifiable only within the designated verifier trust model, not completely trustless in the way many people imagine.
And, of course, there’s the practical side.
Running browser extensions, sidecars, gateways, deployed policy clients, API keys, and operator infrastructure isn’t exactly beginner-friendly today.
The developer experience is improving, but I wouldn’t call it plug-and-play yet.
Still, that’s normal.
Most foundational infrastructure starts out looking complicated before becoming invisible.
Looking at Newton Protocol as a whole, I don’t think the real innovation is proving someone’s Twitter followers.
The interesting part is creating a decentralized authorization layer where verifiable web data, AI decision-making, identity systems, and blockchain execution finally speak the same language.
If that vision keeps maturing, we may eventually stop asking whether blockchain can trust off-chain information.
Instead, we’ll start asking what new applications become possible once it can.
#Newt $NEWT
$TAC
$US