elizaOS

An open-source framework for building autonomous AI agents.

✨ What is Eliza?

elizaOS is an all-in-one, extensible platform for building and deploying AI-powered applications. Whether you're creating sophisticated chatbots, autonomous agents for business process automation, or intelligent game NPCs, Eliza provides the tools you need to get started quickly and scale effectively.

It combines a modular architecture, a powerful CLI, and a rich web interface to give you full control over your agents' development, deployment, and management lifecycle.

For complete guides and API references, visit our official documentation.

🚀 Key Features

• 🔌 Rich Connectivity: Out-of-the-box connectors for Discord, Telegram, Farcaster, and more.
• 🧠 Model Agnostic: Supports all major models, including OpenAI, Gemini, Anthropic, Llama, and Grok.
• 🖥️ Modern Web UI: A professional dashboard for managing agents, groups, and conversations in real-time.
• 🤖 Multi-Agent Architecture: Designed from the ground up for creating and orchestrating groups of specialized agents.
• 📄 Document Ingestion: Easily ingest documents and allow agents to retrieve information and answer questions from your data (RAG).
• 🛠️ Highly Extensible: Build your own functionality with a powerful plugin system.
• 📦 It Just Works: A seamless setup and development experience from day one.

Looking for plugins? Browse the community plugin registry at elizaOS-plugins/registry for a full list of available ElizaOS plugins.

Framework vs. application

elizaOS is two things stacked together. Knowing which one you're working with makes everything else easier.

The framework is the runtime: @elizaos/core, the agent loop, the plugin model (actions, providers, services, evaluators), the message/memory/state primitives, and the model-agnostic LLM layer. If you depend on @elizaos/core from your own code, you are using the framework.

An application is a product built on the framework. apps/app-companion, apps/app-browser, apps/app-knowledge, apps/app-phone, and the rest of apps/ are first-party examples. Each is a self-contained package with its own UI, runtime plugin, data model, and deployment story. They share the framework, not the implementation.

The same split shows up in the directory tree:

packages/        ← FRAMEWORK
  core/          # @elizaos/core — runtime, types, agent loop
  agent/         # @elizaos/agent — AgentRuntime + plugin loader
  app-core/      # API + dashboard host
  elizaos/       # the `elizaos` CLI
  prompts/       # shared prompt scaffolding
  ui/            # shared React component library
  examples/      # 30+ standalone examples (chat, discord, mcp, …)
  benchmarks/    # 30+ evaluation suites (gaia, swe_bench, tau-bench, …)

apps/            ← APPLICATIONS
  app-companion/ app-browser/ app-knowledge/ app-phone/
  app-task-coordinator/ app-training/ app-form/ ...

plugins/         ← runtime plugins (connectors + capabilities)
templates/       ← scaffolds used by `APP create` / `PLUGIN create` flows

A plugin sits between the two: framework-shaped (registers actions/providers/services with the runtime) but shipped and consumed like a product. Community plugins are listed at elizaOS-plugins/registry.

Pick your starting point

You want to…	Start here
Try an agent in 5 minutes	CLI quick start
Use the runtime from your own TypeScript code (no CLI, no UI)	Standalone usage
Build a new agent application	Create a new app
Build a runtime plugin (action / provider / service)	Create a new plugin
See how others did it	Examples
Evaluate or benchmark an agent	Benchmarks
Read the docs	docs.elizaos.ai

CLI quick start

Prerequisites: Node.js v23+, bun. On Windows, use WSL 2.

bun install -g elizaos@alpha
elizaos create my-first-agent        # interactive — pick `fullstack-app` for the standard path
cd my-first-agent
# add OPENAI_API_KEY=... to .env (or your provider's key)
bun install
bun run dev

The scaffolded fullstack-app exposes the runtime scripts you'll use day-to-day: bun run dev, bun run build, bun run test, bun run typecheck, bun run lint, bun run verify. The elizaos CLI itself is intentionally minimal — its job is scaffolding (elizaos create) and template upgrades (elizaos upgrade). For a list of available templates, run elizaos info.

Full reference: elizaos --help or elizaos <command> --help.

Standalone usage

Use @elizaos/core directly — no CLI, no dashboard, just the runtime in your code.

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

# Interactive REPL against a real agent
OPENAI_API_KEY=your_key bun run packages/examples/chat/chat.ts

Nearly every surface has a working example in packages/examples/ — 30+ in total. Each one has its own README and runs independently. They are the fastest way to see the framework standing on its own. See Examples below for the highlights.

About the partial clone. --filter=blob:none gives you the full history but fetches file contents on demand — about 10× smaller. git log, branches, and git checkout work normally; git blame and git log -p will fetch on first use. To upgrade later: git config --unset remote.origin.partialclonefilter && git fetch --refetch. For one-off CI, --depth=1 --single-branch is even smaller.

Create a new app

An application is a self-contained product on top of the runtime: UI, runtime plugin, metadata. Two paths:

1. CLI scaffold (recommended).

elizaos create my-app -t fullstack-app
cd my-app
bun install
bun run dev

fullstack-app lays out a full workspace with a local eliza checkout, default plugins (plugin-sql, plugin-elizacloud, plugin-local-ai, plugin-ollama), and a Vite + React UI you can edit immediately.

2. Copy a template directly. templates/min-app/ is the smallest possible app — Vite + React UI, a runtime Plugin with one action, the elizaos.app metadata block in package.json, and a vitest smoke test. Read templates/min-app/SCAFFOLD.md for the placeholders to replace and the verification contract.

For real-world references, browse apps/. A few starting points by complexity:

• app-companion — chat-first companion with a custom React UI.
• app-browser — agent-driven browser automation.
• app-knowledge — RAG over user documents.
• app-phone — voice + telephony surface.
• app-form — form-driven data collection.
• app-task-coordinator — multi-agent orchestration.
• app-training — trajectory capture + native prompt optimization.

Create a new plugin

A plugin extends the runtime with actions, providers, services, or evaluators — no UI required.

elizaos create my-plugin -t plugin
cd my-plugin
bun install
bun run build

Or copy templates/min-plugin/ directly. See templates/min-plugin/SCAFFOLD.md for the contract.

Once typecheck, lint, and tests pass, publish to npm. Community plugins are listed in elizaOS-plugins/registry.

Examples

packages/examples/ — 30+ runnable references covering connectors, integrations, hosting targets, and gameplay. Each subdirectory is independently buildable and has its own README.

Category	Examples
Conversational	chat, discord, telegram, farcaster, farcaster-miniapp, twitter-xai, bluesky
Web frameworks	next, react, html, browser-extension, rest-api
Hosting / serverless	vercel, cloudflare, gcp, aws, supabase, convex
Protocols	mcp, a2a
On-chain / trading	polyagent, polymarket, trader, lp-manager
Fun / games	tic-tac-toe, text-adventure, game-of-life, town, roblox, elizagotchi
Other	autonomous, avatar, code, form, moltbook, _plugin

Benchmarks

packages/benchmarks/ — 30+ evaluation suites for measuring agent capability. Each lives in its own subdirectory with its own harness and README.

Category	Benchmarks
General agent	gaia, agentbench, tau-bench, gauntlet, realm, trust, experience
Coding	swe_bench, bfcl, mint
OS / desktop	OSWorld, terminal-bench
Web	mind2web, webshop
On-chain / trading	HyperliquidBench, solana, evm, vending-bench
Voice / multimodal	voicebench
Specialized	adhdbench, clawbench, openclaw-benchmark, woobench, rlm-bench, social-alpha
elizaOS-specific	app-eval, configbench, context-bench, framework, orchestrator, orchestrator_lifecycle

The runbook for orchestrator-driven benchmark runs is packages/benchmarks/ORCHESTRATOR_SUBAGENT_BENCHMARK_RUNBOOK.md. The Eliza adapter that lets a benchmark drive an Eliza agent lives at packages/benchmarks/eliza-adapter. A combined results viewer is at packages/benchmarks/viewer.

Working in the monorepo

bun install            # workspace install
bun run dev            # API + Vite UI for apps/app
bun run build          # turbo build across the workspace
bun run lint           # turbo lint across the workspace
bun run test           # full test suite (scripts/run-all-tests.mjs)

Key framework packages:

• @elizaos/core — runtime, types, agent loop. The package the framework starts and ends with.
• @elizaos/agent — AgentRuntime, plugin loader, default plugin map.
• @elizaos/app-core — Express API + dashboard host that runs agents.
• elizaos — the elizaos CLI: create, info, upgrade, version.
• @elizaos/prompts — shared prompt scaffolding.
• @elizaos/ui — shared React component library.
• plugins/ — connectors and capabilities (Telegram, Discord, Farcaster, Twitter/X, browser, video, TEE, …).

Contributing

Contributions welcome. Open an issue before sending a non-trivial PR.

• Bug Report
• Feature Request

License

MIT — see LICENSE.

Contributors