ElizaOS

elizaOS is an open-source TypeScript monorepo for building autonomous AI agents. It bundles a core runtime, a user-facing agent app for web, desktop, and mobile, a CLI, cloud services, native device bridges, and first-party plugins. It's aimed at developers who want to build agents or plugins, run the full agent stack locally, or embed the runtime into their own application.

The stack is split into two layers. Eliza, the app, gives end users chat, voice, memory, knowledge, calendar, messaging connectors, browser and desktop automation, native device bridges (camera, contacts, location), and non-custodial EVM/Solana wallet operations, depending on installed plugins and granted permissions. The framework underneath (@elizaos/core, @elizaos/agent, @elizaos/app, @elizaos/ui) is model-agnostic and extended entirely through plugins that register actions, providers, evaluators, services, model handlers, routes, and events.

Key features

• Model-agnostic runtime: AgentRuntime in @elizaos/core defines canonical types, authorization, memory/state primitives, and a plugin contract that isn't tied to one model provider.
• Plugin architecture: plugins export a Plugin object that can add actions, providers, evaluators, services, model handlers, routes, events, tests, and app views.
• Local inference option: @elizaos/plugin-local-inference runs the Eliza-1 on-device model family (2B/4B/9B/27B text tiers plus embeddings, speech, vision, and image generation) with hardware-aware routing, so eligible operations can run offline once assets are downloaded.
• Flexible backend routing: each model capability can route to local inference, a direct provider, or Eliza Cloud, and local inference is skipped automatically on unsupported hardware.
• Optional Eliza Cloud: adds account/auth services, hosted model routing, app and agent deployment, and cross-device sync, while keeping the local runtime and direct-provider setup fully usable without it.
• Standalone agent host: @elizaos/agent assembles a runnable agent with an HTTP backend, useful for embedding the runtime without the full app shell.
• Native device integrations: bridges for camera, phone, messages, contacts, and location on supported OS targets, with separate distribution tooling for bootable Linux/AOSP builds in the companion elizaOS/os repo.
• Benchmarking suite: a Python-based orchestrator (packages/benchmarks) for running live model benchmarks against configured providers.

Ideal use cases

Use elizaOS if you want to build a custom agent or plugin on a typed runtime with defined memory, state, and authorization primitives, rather than wiring an agent loop from scratch. It also fits if you want to self-host a full personal-assistant-style agent app (chat, calendar, messaging, wallet ops) with control over which model backend handles each capability, including fully offline local inference.

It's a good match for teams building crypto/Discord-adjacent agent products, since first-party plugins and topics cover autonomous agents, wallets, and chat platforms out of the box. It also suits developers who want a standalone agent process embedded in their own backend via @elizaos/agent without adopting the whole app shell.

It's less of a fit if you just need a lightweight prompt-chaining script or a single-provider chatbot wrapper: the monorepo, plugin contracts, and build tooling (Bun, Turbo, native build steps) add real setup overhead for that scope. The project has also stopped accepting third-party plugins or registry submissions, so if you were hoping to publish into a community plugin marketplace, that path is closed; you'd maintain your plugin independently instead.

Installation

The repo pins specific Bun and Node versions in package.json; install those first. Then clone and bootstrap:

git clone --filter=blob:none https://github.com/elizaos/eliza.git
cd eliza
bun install
bun run dev

bun install also sets up submodules and patches, provisions host build prerequisites, and builds or verifies the staged desktop libelizainference. The embedding GGUF model is runtime-managed and downloads automatically during local-inference warmup. Archived artifact fixtures can be fetched explicitly with:

bun packages/scripts/fetch-archive-artifacts.ts

Common repository-level commands:

bun run start       # run the standalone agent host
bun run build       # build the workspace with Turbo
bun run verify      # dependency, type, lint, and audit gates
bun run test        # unit/integration test lane
bun run test:e2e    # end-to-end test lane
bun run cloud:mock  # local Eliza Cloud stack with mocks

Each package has its own build/test scripts documented in its README; scope a command to a package with bun run --cwd <package> <script>.

For benchmarking, use Python 3.11+, install the dependencies for the benchmark suite you want, and run from the repo root:

PYTHONPATH=packages python3 -m benchmarks.orchestrator list-benchmarks
PYTHONPATH=packages python3 -m benchmarks.orchestrator run --benchmarks <id> --provider <provider> --model <model>

Live benchmarks need credentials for the selected provider and can incur usage costs. If you just want to use Eliza without building from source, use the hosted web app, native downloads, or a published GitHub release instead of cloning this repo.