VIKAS JANGRA

Not just the "checks before settlement" pitch everyone repeats.
its four steps. Intent — user wants to do something on Ethereum or Base (more chains coming, not live everywhere yet). Evaluation — each operator gets the transaction plus the policy, and pulls whatever data the policy calls for, could be Chainalysis for sanctions, RedStone for pricing, vaults.fyi for vault history, or Webacy for wallet risk. Consensus — this is the part that actually got my attention. once Newton's out of beta, no single operator decides anything. multiple operators evaluate the same proposal independently, and the network only issues an authorization once enough of them agree.
heres the bit most explainers skip. what makes an operator actually tell the truth isnt reputation, its money. operators back their work with restaked ETH through EigenLayer. if one signs off on a wrong answer, anyone can challenge it during a dispute window and prove it with a zero-knowledge fraud proof. get caught, and you lose part of your stake. thats slashing.
why that matters to me specifically: i tell traders constantly that an opinion without risk behind it means nothing. anyone can say "this trade looks good." the discipline only shows up when your own capital is on the line for being wrong. Newton's operator network runs on the exact same logic, except its enforced by code instead of self-discipline. an operator that lies isnt losing reputation points, its losing actual staked ETH.
last step is attestation. once enough operators agree, their approvals get combined into one compact signature, basically proof that a supermajority independently checked the same thing and landed on the same answer. thats what gets verified onchain.
what i keep going back and forth on: the security model assumes slashing losses outweigh whatever an operator could gain by colluding or lying. that holds up fine at current stake levels. but EigenLayer research itself flags a real tension, if operators are restaking the same capital across many different services, the total potential upside from coordinated dishonesty can outgrow the slashable stake tied to any one of them. doesnt mean Newton's broken, just means the security guarantee is a function of how concentrated operator stake gets over time, not a fixed constant.
worth saying directly since i always look at this side too: NEWT is still trading near its lows, supply still under 25% circulating, more unlocks ahead. interesting mechanism design and token performance are two different conversations and i try not to blur them.
does an operator's economic stake actually stay large enough to keep this honest as adoption grows, or does that safety margin shrink exactly when the system starts handling more value?
$NEWT @NewtonProtocol #Newt $ETH

oracle integrations instead of just the mainnet beta announcement everyone's covering.
heres what i didnt expect: its not one data pipeline. its seven-plus separate oracles, each doing a specific job, that a single policy can combine.
Persona and Veriff handle identity and KYC — real-time jurisdiction checks at the transaction level, not the app level. Human Passport adds a different layer entirely: Stamps score for verified personhood, a Models API that passively flags Sybil-like behavior, and Proof of Clean Hands for zk-based sanctions screening. Etherscan feeds in live gas and network congestion data, so a policy can block or delay a transaction during high congestion automatically. Vaults.fyi brings in historical APY, so agents cant allocate into a vault below a performance threshold. Massive adds treasury yield curve data — a policy can literally block a trade if the 10Y-2Y spread inverts.
thats the part that changed how i was thinking about this project.
most "risk management" tools I've seen check one thing and call it a day. price feed says X, so allow or deny. Newton's policies read like someone actually sat down and asked what a real risk desk checks before approving a transaction — identity, network conditions, vault health, macro signals — combined in one evaluation, not five separate manual checks.
heres the technical bit that matters: this all happens through what they call a PolicyClient. code example straight from the docs uses a simulateTask() call — you pass an intent (from, to, value, calldata) plus policyId and policyAddress, and it returns result.allow as true or false. the evaluation runs off the decentralized operator network, secured through EigenLayer restaking, and produces a BLS attestation thats verifiable onchain. no PII touches the chain, just hashes and commitments.
why does that matter to me specifically. because I run a community where the whole philosophy is fixed risk, multiple confirmations before entry, nothing on gut feeling. watching a protocol combine seven data sources into one pre-transaction check is the same discipline, just automated and enforced instead of self-imposed.
what im still not sure about: who decides which oracle combination is "enough" for a given policy. a stablecoin issuer might need Persona + sanctions data. a DeFi vault might only need Vaults.fyi + Etherscan. does that flexibility make policies genuinely safer per use case, or does it just move the hard judgment call to whoever configures the policy, same problem, different layer?
worth saying plainly: NEWT is still trading near its lows, circulating supply is under 25% of total, more unlocks are coming. the tech being genuinely interesting doesnt automatically mean the token performs. those are two separate questions and I try not to mix them up.
does combining multiple independent data oracles into one policy actually reduce risk, or just distribute the same judgment call across more inputs?
$NEWT @NewtonProtocol l #Newt $NEWT

A𝗻𝗱 𝘄𝗵𝘆 𝗡𝗲𝘄𝘁𝗼𝗻'𝘀 𝗺𝗮𝗶𝗻𝗻𝗲𝘁 𝗯𝗲𝘁𝗮 𝗱𝗼𝗲𝘀 𝘁𝗵𝗲 𝘀𝗮𝗺𝗲 𝘁𝗵𝗶𝗻𝗴
One rule I never break as a trader: don't act on a signal you can't verify. Random Telegram calls, screenshots with no source, "trust me bro" price targets — I've watched people lose serious money acting on data they never checked. Confirmed data before action, every time.
That same problem exists onchain, just with bigger numbers attached. A lot of DeFi risk decisions — whether a vault is over-leveraged, whether a counterparty is safe, whether an oracle price is accurate — get made using data that's assumed correct, not verified in real time. When the data's wrong, the risk system built on top of it is wrong too.
Newton Protocol's mainnet beta, live since late June, is built to close that specific gap. It doesn't just check transactions against a policy before they settle — it checks them against verified data sources. For pricing and risk data, Newton brought in RedStone and Credora as launch partners, alongside Chainalysis and Hexagate for compliance screening. The system doesn't just ask "does this pass the rule," it asks "is the data behind this rule actually accurate," which is the part most people skip.
𝗧𝗵𝗲 𝗳𝗼𝘂𝗿 𝗱𝗼𝗺𝗮𝗶𝗻𝘀 𝗶𝘁 𝗲𝗻𝗳𝗼𝗿𝗰𝗲𝘀:
→ Compliance — OFAC/sanctions screening
→ Identity — verification and eligibility
→ Security — real-time threat blocking
→ Risk — counterparty exposure, leverage, oracle health
Every one of those depends on trustworthy inputs. That's the part I find more interesting than the enforcement mechanism itself — anyone can write a rule that says "block if X." Building a system where X is actually verified before the rule fires is the harder problem, and it's the one most protocols skip.
The team building this is Magic Labs — the same group behind embedded wallet infrastructure now powering 57M+ wallets and 200K+ developers, including the wallet stack behind Polymarket. They're not new to handling infrastructure at scale, which matters when you're asking people to trust a system with real capital behind it.
𝗕𝗲𝗶𝗻𝗴 𝗵𝗼𝗻𝗲𝘀𝘁 𝗮𝗯𝗼𝘂𝘁 𝘁𝗵𝗲 𝗿𝗶𝘀𝗸 𝘀𝗶𝗱𝗲: even verified data partners can be wrong, delayed, or manipulated under extreme conditions — no oracle system is bulletproof. NEWT itself is trading near all-time lows, with circulating supply under 25% of total supply, so more unlocks are still ahead. The real test isn't the tech demo, it's whether real vault curators and institutions actually route meaningful volume through this system over the next few months, not just during a campaign.
Roadmap-wise, the plan is to expand from vaults into RWAs, stablecoins, and AI agents, tied together by what they call an "Internet of Policies" marketplace. If that expansion happens on the same principle — verified data before enforcement — it's a meaningfully different approach than most risk tools that just react after something already went wrong.
$NEWT
@NewtonProtocol o #Newt

𝗡𝗲𝘄𝘁𝗼𝗻 𝗺𝗮𝗶𝗻𝗻𝗲𝘁 𝗯𝗲𝘁𝗮
I spend most of my time telling traders one thing: define your risk before you enter a position, not after. Fixed stop-loss, fixed size, no exceptions. Almost every account I've watched blow up did it by skipping that one step under pressure — entering first, figuring out the risk plan later, if at all.
Turns out DeFi has the exact same blind spot, just at protocol scale. Curated vaults now hold billions, and the rules meant to protect that money — leverage caps, counterparty exposure limits, oracle health checks — mostly live offchain, scattered across spreadsheets and bot scripts. Like a trader without a stop-loss, the risk logic gets enforced after something already breaks, not before.
Newton Protocol's mainnet beta, live this week, builds that missing discipline directly into the chain. Every transaction is checked against an active policy before it settles — not monitored after the fact, but actually approved or blocked in real time, with a signed attestation anyone can verify onchain. Other tools report what already happened. Newton enforces what's allowed to happen.
𝗙𝗼𝘂𝗿 𝗲𝗻𝗳𝗼𝗿𝗰𝗲𝗺𝗲𝗻𝘁 𝗱𝗼𝗺𝗮𝗶𝗻𝘀:
→ Compliance (OFAC/sanctions screening)
→ Identity verification
→ Security (real-time threat blocking)
→ Risk (counterparty exposure, leverage, oracle health)
Basically the same checklist a disciplined trader runs before every entry, just automated at the protocol level. For the mainnet launch, Newton brought in partners who already carry weight in their specific lanes: Chainalysis and Hexagate for compliance, Vaults.fyi for vault standards, and RedStone plus Credora for verified price and risk data — the whole setup secured through EigenLayer restaking.
The team behind it is Magic Labs, the group that built embedded wallet infrastructure now powering 57M+ wallets and 200K+ developers, including the wallet stack behind Polymarket. This isn't a new team experimenting with a trend — it's infrastructure builders extending into a problem adjacent to what they already solved.
𝗪𝗼𝗿𝘁𝗵 𝗯𝗲𝗶𝗻𝗴 𝗵𝗼𝗻𝗲𝘀𝘁 𝗮𝗯𝗼𝘂𝘁 𝘁𝗵𝗲 𝗿𝗶𝘀𝗸 𝘀𝗶𝗱𝗲 𝘁𝗼𝗼, since that's the lens I look at everything through: NEWT is trading near its all-time low, circulating supply is still under 25% of total, and more unlocks are ahead — that's real sell-pressure risk. The bigger thesis depends on whether vault curators, stablecoin issuers, and AI agent platforms actually integrate Newton's policy layer at meaningful scale, not just run a pilot and move on. That part is unproven.
Still, the roadmap path makes sense on paper: start with vaults, expand into RWAs, stablecoins, and AI agents, anchored by what they're calling an "Internet of Policies" marketplace. If onchain finance wants to handle real institutional money, it needs the same pre-transaction authorization check traditional finance has run for decades. Newton's mainnet beta is the first real attempt I've seen to build that natively onchain, instead of bolting it on after the fact.
$NEWT
@NewtonProtocol #Newt