Qiao Anna 乔安娜

I used to think a valid signature answered the most important question in onchain finance: who approved this transaction?
The more I study automated systems, the less convinced I am.
A signature can prove that a wallet had the authority to act. A smart contract can prove that its coded conditions were satisfied. The blockchain can prove that execution followed consensus rules.
None of those things necessarily prove that the action still matched the purpose for which that authority was originally given.
That difference becomes important when software begins controlling real financial value.
Imagine that I give an automated strategy permission to rebalance a vault. The mandate sounds simple: reduce concentration risk, maintain liquidity, and keep exposure within an agreed range.
Market conditions later change.
The agent observes an action that is still technically allowed. The signature is valid. The contract behaves correctly. The transaction settles without an exploit or failing check.
Yet the outcome may no longer serve the economic purpose behind my original instruction.
Nothing has malfunctioned. The system has followed the letter of its permission while drifting away from the intent that permission was supposed to represent.
That is the distinction I think autonomous finance will eventually be forced to confront.
Valid, Authorized and Intended Are Different
Crypto infrastructure is extremely good at determining whether an action can be executed.
Does the wallet control the required key? Has the right approval been granted? Are the contract conditions satisfied? Is there enough collateral? Are the calldata and signatures valid?
These checks matter, but they mostly answer technical questions.
They do not automatically tell me whether an action remains appropriate under a changing mandate, risk environment, or operational objective.
I see three separate layers:
A transaction may be technically valid.
It may also be formally authorized.
But it may still fail to reflect what I actually intended.
With manual finance, a person can sometimes notice that difference before acting. A portfolio manager can pause. A compliance officer can escalate an unusual case. A user can reconsider an instruction when conditions change.
Automation compresses that distance. An agent can process information, select an action, and submit it before a human realizes that the original assumptions are no longer reliable.
Greater speed can improve execution, but it also reduces the time available to question whether the mandate still makes sense.
That is why I do not think the hardest problem in agentic finance will be intelligence alone. It will be preserving intent while authority is delegated at machine speed.
Why Newton Mainnet Beta Caught My Attention
What interests me about Newton Mainnet Beta is not simply that it is connected to automation. I am more interested in where @NewtonProtocol tries to place authorization inside the transaction lifecycle.
Through VaultKit and policy-based checks, an action can be evaluated against predefined conditions before settlement rather than being reviewed only after capital has moved. When the required conditions are satisfied, the system can produce a signed attestation that can be verified.
To me, the important shift is timing.
Traditional monitoring often tells me that something unusual has already happened. An audit may tell me that the code appeared secure at a particular point. A frontend warning may ask me to confirm an action before I sign.
Pre-settlement authorization asks a different question:
Does this action still fit the rules under which it is suposed to be allowed?
That does not make Newton an automatic solution to every risk. It does, however move part of the decision process closer to the moment where the transaction can still be stopped.
I think that becomes more valuable as financial actions become less directly supervised by humans.
A Policy Cannot Judge Its Own Wisdom
The strongest part of policy-based authorization is also where I see its biggest limitation.
A policy can enforce a boundary consistently. It cannot guarantee that the boundary was designed correctly.
Suppose I define a maximum exposure limit, an approved counterparty list, or a collateral threshold. Newton can evaluate an action against those conditions before settlement.
But what happens when the threshold becomes outdated? What happens when the market changes faster than the policy? What happens when my instruction was too broad or based on assumptions that no longer hold?
A signed attestation can help prove that a check was performed according to the defined rule. It does not prove that the rule itself was wise.
That is why I would not describe pre-settlement authorization as guaranteed safety.
I see it as a way to make authority more explicit, observable, and enforceable.
The remaining challenge is governance: who writes the policy, who updates it, how exceptions are handled, and how clearly the user understands the authority being delegated.
Those questions are less exciting than talking about smarter agents, but I think they will matter more once automated systems begin managing larger pools of capital.
The Real Test Is Whether Intent Survives Automation
When I evaluate infrastructure like Newton, I do not only look at whether transactions can be checked.
I want to know whether the system helps preserve the purpose behind delegated authority.
Can a user understand what an agent is alowed to do? Can a vault manager define narrow boundaries instead of granting broad control? Can policies be updated without creating hidden gaps? Can an authorization decision be examined later? Can an action be blocked before settlement when it moves outside an agreed mandate?
These are the signals I would watch.
The future of autonomous finance will probably include agents that are faster and more capable than the systems available today. What feels less certain is whether authorization infrastructure will mature at the same pace.
I do not think people will trust financial agents simply because their decisions are intelligent. Trust will depend on whether those agents remain inside understandable and enforceable boundaries, especially when nobody is watching every action in real time.
That is where I see the deeper relevance of Newton.
The protocol is not only asking whether software can act. It is asking whether an action should still be permitted before the blockchain makes it irreversible.
For me, that is the line separating automated execution from accountable automation.
A valid signature can prove that I granted authority.
The harder task is making sure that authority continues to serve the intention behind it.
$NEWT @NewtonProtocol #Newt