wiki002

Evidence Is Only Half the Story. Moving It Securely May Matter Just As Much.
When people talk about verifiable systems, the discussion usually ends once the proof has been generated.
I used to think the same way.
If a zkTLS proof proves a fact, then the hard part must already be finished.
After reading Newton Protocol's zkTLS example more carefully, I started paying attention to something much less obvious: what happens after the proof is created.
That turned out to be the more interesting design decision.
The example follows a simple flow.
A browser interacts with a TLSNotary extension to generate a cryptographic proof for a Twitter/X follower count. The proof is stored, receives a CID, and is later submitted with a Newton task alongside transaction intent and policy parameters.
At first glance, this looks like a standard proof pipeline.
But the documentation doesn't stop there.
Instead of assuming the stored proof is still correct, the SDK re-derives the CID locally from the original proof bytes after storage. If the returned CID doesn't match, the client rejects it.
Later, when the proof is retrieved, the SDK verifies that the returned bytes still produce the expected CID before allowing them to be used.
Even unsupported multihash algorithms are rejected before any byte comparison occurs.
That changed how I looked at the architecture.
Newton isn't only concerned with proving facts.
It is also concerned with preserving those facts while they move across different system boundaries.
The browser, gateway, storage layer, policy engine, and authorization workflow all become part of the security model.
This distinction matters because cryptographic proofs rarely stay where they were created.
They are transmitted.
They are stored.
They are retrieved.
They pass through services that may be operated by different parties.
A proof that was valid when it left the browser is only useful if every subsequent step preserves its integrity.
Newton's SDK treats that movement as something that must itself be verified.
Another detail reinforced this idea.
The documentation notes that proof storage is expected to migrate from IPFS to a gateway-managed PostgreSQL backend, while the public store/retrieve interface remains unchanged.
To me, this suggests that the storage technology is not the trust anchor.
Evidence integrity is.
As long as the client can independently verify that the retrieved bytes correspond to the expected CID, the underlying storage implementation becomes far less important than many people assume.
That separation feels significant.
Many systems focus on where data is stored.
Newton appears to focus on whether the data remained cryptographically identical throughout its journey.
This also changes how I think about authorization.
policy engines can only make trustworthy decisions if the evidence they consume is itself trustworthy at the moment of evaluation.
Generating a proof is therefore only the beginning.
Maintaining its integrity across browsers, gateways, storage systems, and policy evaluation may be just as important.
The more I looked at the implementation details, the less this felt like an optimization.
It felt like an architectural principle.
Perhaps the real trust boundary isn't where evidence is created.
Perhaps it's every place evidence has to cross before authorization finally happens.
What do you think is the harder problem for decentralized authorization systems generating trustworthy evidence, or preserving its integrity as it moves through the entire workflow?🤔
#Newt @NewtonProtocol $NEWT

I'll be honest.
Last night, I couldn't sleep.
I thought reading a few pages of the Newton Protocol whitepaper might finally make me tired.
Instead, one section completely changed the way I looked at the protocol.
The deeper I read, the more I realized that most people were focusing on programmable compliance, AI agents, or decentralized authorization.
Those are important.
But I don't think they tell the complete story.
What caught my attention wasn't another security feature or another compliance framework.
It was the protocol's economic design.
Most compliance infrastructure today works like traditional enterprise software. Institutions subscribe to services, integrate APIs, and continue paying fixed costs whether they process a handful of transactions or millions every month.
Newton doesn't simply change how authorization works.
It changes how authorization is economically consumed.
Instead of treating authorization as a subscription product, policy evaluation is priced according to the actual computational work performed. Operater rewards are based on execution factors such as WASM instructions, external data-provider requests, and bandwidth consumed during policy evaluation, rather than a flat infrastructure fee.
At first, I thought this was just a technical implementation detail.
The more I thought about it, the more I realized it could become one of Newton's most important long-term design choices.
If authorization becomes metered computation, developers suddenly have an incentive to optimize policy logic in the same way they already optimize smart contracts for gas efficiency.
Every unnecessary oracle request...
Every expensive policy branch...
Every additional verification step...
Now carries a measurable economic cost.
That creates an entirely new optimization problem.
In the future, the best authorization policy may not be the one with the longest list of rules.
It may be the one that delivers the highest level of security with the least amount of computation.
The same incentive extends to operators.
Instead of earning from idle infrastructure or fixed enterprise contracts, they are rewarded according to real policy execution. As demand grows, rewards scale with actual computational work instead of reserved capacity.
To me, that resembles cloud computing far more than traditional compliance software.
Of course, there is a trade-off.
More sophisticated policies usually require additional data sources, more computation, and higher costs. Every application will eventually have to balance stronger protection against cheaper execution.
That balance may become one of the defining design decisions for on-chain finance.
The more I studied Newton's architecture, the less I saw it as just another authorization protocol.
I started seeing it as an experiment in pricing trust itself.
If that idea proves sustainable, developers may one day optimize authorization logic with the same discipline they currently optimize gas consumption.
What do you think?🙋
If authorization becomes a compute market instead of a software product, how much security should applications be willing to pay for?🤔
$NEWT $SXT
#NewtonProtocol #Newt #BinanceSquare
@NewtonProtocol @Binance Square Official

Over the last few days, I noticed something interesting while reading about the Summer.fi exploit and the Bonzo Finance oracle attack.
The two incidents look different on the surface.
One involved a vault exploit.
The other came from a manipulated price oracle that turned a few dollars of collateral into roughly $9 million in borrowing power.
But the part that caught my attention wasn't the exploit itself.
It was the assumption both systems quietly relied on.
They assumed the information they received was correct.
When people discuss DeFi security, the conversation usually revolves around smart contract bugs.
Yet every protocol also depends on another layer that receives much less attention.
The quality of the data used to make decisions.
A lending protocol doesn't decide whether collateral is sufficient.
It trusts an oracle.
A policy engine doesn't determine whether someone satisfies a rule.
It evaluates whatever facts are presented to it.
That distenction matters more than it first appears.
After reading Newton Protocol's documentation again, I realized its architecture already acknowledges this dependency.
Policies don't magically discover truth.
They evaluate inputs coming from Data Oracles, Verifiable Credentials, Application context, and other external sources before operators produce a BLS-signed authorization attestation.
That means authorization isn't only about writing good rules.
It's also about understanding where every piece of evidence originates.
This changes how I think about security.
A perfectly written rego policy can still authorize the wrong action if its inputs have already been corrupted.
The policy isn't broken.
Its understanding of reality is.
Summer.fi and Bonzo remind us that exploits don't always attack execution.
Sometimes they attack the facts that execution depends on.
Of course, strengthening input verification comes with trade-offs.
Adding more verification layers increases latency, operational complexity, and infrastructure costs.
protocols have to balance speed with confidence, especially if autonomous agents are expected to operate continuously.
There isn't a free solution here.
What surprised me is that many discussions frame authorization as the final security checkpoint.
I'm starting to think it's actually the second one.
The first checkpoint is proving that the information entering the authorization process is trustworthy in the first place.
Without that, even the best policy engine is reasoning over corrupted evidence.
As autonomous finance grows, I think the next major security question won't just be Who is allowed to act?
It may become:
How do we verify that the facts used to authorize those actions were genuine before the policy ever ran?🤔
@NewtonProtocol #Newt $NEWT

They standardize behavior.
Think about email.
Its biggest advantage isn't that messages can be sent.
It's that every provider agrees on the same communication standards. Gmail doesn't need a special version to talk to Outlook. The shared rules are what make the network useful.
That made me wonder whether autonomous finance will eventually face a similar challenge.
Today, every protocol defines its own security assumptions.
Every wallet has different permission models.
Every AI application decides in its own way what an agent is allowed to do.
The intelligence may improve, but the rules behind that intelligence remain fragmented.
As more AI agents begin interacting with smart contracts, that fragmentation starts becoming a risk instead of just a design choice.
While reading Newton Protocol's documentation, I kept coming back to one question.
What if the real network effect isn't AI itself?
What if it's shared authorization?
Instead of every application creating its own approval logic from scratch, Newton introduces an authorization layer where programmable policies can be evaluated before execution.If the required conditions are satisfied, execution proceeds. If not, the request never reaches the blockchain.
The interesting part isn't only the policy engine.
It's that every successful evaluation can produce a cryptographic attestation, creating verifiable evidence that the required checks actually happened.
That means different applications could rely on the same trust framework instead of building isolated ones.
If that model expands across wallets, DeFi protocols and AI agents, the value of the network may not come from having the smartest automation.
It could come from everyone speaking the same authorization language.
We've seen this pattern before.
Common standards usually create stronger ecosystems than isolated innovations.
Newton Mainnet Beta makes this idea feel less theoretical than it did a few months ago.
Whether this becomes an industry standard is still an open question.
Adoption is always harder than architecture.
But if autonomous finance continues to grow, I think shared authorization frameworks could become just as important as shared communication standards became for the internet.
That's the possibility I find most interesting.👆#Newt $NEWT @NewtonProtocol

One thing that stands out to me about Newton Protocol is that it focuses on a fundamental issue in blockchain infrastructure that is often overlooked, the execution of transactions without proper authorization. From a developer’s point of view, building automated systems is not only about making transactions faster, but also about ensuring that every action follows clearly defined rules.
Newton’s policy-based authorization approach, built around Rego policies, data oracles, and verifiable attestations, presents an interesting framework for applications that require more control before transaction execution. The integration of identity-based policies through verifiable credentials also shows that compliance requirements can be enforced programmatically instead of being treated as a separate process.
However, the real challenge is adoption. Adding an additional authorization layer can create another complexity for developers. More policies, more verification steps, and more infrastructure components can make the development process harder and can also impact the user experience. Strong controls are important for instetutions, but before replacing existing systems, they will look for easy integration, reliable performance, and clear economic benefits.
My assumption is that this is where Newton’s Long-term success will be tested. The technology addresses a real infrastructure gap, but solving the problem is only the first step. The real challenge will be proving that developers and institutions are ready to adopt a more structured execution model that has traditionally prioritized permissionless simplicity.
If blockchain moves toward more automated and institutional use cases, will verifiable authorization become essential Infrastructure, or will additional complexity slow down adoption?🤔
@NewtonProtocol
#Newt
$NEWT

The Next Billion-Dollar Risk in Autonomous Finance May Not Be a Broken AI Model. It May Be an AI Agent With the Wrong Permissions.
The next phase of crypto will not only be about smarter AI agents.
It will be about whether those agents can be trusted with economic value.
An Ai system can already analyze markets, generate strategies, and interact with decentralized protocols.
But one question remains unanswered:
When an autonomous agent takes an action, how do we prove that the action was actually allowed?
A valid signature proves that a transaction was signed.
It does not prove that the decision behind that signature followed the correct rules.
While studying Newton Protocol's Architecture, the part that changed my perspective was realizing that the biggest challenge for autonomous finance may not be intelligence itself.
AI models are improving quickly.
Execution infrastructure is improving quickly.
But permission management is still largely based on assumptions created for Human-controlled systems.
This is why I started looking at Newton differently.
It is not simply building tools for AI agents.
It is focusing on a deeper infrastructure problem:
How do we create verifiable boundaries around autonomous decisions?
Newton is not solving the intelligence problem of AI agents.
It is solving the permission problem.
From Execution Speed to Execution Trust
Most blockchain innovation has focused on improving execution.
Faster transactions.
Lower costs.
Higher scalability.
But autonomous finance introduces a different challenge.
Execution is no longer the hardest part.
The harder question is whether execution should happen at all.
A human-controlled wallet naturally creates friction. People review actions, question decisions, and manually approve transactions.
AI agents remove that friction.
They can operate continuously, manage multiple strategies, and interact with protocols at machine speed.
That creates a new requirement:
Autonomous systems need Programmable boundaries.
Not because AI cannot make decisions.
But because Ai can make decisions at a scale where mistakes become economically significant.
---
Newton's Core Thesis: Intent Is Not Authorization
The most important concept I found in Newton's design is the separation between intent and authorization.
An AI agent may generate an instruction.
But an instruction is not automatically permission.
Newton introduces a verification layer where proposed actions are evaluated against predefined policies before execution.
The architecture can be simplified as:
AI Agent
↓
Intent Request
↓
PolicyClient Evaluation
↓
Feature Layer Operators
↓
BLS Aggregated Authorization Attestation
↓
Smart Contract Execution
The significance is not only the individual components.
It is where authorization happens.
The decision is evaluated before assets move, not after execution when recovery may already be impossible.
---
How Newton Builds This Authorization Layer
What makes Newton different from a general AI security narrative is the architecture behind this idea.
Through components such as VaultKit SDK, applications can integrate authorization logic directly into asset management workflows.
Policies are defined through programmable rules, including rego-based policy evaluation, allowing organizations to specify conditions around permitted actions.
These conditions can include:
- Transaction limits
- Allowed operations
- Asset permissions
- Strategy constraints
- Operational requirements
The request is then evaluated by Newton's decentralized Feature Layer Operator network.
Operators process policy decisions and generate authorization results.
These results are combined through cryptographic mechanisms such as BLS aggregation, creating a verifiable attestation that smart contracts can consume before allowing execution.
The important innovation is not simply producing a proof.
It is making authorization a native part of the execution process.
---
Why Pre-Execution Authorization Matters Economically
Crypto security today is heavily focused on monitoring.
Detect suspicious activity.
Analyze transactions.
Respond after incidents.
But blockchain transactions are often irreversible.
Pre-execution authorization changes the economic model.
Instead of accepting losses and improving detection afterward, systems can prevent unauthorized actions before they happen.
For individual users, this may appear unnecessary.
For institutions, the equation is different.
Large financial organizations require predictable controls before deploying capital.
They need answers to questions like:
Who approved this action?
Under what conditions?
Was it within policy?
Can the decision process be verified?
Without these answers, autonomous finance remains difficult to integrate into serious financial operations.
---
The Missing Infrastructure Layer for AI Agents
The AI agent ecosystem is often discussed around intelligence.
Better models.
Better reasoning.
Better automation.
But intelligence alone does not create trust.
A highly capable agent with unrestricted permissions can become a risk multiplier.
The future architecture of autonomous finance likely requires three separate layers:
1. Intelligence Layer
Where agents reason and generate strategies.
2. Execution Layer
Where blockchain infrastructure processes transactions.
3. Authorization Layer
Where decisions are verified before execution.
The first two layers are developing rapidly.
Newton's focus is the third.
---
The Institutional Perspective: Control Before Automation
One reason institutions move carefully toward blockchain is not a lack of interest.
It is control requirements.
Traditional finance operates through approval systems, risk frameworks, compliance procedures, and operational policies.
Automation does not remove the need for control.
It increases it.
The more autonomous a system becomes, the more important it becomes to define exactly what that system is allowed to do.
This is where authorization infrastructure becomes more than a security feature.
It becomes a foundation for scalable automation.
---
The Trade-Off: Trust Requires Complexity
A realistic analysis also requires acknowledging the challenges.
A decentralized authorization layer introduces additional complexity.
Operators require incentives.
Policies require maintenance.
Organizations need effective governance processes.
Additional verification can introduce more steps compared with unrestricted execution.
These trade-offs are real.
The question is not whether authorization creates complexity.
It does.
The question is whether that complexity is justified when Autonomous systems control meaningful economic value.
For small transactions, speed may matter more.
For institutional-grade automation, verifiable control may matter more.
---
My Thesis After Researching Newton
The biggest insight I took from Newton is that autonomous finance does not only need smarter agents.
It needs accountable agents.
The future may not be defined by who can execute the fastest transaction.
It may be defined by who can prove that every execution was permitted.
Newton's approach introduces a new possibility:
Wallet control may evolve from simply owning a private key into managing programmable authorization systems.
Smart contracts may no longer only ask:
"Is this signature valid?"
They may also ask:
Was this action allowed according to verified policy?
That difference represents a fundamental shift in how trust can work in an autonomous economy.
The future question is not whether AI agents can manage capital.
They already can.
The real question is whether we can build systems where autonomous decisions remain verifiable, limited, and accountable.
If AI becomes the new financial operator, authorization may become its operating system.
Do you think authorization will become the missing infrastructure layer for AI agents?🤔
#Newt @NewtonProtocol $NEWT

The next security challenge in crypto may not be stopping bad transactions. It may be deciding which transactions deserve to happen.
That thought changed how I look at blockchain authorization.
Most blockchain systems are designed around execution. A transaction is signed, submitted, and processed. But as wallets become smarter, automation increases, and Ai agents begin interacting with assets, one question becomes harder to ignore.
Who decides whether an action should be allowed before it happens?
This is the part of Newton Protocol's architecture that I find most interesting.
Newton separates an Intent from authorization. An Intent represents a requested action, but it is not treated as automatic permission. Instead, it is evaluated against programmable Rego policies by decentralized AVS operators.
The process creates a verification layer before execution:
Intent → Policy Evaluation → Operator Consensus → BLS Attestation → Smart Contract Verification.
What stands out is the idea that authorization can become infrastructure.
Today, many applications create their own permission rules internally. Newton introduces a policy layer where conditions such as spending limits, allowlists, and external verification requirements can be defined and evaluated before value moves.
This creates a different security model.
Blockchains have become very good at proving that something happened.
The next challenge is proving that it happened according to the right rules.
That difference matters even more as autonomous systems become part of on-chain finance. More automation means more efficiency, but without verifiable authorization, it also creates new risks.
The interesting question is not only:
Can a system execute a transaction?
It is:
Can the system prove that the transaction was allowed to execute?
To me, that is the deeper idea behind Newton Protocol, turning authorization from an application-specific assumption into a programmable and verifiable layer.
Do you think future on-chain systems will need permission layers as much as they need execution layers?🤔
#Newt @NewtonProtocol $NEWT