Fun AI Lab

Most AI applications are passive chat boxes. You enter a prompt, receive text, and the engine immediately goes back to sleep. If you want an AI system that checks your email at midnight, coordinates your schedule, interacts with smart contracts, and manages desktop applications natively, traditional chat UI wrappers fall completely short.

Enter elizaOS. With over 19,000 stars on GitHub, elizaOS provides a complete framework and software stack designed to treat autonomous AI agents as first-class citizens. Instead of treating language models as isolated text generators, elizaOS builds an entire agentic operating system around them—combining persistent memory, multi-channel messaging, local OS control, and non-custodial wallet execution into a unified runtime.

---

Why the Shift to an Agentic Operating System Matters

Building production-grade AI agents requires far more than chaining API calls together. A real agent needs:
1. Persistent State and Memory: Remembering user preferences, historical interactions, and domain context across disparate sessions.
2. Model Agnosticism: Switching between OpenAI, Anthropic, local Llama instances, or specialized fine-tunes without rewriting application logic.
3. Platform Access: Interacting natively with cameras, local storage, contacts, web browsers, and system automation tools.
4. Autonomous Execution: Running scheduled background loops, handling incoming events, and making self-directed decisions inside pre-approved safety boundaries.

elizaOS targets this exact architectural surface area. By decoupling the core runtime logic from platform adapters and LLM providers, developers can ship cross-platform agents that run inside a web browser, as desktop software, across mobile devices, or even as bare-metal custom Linux builds.

---

Inside the elizaOS Stack

The elizaOS/eliza repository is structured as a TypeScript monorepo driven by Bun and Turbo. It cleanly separates low-level runtime engine code from user-facing user interfaces and operational plugins.

graph TD
    A[User / System Trigger] --> B[Platform Connectors / UI]
    B --> C[@elizaos/app-core Platform Host]
    C --> D[@elizaos/core AgentRuntime]
    D --> E[Memory & State Engine]
    D --> F[Plugin System]
    F --> G[Browser & Desktop Automation]
    F --> H[EVM & Solana Wallets]
    F --> I[Native Device APIs]
    D --> J[LLM Model Adapters]

Here is how the core modules break down inside the workspace:

1. @elizaos/core

The heartbeat of the entire repository. This package houses the core AgentRuntime engine. It handles:
* The primary event and message routing loop.
* Primitive types for memories, entities, and actions.
* Evaluation pipelines that decide when and how an agent should respond.
* Plugin contracts and state management.

2. @elizaos/agent

A complete backend server wrapper built around @elizaos/core. It spins up an HTTP server alongside websocket bridges, turning a standalone agent engine into a network-accessible microservice.

3. @elizaos/app-core & @elizaos/ui

These modules house cross-platform application wrappers and a shared React component system. They allow the exact same agent logic to render inside a lightweight desktop wrapper, a mobile application, or a browser extension.

4. elizaos CLI

The developer control platform. The CLI handles workspace setup, boilerplate plugin generation, local orchestration, and remote deployment.

---

Key Capabilities and Real-World Use Cases

What can an agent built on elizaOS actually execute? Out of the box, the plugin and core system supports diverse tasks across digital interfaces.

Domain	Capability	Real-World Application
Personal Assistant	Calendar, Inbox, Goals, Health tracking	Auto-scheduling meetings, summarizing missed email threads, tracking weekly metrics.
Native OS Bridge	Camera, SMS, Contacts, Location, Browser control	Filling out forms via web automation, capturing system alerts, taking contextual snapshots.
Crypto / Web3	Non-custodial EVM & Solana wallet operations	Autonomous token swaps, managing decentralized DAO voting, executing micro-payments with transaction approval guardrails.
Developer Operations	Coding agent orchestration, CLI tasks	Monitoring build failures, executing scheduled patch scripts, managing dynamic git workflows.

---

Getting Started: Running elizaOS from Source

Setting up elizaOS is simple thanks to the project’s reliance on Bun for fast package installation and monorepo task execution.

Prerequisites

Make sure you have node (compatible version defined in package.json) and Bun installed locally.

# Clone the repository efficiently without full deep history
git clone --filter=blob:none https://github.com/elizaos/eliza.git

# Navigate into the project folder
cd eliza

# Install all submodules, patches, and dependencies
bun install

# Spin up the local development environment
bun run dev

Essential Repository Commands

Once inside the repository, you can verify, build, and test your setup using the workspace utility scripts:

# Build all monorepo packages via Turbo Engine
bun run build

# Run linting, dependency verification, and type checks
bun run verify

# Execute the core test suite
bun run test

# Spin up a local mock instance of Eliza Cloud for offline testing
bun run cloud:mock

---

Building a Plugin Architecture for Agents

One of the standout design decisions of elizaOS is how clean its extension system is. Every new capability—from an API integration to a native device interface—is structured as a discrete Plugin.

Here is an example structure of how a custom plugin interacts with @elizaos/core:

import { Plugin, Action, Provider, Evaluator } from "@elizaos/core";

// Define a custom action the agent can trigger
const customNotificationAction: Action = {
  name: "SEND_ALERT",
  description: "Sends an urgent alert notification to the user's desktop",
  validate: async (runtime, message) => {
    // Check if permissions and configurations exist
    return true;
  },
  handler: async (runtime, message, state, options, callback) => {
    // Action logic here
    console.log("Desktop notification dispatched!");
    return true;
  }
};

// Export the plugin definition
export const myCustomPlugin: Plugin = {
  name: "desktop-alerts",
  description: "Native desktop notifications for elizaOS",
  actions: [customNotificationAction],
  providers: [],
  evaluators: []
};

By decoupling actions from core logic, developers can share plugins across the community catalog without polluting the standard runtime engine.

---

Common Myths & Misconceptions

Myth 1: “It’s just another wrapper for ChatGPT.”

Reality: elizaOS is model-agnostic and runtime-centric. It includes a custom event loop, a local database state engine, native device bridges, desktop control integrations, and wallet execution layers. LLMs act merely as the decision provider within a larger framework.

Myth 2: “Giving AI crypto wallets is completely unsafe.”

Reality: elizaOS implements explicit approval boundaries around wallet modules. Transaction capabilities run within configurable policy limits, preventing unvetted transactions from taking place automatically.

Myth 3: “You need a dedicated server to run an agent.”

Reality: While you can run agents in cloud environments, elizaOS builds for desktop, mobile, and web runtimes out of the box. You can execute full agent workflows directly on consumer hardware.

---

Actionable Tips for Building with elizaOS

1. Leverage standard CLI tooling: Do not manually configure core runtime configurations from scratch. Use the elizaos CLI to bootstrap plugin templates and manage dependencies smoothly.
2. Keep actions single-purpose: When writing custom actions within plugins, keep each handler focused on a single isolated task. Let the core Evaluator pipeline decide how to chain actions sequentially.
3. Use granular permission scopes: When building agents that interface with native local device components (like cameras, local files, or crypto keys), implement permission gates within the plugin’s validate block before executing heavy commands.

---

The Road Ahead for Autonomous Agents

elizaOS represents a clear trend in AI development: moving away from reactive prompts toward background-capable, event-driven operating runtimes. By consolidating wallet support, native OS bridging, cross-platform deployment targets, and a flexible plugin architecture into a single open-source stack, elizaOS provides standard tooling for building next-generation autonomous software.

Whether you want to launch a background developer assistant or build complex multi-agent workflows, elizaOS offers the foundational tools required to turn LLMs into active computational agents.

📂 Explore the open-source repository on GitHub: https://github.com/elizaOS/eliza