Square By Shahid

Newton Mainnet Beta: The Authorization Layer for DeFi Automation
I was going through Newton's mainnet beta documentation and something stopped me.
Most blockchain automation works like this: you write a smart contract, deploy it, and hope it does what you expect. If something goes wrong, you're left with a transaction hash and a lot of questions.
Newton does it differently. Every automated action gets cryptographically verified. When an agent executes a trade or moves funds on your behalf, it produces a proof that the action stayed within your predefined boundaries. Not just a log entry. A cryptographic receipt.
That changes the trust model entirely.
Instead of trusting the agent or the developer, you trust the math. The protocol combines TEEs (Trusted Execution Environments) with ZKPs (Zero-Knowledge Proofs) to verify that every operation was performed exactly as authorized. No shortcuts. No blind spots.
Newton is building what they call a "verifiable automation layer" — a policy engine that sits between your wallet and the agent, checking every transaction before it settles. Spend limits, counterparty checks, collateral requirements — all enforced programmatically with auditable proofs.
The mainnet beta launched on June 23 with VaultKit SDK, a toolkit that lets developers define programmable transaction rules. RedStone and Credora are already integrated as launch data partners.
What caught my attention wasn't just the technology. It was the gap Newton is trying to close.
Right now, DeFi automation relies on trust. You trust the bot operator. You trust the developer. You trust the infrastructure. Newton is trying to replace trust with verification — making automation safer for institutions and individuals alike.
$NEWT powers this ecosystem — used for staking, gas fees, agent collateral, and governance. ~264M tokens currently circulating.
For me, the real question is: as DeFi becomes more automated, how much trust are you willing to delegate?
@NewtonProtocol ol $NEWT #Newt

I found myself thinking about something Newton's mainnet beta revealed.
We talk about AI agents and automation in crypto constantly — but nobody really asks: how do you know the agent stayed within its bounds? How do you prove it didn't do something it wasn't supposed to?
That's where Newton comes in.
The protocol is built around three core principles: Scoped Autonomy, Verifiable Integrity, and Earned Reputation.
Scoped Autonomy means you define exactly what the agent can and cannot do — using zkPermissions to encode expressive rules that go far beyond simple spend limits. Think counterparty checks, jurisdiction restrictions, collateral requirements, and time-bound permissions.
Verifiable Integrity means every action produces a cryptographic proof that it aligned with those rules. Using a combination of TEEs (Trusted Execution Environments) and ZKPs (Zero-Knowledge Proofs), Newton ensures that every operation is performed exactly as authorized.
Earned Reputation means agents build trust through proven performance. Good behavior earns reputation. Bad behavior triggers economic penalties. The system doesn't rely on blind faith — it relies on incentives and verifiable history.
The mainnet beta launched on June 23 with VaultKit SDK — a toolkit that lets developers build programmable transaction policies. RedStone provides verified price data for policy enforcement. Credora handles credit risk assessment. Together, they form a compliance and risk management layer that institutions can actually rely on.
What I keep circling back to is Newton's positioning as an "authorization layer" for onchain finance. It's not trying to be another L2 or another DeFi protocol. It's trying to be the policy engine that sits between you and your automated agents — making sure nothing happens without your permission, even when you're not watching.
The $NEWT token powers this ecosystem:
· Staking for network security
· Paying gas fees for automation
· Collateralizing agent services
· Governance participation
1 billion total supply, ~264M currently circulating.
It feels like one of those infrastructure projects that could quietly become essential — the kind you don't notice until it's missing.
For me, the real question is: as DeFi becomes more automated, how much trust are you willing to delegate? And how would you even verify that trust after the fact?
Newton is building an answer to that question.
What matters most for safe DeFi automation?
· Cryptographic verification of every action
· Clear user-defined boundaries
· Economic penalties for bad behavior
· All of
the above
@NewtonProtocol $NEWT #Newt

I was testing a routing scenario for OpenGradient the other day when one request kept missing its latency target.
The scheduler chose the nearest inference node. On paper, that was the obvious decision. Except the node didn't have the requested model ready. It started pulling the model while another node, slightly farther away, was already warm and mostly idle. The shorter network path became the slower execution path.
That was the first mismatch.
I had been treating node placement like a geography problem. It's closer to a coordination problem with geography inside it. Distance matters, but so do GPU capacity, queue pressure, model state, and whether the backup node actually fails differently from the primary.
The map looked distributed. The dependency graph did not.
Two nodes in separate cities can still share one cloud provider, one operator, or one regional network failure. And the full nodes shouldn't necessarily follow the same map as inference nodes. They're optimizing proof propagation and failure independence, not just user response time. Data nodes introduce another direction entirely because proximity to the source may matter more than proximity to the user.
OpenGradient's architecture handles this through something called the Hybrid AI Compute Architecture (HACA). Instead of making every validator re-execute every inference — which doesn't scale for AI workloads — the network splits into specialized roles:
· Inference nodes run the models
· Full nodes verify proofs and maintain the ledger
· Data nodes fetch external data in isolated environments
No single node type does everything. They coordinate.
The network has already processed over 2 million verifiable AI inferences and generated more than 500,000 zkML proofs and TEE attestations. Over 4,400 models are now deployed. That's not testnet numbers anymore — that's real usage.
But I'm less certain about the incentive layer. Facility-location models help make those tradeoffs visible, but will operators actually distribute themselves optimally? Or will they cluster where rewards are easiest to earn?
The real test is where the next nodes appear — and whether they reduce the delays and shared failures users can actually feel.$OPG
What matters most when placing OpenGradient nodes globally?
· Latency
· Capacity
· Resilience
#OPG @OpenGradient #DeFAI #AIInfrastructure