SNAX_Y3LLA

@NewtonProtocol
Phần tóm tắt về việc giải quyết tính không xác định của các nguồn dữ liệu bên ngoài phân tán thông qua lớp đồng thuận hai pha tất định thực sự rất hữu ích, nhưng việc triển khai trong thực tế lại phụ thuộc vào khả năng thực thi dữ liệu đó một cách liền mạch trong lớp ứng dụng đa chuỗi.
Vấn đề cốt lõi của hạ tầng cấp quyền trên chuỗi cho đến thời điểm này chính là sự vướng mắc khi triển khai, cụ thể là việc các hợp đồng thông minh hiện có không thể diễn giải cơ chế đồng thuận mật mã có điều kiện mà không cần cập nhật byte-code lõi của chúng.

@NewtonProtocol #Newt $NEWT
Many discussions of AI infrastructure tend to focus on high-level concerns, such as policies or automation.
While reviewing Newton’s developer documentation I stumbled upon a lower-level engineering detail that I think is worth highlighting.
How can several independent operators produce one cryptographic proof based on possibly different data?
This is not a hypothetical problem, because it would arise if several operators independently queried the same external source - for example, a BTC price, sanctions list, or risk score - with varying results due to latency or differing APIs.
This isn’t necessarily an issue in itself, but Newton uses BLS signature aggregation which requires operators to sign the same message for their signatures to be combined.
As such, Newton is vulnerable to the effects of different data being used to produce different signatures.
It would appear that Newton deals with this problem by using a standard two-phase consensus protocol, which means that operators do not evaluate the policies they are asked to execute directly.
Instead, in the Prepare phase, Newton’s Gateway asks every operator to run the Policy Data WASM module, normalize the results with a median, check that all responses are within a configurable threshold, and form a dataset based on those normalized values.
Once the Gateway reaches consensus on the dataset, the operators enter the Commit (Evaluate) phase and use that dataset to evaluate the policy, producing BLS signatures Newton can later aggregate into a single proof.
One other detail I think is interesting is that Newton introduces two digests: the Consensus one, which does not include individual operator attestations and thus can be signed by everyone, and the Full one that contains them and thus must be separately signed.
The split allows every operator to sign the same message (for aggregation) while still being accountable for their individual attestations (in the Full digest).
I think that the approach demonstrates an interesting insight: that many AI protocols will need to address consensus before they can implement verifiable authorization.
In my opinion, this makes Newton’s design a valuable exploration of the ways autonomous AI systems may interact with financial infrastructure.
By focusing on building consensus on an external fact before attempting to build consensus on anything else, including block validation, Newton can satisfy the requirements of both decentralized consensus mechanisms and deterministic execution environments.
This, in turn, allows Newton to claim accountability and transparency without compromising on performance or decentralization.
The post Newton Solves a Consensus Problem Most AI Protocols Never Address appeared first on.

@NewtonProtocol #Newt $NEWT
Last night, for some reason, I got myself re-reading a section of Newton's documentation that most people would probably skim right over.
It didn't describe interesting properties of its AI agents.
It didn't talk about staking or policy evaluation.
It described policy updates.
Specifically, it mentioned that if a new policy replaces an old one, it is not necessarily its direct successor.
At first glance, it seemed logical - I assumed that the simplest way to update a policy was for the new one to overwrite the old one.
The more I read, however, the more I realized that Newton does things differently.
A policy in Newton is not just a set of constraints - it is a living document that must evolve with time.
This got me thinking about banks and their procedures for updating internal risk management rules.
A bank will not use the same sets of constraints for decades - they will update exposure limits, revise internal procedures, and adjust to external developments.
The fact that they update them at all is rarely an issue - the fact that they update them correctly is what determines whether they will survive another decade.
When designing their own systems, smart contract developers sometimes act as if the business logic embedded in them has an infinite lifecycle.
This is rarely the case in the real world.
Markets change, counterparties change, and so do the acceptable risk/reward trade offs.
An interesting thought experiment is to imagine a smart contract system with a fixed collateralization ratio that fails to update this ratio in six months.
Six months later, the same contract would be subject to a different set of constraints.
Reading over Newton's documentation, I started viewing policies as dynamic governance instruments.
The key innovation here is to ensure that the system can continue to function even when the rules change.
In other words, Newton's policies provide a mechanism by which operators can update system-wide assumptions while retaining a certain degree of authorization control.
What got me thinking about this topic was not the mere possibility of policy updates - they are table stakes for any serious autonomous system.
Rather, it was the realization that in Newton, policy logic is separated from on-chain application logic.
This might seem like a minor detail at first - after all, it is common practice in conventional software engineering to separate business logic from the application code itself.
I think this observation touches on something bigger.
If we accept that policy updates provide the necessary mechanism for evolving transactional rules, we realize that the application code itself rarely changes.
The transaction itself is the same - what changes are the constraints surrounding it.
The more I think about it, the more it reminds me of the way financial institutions operate.
They rarely rewrite their core operating systems when a new regulation is issued - they update their procedures.
If anything, I think autonomous finance will follow a similar pattern.
If we want agents to operate in a production environment where regulations, markets, and operating procedures are subject to change, policy layers make far more sense than trying to encode everything in application-specific logic.
Of course, this requires a different approach to auditing and governance.
At no point is this more evident than in Newton's documentation - every policy change is a potential single point of failure.
A poorly designed update can be catastrophic - in many ways, it is similar to a 51% attack on a blockchain.
If anything, I think this is a cautionary tale about the importance of governance in policy-driven systems.
Governance has costs associated with it.
If the wrong entity is charged with responsibility for policy updates, the entire system is compromised.
With that being said, I do not think it is a stretch to say that the mere possibility of policy updates makes systems like Newton far more robust.
The rules encoded in application-specific smart contracts rarely change, but the rules that define policy logic do change regularly.
In a way, it is similar to the evolution of the financial sector over the past few centuries.
The core tools do not change - they get better, but the procedures around them must be revised to account for new developments.
Finally, we must distinguish between the rules that define the system (the contract) and the rules that govern the contract itself (the policy).
Evolving the latter presents far more challenges than designing it in the first place.
It is far easier to write a policy than to update it when new requirements emerge.
At the end of the day, it is not the ability to write rules that defines a system's capability to persist.
It is the ability to update these rules while still retaining the confidence of all stakeholders.

@NewtonProtocol
Một chi tiết trong tài liệu của Newton Protocol cứ kéo tôi quay lại.
Không phải bộ máy chính sách.
Không phải các bản xác thực.
Từ "Intent"
Thoạt nhìn, nó nghe giống như một thuật ngữ kỹ thuật khác. Nhưng càng nghĩ, tôi càng nhận ra nó thay đổi cách một giao dịch có thể được đánh giá.
Thông thường, các blockchain chỉ nhìn thấy hành động cuối cùng.
Chuyển token.
Hoán đổi tài sản.
Gọi một hàm.
Họ kiểm tra rằng giao dịch là hợp lệ, rồi thực thi nó.
Họ không bao giờ hỏi người dùng hay một tác nhân AI thực sự đang cố gắng đạt được điều gì.

@NewtonProtocol
Khi mọi người nói về AI, trọng tâm thường chỉ thu hẹp vào một điều:
Đỉnh cao về khả năng học tập của nó là gì?
Sau khi xem xét Newton Protocol, quan điểm của tôi đã chuyển sang một bộ câu hỏi mới.
Nếu trí thông minh chưa bao giờ là nút thắt thực sự thì sao?
Hãy cân nhắc để tiền của bạn làm việc cho bạn.
Hầu hết chúng ta đã quen thuộc với những quy tắc cốt lõi.
Chúng tôi dự định mua vào khi giá giảm, tránh đưa ra lựa chọn bốc đồng, bám sát chiến lược của mình và chốt lời vào đúng thời điểm lý tưởng.
Nhưng khi sự chuyển động thực sự bắt đầu, nỗi hoảng loạn ập đến.

@NewtonProtocol Mỗi vài tháng, AI lại đạt thêm một mốc quan trọng.
Nó giải quyết những vấn đề phức tạp, tạo ra nội dung tinh tế hơn và đưa ra quyết định nhanh hơn.
Tự nhiên, hầu hết các cuộc thảo luận xoay quanh một câu hỏi:
AI có thể trở nên “thông minh” hơn đến mức nào?
Tôi nghĩ một câu hỏi khác đang trở nên quan trọng hơn.
Điều gì xảy ra khi AI ngừng chỉ tư vấn và bắt đầu hành động?
Đọc phân tích thị trường là một chuyện.
Thực hiện một lệnh giao dịch lại là chuyện khác.
Việc đề xuất một giao dịch khác xa với việc thực sự ký vào giao dịch đó.
Ngay khi AI bắt đầu tương tác với ví, tài sản kỹ thuật số và hợp đồng thông minh, chỉ riêng sự thông minh thôi không còn đủ.

Dạo này mình đã suy nghĩ về một điều. Trong crypto thì rất dễ bị cuốn vào những thông báo lớn, các lộ trình hoành tráng và những lời hứa táo bạo. Mỗi dự án mới nghe đều như thể nó sẽ thay đổi mọi thứ. Nhưng sau một thời gian theo dõi không gian này, mình nhận ra rằng khoảnh khắc quan trọng nhất thường đến sau đó khá lâu, khi mọi người cuối cùng cũng bắt đầu được sử dụng công nghệ.
Vì vậy, việc ra mắt Newton Mainnet Beta mang lại cảm giác như một bước đi có ý nghĩa thực sự.
Với mình, bản beta không phải là để chứng minh rằng mọi thứ đều hoàn hảo. Mà là để mở cánh cửa cho người dùng thật, nhà phát triển thật và nhận phản hồi thật. Đây là nơi những ý tưởng rời khỏi bản trắng (whitepaper) và bắt đầu đối mặt với những thách thức ngoài đời. Wow Có những thứ sẽ hoạt động đúng như mong đợi, trong khi những thứ khác sẽ được cải thiện nhờ phản hồi từ cộng đồng—và điều đó hoàn toàn bình thường.