Eliza

Manages multiple AgentRuntime instances within a single server process, enabling inter-agent communication and shared state through a centralized message service and event system. Each agent maintains its own character definition, memory store, and action registry while accessing common model providers and platform connectors. Agents coordinate via typed message passing and can observe each other's state changes through the event bus.

Abstracts LLM provider APIs (OpenAI, Anthropic, Google Gemini, Ollama, AWS Bedrock, OpenRouter) through a plugin architecture that loads provider implementations at runtime. Each provider plugin implements a standardized interface for completion, embedding, and streaming operations. Configuration is environment-driven, allowing provider switching without code changes. Supports custom provider implementations via the external plugin system.

Provides visual interfaces for managing agents, viewing logs, configuring characters, and monitoring state. The web dashboard connects to the REST/WebSocket server and displays real-time agent activity. The Tauri desktop application bundles the web UI with a local agent runtime, enabling standalone agent deployment. Both interfaces support agent creation, character editing, and action testing.

Provides native implementations and bindings for TypeScript (primary), Rust (WASM), and Python, enabling agents to be built and deployed in multiple languages. The TypeScript core is the reference implementation; Rust bindings compile to WASM for browser deployment; Python bindings enable integration with Python ML/data science ecosystems. All runtimes share the same plugin architecture and API surface.

Ingests documents (text, PDF, markdown) and automatically chunks them for embedding and storage in the vector database. The pipeline handles document parsing, text extraction, chunking strategy selection (fixed-size, semantic, recursive), and embedding generation. Supports batch ingestion for large document collections. Retrieved documents are ranked by relevance and injected into agent context for grounded responses.

Provides structured logging of agent activity, including message processing, action execution, memory updates, and errors. Logs are emitted as typed events and can be persisted to files or external systems. Supports multiple log levels (debug, info, warn, error) and filtering by agent, action, or component. Integrates with the event system for real-time log streaming.

Manages agent configuration through environment variables, configuration files, and runtime overrides. Supports per-agent settings (model provider, temperature, max tokens) and global settings (database connection, server port). Configuration is validated at startup and provides helpful error messages for missing or invalid settings. Supports configuration inheritance and composition for complex setups.

Defines agent identity, knowledge, and behavioral constraints through a character system that includes name, bio, lore, knowledge base, example interactions, and system prompts. Character definitions are loaded from JSON/YAML files and compiled into the agent's context at runtime. The system supports character composition through traits and relationships, enabling agents to maintain consistent personality across conversations. Character-scoped memory ensures each agent's knowledge is isolated.

Combines multiple memory layers: short-term conversation memory (in-process), long-term episodic memory (PostgreSQL/PGLite), and semantic memory via vector embeddings. The system stores memories as typed entities with relationships, enabling agents to retrieve relevant context through both semantic similarity search and relational queries. Memory is character-scoped, preventing cross-agent knowledge leakage. Supports document ingestion with automatic chunking and embedding generation.

Executes agent actions through a typed pipeline that validates action schemas, composes state from multiple providers (memory, relationships, environment), executes the action handler, and evaluates outcomes. Actions are registered at runtime via plugins and can be conditional based on agent state. The system supports action composition (chaining multiple actions) and rollback on failure. State composition dynamically gathers context from memory, relationships, and external providers before action execution.

Abstracts platform-specific communication protocols (Discord, Telegram, Twitter/X, Farcaster) through a plugin-based connector architecture. Each platform connector handles authentication, message parsing, rate limiting, and response formatting. Agents can be deployed to multiple platforms simultaneously, with platform-specific behavior configured via character definitions. The message service normalizes platform messages into a common format for agent processing.

Provides HTTP and WebSocket APIs for agent interaction, message processing, and state management. The server handles concurrent client connections, message routing to agents, and real-time updates via WebSocket subscriptions. Supports both request-response (HTTP) and streaming (WebSocket) patterns. Built-in authentication and authorization layer controls access to agents and their state. Message processing pipeline handles validation, logging, and error handling.

Models agents' knowledge as typed entities (people, organizations, concepts) with relationships and properties. Entities are stored in the memory database with vector embeddings for semantic search. The system supports relationship traversal for multi-hop reasoning and entity linking to connect mentions across conversations. Relationships can have properties (e.g., 'knows' relationship with 'since' date) enabling rich knowledge graphs.

Provides a typed event bus that agents and clients can subscribe to for state changes, action execution, and message events. Events are emitted at key points in the agent lifecycle (initialization, action execution, memory updates). The system supports event filtering and aggregation, enabling clients to subscribe to specific agent or action types. Events are persisted to the database for audit and replay.

Provides command-line interface for creating new agent projects, managing plugins, configuring environments, and running agents locally. The CLI generates project templates with sensible defaults, handles dependency installation, and provides commands for testing and deployment. Supports environment variable management through .env files and configuration validation before startup.