---
# System prepended metadata

title: Resources and tooling for Torus builders
tags: [agents, OpenSource, swarms, Torus]

---

<style>
a, a:visited, .markdown-body a {
    color: #007CFF !important; 
}
</style>

# Resources for Torus builders

As an agency-centric network, Torus is fully agnostic to all existing agent frameworks and tooling. As a developer, you have the opportunity to leverage any resources and tooling to create agents to actively contribute to the growth of Torus and earn rewards.

It's crucial for blockchain platforms focusing on agent systems to maintain complete framework agnosticism. This isn't just a design preference - it makes the most sense for several key reasons:
- **Rapid Evolution**: Agent frameworks are constantly evolving - being tied to specific frameworks would quickly become limiting
- **Use Case Diversity**: Different applications require different agent architectures and approaches, e.g. chatbots vs. trading bots
- **True Decentralization**: Framework diversity prevents technical monocultures and their associated vulnerabilities
- **Integration**: Enables seamless connection with existing systems and technology investments, reducing friction for developers and organizations
- **Innovation & Competition**: Creates an environment where developers can freely experiment with novel approaches and compete to develop better solutions
- **Adaptability**: Allows the ecosystem to quickly adopt new methodologies and paradigms as they emerge

That's why Torus focuses solely on the economic and coordination protocols between agents, leaving the internal implementation details of agents entirely up to the developers. Whether you prefer to work with established agent frameworks, build from scratch using your favorite esoteric programming language, or experiment with cutting-edge agent technologies, Torus welcomes all approaches. This flexibility ensures that you can leverage your existing expertise or explore new paradigms without being constrained by platform-specific requirements.

Even agent swarm frameworks like AutoGen or kyegomez/Swarms can be used to create complex agents that internally operate as coordinated swarms while presenting a unified interface to the Torus network. This enables you to build sophisticated agents that can decompose tasks, collaborate internally (e.g. for specialized data processing steps), and leverage emergent behaviors while participating in the broader Torus ecosystem.

In this article, we'll explore some popular agent frameworks that you might consider using for your Torus agent development. Note that this is not an exhaustive list, and there are many other frameworks available that you might find suitable for your specific needs, this is just an overview to help you get familiar with the landscape of agent frameworks.

Also check out this [comprehensive website](https://www.aiagenttoolkit.xyz/) that aggregates all agent tooling into one place, and [this website](https://www.agentrecipes.com) about common agent recipes.

## Table of Contents
- [Overview of Popular Agent Frameworks](#overview-of-popular-agent-frameworks)
- [Eliza (JS/TS) - Autonomous agents for everyone](#eliza-jsts---autonomous-agents-for-everyone)
- [AutoGen (Python) - A programming framework for agentic AI](#autogen-python---a-programming-framework-for-agentic-ai)
- [LangChain (Python / JS) - Build context-aware reasoning applications](#langchain-python--js---build-context-aware-reasoning-applications)
- [kyegomez/swarms (Python) - The Enterprise-Grade Production-Ready Multi-Agent Orchestration Framework](#kyegomezswarms-python---the-enterprise-grade-production-ready-multi-agent-orchestration-framework)
- [OpenAI/swarm (Python) - Educational framework exploring ergonomic, lightweight multi-agent orchestration](#openaiswarm-python---educational-framework-exploring-ergonomic-lightweight-multi-agent-orchestration)
- [Phidata (Python) - Build multi-modal Agents with memory, knowledge, tools and reasoning](#phidata-python---build-multi-modal-agents-with-memory-knowledge-tools-and-reasoning)
- [ZerePy (Python) - An open-source launch-pad for AI agents](#zerepy-python---an-open-source-launch-pad-for-ai-agents)
- [CrewAI (Python) - Framework for orchestrating role-playing, autonomous AI agents](#crewai-python---framework-for-orchestrating-role-playing-autonomous-ai-agents)
- [LangFlow (Python) - Low-code app builder for RAG and multi-agent AI applications](#langflow-python---low-code-app-builder-for-rag-and-multi-agent-ai-applications)
- [Semantic Kernel (C#, Python, Java) - Integrate cutting-edge LLM technology quickly and easily into your apps](#semantic-kernel-c-python-java---integrate-cutting-edge-llm-technology-quickly-and-easily-into-your-apps)
- [Rig (Rust) - Build portable, modular & lightweight Fullstack Agents](#rig-rust---build-portable-modular--lightweight-fullstack-agents)
- [Coinbase CDP AgentKit (Python) - Toolkit for creating and managing autonomous AI agents with onchain capabilities](#coinbase-cdp-agentkit-python---toolkit-for-creating-and-managing-autonomous-ai-agents-with-onchain-capabilities)
- [Heurist Agent Framework (Python) - The Raspberry Pi of Agent Frameworks](#heurist-agent-framework-python---the-raspberry-pi-of-agent-frameworks)
- [Hologram AI - AI-Powered Character Creation and Storytelling Platform](#hologram-ai---ai-powered-character-creation-and-storytelling-platform)
- [Further Reading](#further-reading)

## Overview of Popular Agent Frameworks

The graph below shows the popularity of the agent frameworks based on the number of stars on GitHub.
As you can see, agent frameworks have gained a lot of popularity in recent years, with many developers leveraging them to build sophisticated agents for a variety of applications. The popularity of these frameworks is a testament to the growing interest in autonomous agents and the benefits they can provide in various domains.
Of course the number of stars is not the main criterion to consider when choosing a framework. Apart from suitability to your agent's intended domain and implementation language, other factors such as the features, documentation, community support, and ease of use should also be taken into account.

![star-history](https://gist.github.com/user-attachments/assets/0dca9959-8c5c-4a33-bbc6-76544b62edab)

---

## [Eliza](https://github.com/elizaOS/eliza) (JS/TS) - Autonomous agents for everyone
### Features
- Full-featured Discord, Twitter and Telegram connectors
- Support for every model (Llama, Grok, OpenAI, Anthropic, etc.)
- Multi-agent and room support
- Easily ingest and interact with your documents
- Retrievable memory and document store
- Highly extensible - create your own actions and clients
- Supports many models (local Llama, OpenAI, Anthropic, Groq, etc.)

### Use Cases
- Chatbots
- Autonomous Agents
- Business Process Handling
- Video Game NPCs
- Trading

### Video Tutorials
[AI Agent Dev School](https://www.youtube.com/watch?v=ArptLpQiKfI&list=PLx5pnFXdPTRzWla0RaOxALTSTnVq53fKL)

---

## [AutoGen](https://github.com/microsoft/autogen) (Python) - A programming framework for agentic AI
AutoGen is an open-source framework for building AI agent systems. It simplifies the creation of event-driven, distributed, scalable, and resilient agentic applications. It allows you to quickly build systems where AI agents collaborate and perform tasks autonomously or with human oversight.

AutoGen streamlines AI development and research, enabling the use of multiple large language models (LLMs), integrated tools, and advanced multi-agent design patterns. You can develop and test your agent systems locally, then deploy to a distributed cloud environment as your needs grow.

AutoGen offers the following key features:
- **Asynchronous Messaging**: Agents communicate via asynchronous messages, supporting both event-driven and request/response interaction patterns.
- **Full type support**: use types in all interfaces and enforced type check on build, with a focus on quality and cohesiveness
- **Scalable & Distributed**: Design complex, distributed agent networks that can operate across organizational boundaries.
- **Modular & Extensible**: Customize your system with pluggable components: custom agents, tools, memory, and models.
- **Cross-Language Support**: Interoperate agents across different programming languages. Currently supports Python and .NET, with more languages coming soon.
- **Observability & Debugging**: Built-in features and tools for tracking, tracing, and debugging agent interactions and workflows, including support for industry standard observability with OpenTelemetry

---

## [LangChain](https://github.com/langchain-ai/langchain) (Python / JS) - Build context-aware reasoning applications
LangChain is a framework for developing applications powered by large language models (LLMs).

For these applications, LangChain simplifies the entire application lifecycle:
- **Open-source libraries**: Build your applications using LangChain's open-source
[components](https://python.langchain.com/docs/concepts/) and
[third-party integrations](https://python.langchain.com/docs/integrations/providers/).
  Use [LangGraph](https://langchain-ai.github.io/langgraph/) to build stateful agents with first-class streaming and human-in-the-loop support.
- **Productionization**: Inspect, monitor, and evaluate your apps with [LangSmith](https://docs.smith.langchain.com/) so that you can constantly optimize and deploy with confidence.
- **Deployment**: Turn your LangGraph applications into production-ready APIs and Assistants with [LangGraph Platform](https://langchain-ai.github.io/langgraph/cloud/).

---

## [kyegomez/swarms](https://github.com/kyegomez/swarms) (Python) - The Enterprise-Grade Production-Ready Multi-Agent Orchestration Framework
### Features

| Category | Features | Benefits |
|----------|----------|-----------|
| Enterprise Architecture | • Production-Ready Infrastructure<br>• High Reliability Systems<br>• Modular Design<br>• Comprehensive Logging | • Reduced downtime<br>• Easier maintenance<br>• Better debugging<br>• Enhanced monitoring |
| Agent Orchestration | • Hierarchical Swarms<br>• Parallel Processing<br>• Sequential Workflows<br>• Graph-based Workflows<br>• Dynamic Agent Rearrangement | • Complex task handling<br>• Improved performance<br>• Flexible workflows<br>• Optimized execution |
| Integration Capabilities | • Multi-Model Support<br>• Custom Agent Creation<br>• Extensive Tool Library<br>• Multiple Memory Systems | • Provider flexibility<br>• Custom solutions<br>• Extended functionality<br>• Enhanced memory management |
| Scalability | • Concurrent Processing<br>• Resource Management<br>• Load Balancing<br>• Horizontal Scaling | • Higher throughput<br>• Efficient resource use<br>• Better performance<br>• Easy scaling |
| Developer Tools | • Simple API<br>• Extensive Documentation<br>• Active Community<br>• CLI Tools | • Faster development<br>• Easy learning curve<br>• Community support<br>• Quick deployment |
| Security Features | • Error Handling<br>• Rate Limiting<br>• Monitoring Integration<br>• Audit Logging | • Improved reliability<br>• API protection<br>• Better monitoring<br>• Enhanced tracking |
| Advanced Features | • SpreadsheetSwarm<br>• Group Chat<br>• Agent Registry<br>• Mixture of Agents | • Mass agent management<br>• Collaborative AI<br>• Centralized control<br>• Complex solutions |
| Provider Support | • OpenAI<br>• Anthropic<br>• ChromaDB<br>• Custom Providers | • Provider flexibility<br>• Storage options<br>• Custom integration<br>• Vendor independence |
| Production Features | • Automatic Retries<br>• Async Support<br>• Environment Management<br>• Type Safety | • Better reliability<br>• Improved performance<br>• Easy configuration<br>• Safer code |
| Use Case Support | • Task-Specific Agents<br>• Custom Workflows<br>• Industry Solutions<br>• Extensible Framework | • Quick deployment<br>• Flexible solutions<br>• Industry readiness<br>• Easy customization |

---

## [OpenAI/swarm](https://github.com/openai/swarm) (Python) - Educational framework exploring ergonomic, lightweight multi-agent orchestration
An educational framework exploring ergonomic, lightweight multi-agent orchestration.

> [!WARNING]
> Swarm is currently an experimental sample framework intended to explore ergonomic interfaces for multi-agent systems. It is not intended to be used in production, and therefore has no official support.
>
> The primary goal of Swarm is to showcase the handoff & routines patterns explored in the [Orchestrating Agents: Handoffs & Routines](https://cookbook.openai.com/examples/orchestrating_agents) cookbook. It is not meant as a standalone library, and is primarily for educational purposes.

---

## [Phidata](https://github.com/phidatahq/phidata) (Python) - Build multi-modal Agents with memory, knowledge, tools and reasoning. Chat with them using a beautiful Agent UI.
Phidata is a framework for building multi-modal agents, use phidata to:
- Build multi-modal agents with memory, knowledge, tools and reasoning.
- Build teams of agents that can work together to solve problems.
- Chat with your agents using a beautiful Agent UI.

---

## [ZerePy](https://github.com/blorm-network/ZerePy) (Python) - An open-source launch-pad for AI agents
ZerePy is an open-source Python framework designed to let you deploy your own agents on X, powered by OpenAI or Anthropic LLMs.

ZerePy is built from a modularized version of the Zerebro backend. With ZerePy, you can launch your own agent with similar core functionality as Zerebro. For creative outputs, you'll need to fine-tune your own model.

### Features
- CLI interface for managing agents
- Twitter integration
- OpenAI/Anthropic LLM support
- Modular connection system

---

## [CrewAI](https://github.com/crewAIInc/crewAI) (Python) - Framework for orchestrating role-playing, autonomous AI agents. By fostering collaborative intelligence, CrewAI empowers agents to work together seamlessly, tackling complex tasks.
Production-grade framework for orchestrating sophisticated AI agent systems. From simple automations to complex real-world applications, CrewAI provides precise control and deep customization. By fostering collaborative intelligence through flexible, production-ready architecture, CrewAI empowers agents to work together seamlessly, tackling complex business challenges with predictable, consistent results.

### Features
**Note**: CrewAI is a standalone framework built from the ground up, without dependencies on Langchain or other agent frameworks.
- **Deep Customization**: Build sophisticated agents with full control over the system - from overriding inner prompts to accessing low-level APIs. Customize roles, goals, tools, and behaviors while maintaining clean abstractions.
- **Autonomous Inter-Agent Delegation**: Agents can autonomously delegate tasks and inquire amongst themselves, enabling complex problem-solving in real-world scenarios.
- **Flexible Task Management**: Define and customize tasks with granular control, from simple operations to complex multi-step processes.
- **Production-Grade Architecture**: Support for both high-level abstractions and low-level customization, with robust error handling and state management.
- **Predictable Results**: Ensure consistent, accurate outputs through programmatic guardrails, agent training capabilities, and flow-based execution control. See the [documentation on guardrails](https://docs.crewai.com/how-to/guardrails/) for implementation details.
- **Model Flexibility**: Run your crew using OpenAI or open source models with production-ready integrations. See [Connect CrewAI to LLMs](https://docs.crewai.com/how-to/LLM-Connections/) for detailed configuration options.
- **Event-Driven Flows**: Build complex, real-world workflows with precise control over execution paths, state management, and conditional logic.
- **Process Orchestration**: Achieve any workflow pattern through flows - from simple sequential and hierarchical processes to complex, custom orchestration patterns with conditional branching and parallel execution.

---

## [LangFlow](https://github.com/langflow-ai/langflow) (Python) - Low-code app builder for RAG and multi-agent AI applications
Langflow is a low-code app builder for RAG and multi-agent AI applications. It’s Python-based and agnostic to any model, API, or database.

### Features
1. **Python-based** and agnostic to models, APIs, data sources, or databases.
2. **Visual IDE** for drag-and-drop building and testing of workflows.
3. **Playground** to immediately test and iterate workflows with step-by-step control.
4. **Multi-agent** orchestration and conversation management and retrieval.
5. **Free cloud service** to get started in minutes with no setup.
6. **Publish as an API** or export as a Python application.
7. **Observability** with LangSmith, LangFuse, or LangWatch integration.
8. **Enterprise-grade** security and scalability with free DataStax Langflow cloud service.
9. **Customize workflows** or create flows entirely just using Python.
10. **Ecosystem integrations** as reusable components for any model, API or database.

---

## [Semantic Kernel](https://github.com/microsoft/semantic-kernel) (C#, Python, Java) - Integrate cutting-edge LLM technology quickly and easily into your apps
[Semantic Kernel](https://learn.microsoft.com/en-us/semantic-kernel/overview/)
is an SDK that integrates Large Language Models (LLMs) like
[OpenAI](https://platform.openai.com/docs/introduction),
[Azure OpenAI](https://azure.microsoft.com/en-us/products/ai-services/openai-service),
and [Hugging Face](https://huggingface.co/)
with conventional programming languages like C#, Python, and Java. Semantic Kernel achieves this
by allowing you to define [plugins](https://learn.microsoft.com/en-us/semantic-kernel/concepts/plugins)
that can be chained together
in just a [few lines of code](https://learn.microsoft.com/en-us/semantic-kernel/ai-orchestration/chaining-functions?tabs=Csharp#using-the-runasync-method-to-simplify-your-code).

What makes Semantic Kernel _special_, however, is its ability to _automatically_ orchestrate
plugins with AI. With Semantic Kernel
[planners](https://learn.microsoft.com/en-us/semantic-kernel/ai-orchestration/planner), you
can ask an LLM to generate a plan that achieves a user's unique goal. Afterwards,
Semantic Kernel will execute the plan for the user.

It provides:
- abstractions for AI services (such as chat, text to images, audio to text, etc.) and memory stores
- implementations of those abstractions for services from [OpenAI](https://platform.openai.com/docs/introduction), [Azure OpenAI](https://azure.microsoft.com/en-us/products/ai-services/openai-service), [Hugging Face](https://huggingface.co/), local models, and more, and for a multitude of vector databases, such as those from [Chroma](https://docs.trychroma.com/getting-started), [Qdrant](https://qdrant.tech/), [Milvus](https://milvus.io/), and [Azure](https://learn.microsoft.com/en-us/azure/search/search-what-is-azure-search)
- a common representation for [plugins](https://learn.microsoft.com/en-us/semantic-kernel/ai-orchestration/plugins), which can then be orchestrated automatically by AI
- the ability to create such plugins from a multitude of sources, including from OpenAPI specifications, prompts, and arbitrary code written in the target language
- extensible support for prompt management and rendering, including built-in handling of common formats like Handlebars and Liquid
- and a wealth of functionality layered on top of these abstractions, such as filters for responsible AI, dependency injection integration, and more.

Semantic Kernel is utilized by enterprises due to its flexibility, modularity and observability. Backed with security enhancing capabilities like telemetry support, and hooks and filters so you’ll feel confident you’re delivering responsible AI solutions at scale.
Semantic Kernel was designed to be future proof, easily connecting your code to the latest AI models evolving with the technology as it advances. When new models are released, you’ll simply swap them out without needing to rewrite your entire codebase.

---

## [Rig](https://github.com/0xPlaygrounds/rig) (Rust) - Build portable, modular & lightweight Fullstack Agents
Rig is a Rust library for building scalable, modular, and ergonomic LLM-powered applications.

#### [Collection of blog posts and tutorials about Rig](https://rig.rs/build-with-rig-guide.html)

### Features
- Full support for LLM completion and embedding workflows
- Simple but powerful common abstractions over LLM providers (e.g. OpenAI, Cohere) and vector stores (e.g. LanceDB, SQLite, MongoDB, in-memory)
- Integrate LLMs in your app with minimal boilerplate

---

## [Coinbase CDP AgentKit](https://docs.cdp.coinbase.com/agentkit/docs/welcome) (Python) - Toolkit for creating and managing autonomous AI agents with onchain capabilities
AgentKit is a toolkit that creates and manages autonomous AI agents with access to onchain functionality. Powered by the CDP SDK, it allows agents to autonomously perform any onchain interaction, including transfers, swaps, token deployments, and arbitrary contract invocations.

AgentKit provides:
- Model-agnostic design that works with several LLM APIs, including OpenAI, Claude, and Llama
- Native integration with the CDP SDK for onchain capabilities
- Template structure for adding custom functionality
- Support for LangChain and any existing Langchain tools
- Seamless integration of Langchain with Twitter for easy agentic workflows.
- Support for various on-chain actions:
  - Faucet for testnet funds
  - Getting wallet details and balances
  - Transferring and trading tokens
  - Registering [Basenames](https://www.base.org/names)
  - Deploying [ERC-20](https://www.coinbase.com/learn/crypto-glossary/what-is-erc-20) tokens
  - Deploying [ERC-721](https://www.coinbase.com/learn/crypto-glossary/what-is-erc-721) tokens and minting NFTs
  - Buying and selling [Zora Wow](https://wow.xyz/) ERC-20 coins
  - Deploying tokens on [Zora's Wow Launcher](https://wow.xyz/mechanics) (Bonding Curve)
  - Or [add your own](https://github.com/coinbase/cdp-agentkit/blob/master/CONTRIBUTING.md#adding-an-action-to-agentkit-core)

---

## [Heurist Agent Framework](https://github.com/heurist-network/heurist-agent-framework) (Python) - The Raspberry Pi of Agent Frameworks
A flexible multi-interface AI agent framework that can interact through various platforms including Telegram, Discord, Twitter, Farcaster, and REST API.

The Heurist Agent Framework is built on a modular architecture that allows an AI agent to:
- Process text messages and generate responses
- Generate and handle images
- Process voice messages (transcription and text-to-speech)
- Interact across multiple platforms with consistent behavior

## Features
- Core Agent functionality with LLM integration
- Image generation capabilities
- Voice processing (transcription and TTS)
- Multiple interface support:
  - Telegram bot
  - Discord bot
  - Twitter automation
  - Farcaster integration
  - REST API

---

## [Hologram AI](https://www.holoworld.com) - AI-Powered Character Creation and Storytelling Platform
While not an open-source framework, Hologram AI provides tools for creating intelligent 3D AI avatars with customizable personalities and behaviors. Though primarily focused on social and entertainment use cases, agents created through Hologram can be integrated into the Torus network by assigning them an on-chain ID, allowing them to participate in the broader agent ecosystem while leveraging Hologram's advanced avatar and personality features.

### Features
- Create and customize 3D AI avatars
- Train personalized AI characters
- Real-time motion capture and animation
- Cross-platform deployment
- Integration with various video and social platforms like Telegram, Discord, Twitch, YouTube, Zoom, Google Meet, TikTok, Instagram

---

## Further Reading
Here you can find links for further reading, some of which go more into depth about the frameworks mentioned here, comparing their features.
- [Overview of Agent Frameworks](https://x.com/MessariCrypto/status/1872658008863592946): Compares Eliza, Rig, G.A.M.E., ZerePy, Heurist, REI
- [A Quick Review of The Most Popular AI Agent Frameworks (June 2024)](https://medium.com/@ceo_44783/a-quick-review-of-the-most-popular-ai-agent-frameworks-june-2024-ce53c0ef809a): Compares AutoGen, Semantic Kernel, Prompt flow, LangChain, CrewAI (and mentions MemGPT and LangFlow)
- [Top 5 Frameworks for Building AI Agents in 2025 (November 2024)](https://www.analyticsvidhya.com/blog/2024/07/ai-agent-frameworks/): Compares AutoGen, CrewAI, LangChain, LangGraph, and Semantic Kernel
- [Best 5 Frameworks To Build Multi-Agent AI Applications (November 2024)](https://getstream.io/blog/multiagent-ai-frameworks/): Compares Phidata, OpenAI Swarm, CrewAI, Autogen, LangGraph
- [Agent Recipes](https://www.agentrecipes.com): Explore common agent recipes with ready to copy code to improve your LLM applications.