The bottleneck of DeFi ultimately lies in its performance limitations. Traditional blockchain architectures constrain the design possibilities for DeFi applications. So, what is the solution proposed by AgentFi, based on AO?

Introduction

It has been over three years since the explosion of DeFi Summer, and more than half a year since the approval of the landmark compliant ETF. Has the situation changed?

Looking back, Ethereum’s smart contracts enhanced the programmability of blockchains, transforming them from simple ledger systems into infrastructures supporting various applications. Among many possible use cases, decentralized finance (DeFi) has undeniably become the most practical and prominent application of blockchain technology.

Let’s take a look at the DeFi TVL data from DeFiLlama. Currently, the TVL of DeFi applications has surpassed $80 billion. In recent years, many public chains have emerged, and even Ethereum’s L2 networks are helping to offload some of the traffic from Ethereum’s L1. However, Ethereum alone still accounts for more than half of the total locked DeFi assets.

Image source: defillama.com/chains

DeFi’s original ambition was to disrupt traditional financial models like lending, payments, and insurance, enabling users to complete these transactions without relying on traditional financial institutions like banks. However, despite this ambition, the TVL in DeFi has stagnated for some time without making a significant breakthrough.

Most experts believe that DeFi has been hindered by Ethereum’s network performance, high costs, and other limitations, preventing it from scaling up or supporting more complex financial use cases. However, even with the emergence of many L2 solutions and high-performance new public blockchains, DeFi has not experienced the expected growth. Instead, issues like liquidity fragmentation and reduced interoperability have arisen. Ethereum still maintains the most complete DeFi ecosystem and the highest level of interoperability, remaining the platform of choice for DeFi projects.

Now, a new trend is emerging: a novel DeFi paradigm based on AO—AgentFi. This innovation is breaking through the traditional limitations of DeFi.

AO, built on Arweave’s storage layer, has created a computational layer that supports parallel process execution, solving scalability issues and enabling nearly infinite expansion. The combination of AO and Arweave is an implementation of the Storage-based Consensus Paradigm (SCP). \
In AO, smart contracts exist as processes. By overcoming performance bottlenecks, anyone can run their own processes to act as their financial agents, with consensus managed by Arweave’s storage layer. This is the foundation of AgentFi.

Will this new form of DeFi, AgentFi, replace traditional DeFi and become the dominant model for decentralized finance? Let me explain in more detail.

Limitations of Traditional DeFi

In traditional blockchain architectures, block space is designed as a scarce resource. Both users and applications must compete to access this limited resource. When network congestion occurs, individuals need to pay higher fees to secure block space. This is the fundamental cause of performance limitations. Ethereum’s performance constraints are now evident, with a modest throughput of around 30 TPS [1], which often falls short during peak times, leading to gas fees skyrocketing by dozens of times. People have become accustomed to this reality. In fact, even L2 solutions and many high-performance public blockchains face similar performance ceilings. While these ceilings may be higher, accommodating business-scale volumes akin to traditional finance remains a difficult challenge.

To conserve performance and reduce gas fees, traditional DeFi has been designed to use a single smart contract to host business assets and run financial operations. However, because both the funds and business logic are managed by a single contract, achieving true diversification and personalized business operations becomes difficult. While this design simplifies management and ensures consistency, it also strips users of autonomy over business logic and financial operations, making it hard to meet the increasingly diverse needs of users.

For developers, writing contracts requires careful consideration of gas fees, with an emphasis on avoiding complex code. On Ethereum, a basic ETH transfer requires a gas limit of 21,000 gwei, while an ERC20 token transfer requires 65,000 gwei. For slightly more complex scenarios like swaps, NFT transactions, or lending, the gas fees can easily exceed 300,000 gwei [2]. As the business logic becomes more complex, gas consumption can become prohibitively expensive for users. This significantly limits the flexibility for developers and stifles the richness and innovation of DeFi.

To fundamentally address these challenges, the market requires a more powerful infrastructure and an accompanying financial system. This is where AO (Actor Oriented) comes in, with AgentFi representing a new exploration of next-generation DeFi within the AO ecosystem.

AO: Infrastructure with Near-Infinite Scalability

AO stands for Actor Oriented, meaning it is a decentralized computational protocol based on role-oriented design. In essence, AO is conceptually closer to the idea of a world computer than Ethereum. I understand AO as a supercomputing layer, with its core goal being to provide trustless and collaborative computing services without scale limitations.

Let’s take a look at the workflow diagram of a super-parallel computer built on AO:

Image source: AO white paper

• Message Generation: Users or processes initiate requests by generating messages. These messages must adhere to the specifications set by the AO protocol to ensure they are properly transmitted and processed across the network.
• Messenger Unit (MU) Relay: The Messenger Unit (MU) receives the user-generated messages, functioning as a router to forward the messages to the appropriate SU (Scheduling Unit) node in the network. During this process, the MU signs the message to ensure data integrity.
• Scheduling Unit (SU) Processing: When a message reaches an SU node, it assigns a nonce to the message to ensure sequence consistency within the same process. The message and its corresponding nonce are then uploaded to the Arweave consensus layer for permanent storage.
• Computing Unit (CU) Computation: Upon receiving the message, the Computing Unit (CU) executes the relevant computational task. Once the calculation is complete, the CU generates a signed result and returns it to the SU. This signature ensures the correctness and verifiability of the computation.

So, where does consensus come from?

In AO, storage equals consensus. As processes run, they generate messages that are transmitted and written to Arweave, creating a “holographic state.” This means that the running state of a process is verifiable. In other words, the immutable storage provided by Arweave guarantees verifiability. This concept may seem counterintuitive at first, but once you fully understand the SCP (Storage-based Consensus Paradigm), it becomes clear. If that’s still unclear, you can think of it as similar to inscriptions to understand the idea.

Beyond verifiability, we also need to solve the question of who will perform the verification. With verifiability in place, anyone can provide verification services. On AO, applications can choose their verification services, allowing them to flexibly decide on the security level based on their specific business needs. Coupled with the economic game of optimistic challenges, the reliability of verification can be ensured.

On the computer built on AO, applications are composed of an arbitrary number of communication processes.
AO does not allow processes to share memory but permits them to communicate via a native messaging standard.
Since messaging is asynchronous, AO achieves a scalability mechanism similar to that of traditional Web2 distributed systems by focusing on message passing.

This means that, theoretically, AO does not have performance limitations.

For developers, they can choose to use public nodes or opt to run their own services on private nodes. In this case, if performance bottlenecks arise, they can simply scale up their own nodes, much like running a Web2 service.
Additionally, this mode of operation brings extra benefits—computation nodes can provide computational power for AI scenarios. This is something we can explore in greater detail at a later time.

What makes AgentFi different?

Unlike traditional DeFi, which relies on a unified smart contract to host funds and run financial operations, the concept behind AgentFi is that individuals can run their own processes on the AO computer and host their own funds to act as their financial agents. But what does this look like in practice? Let’s take the leading DEX on AO, Permaswap, as an example.

In traditional DeFi, let’s say Alice wants to swap Token A for Token B on a DEX. First, a liquidity pool is required, with the smart contract hosting the funds to provide the exchange functionality for tokens A / B. The exchange rate is determined by the market-making curve used by the smart contract (e.g., xy=k). In Permaswap*, however, each liquidity provider (LP) hosts their own market-making funds via their agent process and customizes their market-making curve and strategy. Of course, LPs can also adopt an “extreme market-making strategy”—simply placing a limit order.

In fact, we find that Permaswap can combine both AMM (Automated Market Maker) and order book trading models. For users, when they initiate a transaction, the matching mechanism that helps complete the trade could be either an AMM, a limit order, or even a combination of both.

Overall, AgentFi Features Three Key Characteristics:

1. Self-Custody: Users retain control of their funds through self-managed agent processes, executing their own trading strategies rather than relying on a unified smart contract.
2. Personalization: Users can flexibly set their financial parameters via their agent processes. Essentially, this means a user can operate their own exchange, customizing trading strategies and fee structures. If extended to lending services, it’s akin to running their own bank, where they can define interest rates. Taking it a step further, users can deploy custom financial strategy programs within their self-custodied processes, including AI-enhanced intelligent strategies.
3. Peer-to-Peer: Matching between supply and demand shifts from the traditional pool-to-peer model in DeFi to a truly peer-to-peer model.

On Ethereum, financial operations rely on a distinction between contract accounts (CA) and externally owned accounts (EOA), with various financial scenarios implemented via different smart contract codes, requiring active user participation. In AO, the paradigm is agent-oriented, where different agents can fulfill distinct functionalities, allowing financial behaviors to be executed autonomously via agents. In my view, AgentFi resembles building blocks, enabling the creation of a richer decentralized financial ecosystem through composable agents.

When there are a large number of self-custodied processes, how can they communicate with each other and achieve composability? This is where the FusionFi Protocol comes in. It is the development standard and communication specification for agents on AO. Almost all financial services can be abstracted as the flow and processing of “instruments.” The FusionFi Protocol defines a standardized format for these instruments. With such a standard in place, complex and diverse financial models can be integrated. Developers can build various financial services based on the FusionFi standard, such as exchanges, lending platforms, futures, and even stablecoins.

In the future, the FusionFi Protocol could adopt a proposal mechanism similar to BIP, EIP, and NIP—industry standardization models—to encourage broader participation in the development of the protocol, thus fostering the sustainable growth of the ecosystem.

For a more detailed explanation of the FusionFi Protocol, I will dedicate a separate article to dive deeper into the topic.

Conclusion

Ethereum’s performance and cost issues have constrained the development of DeFi. While L2 solutions and high-performance public blockchains have made notable progress in scaling, an invisible ceiling still hampers the growth of financial applications.

To break through these limitations, a paradigm-shifting network—AO Superparallel Computer—has emerged. With AO’s unlimited scalability, AgentFi has become a reality. Users can run their own processes, self-manage funds, and customize financial operations.

The agent-oriented financial model offers broader application scenarios compared to traditional DeFi.

Data Sources:

1. Ethereum TPS Analysis: https://www.chaincatcher.com/zh-tw/article/2102262
2. Ethereum Gas Usage Statistics: https://etherscan.io/gastracker

References:

1. Technical Analysis of AO Superparallel Computer
2. AO Protocol: Decentralized, Permissionless Supercomputer: https://x.com/kylewmi/status/1802131298724811108
3. Smart Finance: From AgentFi to FusionFi: https://www.notion.so/permadao/AgentFi-FusionFi-6461feb8915c4ea5a1252eca80aa6a4a

Disclaimer:

1. This article is reproduced from [PermaDAO)]. The copyright belongs to the original author [十四君]. If you have any objection to the reprint, please contact Gate Learn team, the team will handle it as soon as possible according to relevant procedures.
2. Disclaimer: The views and opinions expressed in this article represent only the author’s personal views and do not constitute any investment advice.
3. The Gate Learn team translates other language versions of the article. Unless otherwise stated, the translated article may not be copied, distributed or plagiarized.