video-frames Hermes AI Agent Skill

✨ 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 public plugin catalog at plugins.elizacloud.ai. Community registry entries are maintained in this monorepo under packages/registry, and npm packages with the elizaos keyword are discoverable without a registry entry.

Framework, Projects, And App Plugins

elizaOS is a framework plus packages built on top of it. Knowing which layer
you're working with keeps projects, plugins, and app surfaces from getting
mixed together.

The framework is the runtime: @elizaos/core, the agent loop, the plugin model (actions, providers, services), 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.

A project is a deployable product workspace built on the framework. A
generated project owns its branded app shell, usually under apps/app inside
that project workspace.

An app plugin is a runtime plugin that also contributes an app surface inside
Eliza. First-party app plugins live under plugins/app-*, keep npm
names like @elizaos/plugin-companion, and are loaded by package name. They are
plugins, not top-level repo applications.

The same split shows up in the directory tree:

packages/        ← framework and shared packages
  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/      # standalone examples (chat, discord, mcp, ...)
  benchmarks/    # evaluation suites (gaia, swe_bench, tau-bench, ...)

plugins/         ← runtime plugins and app plugins
  app-companion/ app-browser/ app-documents/ app-phone/
  app-task-coordinator/ app-training/ plugin-form/ ...
  plugin-discord/ plugin-openai/ plugin-sql/ ...

packages/elizaos/templates/   ← CLI scaffolds + min-project / min-plugin for APP/PLUGIN create

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 discovered from npm metadata and curated through the in-repo packages/registry catalog.

Pick your starting point

CLI quick start

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

bun add -g elizaos@beta
elizaos create my-first-agent --template project
cd my-first-agent
# add OPENAI_API_KEY=... to .env (or your provider's key)
bun install
bun run dev

The generated project 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.

Local mock stack

One command boots the full local cloud stack with mocks (Hetzner + control-plane + cloud-api with MOCK_REDIS + PGlite, plus cloud-frontend):

bun run cloud:mock          # boot with existing PGlite data
bun run cloud:mock:fresh    # wipe PGlite + re-run migrations first

Ports are auto-picked and printed in a ready banner; logs stream to ./.logs/<service>.log. Pass --help to bun scripts/cloud/mock-stack-up.mjs for flags (skip individual services, pin ports, etc.). Ctrl+C tears the stack down in reverse order.

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 project

A project is a self-contained product workspace on top of the runtime: branded
app shell, local eliza checkout, app plugin selection, platform config, and
deployment scripts. Two paths:

1. CLI scaffold (recommended).

elizaos create my-app --template project
cd my-app
bun install
bun run dev

The project template 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. packages/elizaos/templates/min-project/ 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 packages/elizaos/templates/min-project/SCAFFOLD.md for the placeholders to replace and the verification contract.

For first-party app plugin references, browse plugins/app-*. A few starting points by complexity:

• app-companion — chat-first companion with a custom React UI.
• app-browser — agent-driven browser automation.
• app-documents — RAG over user documents (scoped global / owner-private / user-private / agent-private).
• app-phone — voice + telephony surface.
• plugin-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, or services — no UI required.

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

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

Once typecheck, lint, and tests pass, publish to npm with the elizaos keyword. To request a curated listing, add an entry to packages/registry/entries/third-party and open a pull request.

Examples

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

Benchmarks

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

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 (packages/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