AERI 艾瑞

I used to think blockchain’s biggest challenge was making transactions faster. But the deeper I looked the more I noticed a bigger problem hiding underneath: we have built systems that can move billi0ns of dollars, yet we are still improving the way those systems decide what should be allowed to happen.
That is where @NewtonProtocol caught my attention.
The next phase of Web3 may not be won by the fastest execution layer, but by the smartest authorization layer. As AI agents, automated trading systems, and institutional workflows become more autonomous, the question changes from “Can this transaction happen?” to “Should this transaction happen under these conditions?”
This is the gap Newton is exploring.
Instead of treating compliance and permissions as something added after development, the idea is to make policies programmable before execution. That creates a different security mindset one focused on preventing mistakes rather than explaining them afterward.
What makes this approach interesting is not simply audits or security claims. The real test is whether a system can identify risks before attackers discover them. Prevention is always harder than reaction because defenders must consider countless possibilities while attackers 0nly need one weakness.
Another overlooked opportunity is policy privacy. Institutions do not just protect assets they protect years of accumulated knowledge inside their risk models, approval systems and operational rules. If those rules can be verified without exposing their sensitive logic, authorization itself could become valuable infrastructure.
The future of $NEWT will depend on real adoption: recurring usage, meaningful policies, active developers, and institutions finding measurable value. Narratives attract attention, but sustainable networks are built through repeated demand.
As blockchain moves toward autonomous decision making, trust cannot remain an assumption. It has to become something programmable, verifiable and enforceable before value ever moves.
That may be the real opportunity behind Newton Protocol.
#Newt

got denied a small loan a while back and never received a real explanation for it. Just a number a form letter and a vague line about "insufficient credit history." No specific factor I could actually fix, no way to know which part of my financial life had actually been the problem. I paid down some debt, waited a year and reapplied somewhere else, mostly hoping for a different result rather than actually understanding what had changed.
That's basically how lending works for most people. I think a lot of us have just made peace with it being a black box.
Newton Protocol's approach to credit underwriting caught my attention mainly because it doesn't try to make that black box smarter. It tries to make what feeds into it checkable.
Breaking One Score Into Several Provable Pieces
Here's the actual mechanism. Rather than a lender leaning on one centralized bureau's internal model, Newton's policy engine can evaluate several separate credentials directly credit history, income verification, collateral value each one a distinct, independently signed claim. The output is what the whitepaper calls a credit band and that band is what determines the actual terms a borrower gets offered.
Some of these credentials can lean on selective disclosure specifically. A borrower could prove their income clears a required threshold without ever revealing the exact number using a zeroknowledge proof tied to that specific financial credential. The lender learns exactly what it needs to know this person qualifies without learning anything else about their finances beyond that one line.
That's a genuinely different shape than a single opaque score. Instead of trusting one model's entire output at once, you're looking at several individually checkable pieces: this income credential is signed and valid, this collateral value is attested, this repayment history holds up. Only after each piece checks out does a policy combine them into a band.
Real, But Real Isn't the Same as Fair
Here's where I think it gets genuinely interesting, and also genuinely unresolved.
Whatever function actually converts those verified credentials into a specific band is still a design decision someone made when they wrote that policy. What income counts for how much. What collateral gets weighted at what rate. Newton's architecture can guarantee every input feeding that formula is authentic. It has no way to guarantee the formula itself was built fairly, or that it doesn't quietly underserve some kind of borrower nobody designing it happened to think about.
Traditional lending has already lived through a version of this exact problem. A mortgage underwriter combining a pay stub, a property appraisal and a credit report isn't lying about any of those three documents being real. Lending history still shows scoring models built around one kind of borrower's financial life systematically underserving people whose situation didn't fit that same shape, even while every document in the file was completely genuine. Real inputs and a fair outcome have never automatically been the same thing.
Picture a Newton based lending policy built mostly around onchain collateral and wallet history. A borrower whose actual financial position is genuinely strong but who simply doesn't hold much onchain history yet, could receive an accurate, fully verifiable, and still unfair band not because anything was faked but because the formula was never built with someone like them in mind.
Let's Be Honest About What This Doesn't Fix
None of this works unless a lender actually chooses to expose that level of detail. Newton can make each piece of a credit decision individually auditable. Nothing forces anyone using it to actually let a borrower see which credential dragged their band down. A lender could run this entire system underneath the hood and still hand back the same vague form letter I got, just with better cryptography quietly holding it up.
I keep coming back to this distinction because it isn't unique to lending. It's close to the same shape running through almost everything Newton is built to do. Verified means the inputs were real and the policy ran exactly the way it was written to run. It doesn't mean the policy itself was the right one to write, or that anyone using it chooses to show their work.
So here's what I keep sitting with. Would a transparent, individually verifiable credit band you still can't argue with actually feel better than an opaque score you also can't argue with? Or does transparency only start to matter once it comes with an actual way to push back on what it shows?
@NewtonProtocol $NEWT
#Newt

The Identity That's Supposed to Follow You
I re uploaded my passport photo for the fourth time this year last week, for an app that had nothing to do with the other three. Same document, same selfie held next to my face, same two-day wait before I could actually do anything. At some point identity verification stopped feeling like security and started feeling like a toll booth every app gets to build on its own stretch of road.
Newton Protocol's identity system is built around removing exactly that toll booth. Once I got past the pitch and into the actual mechanics, it turned out to be worth walking through slowly.
Who Actually Vouches for You
Newton runs identity on three roles. Issuers a KYC provider, a government agency, a financial institution, even an onchain analyzer attest to something about a user and sign that attestation. Holders, meaning users themselves, store those signed credentials in their own wallet and decide when to show them. Verifiers check the signature is real and feed a simple yes or no result into whatever policy is running, without necessarily seeing the underlying data itself.
Seven categories of credential exist under this model identity documents, sanctions and watchlist status, financial data, onchain behavior, jurisdiction, accreditation and travel rule attribution. On Mainnet Beta right now, this is exactly what gates access to a Vault: an accreditation credential and a KYC credential, checked before an investor is even allowed in not after.
Here's the part worth sitting with. What gets verified cryptographically is that a credential is authentic and properly signed by whoever issued it. What doesn't get re checked at the moment of verification is whether the underlying claim was actually true when that issuer first signed it. A real signature on a wrong fact is still a real signature.
Proving Just Enough
Some of these credentials support selective disclosure. A person can prove they're over 18 without revealing their birthdate or prove their balance clears a threshold without showing the actual number. The proof answers one narrow question and nothing else.
That's a genuine privacy upgrade over handing over a full document every time. It also has a boundary worth naming. Selective disclosure protects what gets shown at the moment of proof. It says nothing about how well the full underlying credential is protected everywhere else it's stored, the whole time it isn't being selectively shown.
The Credential You Didn't Ask an Issuer For
One category in that list of seven is easy to skip past: onchain behavior. Transaction history, protocol interactions, wallet age verified not by a document but by analyzing the chain itself, then attested to.
This is a different kind of credential than the other six. A KYC document gets issued once, by one party, at one point in time. An onchain-behavior credential is built continuously from a public record that never goes away. A wallet's history becomes evidence about that wallet, indefinitely, in a way a driver's license never quite works you can't really appeal an old transaction the way you can request a corrected document. Whatever a wallet did early on stays part of what it can be judged on later, whether or not it's still relevant.
Carrying It With You, Sometimes
The whole system is designed so a credential travels. Verify once for one application, and that same credential can be presented to another without repeating the process. It's meant to move across chains too and it can refresh without a full re verification, as long as the issuer that originally signed it supports refreshing it that way.
That last clause is the entire hinge. Portability isn't a property of the credential sitting in a user's wallet alone. It depends on a choice made upstream by whoever verified that person first. Two people holding what looks like the same kind of credential could have very different experiences the next time they try to use it, based entirely on decisions neither of them made.
Two Different Things Called Verification
Four mechanisms, one line running through all of them. Newton is genuinely rigorous about one specific question: is this credential real, properly signed and not expired. The cryptography behind that question is tight a forged or tampered credential doesn't pass.
What sits just outside that question is a different one entirely: was the underlying claim fair, current, and correctly issued in the first place. That second question depends on the issuer not on Newton's math and no amount of signature verification reaches back to check it.
That's not a weakness specific to this system. It's the same split every identity system eventually runs into, whether it's a passport office or a blockchain. Newton's contribution is making the first question is this real something you can verify instantly, cryptographically and reuse everywhere instead of proving from scratch every time.
Collecting points for a piece about identity infrastructure without asking what's actually sitting behind the word "verified" misses most of what's worth understanding here.
Would you rather prove who you are once and carry that proof everywhere it's accepted, or keep control by proving it fresh every single time, even when it means uploading the same passport photo for the fifth time this year?
@NewtonProtocol $NEWT #Newt