Author: Kevin, the Researcher at BlockBooster
As a key puzzle piece in the development of the industry, AI Agent framework may have the dual potential to promote the implementation of technology and the maturity of the ecosystem. The hotly discussed frameworks in the market include: Eliza, Rig, Swarms, ZerePy, etc. These frameworks attract developers and build reputation through Github Repo. The form of "library" currency issuance allows these frameworks to have both the characteristics of waves and particles, similar to light, and the Agent framework has both the characteristics of serious externalities and Memecoin. This article will focus on interpreting the "wave-particle duality" of the framework and why the Agent framework can become the last corner.
The externalities brought by the Agent framework can leave spring buds after the bubble subsides.
Since the birth of GOAT, the impact of Agent narrative on the market has continued to increase, just like a Kung Fu master, with his left fist "Memecoin" and his right palm "industry hope", you will always be defeated by one of these moves. In fact, the application scenarios of AI Agent are not strictly distinguished, and the boundaries between platforms, frameworks and specific applications are blurred, but they can still be roughly classified according to the preferences of tokens or protocols. However, according to the development preferences of tokens or protocols, they can still be divided into the following categories:
Launchpad: Asset issuance platform. Virtuals Protocol and clanker on the Base chain, Dasha on the Solana chain.
AI Agent Application: It is between Agent and Memecoin, and has outstanding features in memory configuration, such as GOAT, aixbt, etc. These applications are generally one-way output, and the input conditions are very limited.
AI Agent Engine: Griffain of Solana chain and Spectre AI of base chain. Griffain can evolve from read-write mode to read, write, and act mode; Spectre AI is a RAG engine, which searches on the chain.
AI Agent Framework: For the framework platform, the Agent itself is an asset, so the Agent framework is the asset issuance platform for the Agent and the Launchpad for the Agent. Currently, representative projects include ai16, Zerebro, ARC, and the hotly discussed Swarms.
Other small directions: comprehensive Agent Simmi; AgentFi protocol Mode; falsification Agent Seraph; real-time API Agent Creator.Bid.
Further discussion of the Agent framework shows that it has sufficient externalities. Unlike the developers of major public chains and protocols who can only choose in different development language environments, the total number of developers in the industry has not shown a corresponding increase in market value. Github Repo is where Web2 and Web3 developers build consensus. Building a developer community here is more attractive and influential to Web2 developers than any "plug-and-play" package developed by a single protocol.
The four frameworks mentioned in this article are all open source: Eliza framework by ai16z has 6,200 stars; Zerebro's ZerePy framework has 191 stars; ARC's RIG framework has 1,700 stars; Swarms' Swarms framework has 2,100 stars. At present, Eliza framework is widely used in various agent applications and is the most widely covered framework. ZerePy is not highly developed, and its development direction is mainly on X. It does not yet support local LLM and integrated memory. RIG has the highest relative development difficulty, but it can give developers the freedom to maximize performance optimization. Swarms has no other use cases except the launch of mcs by the team, but Swarms can integrate different frameworks and has a lot of room for imagination.
In addition, in the above classification, the separation of Agent engine and framework may cause confusion. But I think there is a difference between the two. First of all, why is it an engine? It is relatively appropriate to compare it with the search engine in real life. Unlike homogenized Agent applications, the performance of Agent engine is above it, but at the same time it is a completely encapsulated black box adjusted through API interface. Users can experience the performance of Agent engine in the form of fork, but they cannot grasp the overall picture and customization freedom like the basic framework. Each user's engine is like generating an image on the tuned Agent, which is to interact with the image. The framework is essentially for adapting the chain, because the ultimate goal of making Agent framework in Agent is to integrate with the corresponding chain. How to define the data interaction method, how to define the data verification method, how to define the block size, how to balance consensus and performance, these are things that the framework needs to consider. And what about the engine? You only need to fully fine-tune the model and set the relationship between data interaction and memory in a certain direction. Performance is the only evaluation criterion, but the framework is not.
Using the perspective of "wave-particle duality" to evaluate the Agent framework may be a prerequisite for ensuring that we are on the right track
The life cycle of an agent executing an input and output operation requires three parts. First, the underlying model determines the depth and method of thinking, then the memory is the place for customization, and after the basic model has output, it is modified according to the memory, and finally the output operation is completed on different clients.
Source: @SuhailKakar
In order to prove that the Agent framework has "wave-particle duality", "wave" has the characteristics of "Memecoin", representing community culture and developer activity, emphasizing the attractiveness and dissemination ability of Agent; "particle" represents the characteristics of "industry expectations", representing the underlying performance, actual use cases and technical depth. I will explain from two aspects and combine the development tutorials of the three frameworks as examples:
Quick-join Eliza frame
Setting up the environment
Source: @SuhailKakar
Install Eliza
Source: @SuhailKakar
3. Configuration File
Source: @SuhailKakar
4. Set Agent personality
Source: @SuhailKakar
Eliza's framework is relatively easy to use. It is based on TypeScript, a language that most Web and Web3 developers are familiar with. The framework is concise and not overly abstract, allowing developers to easily add the features they want. From step 3, we can see that Eliza can be integrated with multiple clients, and it can be understood as an assembler for multi-client integration. Eliza supports platforms such as DC, TG, and X, as well as multiple large language models. It can be input through the above social media and output through LLM models. It also supports built-in memory management, allowing any developer who is accustomed to it to quickly deploy AI Agents.
Due to the simplicity of the framework and the richness of the interface, Eliza greatly lowers the threshold for access and achieves a relatively unified interface standard.
One-click ZerePy framework
1. Fork ZerePy's library
Source: https://replit.com/@blormdev/ZerePy?v=1
2. Configure X and GPT
Source: https://replit.com/@blormdev/ZerePy?v=1
3. Set Agent personality
Source: https://replit.com/@blormdev/ZerePy?v=1
Performance-optimized Rig framework
Take building a RAG (Retrieval Enhanced Generation) Agent as an example:
1. Configure the environment and OpenAI key
Source: https://dev.to/0thtachi/build-a-rag-system-with-rig-in-under-100-lines-of-code-4422
2. Set up the OpenAI client and use Chunking for PDF processing
Source: https://dev.to/0thtachi/build-a-rag-system-with-rig-in-under-100-lines-of-code-4422
3. Set up document structure and embedding
Source: https://dev.to/0thtachi/build-a-rag-system-with-rig-in-under-100-lines-of-code-4422
4. Create vector storage and RAG agent
Source: https://dev.to/0thtachi/build-a-rag-system-with-rig-in-under-100-lines-of-code-4422
Rig (ARC) is an AI system building framework based on the Rust language for LLM workflow engines. It aims to solve more low-level performance optimization problems. In other words, ARC is an AI engine "toolbox" that provides background support services such as AI calls, performance optimization, data storage, and exception handling.
Rig aims to solve the "calling" problem to help developers better select LLM, better optimize prompt words, more effectively manage tokens, and how to handle concurrent processing, manage resources, reduce latency, etc. Its focus is on how to "use it well" in the collaboration process between AI LLM models and AI Agent systems.
Rig is an open source Rust library that aims to simplify the development of LLM-driven applications (including RAG Agent). Because Rig is more open, it requires developers to have a higher level of understanding of Rust and Agent. The tutorial here is the most basic RAG Agent configuration process. RAG enhances LLM by combining LLM with external knowledge retrieval. In other DEMOs on the official website, you can see that Rig has the following features:
Unified LLM interface: supports consistent APIs for different LLM providers to simplify integration.
Abstract workflow: Pre-built modular components allow Rig to undertake the design of complex AI systems.
Integrated vector storage: Built-in support for vector storage, providing efficient performance in similar search agents such as RAG Agent.
Flexible embedding: Provides an easy-to-use API for processing embedding, reducing the difficulty of semantic understanding when developing similar search agents such as RAG Agent.
It can be seen that compared with Eliza, Rig provides developers with additional space for performance optimization, helping developers to better debug the calls and collaborative optimization of LLM and Agent. Rig uses Rust-driven performance, and takes advantage of Rust's advantages of zero-cost abstraction and memory safety, high performance, and low-latency LLM operations. It can provide more freedom at the underlying level.
Decomposing the Swarms framework
Swarms aims to provide an enterprise-level production-grade multi-agent orchestration framework. The official website provides dozens of workflow and agent parallel and serial architectures. Here is a small part of them.
Sequential Workflow
Source: https://docs.swarms.world
The Sequential Swarm architecture processes tasks in a linear order. Each agent completes its task before passing the result to the next agent in the chain. This architecture ensures in-order processing and is useful when tasks have dependencies.
Use Cases:
Each step in a workflow is dependent on the previous step, such as an assembly line or sequential data processing.
Scenarios that require strict adherence to the order of operations.
Hierarchical architecture:
Source: https://docs.swarms.world
Implements top-down control, where the upper-level agent coordinates tasks between subordinate agents. Agents perform tasks simultaneously and then feed their results back into the loop for final aggregation. This is very useful for highly parallelizable tasks.
Spreadsheet structure:
Source: https://docs.swarms.world
A large-scale swarm architecture for managing multiple agents working simultaneously. It can manage thousands of agents simultaneously, each running on its own thread. It is ideal for supervising the output of large-scale agents.
Swarms is not only an agent framework, but also compatible with the above-mentioned Eliza, ZerePy and Rig frameworks. With the modular idea, it maximizes the performance of agents in different workflows and architectures to solve corresponding problems. There is nothing wrong with the conception of Swarms and the progress of the developer community.
Eliza: The easiest to use, suitable for beginners and rapid prototyping, especially for AI interaction on social media platforms. The framework is simple, easy to integrate and modify quickly, and suitable for scenarios that do not require excessive performance optimization.
ZerePy: One-click deployment, suitable for rapid development of AI Agent applications for Web3 and social platforms. Suitable for lightweight AI applications, with a simple framework and flexible configuration, suitable for rapid construction and iteration.
Rig: Focuses on performance optimization, especially in high-concurrency and high-performance tasks, suitable for developers who need detailed control and optimization. The framework is relatively complex and requires certain Rust knowledge, suitable for more experienced developers.
Swarms: Suitable for enterprise applications, supports multi-agent collaboration and complex task management. The framework is flexible, supports large-scale parallel processing, and provides a variety of architecture configurations, but due to its complexity, it may require a stronger technical background to apply effectively.
In general, Eliza and ZerePy have advantages in ease of use and rapid development, while Rig and Swarms are more suitable for professional developers or enterprise applications that require high performance and large-scale processing.
This is why the Agent framework has the characteristics of "industry hope". The above framework is still in its early stages, and the top priority is to seize the first-mover advantage and establish an active developer community. The performance of the framework itself and whether it lags behind the popular Web2 applications are not the main contradictions. Only the framework that attracts a steady stream of developers can win in the end, because the Web3 industry always needs to attract the attention of the market. No matter how strong the framework performance is and how strong the fundamentals are, if it is difficult to get started and no one is interested, it is putting the cart before the horse. On the premise that the framework itself can attract developers, the framework with a more mature and complete token economic model will stand out.
The fact that the Agent framework has the characteristics of "Memecoin" is very easy to understand. The above framework tokens do not have a reasonable token economic design, the tokens have no use cases or the use cases are very simple, there is no proven business model, and there is no effective token flywheel. The framework is just a framework, and there is no organic combination between the framework and the token. In addition to FOMO, the growth of the token price is difficult to obtain fundamental support, and there is not enough moat to ensure stable and lasting value growth. At the same time, the above framework itself is also relatively rough, and its actual value does not match the current market value, so it has a strong "Memecoin" characteristic.
It is worth noting that the "wave-particle duality" of the Agent framework is not a disadvantage, and it cannot be roughly understood as a half-full tank of water that is neither a pure Memecoin nor has a token use case. As I mentioned in the previous article: the lightweight Agent is covered with the ambiguous veil of Memecoin, community culture and fundamentals will no longer be a contradiction, and a new asset development path is gradually emerging; although there are bubbles and uncertainties in the early stage of the Agent framework, its potential to attract developers and promote the implementation of applications cannot be ignored. In the future, a framework with a complete token economic model and a strong developer ecosystem may become a key pillar of this track.
