wiki002

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

ニュートンのドキュメントを開いたとき、大きなアイデアを探していたわけではありません。
私は、Verifiable Credentials がどのように機能するのかを理解しようとしていただけでした。
ほとんどの人と同じように、まず SDK のリファレンスから始めました。そこで私の目を引いたのは、あるメソッドです。registerUserData。
最初は、オンボーディングの際に開発者が使う単なる別の関数だと考えました。
すると、ほとんど見落としそうになった何かに気づきました。
ドキュメントには、ユーザーデータはアプリケーションの identity domain 内で登録されると書かれています。
その後、その文を何度も読み返しました。見た目以上にずっと多くのことをしていると思ったからです。

With roughly $295B in market capitalization, $7.1T in monthly transfer volume, and more than 271 million holders, stablecoins have become the settlement layer of the digital asset economy. We already know how to make money programmable. The bigger challenge is making the rules governing that money programmable as well.
That is why @NewtonProtocol and the Newton Mainnet Beta stand out to me.
Most conversations about onchain automation revolve around faster execution, lower fees, or AI agents that can perform complex tasks. Those are meaningful improvements, but they leave one fundamental question unanswered: How do we verify that an automated action follows the intended policy before it is executed?
Newton's architecture focuses on that missing layer. Rather than assuming automation should execute first and be audited later, it emphasizes policy-driven execution, where predefined conditions can be evaluated and cryptographically verified before settlement. That transforms automation from being merely autonomous into something that is transparent, constrained, and accountable.
I think this matters far beyond one protocol. As AI agents begin managing wallets, liquidity, and cross-chain operations, the limiting factor will no longer be execution speed. It will be trustworthy execution. systems will need to prove that decisions comply with defined rules instead of asking users to trust opaque logic.
To me, the Newton Mainnet Beta is an important step toward that future. Stablecoins made value Programmable. Newton is exploring whether trust itself can become programmable through verifiable policy enforcement. If that model proves scalable, it could become one of the foundational building blocks for the next generation of autonomous onchain finance.
What matters more for AI-powered finance: faster execution or verifiable execution?🤔
@NewtonProtocol $NEWT #Newt

暗号領域でAIの物語を追いかけるほど、同じパターンが繰り返されていることに気づきます。
ほとんどの議論は「知能」に焦点を当てています。
AIエージェントはどれほど能力が高いのでしょうか？
彼らは何件のタスクを自動化できますか？
彼らはどれくらいの速さで取引を実行できますか？
これらは重要な問いですが、Web3におけるAIの次のフェーズを定義するものにはならないと思います。
私が何度も立ち返る問いは、もっとずっと単純です。
AIエージェントが、人間が対応できるよりも速く金融上の判断を下したらどうなるでしょうか？
自律エージェントは、数秒ごとに確認を求めるために立ち止まりません。いったん運用を許可されれば、ポートフォリオのリバランス、流動性の移動、取引の実行、そして複数のプロトコルとの連携を、数秒で行えます。

I thought I already understood what @NewtonProtocol was trying to build. The Human Passport announcement made me realize I had been looking at it from a different angle. At first, it looked like another integration adding identity verification to a blockchain project. Crypto has seen plenty of those. After reading the announcement and then going back through Newton's Mainnet Beta architecture, I came away thinking the integration is actually about something much bigger than identity.
The part that stayed with me wasn't human Passport itself. The more I thought about it, the less the integration itself seemed like the main story. What stayed with me was where Newton chose to place it.
One of the recurring themes throughout Newton protocol is that authorization should exist independently from settlement. That idea first became clear in the Mainnet Beta, where the protocol introduced an authorization layer that evaluates policies before transactions are executed. The Human Passport integration doesn't change that direction. It extends it. That distinction matters because I don't think Sybil resistance was ever just an identity problem to begin with. in practice, it rarely is. Applications don't make trust decisions based on identity alone. They also look at behavior, reputation, compliance requirements, and context. The challenge isn't finding one perfect signal. It's deciding how different signals should work together before value moves onchain.
That was the point where the announcement started to make more sense to me.
Instead of asking developers to build those decisions directly into every application, Newton allows Human Passport Stamps, behavioral analysis through the Models API, and Proof of Clean Hands attestations to become inputs inside a programmable policy. The protocol isn't saying one signal is enough. It's acknowledging that trust is usually built from several independent observations rather than a single verification check.
The more I thought about it, the more it felt consistent with Newton's broader architecture. Smart contracts are designed to make execution predictable. Trust assumptions aren't nearly as stable. Attack strategies evolve. Regulations evolve. User behavior evolves. If authorization is expected to change while settlement remains reliable, separating those responsibilities begins to look less like a technical preference and more like a practical design decision.
I also don't think the implications stop with Sybil protection. AI agents, DAO treasuries, DeFi protocols, stablecoins, and tokenized real-world assets all make different trust decisions before assets move. They shouldn't all follow identical policies, but rebuilding those policies from scratch inside every application doesn't seem like the most sustainable path either. Newton's authorization layer offers a different model where applications define their own rules while relying on a shared framework to evaluate them.
That doesn't mean every challenge disappears. Developers still have to decide which signals matter, where policy thresholds belong, and how much friction users are willing to accept. Those trade-offs don't vanish because the policy layer becomes programmable. Good architecture can't replace good judgment.
The more I compared this announcement with Newton's Mainnet Beta, the more it felt like the same architectural idea showing up in a different form. I don't think the Human Passport Integration is the real story. The real story is that @NewtonProtocol keeps reinforcing the same architectural idea from different angles. Whether the input is identity, compliance, behavioral analysis, or something else in the future, the protocol is gradually treating authorization as infrastructure instead of something every application has to reinvent on its own.
If that direction continues, the lasting contribution of Newton Protocol may not be a single integration. It may be changing where the onchain economy decides who, or what, is trusted before a transaction ever reaches settlement.
Can authorization become crypto's next shared infrastructure layer?🤔
$NEWT #Newt

Whenever I read about cross-chain infrastructure, the conversation usually comes back to the same topics: moving assets, passing messages, and making different networks communicate more efficiently. After spending time reading different protocol designs, I started wondering if those were actually the hardest problems to solve. Before any chain accepts a transaction, a signature, or an authorization, it first has to decide whose judgment it trusts. If every destination chain has to figure that out from scratch every time it verifies something, interoperability starts looking less like a communication problem and more like a trust problem.
That thought stayed with me while reading Newton Protocol's cross-chain architecture. I expected to find another approach to connecting blockchains. Instead, what kept drawing my attention was how the protocol separates creating trust from using trust. Rather than asking every destination chain to rediscover the current operator set whenever a task needs to be verified,Newton synchronizes a cryptographically verifiable snapshot of that operator set ahead of time. Once that snapshot exists, later verification becomes much simpler because the trust has already been established.
The comparison that kept coming to mind was caching. The two ideas aren't exactly the same, but the analogy helped everything click for me. In distributed systems, expensive work is often done once so the result can be reused instead of recalculated over and over again. Newton seems to apply a similar idea to decentralized trust. Operator registrations, stake updates, deregistrations, and slashing events are reflected in a BLS-signed operator table. Once that table is synchronized to a destination chain, individual task certificates can be verified against an already trusted reference instead of rebuilding the same trust assumptions every time.
What surprised me is where the efficiency actually comes from. It isn't achieved by reducing security or skipping verification. The expensive coordination still happens, but it happens only when the operator set changes. Everyday verification simply reuses the synchronized state that consensus has already established. Looking at it this way, the architecture feels less like a performance optimization and more like a decision about where expensive work should happen in the first place.
Another part I almost overlooked was what happens after the operator table reaches a destination chain. At first it felt like an implementation detail, but the more I thought about it, the more important it seemed. The destination chain no longer has to keep asking Ethereum for operator information whenever it verifies a certificate. Instead, it continues working from a cryptographically authenticated snapshot until that snapshot legitimately needs to be refreshed. That changes the relationship between source and destination chains in a meaningful way.
Of course, that immediately raises another question. What happens when the snapshot becomes outdated? Newton answers that through staleness protection. Operator tables aren't assumed to stay correct forever. If the synchronization isn't refreshed within the allowed period, certificate verification simply stops until a new operator table arrives. I actually like this trade-off because it recognizes that efficiency only matters if the underlying trust remains valid. Independence is useful, but not at the cost of drifting away from reality.
I also found the treatment of historical state particularly interesting. Certificates are verified against the operator table that existed at the referenced block height instead of whatever the network looks like today. That keeps verification deterministic. A task shouldn't suddenly produce a different result just because operators joined, left, or were slashed after the task was originally created. Tying verification to the historical operator set keeps that result consistent even as the network continues evolving.
Even the transport layer follows the same philosophy. Anyone can relay a valid operator table update, but the relayer itself isn't what makes the update trustworthy. The trust already exists because operators collectively signed the snapshot before it was transported. That distinction is easy to miss, yet it says a lot about where Newton places its security assumptions.
By the time I finished reading, I stopped thinking of this as just another interoperability design. It felt more like a system that tries to make trust something you can reuse across chains instead of rebuilding every time two networks interact.
I didn't arrive at that conclusion immediately. At first I thought the operator table was just another internal component. I went back and reread the synchronization section a few times before it started making sense how everything fit together. Once I saw it that way, the rest of the design felt more connected.
I'm still not completely sure if "reusable trust" is the right label for it, but it's the idea I kept coming back to while reading the documentation. Do you see it the same way, or is there another part of the design that feels more important?🤔
@NewtonProtocol $NEWT #Newt

Most discussions about AI agents in crypto focus on what they can automate. A question that gets far less attention is what happens when an agent attempts something it was never meant to do.
That question becomes much more serious once an AI agent controls a wallet. If the model is compromised, manipulated through prompts, or simply produces an unexpected output, the result isn't just a software mistake. It can become an irreversible blockchain transaction.
This is one area where Newton Protocol takes a different approach. Rather than assuming an agent's decision should automatically be trusted, it checks every agent-generated transaction against a predefined policy before the transaction is allowed to exexecute. Those rules are written in Rego, turning authorization into something that can be programmed, reviewed, and updated instead of relying on trust alone.
The distinction is subtle but important. AI generates a decision, while the policy decides whether that decision is allowed to become an on-chain action. Separating those two responsibilities reduces the amount of trust placed in the model itself. The system no longer depends entirely on the agent making the right choice every time.
Many wallet security models rely on fixed allowlists or manual approvals. They work for simple workflows, but they become harder to manage as autonomous agents take on broader responsibilities. Expanding permissions increases risk, while restrictive controls can limit the usefulness of automation.
Newton's policy layer tries to balance those competing needs. Instead of asking whether an AI agent wants to perform an action, it evaluates whether that action stays within predefined rules. A policy can define which contracts an agent may interact with, how much value it can move, or which actions require additional approval. If a transaction falls outside those boundaries, it never reaches execution.
That separation also improves accountability. When an agent behaves unexpectedly, the investigation is no longer limited to the model's reasoning. It becomes possible to verify whether the transaction itself complied with the authorization policy. In practice, that creates a clearer foundation for auditing autonomous systems because decision-making and permission are evaluated independently.
This doesn't remove every security challenge. Policies still need thoughtful design and regular updates. Weak rules may approve transactions they shouldn't, while overly restrictive ones can interfere with legitimate activity. The trust assumption doesn't disappear—it shifts toward the quality of the authorization policy, where it is easier to review, test, and refine.
As autonomous agents begin handling trading, treasury management, and other on-chain operations, verifying whether a transaction should happen may become just as important as executing it efficiently.Automation becomes easier to trust when intelligence is paired with enforceable boundaries rather than unrestricted authority.
@NewtonProtocol #Newt $NEWT
If AI agents become a normal part of on-chain finance, should programmable authorization become a standard layer for every autonomous wallet, or will the industry adopt a different way of separating AI decisions from transaction authority?🤔

@NewtonProtocol がグローバル・ブロックチェーン・ビジネス・カウンシル（GBBC）101の「実世界のブロックチェーンのユースケース・ハンドブック」（2026年版）で取り上げられているのを見たとき、私はその評価そのものには関心がありませんでした。
私を惹きつけたのは、もっと大きな問いでした。
機関は実際に「現実世界のブロックチェーンのユースケース」とは何を考えているのでしょうか？
ニュートン・プロトコルのアーキテクチャとメインネット・ベータを掘り下げていくと、私は思っていたのとは別の結論に至りました。ブロックチェーン導入の次の段階は、取引を最速で実行できるのが誰かによって決まるのではなく、それらの取引が実行される前に、検証可能にできるのが誰かによって決まるかもしれません。

ここ数カ月、さまざまなインフラストラクチャのプロジェクトを読み進める中で、興味深いことに気づきました。
規制、コンプライアンス、そして制度への導入については、皆が議論します。でも、もっと単純な質問をする人はほとんどいません。もし、インフラ自体がまだ準備できていないとしたらどうなるのでしょうか？
私が @NewtonProtocol $NEWT を調べるときに使ったのは、そういう見方でした。
目立った点は、ニュートンがミドルウェアをもう1層追加してコンプライアンスを解決しようとしていないことです。設計は、認可をプロトコル自体の一部として組み込むことを示唆しています。それによって、会話の内容が変わります。