ElizaOS Documentation
Welcome to ElizaOS - a comprehensive framework for building AI agents with persistent personalities across multiple platforms. ElizaOS provides the architecture, tools, and systems needed to create sophisticated agents that maintain consistent behavior, learn from interactions, and seamlessly integrate with a variety of services.
New to ElizaOS? Check out What's new in ElizaOS V2 to understand how it compares to previous versions.
System Architecture
ElizaOS uses a modular architecture that separates concerns while providing a cohesive framework for AI agent development:
How ElizaOS Works
When a user message is received:
- Service Reception: Platform service (Discord, Telegram, etc.) receives the message
- Runtime Processing: Agent runtime coordinates the response generation
- Context Building: Providers supply relevant context (time, recent messages, knowledge)
- Action Selection: The agent evaluates and selects appropriate actions
- Response Generation: The chosen action generates a response
- Learning & Reflection: Evaluators analyze the conversation for insights and learning
- Memory Storage: New information is stored in the database
- Response Delivery: The response is sent back through the service
This creates a continuous cycle of interaction, reflection, and improvement that allows agents to maintain consistent personalities while adapting to new information.
Core Components
 |  |  |
|---|---|---|
| 🤖 Agent Runtime — Orchestrates agent behavior, manages state, and coordinates components. | 📚 Services — Enables agents to communicate across Discord, Twitter, Telegram, and other platforms. | 💾 Database — Stores memories, entity data, relationships, and configuration using vector search. |
Intelligence & Behavior
 |  |  |  |
|---|---|---|---|
| ⚡ Actions — Executable capabilities for agents to respond and interact with systems. | 🔌 Providers — Supplies context to inform agent decisions in real time. | 📊 Evaluators — Analyzes conversations to extract insights and improve future responses. | 🧠 Knowledge — RAG system for document processing and semantic memory. |
Structure & Organization
 |  |  |
|---|---|---|
| 🌐 Worlds — Organizes environments like servers or projects. | 💬 Rooms — Spaces for conversation, like channels or DMs. | 👤 Entities — Represents users, bots, and other participants. |
Development & Integration
 |  |  |
|---|---|---|
| 🧩 Plugins — Modular extensions that add new capabilities. | 📝 Projects — Defines and deploys agents with configurations. | 📋 Tasks — Manages scheduled and deferred operations. |
Key Concepts
Action-Provider-Evaluator Cycle
The core of the ElizaOS system operates as a continuous cycle:
- Providers gather context before response generation
- Actions determine what the agent can do and are executed to generate responses
- Evaluators analyze conversations after responses to extract insights
- These insights become part of the agent's memory
- Future Providers access this memory to inform new responses
This creates a virtuous cycle where agents continuously learn and improve from interactions.
Entity-Component Architecture
ElizaOS uses an entity-component architecture for flexible data modeling:
- Entities are base objects with unique IDs (users, agents, etc.)
- Components are pieces of data attached to entities (profiles, settings, etc.)
- This approach allows for dynamic composition without complex inheritance hierarchies
Memory System
The memory system in ElizaOS provides:
- Vector-based semantic search for finding relevant memories
- Multi-level memory types (messages, facts, knowledge)
- Temporal awareness through timestamped memories
- Cross-platform continuity while maintaining appropriate context boundaries
Getting Started
If you're new to ElizaOS, we recommend this learning path:
- Start with this overview to understand the system architecture
- Explore the Agent Runtime to understand the core system
- Learn about Projects to set up your development environment
- Understand how Actions and Providers work together
- Explore Services to connect with external platforms
- Dive into Plugins to extend functionality
FAQ
What's the difference between Actions, Evaluators, and Providers?
Actions define what an agent can do and are executed during response generation. Evaluators analyze conversations after they happen to extract insights and improve future responses. Providers supply contextual information before the agent decides how to respond.
How does ElizaOS handle cross-platform conversation context?
ElizaOS maintains separate conversation contexts for different platforms by default, but shares entity relationships and learned facts across platforms. This ensures agents maintain a consistent understanding of users while respecting platform-specific conversation boundaries.
How does the memory system work?
Memory is organized into different types (messages, facts, knowledge) and stored with vector embeddings for semantic search. This allows agents to retrieve relevant memories based on context rather than just recency, creating more natural conversations.
What's the relationship between Worlds, Rooms, and Entities?
Worlds are container spaces (like a Discord server) that can have multiple Rooms (channels, DMs). Entities (users, agents) participate in Rooms within Worlds. This hierarchical structure mirrors real-world platforms while providing a consistent abstraction.
How extensible is ElizaOS?
ElizaOS is highly extensible through its plugin system. You can create custom actions, providers, evaluators, services, and more to extend functionality. The architecture is designed to be modular and composable at every level.
Additional Resources
- API Reference - Detailed API documentation for developers
- GitHub Repository - Source code and contributions
- Package Showcase - Explore available plugins and extensions