Eliza

Manages multiple AgentRuntime instances within a single server process, enabling inter-agent communication and state sharing through a unified event system and message service. Each agent maintains isolated character definitions and memory while accessing shared model providers and platform connectors, coordinated via the elizaOS server's message routing layer that dispatches events across agent boundaries.

Abstracts LLM interactions through a plugin architecture that supports OpenAI, Anthropic, Google Gemini, Ollama, AWS Bedrock, OpenRouter, and custom providers. Each provider is loaded at runtime as a plugin implementing a standardized interface, allowing agents to switch models or use multiple providers simultaneously without code changes. Settings and configuration are injected via environment variables and character definitions.

Provides elizaos CLI binary for project creation, agent management, and development workflows. CLI scaffolds new agent projects with boilerplate configuration, plugin setup, and example agents. Environment configuration is managed via .env files with validation and type checking. CLI commands enable local development (agent startup, hot reload), testing, and deployment preparation.

Provides web-based dashboard and Tauri desktop application for managing agents, viewing logs, and monitoring performance. Dashboard displays agent status, message history, memory contents, and action execution logs. Desktop app packages dashboard as standalone application with native OS integration. Both UIs communicate with elizaOS server via REST/WebSocket APIs.

Uses Protocol Buffers (protobuf) to define typed schemas for messages, events, and data structures, enabling type-safe serialization and cross-language communication. Schemas are defined in .proto files and compiled to TypeScript, Python, and Rust code. All inter-process communication (agent-to-agent, server-to-client) uses protobuf-serialized messages, ensuring type safety and backward compatibility.

Implements a typed event system where agents and components emit and subscribe to events using TypeScript interfaces. Events are defined as types with payload schemas; subscribers register handlers for specific event types. Event emission is synchronous with optional async handlers. The event system enables loose coupling between agents and components while maintaining type safety.

Provides structured logging system that captures agent actions, decisions, and errors with context (agent ID, timestamp, action name). Logs are written to files and optionally to external services (Datadog, CloudWatch). Performance metrics track action execution time, memory usage, and API call counts. Logging is configurable per component with different verbosity levels.

Provides database abstraction layer supporting PostgreSQL for production and PGLite (SQLite in WASM) for local development. All persistent state (memories, entities, relationships, messages) is stored in database with schema migrations. Database connection is managed centrally; agents access data through typed query interfaces. PGLite enables zero-setup local development without external database.

Defines agent behavior through a character system that specifies personality traits, knowledge base, example interactions, and behavioral rules as structured data (JSON). The character definition drives prompt engineering, memory retrieval, and action selection; agents use character context to maintain consistent personas across conversations. Memory is stored in PostgreSQL/PGLite with vector embeddings for semantic retrieval, enabling agents to learn from past interactions.

Implements a typed action execution system where agents select and execute actions based on current state, character context, and memory. Actions are plugins implementing a standardized interface; evaluators assess whether actions should run; providers supply dynamic state (market data, social feeds, etc.). The pipeline uses state composition to merge character context, memory, and provider data into a unified state object passed to the model for decision-making.

Abstracts platform-specific communication through a plugin architecture supporting Discord, Telegram, Twitter/X, Farcaster, and custom platforms. Each platform connector handles authentication, message routing, and protocol-specific formatting. Agents receive platform-agnostic message objects and respond with text/structured data; connectors translate to platform-specific formats. The message service routes incoming messages to appropriate agents and broadcasts responses.

Stores agent memories and knowledge as vector embeddings in PostgreSQL or PGLite, enabling semantic similarity search without explicit indexing. Memories are created from conversations, documents, and knowledge bases; embeddings are generated via model provider plugins. The memory system retrieves relevant past interactions and knowledge based on semantic similarity to current context, injecting retrieved memories into prompts for grounded reasoning.

Provides HTTP REST API and WebSocket server for agent interaction and management. REST endpoints expose agent lifecycle management, message sending, and state queries; WebSocket connections enable real-time bidirectional communication with agents. The server handles authentication, message routing to appropriate agents, and event broadcasting. Built on Node.js/Bun with typed request/response schemas.

Tracks entities (people, organizations, concepts) and relationships between them, building a knowledge graph from agent interactions and ingested data. Entities and relationships are stored in PostgreSQL with semantic embeddings, enabling agents to understand context and connections. The system supports entity resolution (linking mentions to canonical entities) and relationship inference.

Provides a plugin system for extending agent capabilities through custom actions (executable behaviors), evaluators (precondition checkers), and providers (state suppliers). Plugins are loaded at runtime from npm packages or local directories, implementing standardized TypeScript interfaces. The bootstrap plugin provides core functionality; official plugins extend with platform connectors, model providers, and common actions.

Provides TypeScript as primary runtime with Rust implementation compiled to WASM for performance-critical paths, and Python bindings for integration with Python ecosystems. Core logic is implemented in TypeScript (@elizaos/core); Rust components handle computationally expensive operations (embeddings, vector operations). Python bindings expose core APIs for Python developers. Cross-language interoperability is achieved through protobuf schemas and language-specific wrappers.