SNAX_Y3LLA

@NewtonProtocol
Setelah melakukan penelitian tentang bagaimana protokol terdesentralisasi dapat mengatasi risiko pembaruan runtime yang berjalan (live), saya menyimpulkan bahwa kerentanan paling kritis pada smart contract terdesentralisasi adalah kemungkinan pihak ketiga untuk mengubah aturan aktif melalui kunci tata kelola (governance keys). Berikut cara Newton Protocol mengatasi masalah khusus ini secara desain dengan cara yang tidak memerlukan penulisan ulang seluruh sistem backend seseorang.
Salah satu tantangan mendasar yang terkait dengan otomasi on-chain yang tidak memerlukan izin adalah kemampuan untuk memperbarui aturan permainan dari waktu ke waktu. Jika kontrak tata kelola atau akun multi-sig yang bertanggung jawab untuk membuat keputusan-keputusan tersebut bertindak dengan itikad buruk dan memodifikasi batasan runtime, itu menciptakan 'policy update vector' untuk serangan.

@NewtonProtocol
Ringkasan untuk menyelesaikan non-determinisme dari sumber data eksternal terdistribusi melalui lapisan konsensus dua fase yang deterministik memang bermanfaat, tetapi implementasi praktisnya bergantung pada kemampuan untuk mengeksekusi data tersebut dalam lapisan aplikasi multi-rantai secara mulus.
Masalah utama dengan infrastruktur permissioning on-chain sejauh ini adalah adanya gesekan implementasi, yaitu ketidakmampuan kontrak pintar yang ada untuk menafsirkan konsensus kriptografis bersyarat tanpa memperbarui byte-code inti mereka.

<c-39/>#Newt $NEWT
Banyak diskusi tentang infrastruktur AI cenderung berfokus pada kekhawatiran tingkat tinggi, seperti kebijakan atau otomasi.
Saat meninjau dokumentasi pengembang Newton, saya menemukan detail rekayasa tingkat lebih rendah yang menurut saya menarik untuk disorot.
Bagaimana beberapa operator independen dapat menghasilkan satu bukti kriptografis berdasarkan data yang mungkin berbeda?
Ini bukan masalah hipotetis, karena masalah seperti ini akan muncul jika beberapa operator secara independen mengakses sumber eksternal yang sama—misalnya harga BTC, daftar sanksi, atau skor risiko—dengan hasil yang berbeda akibat latensi atau perbedaan API.

@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
Satu detail dalam dokumentasi Newton Protocol terus menarik saya kembali.
Bukan policy engine.
Bukan attestasi.
Kata "Intent"
Sekilas, itu terdengar seperti istilah teknis lain. Tapi semakin saya memikirkannya, semakin saya menyadari bahwa itu mengubah cara sebuah transaksi bisa dievaluasi.
Biasanya, blockchain hanya melihat aksi terakhir.
Transfer token.
Tukar aset.
Panggil sebuah fungsi.
Mereka memverifikasi bahwa transaksi itu valid, lalu mengeksekusinya.
Mereka tidak pernah menanyakan apa yang sebenarnya ingin dicapai oleh pengguna atau agen AI.

@NewtonProtocol
Ketika orang membicarakan AI, fokus biasanya menyempit ke satu hal:
Apa puncak kemampuan belajarnya?
Setelah meninjau Newton Protocol, pandangan saya berubah menjadi serangkaian pertanyaan baru.
Bagaimana jika kecerdasan tidak pernah menjadi hambatan utama?
Pertimbangkan untuk membuat uang Anda bekerja untuk Anda.
Kebanyakan dari kita sudah familiar dengan aturan-aturan dasar.
Kami berencana untuk membeli saat harga turun, menghindari keputusan impulsif, mengikuti strategi kami, dan mengunci keuntungan pada momen yang ideal.
Namun ketika pergerakan sebenarnya dimulai, kepanikan mulai terjadi.

@NewtonProtocol Setiap beberapa bulan, AI mencapai tonggak berikutnya.
Ia menyelesaikan masalah yang rumit, menghasilkan konten yang lebih bagus, dan membuat keputusan yang lebih cepat.
Secara alami, sebagian besar diskusi berputar pada satu pertanyaan:
Seberapa jauh AI bisa menjadi lebih cerdas?
Saya pikir pertanyaan yang berbeda menjadi semakin penting.
Apa yang terjadi ketika AI berhenti memberi saran dan mulai bertindak?
Membaca analisis pasar adalah satu hal.
Mengeksekusi sebuah transaksi adalah hal lain.
Merekomendasikan sebuah transaksi sangat berbeda dengan benar-benar menandatanganinya.
Saat AI mulai berhubungan dengan wallet, aset digital, dan smart contract, kecerdasan saja tidak lagi cukup.