A team that can crack how to create a sustainable open-source economy while maintaining the core spirit of its code will have an impact that far exceeds the framework of agents.

Written by: Shlok Khemani, Oliver Jaros

Compiled by: Shan Ouba, Golden Finance

Over the past year, Decentralised.co has delved into the intersection of cryptocurrency and artificial intelligence. We even built a product used by over 70,000 people to track AI agents and agent infrastructure. Although the frenzy around the field has subsided in recent weeks, the impact of AI on technology and society is something we have never seen since the internet. If cryptocurrency is to become the financial rails of the future, as we predict, then its intertwining with AI will be a recurring theme rather than a one-off.

One of the more interesting categories of projects emerging from this wave is the crypto-native AI agent frameworks. They are an engaging experiment that brings the core principles of blockchain—permissionless value transfer, transparency, and consistent incentives—into AI development. Their open-source nature provides us with a rare opportunity to peek into their inner workings, analyzing not only their promises but also how they actually function.

In this article, we first dissect the practical implications of agent frameworks and their significance. Then, we address an obvious question: why do we need crypto-native frameworks when mature options like LangChain exist? To this end, we analyze leading crypto-native frameworks and their advantages and limitations in different use cases. Finally, if you are building an AI agent, we will help you decide which framework might suit your needs—or whether you should use a framework at all.

Let’s dive in.

Abstract

"The progress of civilization is measured by the number of important operations we can perform without thinking." - Alfred North Whitehead

Think about how our ancestors lived. Every household had to grow its own food, make its own clothes, and build its own shelter. They spent countless hours on basic survival tasks, leaving little time for anything else. Even two centuries ago, nearly 90% of people worked in agriculture. Today, we buy food from supermarkets, live in houses built by experts, and wear clothes produced in distant factories. Tasks that once consumed generations of effort have turned into simple transactions. Today, only 27% of the global population is engaged in agriculture (with developed countries dropping below 5%).

As we begin to master a new technology, familiar patterns emerge. We first understand the basic principles—what works, what doesn’t, and which patterns keep recurring. Once these patterns become clear, we package them into easier, faster, and more reliable abstractions. These abstractions free up time and resources to tackle more diverse and meaningful challenges. Building software is no different.

Take web development as an example. In the early days, developers had to write everything from scratch—handling HTTP requests, managing state, and creating UIs—tasks that were both complex and time-consuming. Then frameworks like React emerged, greatly simplifying these challenges by providing useful abstractions. Mobile development followed a similar path. Initially, developers needed deep, platform-specific knowledge until tools like React Native and Flutter allowed them to write code once and deploy it anywhere.

A similar pattern of abstraction has emerged in machine learning. In the early 2000s, researchers discovered the potential of GPUs for ML workloads. At first, developers had to wrestle with graphical primitives and languages like GLSL from OpenGL—tools not built for general-purpose computing. In 2006, NVIDIA launched CUDA, making GPU programming more accessible and bringing ML training to a broader developer audience, changing everything.

As ML development gained momentum, specialized frameworks emerged to abstract the complexities of GPU programming. TensorFlow and PyTorch enabled developers to focus on model architecture rather than getting bogged down in low-level GPU code or implementation details. This accelerated the iteration of model architectures and the rapid advancements in AI/ML we have seen in recent years.

We now see a similar evolution with AI agents—software programs capable of making decisions and taking actions to achieve goals, much like human assistants or employees. They use large language models as their "brains" and can leverage various tools, such as searching the web, making API calls, or accessing databases to complete tasks.

To build an agent from scratch, developers must write complex code to handle every aspect: how the agent thinks about problems, how it decides which tools to use and when, how it interacts with those tools, how it remembers the context of earlier interactions, and how it breaks down large tasks into manageable steps. Each pattern must be addressed individually, leading to duplicated efforts and inconsistent results.

This is where AI agent frameworks come into play. Just as React simplified web development by handling the tricky parts of UI updates and state management, these frameworks tackle common challenges in building AI agents. They provide ready-made components for effective patterns we discover, such as how to construct the decision-making process of an agent, integrate different tools, and maintain context across multiple interactions.

With a framework, developers can focus on the unique aspects that make their agents stand out—their specific functionalities and use cases—rather than reinventing these foundational components. They can create complex AI agents in days or weeks instead of months, experiment with different approaches more easily, and draw on best practices discovered by other developers and the community.

To better understand the importance of frameworks, consider a developer building an agent to help doctors review medical reports. Without a framework, they would need to write all the code from scratch: handling email attachments, extracting text from PDFs, formatting the text correctly for the LLM, managing conversation history to track what has been discussed, and ensuring the agent responds appropriately. This is a lot of complex code for tasks that are not unique to their specific use case.

With an agent framework, many of these building blocks can be used directly. The framework handles reading emails and PDFs, provides patterns for constructing medical knowledge prompts, manages conversation flows, and even helps track important details across multiple exchanges. Developers can focus on the aspects that make their agents unique, such as fine-tuning medical analysis prompts or adding specific safety checks for diagnoses, rather than reinventing common patterns. What might have taken months to build from scratch can now be prototyped in days.

LangChain has become the Swiss Army knife of AI development, providing a flexible toolkit for building LLM-based applications. While not strictly an agent framework, it offers the foundational building blocks for constructing most agent frameworks, from chains for sorting LLM calls to memory systems for maintaining context. Its extensive integration ecosystem and rich documentation make it the preferred starting point for developers looking to build practical AI applications.

Then there are multi-agent frameworks like CrewAI and AutoGen, which enable developers to build systems where multiple AI agents work together, each with its unique roles and capabilities. These frameworks do not simply execute tasks sequentially; they emphasize agent collaboration through dialogue to solve problems collectively.

For example, when assigning a research report, one agent might outline its structure, another might gather relevant information, and a third might comment on and refine the final draft. It’s like assembling a virtual team where AI agents can discuss, debate, and collaboratively improve solutions. Multi-agent systems that work together to achieve higher-level goals are often referred to as AI agent "clusters."

AutoGPT, while not a traditional framework, pioneered the concept of autonomous AI agents. It demonstrated how AI could take a high-level goal, break it down into subtasks, and independently complete them with minimal human input. Despite its limitations, AutoGPT sparked a wave of innovation in autonomous agents and influenced the design of subsequent, more structured frameworks.

But why crypto?

All this background ultimately brings us to the rise of crypto-native AI agent frameworks. At this point, you might wonder why Web3 needs its own frameworks when we have relatively mature options like LangChain and CrewAI in Web2. Surely, developers can use these existing frameworks to build any agents they want? Given the industry's penchant for imposing Web3 on any and all narratives, this skepticism is reasonable.

We believe there are three compelling reasons for the existence of Web3-specific agent frameworks.

On-chain financial agents

We believe that most financial transactions in the future will occur on blockchain rails. This accelerates the demand for a class of AI agents that can parse on-chain data, execute blockchain transactions, and manage digital assets across multiple protocols and networks. From automated trading bots that can detect arbitrage opportunities to portfolio managers executing yield strategies, these agents rely on deep integration of blockchain functionality in their core workflows.

Traditional Web2 frameworks do not provide native components for these tasks. You have to piece together third-party libraries to interact with smart contracts, parse raw on-chain events, and handle private key management—introducing complexity and potential vulnerabilities. In contrast, dedicated Web3 frameworks can handle these functionalities out of the box, allowing developers to focus on the logic and strategy of their agents rather than wrestling with low-level blockchain plumbing.

Native coordination and incentives

Blockchains are not just about digital currencies. They provide a global, trust-minimized record system with built-in financial tools that can enhance multi-agent coordination. Developers can use on-chain primitives like staking, escrow, and incentive pools to align the interests of multiple AI agents, rather than relying on off-chain reputations or isolated databases.

Imagine a group of agents collaborating to complete a complex task (e.g., data labeling for training a new model). The performance of each agent can be tracked on-chain, and rewards can be automatically allocated based on contributions. The transparency and immutability of blockchain-based systems allow for fair compensation, stronger reputation tracking, and real-time evolving incentive schemes.

Crypto-native frameworks can explicitly embed these functionalities, allowing developers to design incentive structures using smart contracts without having to reinvent the wheel every time they need to establish trust among agents or pay another agent.

New opportunities in early markets

Although frameworks like LangChain have already established thought-sharing and network effects, the field of AI agents is still in its infancy. It remains unclear what the final state of these systems will look like, and there is no single method that can lock in the market.

Cryptoeconomic incentives open up new possibilities for how frameworks can be built, managed, and monetized, possibilities that cannot be fully mapped to traditional SaaS or Web2 economics. Experiments at this early stage can unlock new monetization strategies for the frameworks themselves, not just the agents built on top of them.

Competitors

ElizaOS, associated with the popular project AI16Z, is a TypeScript-based framework for creating, deploying, and managing AI agents. It is designed as a Web3-friendly AI agent operating system, allowing developers to build agents with unique personalities, flexible tools for blockchain interaction, and easy scalability through multi-agent systems.

Rig is an open-source AI agent framework developed by Playgrounds Analytics Inc., built using the Rust programming language, for creating modular and scalable AI agents. It is associated with the AI Rig Complex (ARC) project.

Daydreams is a generative agent framework initially created for autonomous agents in on-chain games but later expanded to execute on-chain tasks.

Pippin is an AI agent framework developed by Yohei Nakajima, the founder of BabyAGI, aimed at helping developers create modular and autonomous digital assistants. Yohei first built a standalone agent and then expanded it into a general framework.

ZerePy is an open-source Python framework designed to deploy autonomous agents across multiple platforms and blockchains, focusing on creative AI and social media integration. Like Pippin, Zerepy was initially a standalone agent called Zerebro, which later expanded into a framework.

Standards

To evaluate the strengths of each framework, we take the perspective of developers who want to build AI agents. What would they care about? We find it useful to categorize the evaluation into three main areas: core, functionality, and developer experience.

You can think of the core of a framework as the foundation for building all other agents. If the core is weak, slow, or not continuously evolving, the agents created using that framework will be similarly limited. The core can be evaluated based on the following criteria:

Core reasoning loop: The brain of any agent framework; how it solves problems. A strong framework supports everything from basic input-output flows to complex patterns like thought chains. Without robust reasoning capabilities, agents cannot effectively break down complex tasks or evaluate multiple options, reducing them to mere chatbots.

Memory mechanisms: Agents need both short-term memory for ongoing conversations and long-term storage for persistent knowledge. Good frameworks do not just remember—they understand the relationships between different pieces of information and can prioritize which information is worth retaining and which should be forgotten.

Embedding and RAG support: Modern agents must utilize external knowledge, such as documents and market data. Strong frameworks can easily embed this information and retrieve it contextually through RAG, building responses based on specific knowledge rather than solely relying on foundational model training.

Personality configuration: The ability to shape how customer service representatives communicate (tone, etiquette, and personality) is crucial for user engagement. Good frameworks can easily configure these traits, recognizing that the personality of the representative significantly impacts user trust.

Multi-agent coordination: Strong frameworks provide built-in patterns for agent collaboration, whether through structured dialogue, task delegation, or shared memory systems. This can create specialized teams, with each agent leveraging unique capabilities to solve problems together.

Beyond core functionalities, the practical utility of a framework largely depends on its features and integrations. Tools greatly expand the practical capabilities of agents. An agent with access only to LLM can engage in conversations, but if granted access to a web browser, it can retrieve real-time information. Connecting it to your calendar API allows it to schedule meetings. Each new tool exponentially increases the agent's capabilities. From a developer's perspective, the more tools available, the greater the options and scope for experimentation.

We evaluate the functionalities of crypto-native frameworks from three dimensions:

AI model support and capabilities: Strong frameworks provide native integration with various language models—from OpenAI's GPT series to open-source alternatives like Llama and Mistral. But it’s not just about LLMs. Support for other AI functionalities, such as text-to-speech, browser usage, image generation, and local model inference, can significantly expand the capabilities of agents. Strong model support is becoming a prerequisite for many such frameworks.

Web3 infrastructure support: Building crypto agents requires deep integration with blockchain infrastructure. This means supporting necessary Web3 components, such as wallets for transaction signing, RPC for chain communication, and indexers for data access. Strong frameworks should integrate with the essential tools and services of the entire ecosystem, from NFT marketplaces and DeFi protocols to identity solutions and data availability layers.

Chain coverage: Web3 infrastructure support determines what agents can do, while chain coverage determines where they can do it. The crypto ecosystem is evolving into a decentralized multi-chain behemoth, highlighting the importance of broad chain coverage.

Finally, even the most powerful frameworks can only be as good as the developer experience. A framework can have top-notch features, but if developers find it difficult to use effectively, it will never achieve widespread adoption.

The language used by the framework directly impacts who can build with it. Python dominates the fields of AI and data science, making it a natural choice for AI frameworks. Frameworks written in niche languages may have unique advantages but could isolate themselves from a broader developer ecosystem.

The ubiquity of JavaScript in web development makes it another strong contender, especially for frameworks aimed at web integration.

Clear and comprehensive documentation is the lifeline for developers adopting new frameworks. This is not just about API references, although those are crucial. Strong documentation includes conceptual overviews explaining core principles, step-by-step tutorials, well-commented example code, educational tutorials, troubleshooting guides, and established design patterns.

Results

The table below summarizes the performance of each framework based on the parameters we just defined (ranked 1-5).

While discussing the reasons behind each data point is beyond the scope of this article, here are some standout impressions each framework left on us.

Eliza is by far the most mature framework on this list. Given that the Eliza framework has become a focal point for the crypto ecosystem's engagement with AI in the recent wave of agents, one of its standout features is the sheer number of supported features and integrations.

Due to its generated notoriety, every blockchain and development tool is eager to integrate itself into this framework (it currently boasts nearly 100 integrations!). At the same time, Eliza has attracted more developer activity than most frameworks. Eliza is benefiting, at least in the short term, from some very clear network effects. The framework is written in TypeScript, a mature language used by both beginners and experienced developers, further propelling its growth.

Eliza also stands out for the wealth of educational content and tutorials it provides for developers using the framework.

We have seen a range of agents built using the Eliza framework, including Spore, Eliza (the agent), and Pillzumi. A new version of the Eliza framework is expected to be released in the coming weeks.

Rig's approach is fundamentally different from Eliza's. It stands out for having a powerful, lightweight, and high-performance core. It supports various reasoning modes, including prompt chaining (sequential application of prompts), orchestration (coordinating multiple agents), conditional logic, and parallelism (concurrent execution of operations).

However, Rig itself does not have as rich an integration landscape. Instead, it takes a different approach, which the team calls "Arc handshake." Here, the Arc team collaborates with different high-quality teams in Web2 and Web3 to expand Rig's capabilities. Some of these collaborations include developing agent personalities with Soulgraph and blockchain functionalities with Listen and the Solana Agent Kit.

Nonetheless, Rig has two drawbacks. First, it is written in Rust, which, while excellent in performance, has relatively few developers familiar with it. Second, we have only seen a limited number of Rig-driven agents in actual applications (AskJimmy being an exception), making it difficult to assess true developer adoption.

Before starting Daydreams, founder lordOfAFew was a major contributor to the Eliza framework. This gave him insight into the framework's growth and, more importantly, exposure to some of its shortcomings. Daydreams differs from other frameworks in that it focuses on thought chain reasoning to help agents achieve long-term goals.

This means that when given a high-level and complex goal, the agent engages in multi-step reasoning, proposing various actions, accepting or discarding them based on whether they contribute to achieving the goal, and continuing this process to make progress. This gives agents created with Daydreams a true sense of autonomy.

The founder's background in building gaming projects influenced this approach. Games, especially on-chain games, are ideal testing grounds for training agents and testing their capabilities. Unsurprisingly, some early use cases for Daydreams agents were in games like Pistols, Istarai, and PonziLand.

The framework also features strong multi-agent collaboration and orchestration workflow implementations.

Similar to Daydreams, Pippin is also a latecomer in the framework game. We detail its release in this article. At the core of Yohei's vision is to make agents a "digital presence" that can operate intelligently and autonomously by accessing the right tools. This vision is reflected in Pippin's simple yet elegant core. With just a few lines of code, a complex agent can be created that operates autonomously and can even write code for itself.

The drawback of this framework is that it even lacks basic functionalities like support for vector embeddings and RAG workflows. It also encourages developers to use the third-party library Composio for most integrations. Compared to the other frameworks discussed so far, it is simply not mature enough.

Some agents built using Pippin include Ditto and Telemafia.

Zerepy has a relatively simple core implementation. It effectively selects a task from a set of configured tasks and executes it when needed. However, it lacks complex reasoning patterns such as goal-driven or thought chain planning.

While it supports reasoning calls to multiple LLMs, it lacks any embedding or RAG implementations. It also lacks any primitives for memory or multi-agent coordination.

This lack of core functionality and integration is reflected in Zerepy's adoption. We have not yet seen any actual agents using this framework go live.

Building with the Framework

If all of this sounds very technical and theoretical, we wouldn't blame you. A simpler question is, "What kind of agents can I build using these frameworks without having to write a bunch of code myself?"

To evaluate these frameworks in practice, we identified five common types of agents that developers often want to build. They represent different levels of complexity and test various aspects of each framework's capabilities.

Document chat agents: Testing core RAG functionalities, including document processing, context maintenance, citation accuracy, and memory management. This test reveals the framework's ability to navigate between true document understanding and simple pattern matching.

Chatbots: Evaluating memory systems and behavioral consistency. The framework must maintain consistent personality traits, remember key information in conversations, and allow for personality configuration, essentially transforming a stateless chatbot into a persistent digital entity.

On-chain trading bots: Stress-testing external integrations by processing real-time market data, executing cross-chain trades, analyzing social sentiment, and implementing trading strategies. This reveals how the framework handles complex blockchain infrastructure and API connections.

Game NPCs: Although the world has only recently begun to focus on agents, agents have played a crucial role as non-player characters (NPCs) in games for decades. Game agents are transitioning from rule-based agents to LLM-driven intelligent agents and remain a primary use case for frameworks. Here, we test the agents' ability to understand their environment, autonomously reason through scenarios, and achieve long-term goals.

Voice assistants: Evaluating real-time processing and user experience through voice processing, quick response times, and messaging platform integration. This tests whether the framework can support truly interactive applications rather than just simple request-response patterns.

We scored each framework for each type of agent on a scale of 1 to 5. Here’s how they performed:

Open Source Metrics

When evaluating these frameworks, most analyses place significant emphasis on GitHub metrics such as stars and forks. Here, we will quickly introduce what these metrics are and to what extent they indicate the quality of a framework.

Stars serve as the most obvious signal of popularity. They are essentially bookmarks that developers give to projects they find interesting or want to track. While a high number of stars indicates broad recognition and interest, it can be misleading. Projects sometimes accumulate stars through marketing rather than technical value. Think of stars as social proof rather than a quality metric.

The number of forks tells you how many developers have created their own copies of the codebase to build upon. More forks typically indicate that developers are actively using and extending the project. That said, many forks ultimately get abandoned, so the original fork count needs context.

The number of contributors reveals how many different developers have actually submitted code to the project. This is often more meaningful than stars or forks. A healthy number of regular contributors indicates that the project has an active community maintaining and improving it.

We went a step further and designed our own metric—contributor score. We assess each developer's public history, including their past contributions to other projects, frequency of activity, and the popularity of their accounts, assigning a score to each contributor. We then average the scores of all contributors to a project and weight them based on the number of contributions they made.

What do these numbers mean for our frameworks?

In most cases, the number of stars can be disregarded. They are not a meaningful indicator of adoption. The exception here is Eliza, which at one point became the number one trending repository on GitHub, aligning with its status as a focal point for all crypto AI. Additionally, well-known developers like 0xCygaar have contributed to the project. This is also reflected in the number of contributors—ten times more than other projects—Eliza attracts contributors.

Aside from that, Daydreams is interesting to us simply because it attracts high-quality developers. As a latecomer launched after the peak of hype, it has not benefited from the network effects of Eliza.

What’s Next?

If you are a developer, we hope we have at least provided you with a starting point for which framework to choose to build with (if you need one). Beyond that, you still need to put in the effort to test whether each framework's core reasoning and integrations fit your use case. This is unavoidable.

From an observer's perspective, it is important to remember that all of these AI agent frameworks are less than three months old. (Yes, it feels longer.) During this time, they have transitioned from extreme hype to being referred to as "castles in the air." This is the nature of technology. Despite this volatility, we believe this field represents an interesting and lasting new experiment in the crypto space.

What’s next is how these frameworks mature in terms of technology and monetization.

From a technical standpoint, the biggest advantage a framework can create for itself is enabling agents to interact seamlessly on-chain. This is the primary reason developers choose crypto-native frameworks over generic ones. Additionally, agent and agent-building technology are at the forefront of global technological issues, with new developments emerging daily. Frameworks must also continuously evolve and adapt to these advancements.

How frameworks achieve monetization is even more interesting. In these early stages, creating a launch platform inspired by Virtuals is a low-hanging fruit for projects. But we believe there is a lot of experimental space here. We are moving toward a future with millions of agents specializing in every conceivable niche. Tools that help them coordinate effectively can capture tremendous value from transaction fees. As the portal for builders, frameworks are certainly best positioned to capture this value.

At the same time, the monetization of frameworks also disguises the issue of monetizing open-source projects and rewarding contributors, who have historically engaged in free, thankless work. If a team can crack the code on how to create a sustainable open-source economy while maintaining the spirit of its core code, the impact will extend far beyond agent frameworks.

免责声明：本文章仅代表作者个人观点，不代表本平台的立场和观点。本文章仅供信息分享，不构成对任何人的任何投资建议。用户与作者之间的任何争议，与本平台无关。如网页中刊载的文章或图片涉及侵权，请提供相关的权利证明和身份证明发送邮件到support@aicoin.com，本平台相关工作人员将会进行核查。