Hieu_30

I watched someone click through four consecutive warning screens to approve a transaction last month, not because they didn't see them, but because they'd learned that most warnings are noise. Two were legitimate risk flags. Two were standard boilerplate that fires on nearly every transaction. From the outside, all four looked identical, red text, a button, a decision made in under a second.
That's the actual failure mode in warn-and-let-through security design, and it's not a UX polish problem. It's structural. A warning only stops someone who was already leaning toward stopping. Everyone else learns, transaction by transaction, that clicking through is what you do, and the warning stops functioning as a warning somewhere around the tenth time it fires on something harmless.
I used to think the fix was better warnings, clearer language, fewer false positives, more precise risk signals. Better warnings help, but they don't solve the actual mechanism of the failure. Even a perfectly calibrated warning still depends on a human reading it correctly and choosing right, every single time, under time pressure, often on a device optimized for speed over deliberation. That's a lot of weight to put on one moment of attention.
Hard-blocking removes that dependency at the specific moments where the cost of a wrong choice is high enough to justify it. Newton's policy checks resolve to a binary, the transaction settles because it satisfied the policy, or it doesn't, not a warning a user can dismiss. There's no click-through path around a failed policy check the way there's a click-through path around a phishing banner.
I don't think that makes hard-blocking the right default everywhere. Plenty of legitimate transactions look risky by some reasonable metric, and a system that blocks too aggressively just pushes users toward workarounds or abandons the product entirely. The judgment call isn't warn versus block in the abstract. It's which specific decisions are important enough, and clear-cut enough, to take the choice out of a rushed user's hands entirely, versus which ones genuinely need a human's context to resolve correctly.
That's actually a harder design question than it sounds, because it means admitting that user autonomy and user protection aren't always the same goal, and sometimes optimizing for one costs you the other. A warning preserves autonomy and mostly fails at protection once fatigue sets in. A hard block guarantees protection on that specific check and costs some autonomy on every transaction it touches, including the legitimate ones.
I don't think there's a clean universal answer to which side to pick. What I do think is that most of the industry has defaulted to warnings, not because warnings are the better tradeoff, but because they're the easier one to ship, and the phishing banner nobody reads anymore is the visible cost of that default.
So the question worth sitting with for anyone designing this: is the goal to inform the user, or to actually stop the bad outcome, because after enough repetitions, a warning stops being able to do both.
$NEWT #Newt @NewtonProtocol

A friend building a payments product got a wallet flagged by a risk-scoring API last year, blocked from an onboarding flow with a score of 87 out of 100 and nothing else. No explanation, no list of signals, no way to appeal beyond emailing support and waiting. The wallet turned out to belong to someone who'd simply interacted with a since-delisted DeFi protocol years earlier, unrelated to anything the person was actually doing.
That story stuck with me because the score wasn't wrong exactly. It just wasn't checkable. My friend's team had no way to see what triggered it, no way to know if the model was outdated, no way to distinguish a real risk signal from stale noise carried forward by an algorithm nobody could inspect.
Risk scoring as a category has this problem built in. A number between 0 and 100 carries real authority, enough to block a transaction, freeze an account, deny an onboarding, and almost none of that authority comes with a visible reason attached. That's tolerable when the score matches what you'd already suspect. It's a real cost the one time it doesn't, because there's nothing to contest except the number itself.
Magic Labs' risk scoring, now integrated into Newton policies, draws on seven years of transaction data across more than 50 million wallets, combined with OFAC sanctions data and public datasets. That's a serious data foundation, more than most standalone risk tools have access to. But depth of data was never actually my friend's problem. The problem was that the number arrived with no reasoning attached, from any provider, regardless of how good the underlying data was.
Here's the part that's actually different about running that scoring through a Newton policy instead of a bare API call. The evaluation produces an attestation: a record of which policy ran, what signals it weighed, and what it concluded, viewable afterward in the Newton Explorer. The score itself doesn't become more accurate because it's attested. What becomes possible is checking the reasoning after the fact instead of just accepting or disputing a number in isolation.
I don't think this solves risk scoring's harder problem, whether the underlying model is actually well-calibrated, whether stale signals get weighted too heavily, whether a flagged wallet has any real path to correction. An attestation proves a policy ran and what it decided. It doesn't prove the policy was the right one.
What it does change is where the accountability sits. A black-box score is a decision nobody outside the vendor can inspect. An attested one is a decision anyone affected by it can actually go check.
My friend's wallet got unblocked eventually, after a support ticket and a manual review that took longer than it should have. I'd rather the reasoning had been checkable from the start than have to fight to get a human to explain a number.
$NEWT #Newt @NewtonProtocol