『AO: The Hyper Parallel Computer You Need to Know - Sam Williams, Ep. 255』のスクリプト書き起こしと日本語訳

2024年4月26日に公開された、Arweave FounderのSam Williamsへのインタビュー動画『AO: The Hyper Parallel Computer You Need to Know - Sam Williams, Ep. 255』の英語スクリプトとその翻訳です。

AOについて知るためにはまずこの動画を視聴するのが最もおすすめです。発足経緯など含めわかりやすくAOの全容を知ることができるだけけでなく、血の通った理念についても触れることができます。

日本語スクリプト

[00:00]
最も基本的な金融プリミティブの表現はチェーン上にありましたが、それらの取引を行う理由はチェーン外にありました。AOでは、ネットワーク内で任意に大規模な計算をホストし、スマートコントラクトのような保証を提供できるため、インテリジェンスを外部ではなく内部に持つシステムを構築でき、そのインテリジェンスにスマートコントラクトのような保証を提供することができます。簡単な例を挙げると、個人の資産運用において、AOのプロセスを持ち、すべての価値を特定のポートフォリオ分割で表現したいとします。例えば、80%を何らかのトークンに、20%をイーサリアムやステーブルコインなどに配分するような場合です。

[00:37]
誰かがあなたにトークンを送ると、AOのプロセスが即座にあなたに代わって知的に応答し、システム内でポートフォリオのリバランスを行います。そしてそれは、レンディングプロトコルから得られるのと同じ保証を持って、トラストレスに行われます。しかしこれは基本的なものです。もし代わりに、完全にオンチェーンのアルゴリズム取引ファンドを持ちたい場合はどうでしょうか。そうすると、基本的なケースでは、ビットコインの価格が上下するのを見て、注文を上下に動かすファンドを持つことができます。なぜなら、すべてが0.82の相関を持っているからです。これは合理的なシステムで、ある程度市場に対して中立的な立場を保つことができます。

[01:19]
このファンドをAOのプロセスとして作成し、スマートコントラクトの保証を持って自律的に実行させることができます。そうすることで、人々は上部でトークンを入れ、エージェントが経済の中で活動を行い、下部でトークンを取り出すことができます。もはやファンドマネージャーを信頼する必要はありません。

[01:50]
Web3は新しいペトリ皿を提供します。私たちの仕事は、素晴らしい技術を適切な価格で購入することです。AIもリバタリアン的です。今日の人々が実現できなかったユースケースを可能にします。何億人ものプレイヤーが、モバイルを通じて市場にやってくるでしょう。私が今後12ヶ月で楽観的になれる個人的な理由はそこにあります。

[02:21]
皆さん、こんにちは。Block Crunchポッドキャストの新しいエピソードへようこそ。私はホストのJason Choyです。エンジェル投資家であり、Tangentの共同創設者です。免責事項として、このショーで議論する内容は金融アドバイスではなく、私たちの各会社の公式な意見を反映するものでもありません。また、私たちは議論する資産を保有している可能性があります。最近、分散型ストレージネットワークのArweaveは、AOの立ち上げを発表しました。これは新しいハイパーパラレルコンピュータで、彼らのビジョンの次のフェーズとなります。

[02:50]
彼らはこれを「途方もなくスケーラブルなネットワーク」と呼んでいます。これは私が気に入った表現です。2018年からインフラのスケーラビリティを最大化することをテーゼとしている投資家として、私は非常に興味を持ちました。AOとは何か、そしてそれが暗号資産の次のダークホースになり得るかを理解するために、本日はArweaveの創設者であるSam Williamsをポッドキャストにお迎えできることを光栄に思います。Sam、ようこそ。このエピソードは、YGGの提供でお送りします。

[03:14]
本日のエピソードで、Yield Guild Gamesとパートナーシップを組めることを嬉しく思います。皆さんはYGGをAxie InfinityやPixelsなどのWeb3ゲームの成功を牽引した主要なギルドとして知っているかもしれませんが、彼らの野心はそれよりもはるかに大きいものです。私も創設者のGabby Dizonから長年にわたってゲームについて多くを学んできました。ここで、なぜ多くのギルドが独自のレイヤー2を立ち上げているように見えるのに、YGGはそうしないことを選んだのか、Gabbyに説明してもらいましょう。

[03:45]
「現在、YGGはL2を立ち上げる計画はありません。その理由は、L2を持つと垂直型プラットフォームとしてロックインされ、独自のプラットフォーム上にコンテンツを引き付け、ブロックスペースを埋める必要があるからです。YGGはユニークで、水平方向にスケールすることを考えています。つまり、どのチェーン上のどのプラットフォーム上のゲームでも選んで支援することができ、資産、コミュニティ、クエストや評判プログラムで様々な方法で支援できます。これにより、Web3全体から最高のゲームを選び、それらの成功を支援することができます。」

[04:14]
では、エピソードに戻りましょう。ご参加ありがとうございます。AOについて掘り下げる前に、Arweaveにも多くの歴史があります。Arweaveは、人々がオンライン上で永久に情報を保存する方法として始まりました。これは本当にクールな目標だと思いました。その歴史と、それがどのようにAOにつながったのか、簡単に説明していただけますか？

簡単に言えば、約4年前に私たちは気づきました。データを永久に保存するマシンと決定論的な仮想マシンがあれば、計算の結果として再現可能な状態を作り出すメカニズムがあるということです。

[04:47]
本質的に、決定論的な仮想マシンと入力ログ、そして初期状態を取り、それらを失われることのない分散化された方法で保存すれば、基本的に無料で分散化された計算が得られます。私たちはこれを2020年初頭頃から知っており、それはSmartWeaveとして知られるようになりました。そして私たちが出したプルーフ・オブ・コンセプトは、本当に単なる例示でした。チームの誰かと午後に作った約150行のJavaScriptでした。それが最初のバージョンでした。

[05:22]
その後、私たちは気づきました。この機械には、既存の分散化された計算メカニズムよりもはるかに強力な何かがあると。特に、計算を後の段階に延期できることです。基本的には最初は読み取り手に、そして後には合意の外部に延期できました。つまり、非同期で状態を提供するノードと対話できるようになりました。これは非常に強力な機能となります。

[05:58]
例えば、スマートコントラクトの相互作用の中で任意の量の計算を実行できます。なぜなら、データを分散化し、その順序に合意を提供するノードを、計算タスク自体から切り離しているからです。そのため、長時間実行されるスマートコントラクトがある場合、実行する人々は結果を得るために一定期間待つ意思があると言えば、ネットワークは引き続き前進し、合意に達することができます。当時、私たちは世界でこれについて話している唯一の存在でした。

[06:28]
コンピュータサイエンスでは、このアプローチは「遅延評価」と呼ばれています。Coindeskは当時、Arweaveがスマートコントラクトに対して「怠惰なアプローチ」を取っていると書きましたが、これはあまり役に立ちませんでした。2020年頃にこのアイデアに本当に気づいていた唯一の他の人々は、後にCelestiaとなったLazy Ledgerでした。それ以来、私たちは気づいていました。

[07:06]
このシステムにはある種の超能力があるのですが、それはまだ完全ではありません。私たちが見たいと思う完全にスケーラブルな計算システムではありません。そして私たちは心の奥底で、おそらく2022年頃から知っていました。もしSmartWeaveが他のプロセスやコントラクトに非同期でメッセージを送信できるようになれば、この計算を並列で任意の量実行する方法が得られるということを。

[07:46]
現在、事実上すべてのスマートコントラクトシステムは、グローバルに同期された状態を持っています。これは基本的に、単一のリーダーを選出する必要があることを意味します。それは非常に大きなリーダーかもしれませんが、時間とともに世界中を回転する1つのコンピュータです。簡単に言えば1つのコンピュータです。私たちは気づきました。実際には、Arweaveをメッセージバスとして使用して非同期で並列なスマートコントラクトを作り、それらが互いにメッセージを送り合うようにすれば、それらのスレッドを任意の数、同時に実行し、協調させることができます。

[08:22]
それが約1年前まで、私たちは本当に...それはベア市場だったので、考えて構築する時間がありました。それは常に素晴らしいことです。私たちはその時間を使って、実際にその問題を解決できるか、それを機能させることができるかに焦点を当てました。そして確かに、私たちにはそれができました。そして最終的に得られるのは、簡単に言えばスーパーコンピュータです。基本的には、計算能力を追加すると出力量が増加する分散型計算ネットワークです。

[09:01]
これは普通に思えるかもしれませんが、これは暗号資産のネットワークとプロトコルなので、これまではそのように機能していませんでした。イーサリアムに計算能力を追加しても、ブロックごとの状態削減の数は全く同じです。それは全く変わりません。そしてそれはSolanaや、実際にはほとんどすべてのものにも当てはまります。そこで私たちは、Arweaveをメッセージバスとして使用する任意の数の並列仮想マシンを持つことができるシステムを構築しました。

[09:38]
そして計算の履歴がコンピュータを生み出すという起源に戻るのですが、それが本質的に私たちが構築したものです。それは本当に本当に興味深いですね。Lazy Ledgerについての話も興味深いです。私の前の仕事では、彼らがCelestiaにピボットする前にLazy Ledgerに投資していましたが、あなたたちも同じようなことをしていたという話は知りませんでした。

[10:09]
あなたが位置づけを描写する方法も非常に興味深いと思います。イーサリアムにバリデータを追加しても、まだ1つのブロック提案者があり、ネットワークを高速化することはできません。しかしこの場合、それが無限のスケーラビリティの源となっているようです。ネットワークにアクターを追加すれば追加するほど、より速くなることができるという、おおまかな直感がありますね。

[10:37]
はい、その通りです。それがどのように機能するかというと、分散型ネットワークには...ちょうど私のオフィスにあるので、お見せできます。システムには基本的に3つの異なるサブユニットがあります。私たちは従来のブロックチェーンノード構造をサブコンポーネントに分解し、それぞれのサブコンポーネントを水平方向にスケールできるようにし、それを再び組み合わせ、その上にArweaveを基本的な決済レイヤーとして置きました。

[11:08]
そして、このデザインで得られるのは、分散型ネットワーク、計算ユニット、スケジューリングユニット（基本的にはデータ可用性プラスアルファ）、そしてメッセージングユニットです。これら3つのものがあり、それぞれを水平方向にスケールできるようになると、それらを再び組み合わせた時に、私が思うに計算ネットワークというよりは単一のコンピュータとして説明する方が適切なものになります。

[11:38]
なぜなら、コンピュータサイエンスで「単一システムイメージ」と呼ばれるものを作り出すからです。これは実際には分散オペレーティングシステムの概念で、彼らは40-50年前にこれを扱っていました。基本的なアイデアは、従来の計算環境が常にそうであったように、計算を水平方向にスケールする必要がある場合、マシンのクラスターを、エンドユーザーにとって単一のマシンのように見せることができるかということでした。そしてそれがまさにAOが行うことです。AOのプロセスは、他のプロセスのメモリを読み取ることはできません。それにはグローバルに同期された状態が必要となり、そこからボトルネックが生まれてしまうからです。

[12:13]
代わりに、私たちは各プロセスにローカルな状態を持ち、スケジューリングサブネットを使用して、それらを並列で任意の数実行する能力を持ちます。そして計算サブネットは、その中で行われる計算の量に関係なく、それらの状態遷移を解決する能力を提供します。そしてメッセージングレイヤーは、基本的にArweaveを任意のサイズのメッセージバスとしてプロセス間で使用します。

[12:49]
彼らはもはやお互いのメモリを呼び出すことはできませんが、単にメッセージを送ることができます。例えば、あなたが私にトークンを送りたい場合、AOで言うところのプロセス、つまりコントラクトにトークンを送り、そのプロセスが私に対してクレジット通知を送り、あなたにデビット通知を送るというような形です。これらのメッセージはシステム内で非同期に送られ、この相互作用が発生する時に、お互いを待つ同期ポイントはありません。

[13:22]
そしてそれを組み合わせると、1つの巨大なマシンを使用しているように感じます。私たちは、イーサリアムがこのような概念実証だと考えています。世界中の人々が科学電卓を共有しているようなものです。その中でプログラムを構築でき、あなたのプログラムは私のプログラムに書き込むことができ、私のプログラムはあなたのプログラムに書き込むことができ、そこからコンポーザビリティが生まれます。

[13:53]
しかし、私たちはそれを拡張し、任意の大規模な計算が可能になりました。本当にスーパーコンピュータのように感じます。現在、テストネットは220台のマシンで動作しており、計算でそれらのマシンの全能力を使用することができます。そして私たちが望むように動作するようになれば、それは数万台のマシンになるでしょう。つまり、文字通り民主化されたスーパーコンピュータとなります。

[14:21]
開発者の観点から、イーサリアムやSolanaでスマートコントラクトを書くことに慣れている人々にとって、スマートコントラクトが互いにどのように相互作用するかについて考える方法は、AOにも転用可能ですか？それとも根本的な違いや適応が必要ですか？

1つの適応が必要です。共有メモリのシステムを使用せず、代わりにプロセス間でメッセージを送ることで調整する必要があります。しかし、実際には、大規模システムを考える場合、この方が共有メモリのアプローチよりも直感的だと考えています。

[14:49]
共有メモリのアプローチは、人間の観点から言えば、2人が出会い、状態の一部を交換し、これが発生する間は両者がロックされ、一方が他方を待っているかもしれず、その後それぞれが別のことをしに行くという、奇妙なアイデアです。これを世界経済全体で考えてみてください。それが本質的に、イーサリアムやSolanaが試みていることです。

[15:19]
AOでは、プログラミングの観点からより直感的です。私はシステムの中のアクター（AOはアクター指向の略です）であり、それぞれの計算の部分がアクターとして見なされ、それらは互いにコミュニケーションを取ることができます。何かを達成したい時、私はあなたにメッセージを送ります。このインタビューをセットアップしたように、Telegramでメッセージを送るように。

[15:19]
そして、あなたは好きな時にそのメッセージに対応でき、返信することができます。その間、私は他のことをしています。基本レベルでは、AOは実際には仮想マシンに依存しません。理論的には、EVMやSolana VM、Bitcoin Scriptでも書くことができます（もし本当にそうしたいのであれば）。

[16:00]
しかし、私たちはその上にAOSと呼ぶ別のレイヤーを構築して立ち上げました。これは基本的に分散型オペレーティングシステムで、Luaでプログラミングすることができます。Luaは非常に一般的な言語ではありませんが、非常に簡単で直感的でシンプルな言語です。テストネットでは既に約5,000人の開発者が参加してこのシステムを使用しており、私たちは3週間前に立ち上げたばかりです。開発者の反応は本当に驚くべきものでした。

[16:35]
コミュニティの他の部分にもまだ広がっていますが、開発者たちは「これは分散型計算の根本的に新しい方法だ」と直感的に理解したと思います。使用感は、無限のリソースを持つ巨大なグローバル共有コンピュータを使用しているような感じです。イーサリアムで大規模なスマートコントラクトをデプロイするのに、ブル相場で6,000から7,000かかるような、非常に制約の多いアプローチとは全く異なります。

[17:14]
AOやAOSを開発者として使用する方法は、プロセスにログインするだけです。セキュアシェルを使用するのと同じように、すべての開発者が、Web2サーバーにデプロイする時のようにログインします。そして、コマンドを発行し、コマンドラインを持ち、人々があなたに送るメッセージを見て、インタラクティブにハンドラを追加し、プロトタイプを作ることができます。そして、それが機能したら不変にすることもできますが、

[17:45]
基本的にはリアルタイムでスマートコントラクトを構築し、デバッグのためにログインし、不変にしたいと思うまではいつでもコードを変更することができます。既存のシステムとは根本的に異なる、より良い開発フローを提供しており、開発者たちはそれを本当に気に入っていると思います。

[18:14]
2018年頃にSolanaのAnatolyにインタビューした時、ゼロから1への瞬間だと感じました。そして、あなたがAOSについて説明する方法からも、同様の感覚を得ています。アクター指向について、技術的でない観察者にも理解できるように説明したいと思います。実際に、私はホワイトペーパー全体をChatGPTに入力し、5歳児に説明するように頼みました。その説明を読んで、正確かどうか確認したいと思います。

ChatGPTはこう言っています：アクター指向コンピューティングの概念は、人々でいっぱいの大きな部屋を想像するようなものです。これらの人々がアクターです。彼らは自分の場所から動くことはできませんが、物事を達成するために互いにメッセージを叫ぶことができます。

[18:42]
各人は自分のスキルセットと実行できるタスクを持っており、メモや伝言を回すことでコミュニケーションを取ります。誰かが何かを必要とする場合、メモを書いて送り、受信者がそのメモを読んで必要なことを行います。このようにして、全員が自分の小さなスペースに立っているだけでも、メモを通して話すことで円滑に協力することができます。これは何らかの形でアクター指向の正確な説明になっていますか？

[19:09]
それは、人間がどのように機能するかという私の例から、それほど遠くないですね。なぜなら、それはまさに人間社会という分散型計算システムがどのように機能するかを示しているからです。各人が個別に行動し、集合的に物事が達成されます。これはアクター指向プログラミングでも同じように起こります。「誰も動き回れない」という部分には同意しませんが、ChatGPTにはまだ制限があります。

[19:43]
以前、コンポーザビリティについても言及されましたが、異なるアプリケーション間で共有メモリがない場合、コンポーザビリティにトレードオフはありますか？他のアプリケーションと対話したり、他のDeFiプールから流動性を引き出したりすることは、AOでも可能ですか？

完全に可能です。人々は既にそれを実行しています。最初のアプリケーションは、基本的に予想される通り、Bのような分散型AMM（自動マーケットメーカー）です。ただし、従来のシステムとは異なり、すべてのAMMペアが独自の非同期プロセス上で実行されます。そのため、イーサリアムでは得られない、あるいはイーサリアムにはまったく近づけないような、単一のCPUコアから得られる全能力を各トークンペアに対して得ることができます。

[20:19]
任意の数のペアを持つことができ、単一のスレッドでコンポーザビリティやスケーラビリティが不足した場合、異なるプロセスで実行される複数のペアを立ち上げることもできます。そうすると、それらの間に裁定取引の機会が生まれます。これは、実際には中央集権型の伝統的な取引所が、スケールしたい時に行うことと大きく異なりません。単一のスレッドの容量が不足した場合、基本的に複数の注文書を作成し、人々をその間で分散させ、自動マーケットメイキングやマーケットメイキングボットをその間に置きます。

[21:22]
しかし、現在の方向性は本当に興味深いものです。基本的なものは整っており、従来のDeFiと同じようなコンポーザビリティを持っていますが、今ではチェーン上で大規模な計算を実行することができます。わずかに大きな計算量というだけでなく...名前は挙げたくありませんが、前世代のスマートコントラクトシステムでは、合意と実行を組み合わせたアプローチを取り、基本的にマシンのサイズを拡大しただけでした。

[21:55]
そこには実際に触れるべき点があるかもしれません。ハイパーパラレル計算と言う時、それは単なるマーケティングの言葉ではありません。そこには意味があります。現在、認知度を高めている並列計算システムが多くありますが、それらは基本的にSolanaのルートを取っています。MonadはただのEVM Solanaです。メモリの小さな部分をロックし、それらに対して操作を行い、最終的にブロックが構築される時に状態が単一のポイントに解決されます。

[22:37]
それは理解できると思います。Solanaのように、ある程度の並列計算を行うことができ、相互作用や上書きしない取引は、1つのポイントにマージされます。そしてそのポイントをブロックと呼びます。AOは異なります。1台のマシンの計算量だけではありません。つまり、ボックスの端まで並列というわけではありません。AOでは、多くのボックスで任意の量の計算を並列に実行することができ、その後、メモリを共有する代わりにメッセージを送り合うことができます。

[23:13]
これは、最初にSmartWeaveで説明したような、非常に長時間実行される計算が可能になることを意味しますが、今度はメモリが混ざり合うことなく実行できます。これはAIのユースケースに完璧です。システムには現在DeFiの基本的な部分がありますが、次に向かう方向性については、まだ適切な言葉がありません。あなたの意見を聞きたいと思います。おそらく自律型金融と呼べるかもしれません。

[23:51]
基本的に、金融システムがチェーン自体の決済レイヤーによってだけでなく、それを構成するインテリジェンスによっても表現されるということです。今日のグローバル金融システムを見ると、例えばテスラやビットコインの価格を目にします。私たちが観察している価格は、実際には人間の期待と理解の分散化された計算の集合知の結果です。

これは資産の価値に対する私たちの理解を推定する、非常に複雑なプロセスです。誰もが独自の視点を持っていますが、最終的に1つの数字が得られます。これは一種の知的な計算の結果と言えます。現在のDeFiにおいて、チェーン上にあるのは実際には決済メカニクス、つまりネットワーク自体に表現されているメカニズム設計です。

[24:29]
それは支払いから始まりました。私があなたに何かの対価を支払うかもしれませんが、なぜ支払ったのかという理由はチェーン外にあり、その取引の決済だけがチェーン上で行われます。その後、イーサリアム上でスワップのようなものが登場しました。私が1つのトークンを入れ、あなたが別のトークンを入れ、トークンが反対側から出てきて、私たちの間でスワップが行われます。

[25:03]
その後、レンディングプロトコルのようなものが登場しました。私がトークンを貸し出し、あなたがそれを取って何かを行い、返却します。しかし、それらの相互作用、つまり最も基本的な金融プリミティブの表現だけがチェーン上にありました。それらの相互作用を行う理由はチェーン外にありました。AOでは、ネットワーク内で任意に大規模な計算をホストし、スマートコントラクトのような保証を提供できるため、

[25:43]
インテリジェンスを外部ではなく内部に持つシステムを構築でき、そのインテリジェンスにスマートコントラクトのような保証を提供することができます。簡単な例を挙げると、個人の資産運用において、AOのプロセスを持ち、すべての価値を特定のポートフォリオ分割で表現したいとします。例えば、80%を何らかのトークンに、20%をイーサリアムやステーブルコインなどに配分するような場合です。

[26:23]
誰かがあなたにトークンを送ると、AOのプロセスが即座にあなたに代わって知的に応答し、システム内でポートフォリオのリバランスを行います。そしてそれは、レンディングプロトコルから得られるのと同じ保証を持って、トラストレスに行われます。しかしこれは基本的なものです。もし代わりに、完全にオンチェーンのアルゴリズム取引ファンドを持ちたい場合はどうでしょうか。

[27:00]
基本的なケースでは、ビットコインの価格が上下するのを見て、注文を上下に動かすファンドを持つことができます。なぜなら、すべてが0.82の相関を持っているからです。これは合理的なシステムで、ある程度市場に対して中立的な立場を保つことができます。このファンドをAOのプロセスとして作成し、スマートコントラクトの保証を持って自律的に実行させることができます。そうすることで、人々は上部でトークンを入れ、エージェントが経済の中で活動を行い、下部でトークンを取り出すことができます。もはやファンドマネージャーを信頼する必要はありません。完全に自律的です。

[27:35]
基本的なレベルで起きているのは、マシンを動かしているインテリジェンス、つまり人々に取引を行わせている理由が、チェーン上に取り込まれ、DeFiがプリミティブをチェーン上に取り込んだのと同じように、トラストレスにされているということです。これは大きな可能性を秘めていると考えています。

それでは、トレーニングやこれらのAIボットのメンテナンスはすべてチェーン外で行われ、その出力をチェーン上に持ってくるのですか？それともプロセス全体が完全にチェーン上にあるのですか？

必ずしもそうである必要はありません。望めば、トレーニングもチェーン上で行うことができます。

これは現在のブロックチェーンではまったくできないことです。2つの理由があります。1つは、実行と合意を結びつけているためです。これは、Lazy LedgerとArweaveが早い段階で気づいた、賢明ではないアイデアでした。なぜなら、合意が計算の終了を待つ必要があり、計算が長い場合は機能しないからです。

[28:37]
もう1つの理由は、異なるプロセス間で状態を共有しないため、並列に実行できるということです。基本的に、システム内で好きなだけのプロセスを、望むだけ頑張って動作させることができると考えてください。例えば、オンチェーンの注文書のような非常にリアルタイム性が求められるものを持つことができ、メッセージを送らない限り、それらは基本的に相互作用せず、互いを待つことはありません。これは既存のシステムとは根本的に異なります。

[29:09]
セキュリティのトレードオフに関して、イーサリアム上のDeFiプリミティブのような、あるいは類似のセキュリティ保証を提供できるとおっしゃいましたが、どのようにしてセキュリティを保証しているのでしょうか？

基本的なレベルでは、AOは実際にはArweaveの上に構築されたデータプロトコルです。興味深いことに、プロセスとは何か、メッセージとは何か、そしてそれらがコアプリミティブであることを表現する方法に過ぎません。それはかなりシンプルです。そして、どの仮想マシンを使用するかなど、これらすべてがArweaveに保存されています。そのため、ログの長期保存に関して、Arweaveのコンセンサスとセキュリティを継承しています。

[29:44]
フロントエンドでは、システム内の異なるユニット、つまりサブネットで、現在は権限の証明システムを使用しています。これは基本的に、開発者が最初に信頼するキーを選択し、それらのキーがそれらのログに書き込むことができるというものです。イーサリアムのスマートコントラクトで得られる機械的なセキュリティと同じように、誰がステークを所有しているかに関係なく、誰もあなたのUSDCの残高を10億に、私の残高を0に変更することはできません。それは状態計算によって不可能だからです。

[30:21]
そのような保証は既に得られていますが、AOのテストネットでは「信頼されたシーケンサー」と呼べるメカニズムがあります。次のステップとして、各サブネットを保護する分散型のプルーフ・オブ・ステークネットワークを構築しています。これにより、スケジューラーがあなたのシステムとの相互作用を望むすべての取引やメッセージを、あなたのプロセスのフローに書き込むことを保証します。

検閲を行わないようにし、他の基本的な特性もこのプルーフ・オブ・ステークシステムによって強制されます。メッセージの受け渡しに関しては、メッセージが正当に転送されることを確認します。つまり、途中でメッセージの偽造が行われないようにし、これもまたステークによって保証されます。

[31:00]
AOの興味深い点は、処理しているメッセージに必要なステークを選択できることです。実際にはこれは次のように機能します：イーサリアムを使用する時、100ドルの決済であっても、すべての相互作用に対して約640億ドル相当のステークを購入していることになります。これはあまり理にかなっていません。代わりにAOでは、こう言うことができます：この相互作用による最大の経済的損害は100ドルなので、10,000ドルや100,000ドル以上のステークは本当に必要ありません。

[31:36]
ユーザーやシステム内のプロセスとして、これらのパラメータを選択できます。これは非常に強力だと思います。これ自体が既存のネットワークからの大きな変化です。コンピュートユニットにも有効性の保証が流れていきます。メッセージングユニットがリレーするメッセージに対してステークを置くように、コンピュートユニットはユーザーやスケジューリングユニットに提供する状態証明に対してステークを置きます。タスクを達成するために、それらは互いに通信も行います。

[32:16]
これをブロックチェーントリレンマの文脈で理解したいと思います。この概念は、ブロックチェーン自体の概念が、分離されたDAレイヤー、分離された決済と実行レイヤーの導入によって課題を突きつけられた後でも、異なる設計を理解する上で役立つと常に考えてきました。

[32:45]
セキュリティ、スケーラビリティ、分散化というトリレンマの中で、AOはどのようなトレードオフを行っているのでしょうか？

興味深いことに、AOは異なるタイプのセキュリティシステムを実装するためのフレームワークの基本レイヤーであり、それぞれが独自のトレードオフを持つものです。例えば、本当にビットコインをAOプロセスのシーケンサーとして使用し、その後Arweaveに書き込むことを望むのであれば、ビットコインの非常に高いデータ可用性セキュリティを継承することができます。

[33:19]
また、単にステークノードを持ち、活性問題などがある場合にそのステークをスラッシュする方法を持つシステムを構築することもできます。つまり、ここには設計空間が示されています。興味深いことに、Internet Computer Protocolの開発者の一人、

私は"afat"と発音しますが、彼は"Afat"というスペルを好むのかもしれません。彼はTwitterでその名前を使用しています。彼はAOについての記事を書きました。なぜなら、Internet Computerの人々はワールドコンピュータの構築に非常に興奮していて、AOを見た瞬間、「これは我々が目指していたものではないか」と気づいたからです。

[33:58]
彼はAOを調査し、エレガントな図を作成しました。トリレンマの形式では示していませんでしたが、かなり近いものでした。トリレンマの2次元版で、要素の1つを除いたものです。彼は「ここにICPがあり、ここにビットコインがあり、イーサリアムなどもある」と示しました。しかし、AOはそのグラフ上の1点ではなく、実際には網掛けされた領域、設計空間のほぼ全体を包含する大きな領域となっています。

[34:30]
つまり、答えとしては、ユーザーとそのプロセスの要件に応じて、設計空間とトレードオフ空間の中で適切な位置を選択できるということです。これは非常に強力だと考えています。実際、私もそのスレッドを見ました。以前はDfinityと呼ばれ、現在はInternet Computer Protocolと呼ばれる彼らの開発者が、AOについて語っているのを見て驚きました。

[35:10]
なぜなら、彼は基本的に自分たちの利益に反することを話していたからです。彼は「AOは私たちが構築したかったものそのものだが、他の誰かが先に実現してしまった」と言っていました。ICPコミュニティの真剣な開発者たちは、AOの登場に対して remarkably驚くほどオープンマインドでした。

[35:42]
彼らはAOとICPの違いや、基本的な利点をいくつかのスレッドで概説しました。AOの設計の違いを理解するのに時間がかかったようです。基本的に、合意と計算を分離できるという考えは、ICPの世界ではまったく考えられていなかったものでした。彼らはまだそこまで至っていませんでした。しかし、それ以外の点では、彼らは非常に好意的でした。これは驚きでした。

[36:17]
ICPコミュニティの一部のメンバーは、時々私がTwitterの投稿でタグ付けされ、ランダムに「私にはAOは必要ない、ICPだけでいい」と言うことがあります。そしてそれがランダムな会話で持ち出されます。本当に騒ぎを引き起こしています。

Earlier you mentioned how extensible AO can be - 以前、AOが拡張可能であることについて触れました。ビットコインのセキュリティを活用したり、EVMやSVMを活用したりできるため、すべてのエコシステムに統合できます。そのため、最初にSolidityやRustではなく、Luaから始めることを選択したのは意外でした。その理由を説明していただけますか？

AOを使用する時、ログインしてチャットクライアントを読み込み、マシン内で友人とチャットを始めることができます。彼らは物事を構築し、それにメッセージを送ります。すべてが対話的で柔軟で直感的で寛容です。これは本当に基本的なことですが、これらの他の言語にはほとんど見られない特徴です。

[37:26]
基本的に、人々が書くその他の言語は、システムプログラミング言語の系統から継承されています。それらは非常に効率的であることを目的として構築されているからですが、これは私の考えでは完全に不条理です。Arweaveを始める前、私は分散オペレーティングシステム設計の博士課程で研究をしていました。面白いことに、その時に夢見ていた分散型オペレーティングシステムを、最終的に構築することになりました。当時は適切なツールがありませんでしたが。

[38:07]
その研究では、多くのCとアセンブリを書きました。何十億ドルもの資金を管理し、セキュアに運用する必要があるスマートコントラクトを、これらの言語の系統、つまりSolidityやRustで構築しているというのは、ほとんど理解できないことです。実際、私はCが大好きです。その柔軟性のために素晴らしい言語だと思います。プログラミングの複雑さについては深入りしたくありませんが、それは野性的な性質を持っています。

[38:37]
マシンと直接対話できる、アセンブリ言語と同じように、何でもできます。しかし、そのような環境で超セキュリティに敏感なコードを書くことがどれほどストレスフルかは想像できません。悪夢のように思えます。なぜなら、抽象化の間違ったレベルで考えているからです。Rustはシステムプログラミング用に構築されています。非常に高性能なコードのために構築されており、そのためブロックチェーン空間で使用されることになりました。

[39:09]
基本的に、これらは極めて制限されたコンピュータだからです。しかし、もしそのような制限されたコンピュータを持っていないのであれば、期待を再設定し、高レベルでプログラミングすべきだということが、唯一理にかなっています。メモリ割り当てのような問題について考える必要なく、計算の抽象的なメカニズムについて考えるべきです。

「ポインタを解放すべきか」というようなことを考える必要はないはずです。本当に重要なことは、数字を合計した時に、ある人が価値を生み出し、別の人が失うことになる、これが正しく行われているかということに集中することです。これは非常に基本的なことで、正しい領域に極端な焦点と注意を必要とします。

[39:47]
このため、Luaが提供するものは、非常にシンプルで柔軟で、適切な高レベルの抽象化を持っています。プログラミング言語設計では、これを「高水準抽象化」と呼びます。つまり、コンピュータの管理自体に関する多くのタスクで頭を悩ませることなく、問題について考えることができます。非プログラマーにこれを説明するなら、次のようになります。

[40:23]
私の頭はコンピュータを管理するすべてのタスクで忙しくなく、単にお金を動かす数学や、このDeFiプリミティブ、あるいは市場で人々のお金を運用するAIエージェントに集中できます。これは非常に重要な仕事であり、それを行う際には、頭の中に可能な限り余計なものがないようにする必要があります。

[40:58]
Luaはそれを提供します。なぜなら、基本的にはJavaScriptからクレイジーな部分を取り除いたようなものだからです。単純で合理的な抽象化があり、メモリ管理などの話はありません。一方、Solidityでは、開発者が行っていることは、ある意味でかなり無茶です。開発者はガスを最適化するために、頻繁にプログラムのアセンブリレベルに直接切り替えて書くことになります。

[41:32]
最高のアプリを構築することに集中するのではなく、このアプリを機能させるためにインフラストラクチャレイヤーで何を調整すべきかを考えなければなりません。彼らはバックエンドとフロントエンドの両方を担当することになり、その複雑さは本当に狂気じみたものになります。アセンブリ言語で書く時、それはまるで電卓のようにコンピュータと対話しているようなものです。

それは非常に基本的なものであり、効率性のために行うことはできますが、私は金融プリミティブとそれを混ぜ合わせたくはありません。それは待ち受けている惨事のようなものです。しかし、それは絶えず起こっています。

[42:00]
そのため、大規模な監査産業が存在するのです。非開発者の方々にとって、良い例えをお話しましょう。車を運転することを想像してください。しかし、運転中にエンジンを調整し、ホイールを自分で回転させ、基本的に車そのものの実際の細かい操作に関わらなければならないのです。単にアクセルを踏んでハンドルを切るだけではないのです。それは手動の車のようなものですが、はるかに手動なのです。

[42:29]
Sam、最後の部分として、エコシステムとコミュニティの側面に焦点を当てたいと思います。現在、多くの開発者がAOに興味を持っているとおっしゃいましたが、人々が何を構築することに興味を持っているか、そして他のチェーンでは構築できない、AOで構築してほしいものは何かありますか？

はい、彼らは既にそれを行っています。思い浮かぶのは、システム内に存在するArenaゲームに人々が本当に夢中になっているということです。

[42:56]
これは完全にオンチェーンのゲームで、オフチェーンの要素は一切ありません。トークンがオンチェーンで決済されるというようなものではなく、すべてのメカニクスがAOの中に存在しています。これは、プレイヤーが移動して互いに攻撃できる、基本的なエネルギー管理などを使用できるアリーナです。興味深いのは、これらの開発者たちが、このアリーナで24時間365日プレイする、より優れたAIエージェントを構築するために競い合っていることです。

[43:26]
彼らはテストネットのトークンを獲得するために、これらのボットに賭けているのです。興味深いのは、私たちがテストネット立ち上げ前にアリーナを構築したことです。それは開発者にとって魅力的なゲームであるだけでなく、経済を構成する基本的なプリミティブでもあるからです。これらの市場は基本的にゲームであり、レンディングプロトコルのメカニクスも、文字通りゲームデザインと呼んでいます。

メカニズム設計と呼んでいます。そして、これらの基本的な要素が整っており、人々が互いに対してトレーニングするエージェントを構築し始めています。今日では、ボットが移動して互いに撃ち合うような楽しいゲームですが、

[44:02]
明日には、完全に分散化されたオンチェーンの知的な市場になるでしょう。これは非常に刺激的だと考えています。そしてそれは同じメカニクスを持っています。基本的に、誰かよりも優れたボットを構築すれば、プレイヤー対プレイヤーのアリーナスタイルで、そのボットからトークンを獲得できます。これは最終的に市場も同じように機能します。人々はまた、オンチェーンのソーシャルシステムも構築しています。

[44:36]
残念ながらまだ話せないものもありますが、別のものは分散型チャットルームのようなもので、Twitterのような要素があり、人々が会話中にトークンを送り合うことができます。テストネットの開始からわずか2週間半から3週間ですが、彼らが何かを構築していること自体が信じられないことです。エコシステムの萌芽は既にそこにあります。Arweaveが同じレベルに到達するのに2-3年かかったと思います。

[45:09]
最後の質問として、多くの人々がタイムラインに興味を持っていると思います。AOの現状について理解しています。テストネット段階にあるとのことですが、次の重要なマイルストーンはいつ頃を予定していますか？また、人々は何に注目すべきでしょうか？

基本的に、セキュリティに関わる事項を急ぐことはありません。また、コア仕様が変更を必要としないとほぼ確信できるまで、メインネットとは呼びません。私たちは本物のプロトコルの構築を強く信じています。

[45:38]
暗号資産は、ビットコンからWeb3に至る過程で、残念ながらかなり道を見失ってしまったと考えています。中央集権的なスタートアップと製品とプロトコルの境界線が非常に曖昧になってしまいました。根本的に、プロトコルは何をすべきなのでしょうか？それは、多くの参加者が共にタスクを達成するために使用できる中立的な言語であるべきです。それが常に変更されるのであれば、中立的な言語とは言えず、製品にずっと近いものになってしまいます。

[46:16]
そして、本物のプロトコルでなければ、ユーザーに権利を提供することはできません。例えば、18ヶ月前のプルーフ・オブ・ステークへの移行前にイーサリアムマイナーだった場合、イーサリアム内部で作られた経済ゲーム、つまりイーサリアムそのものにおけるあなたの権利は保護されませんでした。そして、その移行の日に80億ドル相当のGPUが無用の長物となりました。これは本物のプロトコルとは言えません。

申し訳ありません。私はイーサリアムを愛していて、ICOにも参加しました。実際、当時のウェブサイトのキャッチフレーズは「イーサリアムはワールドコンピュータ」でした。私はそれに魅力を感じ、参加したいと思いました。

[46:54]
そのため、マイニングしていたビットコインの一部をICOに投資しました。彼らは確かに驚くべきものを作り出しました。スマートコントラクトシステムと分散型金融です。しかし、それはワールドコンピュータではありません。おそらくよりプロトコルに近づいているかもしれませんが、現実的には、ユーザーにそれほど多くの権利を提供しているわけではありません。

[47:30]
システムについて変更を約束する長いロードマップがあり、それがある場合、実際のプロトコルが提供する保証と調和させることは非常に難しくなります。暗号資産以外の分野や、ビットコイン自体でも同様です。AOでは、プロトコル自体、つまりコンポーネントをメインネットと呼ぶ前に安定化させることを確実にしようとしています。実際、私たちはそれにかなり近づいていると考えています。

[48:02]
イーサリアムを見ると、彼らが最も時間を費やしたのはスケーラビリティの解決を試みることでした。そして、これらの他のシステムのほとんどを見ると、根本的な問題は、まだスケーラブルではないため、完全で完成したものにはなれないということです。私たちは、ネットワークが今日機能するだけでなく、私たちの介入なしでも永久に機能し続け、任意にスケールできる地点まで到達させたいと考えています。

[48:36]
このような権利を人々に提供することで、人々はそれに基づいて構築することができます。私たちは、コンピュートユニットを実行するデータセンターを設置し、メッセージの受け渡しのために大量の資金をシステムにステークしてほしいと考えています。これは、「このシステムは私の足元から変わることはない」と人々が理解できれば、より容易になるでしょう。

[49:10]
ここで物議を醸す見方をお話ししましょう。ある意味で、ロードマップはラグプル（資金引き出し詐欺）です。将来的に物事が変更されることを約束しているということは、今日システムを使用する方法が、現在提示されている形で奪われることを意味します。例えば、GPUの所有者は、システムによってある種のラグプルを受けたと言えます。

また、常に介入してロードマップに沿って変更を加えるグループがある場合、90%のケースではロードマップの実行を完了できず、残りの10%のケースでは実行されて、システムに現在存在する権利を失うことになります。

[49:42]
これは私たちが考える暗号資産の本質ではありません。ここで私たちには機会があります。システムは任意にスケーラブルで、何度か定義したように非常に柔軟です。望む仮想マシンを接続でき、プロセスで使用したいステーキングやセキュリティシステムを選択できます。この柔軟性があるため、私たちは安定したプロトコルを提供できる良いチャンスがあると考えています。

[50:12]
このプロトコルは、ユーザーに本当の権利を提供し、他の人々が奪われることのない保証を持って構築できるものとなります。これは締めくくりとして素晴らしいですね。ロードマップをスローモーションのラグプルとして描写する見方は、これまで誰からも聞いたことがない表現でした。とても興味深いです。Sam、ショーに出演していただき、本当に光栄でした。AOのビジョンについて説明していただき、ありがとうございます。これらの最新情報を追い続けたい人々のために、最適なチャネルを教えていただけますか？

[50:40]
はい、TwitterのAO the computerアカウントが主要なものの1つです。幸いにも、AOの周りには既に分散型のエコシステムが存在します。テクニカルな方々は、AO Computer Clubもフォローするとよいでしょう。AOの各部分について話し合っており、この考えに基づいて、共有コンピュータで互いの上に構築できるという考えに基づいています。それはメーリングリストや雑誌のような雰囲気を持っています。AO the computerはより暗号資産に焦点を当てています。

[51:07]
ウェブサイトはao.devまたはao.anyのゲートウェイからアクセスできます。素晴らしい、完璧です。ショーに出演していただき、ありがとうございました、Sam。これは素晴らしい時間でした。Block Crunchポッドキャストの新しいエピソードをサポートしていただき、ありがとうございます。このエピソードを楽しんでいただけたなら、SpotifyやApple Podcast、あるいはお使いのプラットフォームで5つ星の評価をつけていただけると幸いです。

[51:32]
私たちにとって大きな助けとなります。YouTubeをお好みの方は、エピソードを見逃さないようにYouTubeチャンネルもご登録ください。皆さんからのご意見もお待ちしています。私は個人的にYouTubeのすべてのコメントや、私に向けられたツイートを必ず読むようにしています。コメントを残すなり、どのプロジェクトを取り上げてほしいか、どのトレンドについて話し合いたいかをお知らせください。

TwitterのMr Jason Choyまたはtheblockcrunchでツイートしていただいても結構です。サポートしていただき、ありがとうございます。次のエピソードでお会いしましょう。[音楽]

英語スクリプト

(00:00)
most basic representation of those financial Primitives was expressed on the Chain the reason that you did those interactions was held off chain with AO because we can host arbitrarily large computations inside the network themselves and give them smart contract like guarant guarantees you can build systems that have the intelligence inside not outside and also give smart contract like guarantees to uh to that intelligence so a simple example might be for your personal finance imagine that you have a process in AO and you want all of your

(00:37)
value to be expressed in a specific portfolio split like 80% and know some token and 20% f it something like that or or stable coins okay so when someone sends you a token your process in AO can immediately respond on your behalf intelligently going to rebalance your portfolio for you inside the system and it does so trustless with the same guarantees that you would get from a lending protocol but that's just basic What If instead we wanted to um have an algorithmic trading fund but fully onchain so you could have a fund that in

(01:19)
again the basic case looks at the price of Bitcoin as it moves up and down it moves its orders up and down because everything is 0.82 correlated this is a this is a sensible system and will allow you to remain neutral in the market to some extent well you can make that fund as a process in AO and have it run autonomously with smart contract guarantees and so people can come along and put tokens in the top the agent does things in the economy and they take tokens at the bottom and they don't have to trust a fund manager

(01:50)
anymore web 3 offers a brand new petri dish our jobs to buy Great Tech at great prices AI is also libertarian right enable a use case that people haven't been able to do today hundreds of millions of players they will come to the market through mobile my personal reason why I could be bullish in the next 12 months is all right hey everybody welcome back to another episode of The Block wrench podcast with me your host Jason Choy I'm an angel investor and co-founder of tangent now as a disclaimer nothing we

(02:21)
discuss on this show is financial advice and nothing we discuss is reflective of our respective company official opinions and we may also hold assets we discuss now recently the decentralized storage Network rwe announced the launch of AO which is a new hyperparallel computer and as the next phase in its Vision so they call it an absurdly scalable Network which I really liked and as an investor whose thesis for infrastructure since 2018 is to maximize scalability I was very very intrigued by this so to understand what AO is and see whether it

(02:50)
could be the next Dark Horse in crypto I'm really honored to have R we founder Sam Williams on the podcast with us today so Sam welcome to the show this episode is brought to you by ygg I'm excited to partner with you Guild games to bring you today's episode you may know y as the leading Guild in web 3 that helped Drive the success of games like axi infinity and pixels but they actually have much bigger Ambitions than just that I've also learned a lot about gaming from the founder Gabby Danon

(03:14)
throughout the years so here is Gabby to tell us more about why so many guilds seem to be launching their own layer twos but y chose not to right now there's no plans for y to launch an L2 and the reason for that is that if you have your L2 that locks in as a vertical platform meaning that that you want to attract your own content to build on top of your own platform and fill up the block space right Y is unique in that we consider ourselves uh to scale horizontally meaning that we can pick and choose to support a game on any

(03:45)
chain on any platform and support it in different ways with assets with our community with our questing and reputation programs so that we can choose from the best games uh across web 3 no matter what chain they're on and make sure that we help them become more successful and now back to the episode thank you so much for having me before we dive into AO uh rwe has a lot of history as well so rwe started as a way for people to store info online forever which I thought was a really really cool goal so can you explain kind of briefly

(04:14)
the history there and how did that lead to AO to put it simply we realized at some point approximately four years ago that if you have a machine that stores data forever and you have deterministic virtual machines you have a mechanism by which which to create reproducible State as a result of computation so essentially if you take a deterministic virtual machine and an input log as well as an initial State and you store those in a way that that can't be lost and is decentralized then you essentially get

(04:47)
decentralized compute if you will for free on top of it um we we knew this since about early 2020 approximately and it became known as smart weave and then after the proof of concept that we put out which was really just a an Exemplar it was like 150 lines of JavaScript that I built with someone else on the team in an afternoon it's like the first version um yeah after that we realized there's something about this machine that is that is far more powerful than the existing mechanisms of decentralized

(05:22)
compute um particularly what you could do with that is you could defer computation to the uh later stages basically to the reader potentially was the first way it started and then later it was just outside of consensus so there would be nodes you could speak to that would give you the state uh of the computation but they would do so asynchronously from the consensus about the inputs itself this ends up being like super super powerful uh one of the things you can do with it for example is run arbitrary amounts of compute inside

(05:58)
smart contract interactions because you're no longer requiring the nodes that are decentralizing the data essentially and giving consensus on its ordering um yes you are dissociating those from the computation task itself and so if you have a long running smart contract you can just say well okay the people that are going to execute this are going to be willing to wait some period of time in order to get the result but the network still continues to
move forward and come to consensus and at the time we were like the only

(06:28)
people in the world talking about this um uh there's there's a name for this approach in computer science which is called lazy evaluation and uh coindesk wrote an article at the time that said that you know are we've had a quote lazy approach to um to Smart contracts which was not very helpful um but the the only other people that had really coton on to this idea around approximately that that moment in 2020 were was lazy Ledger that then became Celestia and ever since then we've known that okay so you have some

(07:06)
superpowers in this if you will uh but they're not quite complete like it's not the fully scalable compute system that we would like to see um and we've kind of known in the back of our minds yeah since approximately I guess 2022 something like that that uh if you could get smart weave to be able to send messages a asynchronously to other processes or contracts we used to call them um then you can have a way for arbitrary amounts of this computation to happen in parallel so the way that virtually every

(07:46)
smart Contracting system right now is built is that there is a global synchronized State and what this means is that fundamentally you must elect a single leader it might be a very large leader but it's one leader who writes to the network over time and that rotates around the world but it's it's one computer to put it simply um and we realized well actually if you can make asynchronous parallel smart contracts that message each other using rwe as a message bus then you can have any number of those threads running uh

(08:22)
asynchronously at the same time and coordinating together and it wasn't until about this time last year something like that that we started really it was the bare market so we had some time to to think and to build which is always great uh yeah we we use that time to focus on okay can we actually solve that problem can we make it so that this works um and sure enough we can and what you get out the end of it is a is it's a superc computer to put it simply basically it's a decentralized compute Network where where if you add

(09:01)
more computation capacity you increase in the amount of output that you can create which should seem normal but this is crypto uh the networks and protocols so far don't work like that you add more computation power to ethereum you get exactly the same number of State reductions per block it just doesn't change um and the same is true of salana and really pretty much everything at this point so yeah we built this system that lets you have arbitrary numbers of parallel virtual machines with ar as a me message bus between them and what

(09:38)
links back to if you will the origins is it turns out like a history of computation gives rise to a computer and that's essentially exactly what we built that is really really interesting and I like the tidbit about lazy Ledger as well cuz uh in my last job we invested in lazy leer before they pivoted Celesta but I didn't know about the the story you guys were also doing this this thing and I think it's quite interesting that the way you you portray the positioning as well the fact that if you add more validators to ethereum you

(10:09)
know it's still kind of one block prop proposer you know you're not going to speed up the network by adding more actors but in this case it seems like that's where the infinite scalability comes from where the more kind of actors you add into the network the the faster it can become there like the kind of rough intuition yeah that's exactly right um the way that it works is that there are distributed networks have actually this just kind of helpful being in my office I can show you this oh nice there's

(10:37)
three different subunits in the system basically we broke down the traditional blockchain node structure into subcomponents and then made each of those subcomponents scale horizontally and then glued it back together if you will and then put rwe as the base settlement layer on top where the consensus is derived from um yes and so what what you get in this design is decentralized Networks compute units scheduling units which kind of like data availability plus a little bit more basically as well as messaging units and

(11:08)
once you have those three things and you can make each scale horizontally then when you glue it back together you end up with what I think is better described as a single computer not a compute Network per se because it creates what we call in computer science a single system image that is it's actually a concept from distributed operating system so they were're messing with like 40 50 years ago the basic idea was okay if we're going to have to scale computation horizontally which is the way that the traditional Computing

(11:38)
environment has always worked can we make it so that a single uh or rather a cluster of machines looks like a single machine to the end user and that's that's exactly what AO does so any process in AO is not able to read the memory of any other process there's no that would require Global synchronized state which is where you get these bottleneck from uh instead what we do is we have local state to each process and then using the scheduling uh subnet the ability to have any number of those in parallel and then

(12:13)
the compute subnet gives us the ability to resolve the state of those transitions um regardless of the amount of computation that happens inside them and then a messaging layer it basically uses rwe as an if you will yeah arbitrarily sized me message bus between processes and so they can't call each other's memory anymore but they can just send a message and so that would be something like you know if you want to send a token to me perhaps you would send a token to the contract the process in AO speak um and that process would

(12:49)
then send another message to me saying you have a credit notice and it would send a debit notice to you and these messages are pushed around the syn around the system asynchronously so there's no point of um synchronization where if you will they are waiting for one another when this interaction happens yeah and and when you glue it together it feels like you're using one giant machine we like to to think that ethereum is kind of the proof of concept of this like where you where you could do it's it's like everyone in the world

(13:22)
is sharing a scientific calculator it's it's kind of cool like you can build programs inside and and you can write to my programs and mine can write to yours and and that's where we get composability from but we've just scaled that up so that it's arbitrary massive compute and it really does feel like a supercomputer the moment the test Net's running on 220 machines something like that and you can use the full power of those machines in your computations and by the time it's you know running as we want it to be

(13:53)
that'll be tens of thousands of machines so it literally be a democratized supercomputer I guess from a developer perspective uh for people who are used to writing smart contracts on ethereum or you know writing smart contracts in sou salana is the experience or the way they think about how smart contracts interact with each other is it uh transferable to AO as well or they kind of fundamental differences or adaptations they have to make there's one adaptation they need to make they they need to not uh use the system of

(14:21)
shared memory uh and instead coordinate via sending messages between processes but we actually think this is even more intuitive when you think about large scale systems than a shared memory approach a shared memory approach is this kind of weird idea if you were to put it in human terms that you would create like a rendevu with someone like two people get together they exchange a bit of state and they're both locked when this happens and one might be waiting for the other and then they leave and they go to

(14:49)
do something else now imagine that across an entire global economy that's essentially what ethereum and salana are attempting to do um with AO it's it's more intuitive from a programming point of view it's okay I am an actor in the system if you will AO stands for actor oriented it's a type of programming where yeah every piece of computation is seen as an actor and they can communicate with one another yes so when I want to get something done I might send you a message like on telegram we

(15:19)
did to set this up uh and you can get to that message when you want to and reply and meanwhile I've gone off and done other things and so there there's something about this that's very very intuitive at the base level AO is is actually virtual machine agnostic so you could in theory write using evm or salana VM um Bitcoin script I guess if you really want to um but but we built on top of it to to launch it another layer which we called AOS which is basically a decentralized operating system and it it lets you

(16:00)
program in lure which is not a super common language but it is an extremely easy and intuitive and simple language and so I think in the the test net already we've had somewhere around 5,000 developers get on board and use this system and we launched I think three weeks ago so the developer response has been pretty pretty crazy frankly um yeah the the word is still spreading in the rest of the community but but I think the developers have intuited oh I see this is a radically new way of doing decentralized computation uh and what it

(16:35)
offers just feels different it yeah to use it feels like you're using a giant Global shared computer that has infinite amounts of resources essentially rather than this hyper constrained constricted approach where you know every smart contract to deploy might cost you6 or 7,000 for the large ones on ethereum in a bone Market it's it's night and day difference the way that you use AO uh AOS at least is that as a developer you just log into a process you log into it just like you're using secure shell uh which every

(17:14)
developer is familiar with and they're deploying to like a web2 server and then you issue it commands and you have a command line and you see the messages people are sending to you you add handlers interactively and you prototype stuff and then when it works you can make it immutable but you can also yeah essentially build your smart contracts in real time and then log into them to debug them and just change the code whenever you want until the point that you want to make it immutable so it offers people rights when they use it

(17:45)
but that development flow is just so radically better than the existing systems uh the developers really love it I think so I I remember I was interviewing uh Anatoli from salana back in like like 2018 and in the interview I kind of got the sense that hey this is like a zero to one type of moment and I'm kind of getting a similar sense here from the way that you're describing AOS there like a zero to one kind of Nick step in what decentralized Computing should look like so I really want to make sure whoever is listening to this

(18:14)
to really understand actor oriented um so in order to explain it to a less technical audience I actually plugged the entire white paper into chat gbt and asked it to explain to me as if I'm a 5-year-old so I like to kind of read that explanation and just to get your take on whether this is accurate at all so this is what chbt says they said the concept of an actor-oriented Computing is like imagining a big room full of people and these people are the actors they cannot move from their spots but they can shout messages to each other to

(18:42)
get things done so each person has their own set of skills and task they can perform and they communicate by passing notes or messages around so if one person needs something done they write a note send it across they recipient reads the note does what's needed and this way even though everyone is just standing in their own little space they work to together smoothly by talking through notes is that in any way an accurate assessment of what act oriented is that's actually not so far from the example I gave of how it feels intuitive

(19:09)
to people because it's exactly how humans work we are all actors if you will in this you know decentralized decentralized comput compute system of human society right like it it achieves tasks together in precisely the same way every person acts individually and uh and collectively you know things get done which is precisely what happens in act oriented programming too I'm not sure I would go with the like no one can move around thing but there are limitations to J gbt still and I I think earlier you also mentioned

(19:43)
the point about composability is there a trade-off in composability and if there's no shared memory between different applications like if I want to talk to another application or I want to draw liquidity from some other D5 pool like is that still possible with AO totally yes people have already done it um the the first applications are essentially the the well were the the ones you'd expect things like B which is a uh decentralized amm except unlike traditional systems every single amm pair runs on its own asynchronous

(20:19)
process so you get the full power of a single threat of execution which is essentially all the power that you get in ethereum or well I mean ethereum doesn't even come close actually but the the full power that you can get from a single CPU core um yes per per pair of tokens that you want to trade and then you can have an arbitrary number of those and if you ran out of composability or scalability on a single thread you could also just spin up multiple pairs running in different processes and then you'd have Arbitrage

(20:52)
opportunities between those actually not far from what happens in uh centralized trafy exchanges when they when they want to scale you know if you run out of capacity on a single thread where you basically just make multiple order books and just have people spread between them and then there's automated Market making or or Market making Bots between them um yeah but but where things are heading now I think is is really interesting which is that we have those basics in place you had all the composability that you do

(21:22)
with traditional defy but now you can run large amounts of compute on chain and we don't just mean like slightly larger amounts uh like I don't want to mention names but the the the let's say the prior generation of smart Contracting systems where they they went for this combined consensus and execution approach uh where they basically just scaled up the size of the machine if you will and there's actually probably something we should get into there uh when we say hyperparallel compute that's not just like

(21:55)
marketing buzzword there we there is meaning behind the hper um there are many parallel computation systems right now that are gaining in uh at least awareness and they are essentially going the salana route so monad is just evm salana um you can lock small parts of memory and uh yeah operate on them and then eventually when the block is constructed the the state is resolved to a single point if that makes sense just like Sal you can do some amount of parallel computation and then you know the the the transactions that don't interact or

(22:37)
override each other they get merged together into one point and we call that point the block um with AO is is different you you have not not just one machine's worth of computation so that's sort of parallel if you will to the edge of a box with AO we we allow you to to perform arbitrary amounts of computation across many boxes in parallel and then they can message each other rather than sharing memory when when they do this it means that you can do very long running computation like I described with smart weave at the

(23:13)
beginning but now without the intermingled memory um which is perfect for AI use cases yes we have the the the basics of defi in the system now but where we think this is going next is there's no good word for this yet I'm curious what you think of these um maybe autonomous Finance could be one way of saying it basically the financial system not just being expressed in the chain Itself by the settlement layer but also by the intelligence that makes it up so if you look at the Global Financial system today we we see things

(23:51)
like the price of Tesla right or the price of Bitcoin and the price that we're observing is actually the result of this of decentralized computation hive mind of human expectation and uh understanding right it's an estimation of our understanding of the value of a of an asset and this is extremely complex to derive everyone has their own points of view but we get one number at the end so this is the result of a a sort of intelligent computation you could say and in defi at the moment what we really have on chain is the

(24:29)
settlement mechanics the mechanism design expressed on the network itself things like well it started with payments right so I might pay you to do something but why I paid you to do something is offchain it's just that the settlement of that transaction happened onchain um then we had things like swaps on ethereum right so I put in one token you put in another token tokens come out the other side uh swap between us okay then there were things like lending protocols I lend some tokens um you take them you

(25:03)
do something with them you return them but only those interactions the base layer of the most what you say the b most basic representation of those financial Primitives was expressed on the Chain the reason that you did those interactions was held offchain and with AO because we can host arbitrarily large computations inside the network themselves and give them smart contract like guarant guarantees you can build systems that have the intelligence inside not outside and also give smart contract like guarantees to uh to that intelligence so

(25:43)
a simple example might be well yeah uh for your personal finance imagine that you have a process in AO and you want all of your value to be expressed in a specific portfolio split like 80% I know some token and 20% F something like that or or stable coins okay so when someone sends you a token your process in AO can immediately respond on your behalf intelligently going to rebalance your portfolio for you inside the system and it does so trustless with the same guarantees that you would get from a lending protocol but that's just basic

(26:23)
What If instead we wanted to um have an algorithmic Trading fund but fully on chain so you could have a fund that in again the basic case looks at the price of Bitcoin as it moves up and down it moves its orders up and down because everything is 0.82 correlated this is a this is a sensible system and will allow you to remain neutral in the market to some extent well you can make that fund as a process in AO and have it run autonomously with smart contract guarantees and so people can come along and put tokens in the

(27:00)
top the the the agent does things in the economy and they take tokens at the bottom and they don't have to trust a fund manager anymore it's entirely autonomous and to think about it at sort of basic level what's happening is that the intelligence that is running the machine right that's causing people to make the trades that they're making is taken onchain and made uh trustless in the same way that defi Took The Primitives onchain and we think that could be huge wait so the is the training and I guess uh you know the

(27:35)
maintenance of these AI Bots is that all happening offchain and then you're bringing the the output on chain or is the entire process end to end just on chain uh it doesn't have to be yeah you could have the training onchain if you want to as well oh wow and so this is something that you really can't do on the current blockchains which just because of the scale constraints yeah absolutely because they tie well two reasons they they tie uh execution with consensus which was something that lazy Ledger and and and uh we had are we've

(28:08)
you conned on too early that wasn't a sensible idea um because it means that your consensus basically has to wait for the computation to end and if the computation is long it's not going to work so so there's that component and then the fact that we don't uh share State between different processes they run in parallel um yeah really allows you to run arbitrary amounts of computation asynchronously you essentially think of it like fundamentally you can have any number of processes inside the system working as

(28:37)
hard as they want I can have like something that needs to be extremely real time like an onchain order book and um they don't interact fundamentally unless we send messages they're just not waiting on each other they're just unblocked if you will yeah it it is radically radically different than the existing systems I guess in terms of the security trade-off because you mentioned that you know some of the we can run for instance AI Bots and you can have the same security guarantees or similar security guarantees as like defi

(29:09)
Primitives on ethereum so how are you able to kind of guarantee the security so the at the basic level AO is actually just a data protocol interestingly built on top of aiv it's just a way of representing what is a process what's a message and see that those are the core Primitives it's pretty simple um and then you know what virtual machine you should use with it and so on and all of this is stored in our so we inherit R's consensus and the security from that for the long-term preservation of the log um on the on the front end in

(29:44)
these different um units that we that we have in the system the subnets at the moment it uses a proof of authority system which is essentially the developer chooses the keys that they trust at the beginning and those keys can um right to those locks so in the same way that you get mechanistic security of smart contracts on ethereum regardless of who owns the stake like no one can uh just change your balance in usdc to a billion and mine to zero you can't do that because it's state computations you get those um those guarantees already

(30:21)
but you have a mechanism of um you could say trusted sequences but this is just in the test net of AO where we're going next is building a decentralized proof of stake Network that uh essentially safeguards each of those subnets so ensuring that scheduler will uh write every transaction or message that that you want to have interact with your system uh into the flow of of your process doesn't sensor so it also has liveness and a few other fundamental properties enforced by this proof of stake system and then for message

(31:00)
passage we make sure that messages are um yeah are validly transferred so there's no forging of messages in the middle and so on and we do so against stake of course but the interesting part about that in AO is that you get to choose the stake that you need for the for the message that you are processing essentially and so what this looks like in in practice is that well when I use if ethereum I'm buying about $64 billion worth of stake for every interaction I make even if it's like a $100 you know

(31:36)
settlement this doesn't really make sense instead in AO what you can do is you can say okay well this interaction has a maximum economic damage of 100 bucks so I really don't need to see more than 10,000 or $100,000 of stake and so you you get to choose these parameters as a user and as a process in the system which is really powerful I think actually like yeah again that in itself is a huge huge shift from the existing networks and and the the uh would you say the validity guarantees flow back to compute units as well these units that

(32:16)
basically calculate your State uh just like messenger units are State against the messages that they relay compute units are State against the state attestations that they give to you as a user or to a m suing unit also they talk to each other in order to achieve a task I love to kind of contextualize this uh in the context of the blockchain trma right because I thought always thought this concept is quite helpful even after the concept of a blockchain itself was challenged with the introduction of you know separate da layers separate

(32:45)
settlement and execution layers people can still kind of contextualize um different designs within this trma so in the trma of uh what's the three security scalability and decentralization how what what kind of trade-offs is uh AO making well the interesting thing about it is that it is fundamentally more of the base layer of framework for implementing different types of security systems which will have their own trade-offs rather than something that's prescriptive so so you can for example if you really want to use Bitcoin as

(33:19)
auler as a sequencer uh for an AO process and then have it written to awe um afterwards and so you inherit the the you say data availability security of Bitcoin which is extraordinarily high of course um you can also have a system where you just have a Stak node and you have a way of slashing that stake uh if there's you know liveness problems and so on and so so it it outlines a design space there actually interestingly an internet computer protocol developer I believe he calls himself well I would pronounce it a fat

(33:58)
but I wonder if he wants it spelled afat I know he's on Twitter goes by that name uh and he he wrote an article about AO because you know the internet computer people are very excited about building a world computer and as soon as they saw AO right they realized wait isn't that what we were gunning for and uh and so he looked into it and he he made this pretty elegant graphic that showed okay he didn't quite show it in in the form of the trilemma but pretty close it's like a two-dimensional version of the trilemma um missing out

(34:30)
one of the the factors but he showed okay so here's ICP it's here here's Bitcoin and a couple of others in ethereum uh well instead of just being a point on that graph AO is actually a kind of shaded area it's a large area that more or less encompasses the whole design space so so the answer is that uh depending on the requirements of the user and of the process in question you can choose the right spot in the design space and the trade-off space for you and and we think that is super super powerful yeah and and to be frank I I

(35:10)
think I I saw that threat as well uh I remember I I was quite surprised to see um I guess they used to be called definity now they're called internet computer protocol I was surprised to see this guy kind of talking about AO just because he's kind of talking against his own interest basically but he was saying AO is like exactly what we want wanted to build but someone else did it for us and to that credit the the serious developers in the ICP Community were remarkably open-minded when AO came along um which was which

(35:42)
was great to see like they wrote a number of threads uh outlining you know where AO is different than ICP and uh and outlining some of the fundamental advantages I think it took them a while to get their heads around the difference in design fundamentally the idea that you can dissociate consensus from computation with something that's just not not like in the ICP sere at all they just haven't really bred that yet uh but other than that they they really were quite welcoming which was surprising the there were some members of the ICP

(36:17)
community that uh sometimes I now get tagged in posts on Twitter where people just randomly say no AO for me only ICP okay um and it gets brought up in like random conversations so it's really kicked up a stir there you mentioned earlier is actually how extensible AO can be because you can be you know leveraging the security of Bitcoin leveraging the the evm leveraging svm as well so you can actually be integrated into all the ecosystems which is why I found it quite surprising you guys decided to start with Lua first and not

(36:50)
you know solidity or rust so can you explain the kind of rationale there so when you use AO you log into it you can load a chat client you start chatting with your friends inside the machine you they build stuff you send messages to it um all of it is interactive and flexible and intuitive and forgiving which is a really fundamental thing which is not the case in I think essentially all of these other languages and basically the other languages people write in are inherited from the line of systems programming

(37:26)
languages because they're buil to be extremely efficient which is completely absurd in my mind uh when when before I started AR I I was doing a PhD in distributed operating system design which funny enough I ended up building the distributed or decentralized operating system I I had dreamed of back then but didn't have the right tools for but when I was doing so I wrote a lot of uh C and assembly and it's it's virtually unfathomable that the the lineage of languages so solidity and rust that people build smart contracts that going

(38:07)
to manage billions of dollars and they have to do so securely are written in these languages I love C actually I think it's an incredible language because of its flexibility and and sort of don't want to get into the complexities of the programming but it's it's wild it's got a wild nature to it you can really do whatever you want it let you interact directly with the machine same with Assembly Language but I can't imagine how stressful it is to write hypers security sensitive code in

(38:37)
those environments it sounds like a nightmare because you're thinking about the wrong level of abstraction like rust is built for systems programming it's it's built for extremely highly performant code which is why it was ended you know it ended up uh being used in the blockchain space because basically we have these extremely Limited computers but now if we don't have those limited computers the only thing that makes sense to do is to reset our expectations that we should be programming at a high level we should be

(39:09)
thinking about our would you say computational abstracts uh yeah abstract computational mechanisms uh with no concern for things like memory allocation you know have I freed my pointer should not be something you're having to worry about when you're really trying to focus on when I sum up these numbers one person is going to create value and or move value and the other is going to lose it is this done correctly there this really fundamental thing that needs extreme focus and attention on the right areas basically

(39:47)
and so what Lu gives us is something that is extremely simple and flexible and it has the right level of high what would you say yeah high level AB abration we call it in programming language design where you're you're thinking about the problem with the with the right level of how would you describe this to a non-programmer it's like I'm my mind is not busy with all of these tasks about managing the computer the computer man itself yeah it's simplified and I'm just focused on the mathematics of moving

(40:23)
money around or you know doing this defi primitive or an AI agent that's going to you know basically uh put people's money in the market and that's that's very serious stuff and you need to make sure that the there's as little clutter in the mind as possible when you're doing that and Lu Lu offers that because it's it's essentially JavaScript without the crazy if you will like it's JavaScript that really cut down to the basic elements um simple sensible abstractions and and no talk of like

(40:58)
memory management or anything like this whereas in solidity what these developers are doing is is quite crazy in a way is the developers will frequently switch to writing the assembly level of the program directly in order to optimize gas very lowlevel developers versus just focusing on building the best app they have to figure out okay what do I tweak in the infrastructure layer to make this app work and they become backend and front end and all that complexity just becomes crazy yeah exactly when you write in

(41:32)
Assembly Language it's like you are interacting with a computer as if it's a calculator it's it's extremely extremely basic and you can do it for efficiency purposes but I really wouldn't want to to mix those efficiency purposes with financial Primitives seems like a catastrophe as say a catastrophe waiting to happen but we see it happen all the time all the time that's why there's a massive auditing industry as well and I think for for the non-developers in the audience I think a good analogy is like

(42:00)
imagine you're supposed to drive a car but uh when you're driving the car you also have to tweak the engine and also spin the wheel yourself and basically get into the the the the actual nitty-gritty of operating the car itself instead of just you know stepping on the gas and trading the wheel right yes it's like it's like a manual car but like way more manual Sam for the last part of this I wanted to focus on the ecosystem Community side because you mentioned there's um a a lot of developers that are interested in AO

(42:29)
right now what are you seeing in terms of what people are interested to build and are there things that you simply cannot build on you know other chains that you'd like to see people build on AO now yeah they're already doing it um the thing that comes to mind is that people have really taken to this Arena game that exists inside the system so it's a fully onchain game there's there's no elements of it that that exist offchain it's not like the token is settled onchain or something like

(42:56)
this but the entire all the mechanics they just live inside AO and it's a it's an arena where there are players they just move around and they can attack each other they can you some basic things as energy management this type of thing um and what what's interesting about it is that these developers are competing against each other to build better and better AI agents that play in this Arena 24/7 to earn tokens to earn testnet cred from one another they're essentially betting them on on these

(43:26)
Bots um and what's interesting about that is that we we actually built the arena before testet launch and we did so because a game like that is engaging to developers but also it's it's the Primitive that makes up the economy fundamentally these markets are just games those mechanics of you know lending Protocols are just we literally call it game design right it's mechanism design um yes and so when you have those basics in place and people are starting to build agents that train against each

(44:02)
other today it's you know fun games with Bots that move around and shoot each other or whatever it is uh but tomorrow it will be markets fully decentralized onchain intelligent Market uh and so we we think that that's super super exciting um and it has the same mechanics which is basically if you build a better bot than someone else you can earn the tokens from that bot in like a play of versus player Arena style which again exactly like markets are eventually so so that's that's an exciting beginning people are also

(44:36)
building you know onchain social systems um it's one of those we can't yet talk about unfortunately but another is that uh you know it's like a decentralized chat room and has Twitter like elements you can send tokens to people as they talk and really it's been like two two and a half three weeks of of test net so the that they're building things at all is kind of incredible and the uh the seeds of an ecosystem are already there I mean it took two or three years for our we to get to the same level at least I think

(45:09)
the closing question here I'm sure a lot of people are excited about the timeline so what is the current status in AO I understand you guys are in testet when can we expect you know the next big milestones and what should people be watching out for uh we don't rush security sensitive things fundamentally we we're not going to we're also not going to call it main net until we're virtually certain that the core specification doesn't need to change like we we really believe in building real

(45:38)
protocols uh we think that the crypto has unfortunately lost its way quite significantly uh in the in the path between Bitcoin and web3 as we see it today where the line between a centralized startup and a product and a protocol has become extremely blurred and fundamentally what is a protocol supposed to do well it's supposed to be a neutral language that many participants can use to achieve a task together and if it changes all the time it's not a neutral language it looks far closer to a product and if it's not a

(46:16)
real protocol then it can't offer users rights right like if you use you know ethereum before or if you're an ethereum minor before the proof of stake um switch over was it 18 months ago now then your rights in the economic game that was created inside ethereum that is ethereum if you will uh we're not protected and then the day that that switch happened 8 billion worth of gpus became useless that's not a real protocol sorry I I love ethereum took part in the Ico way back I funny enough on the website the the tagline at that

(46:54)
point was ethereum is the world computer H that's cool I want to be part of that um so I took some Bitcoin I'd mind and and put it in the Ico but and and they they did create something truly astonishing smart contract systems and decentralized finance um but it's not the world computer and it's becoming more of a protocol perhaps but realistically it it doesn't necessarily give users that many rights it has a long road map of things that they promise will change about the system and when you have that it's just

(47:30)
very hard to marry it with uh the guarantees that are offered by real protocols in the you know space outside of crypto um or or Bitcoin itself so with AO what we're trying to do is make sure that the protocols themselves the components are stabilized before we call it main net and we think we're actually pretty close to that and when you look at ethereum like what they spent most of the time doing is attempting to solve scalability and if you look at most of these other systems really the fundamental thing is well it can't be

(48:02)
full and complete because it isn't yet scalable so we want to get it to that point where the network is truly at a at a place where um it it not only works today and it would work without our intervention ever again but it would also work and scale arbitrarily that's the kind of thing that gives people rights that they can build against we want people to set up data centers running compute units we want people to stake large amounts of money in the system for the passage of messages that will happen much easier if

(48:36)
people can understand well this thing isn't going to change from under my feet you could okay here's a controversial take in some senses a road map is a rug pull right what you're promising is that in the future things will shift so if you use the system today the way it is presented to you now will be taken from you right if were those uh you know GPU owners well the system kind of rug pulled you right um and if if there's a group that's always constantly stepping in and changing it along some road map for

(49:10)
start maybe they don't actually finish executing the road map which is what happens 90% of the time and the other 10% of the time they do and you lose your rights as they currently existed in the system and yeah this this just doesn't speak to us this is not what crypto is about and so we have the opportunity here because the system is arbitrarily scalable and you know we defined it a couple of times it's very flexible you can plug in whatever virtual machine you want uh you can choose whatever staking

(49:42)
or security system that you want to use with your process because it has that flexibility we think we have a good shot of getting a stable protocol out there that that really does offer users rights and other people can can build on with guarantees that be taken from them I think that's an amazing note to end this on I really like that uh that portrayal of uh road maps as like a slowmo four toad rug that's the first time I've heard anyone put it that way so that's very interesting um well Sam

(50:12)
I'm really really honored that you came on the show and and explain to us what the AO vision is for people who want to stay on top of all of this what are the best channels for them to do this yeah there's AO the computer is Twitter account one of the main ones there's also a decentralized ecosystem around AO already fortunately um so this AO Computer Club if you're like a sort of techy you might want to follow that as well they talk about the parts of AO that you know based on this idea it is a

(50:40)
shared computer and you can compose on each other's stuff and it's it's almost like a what would you say like a mailing list or like a magazine um so it has that kind of feel to it AO the computer is much more sort of crypto focused um yeah and ao. dodev or actually ao. any we Gateway we'll get you to the website awesome perfect well thank you so much for coming on the show Sam this was a blast amazing thanks for having me hey thanks for supporting another episode of The Block wrench podcast if you've

(51:07)
enjoyed this episode please give us a five-star rating on Spotify and apple podcast or whatever platform you're listening to this on it really helps us a lot or if you prefer YouTube you can subscribe to our Channel on YouTube as well to not miss an episode I'd love to hear from you guys as well and I personally make sure to read every single comment on YouTube or tweets that are directed at me so feel free leave a comment there let us know what project you want us to bring on or what trends you want us to talk about or tweet at me

(51:32) at Mr Jason Troy or at theblock crunch on the platform previously known as Twitter currently known as X and thank you so much for supporting and I'll see you in the next episode [Music]

---

〈Arweave Japan とは〉
Arweave Japan は Arweave / AO の日本語ビルダーエコシステム構築を目的とした分散型組織です。

〈​Arweave / AO とは？〉
イーサリアム L1 のリステーキングによってセキュリティが担保され、TVL はローンチ数ヶ月で 1000 億円近くまで上がり、今後数兆円規模の市場が期待されます。完全フェアローンチされた AO のトークン設計によって、この流動性は AO 上のプロジェクトが活用することができ、ビットコインと同じ半減スケジュールでミントされる AO トークンは開発者やプロジェクトが受け取れる仕組みとなっています。

​Web2 を置き換えるレベルで実用的なプロジェクトが構築できる唯一無二の分散型プロトコル AO で開発することはグローバルの第一線で活躍する非常に大きなチャンスとなっています。

〈Social Links〉
Website
X(Twitter)
Discord Community
Github

〈Tech Blog〉
Qiita Organization
Zenn Publication
dev[.]to