ElizaOS Skill

ElizaOS is an open-source TypeScript framework for building and deploying autonomous AI agents. Created by the ai16z community, it enables developers to create agents with custom personalities that can operate across multiple platforms, trade on-chain, manage social media, create content, and interact with any API or blockchain.

Core Philosophy: "Ship Fast, Scale Freely, Truly Open" - three commands to deployment, from single characters to millions of interactions, fully open-source with community extensibility.

When to Use This Skill

This skill should be triggered when:

• Building autonomous AI agents with custom personalities
• Creating multi-platform bots (Discord, Telegram, Twitter, Farcaster)
• Developing blockchain-integrated agents (EVM, Solana DeFi)
• Implementing multi-agent orchestration systems
• Setting up RAG-based knowledge agents
• Configuring ElizaOS plugins and character files
• Deploying agents to production environments

When NOT to Use This Skill

• For simple chatbots without agent autonomy (use basic bot frameworks)
• For non-TypeScript/JavaScript projects (ElizaOS is TypeScript-native)
• For single-purpose scripts without persistent state
• For cloud function integrations only (use serverless frameworks)

Core Concepts

Architecture Overview

┌─────────────────────────────────────────────────────────────────┐
│                      ElizaOS Architecture                        │
└─────────────────────────────────────────────────────────────────┘

                    ┌──────────────────────┐
                    │   Character Files    │
                    │  (Personality/Bio)   │
                    └──────────┬───────────┘
                               │
                    ┌──────────▼───────────┐
                    │     Agent Runtime    │
                    │  - Memory System     │
                    │  - State Management  │
                    │  - Event Processing  │
                    └──────────┬───────────┘
                               │
        ┌──────────────────────┼──────────────────────┐
        │                      │                      │
┌───────▼───────┐    ┌────────▼────────┐    ┌───────▼───────┐
│   Plugins     │    │   Providers     │    │   Actions     │
│ - Bootstrap   │    │ - OpenAI        │    │ - Message     │
│ - SQL         │    │ - Anthropic     │    │ - Trade       │
│ - Knowledge   │    │ - Ollama        │    │ - Analyze     │
│ - Discord     │    │ - Google        │    │ - Create      │
│ - Twitter     │    │ - Grok          │    │ - Execute     │
│ - Telegram    │    │ - OpenRouter    │    │               │
│ - Solana      │    │                 │    │               │
│ - EVM         │    │                 │    │               │
└───────────────┘    └─────────────────┘    └───────────────┘
        │                      │                      │
        └──────────────────────┼──────────────────────┘
                               │
                    ┌──────────▼───────────┐
                    │  Platform Clients    │
                    │ Discord │ Telegram   │
                    │ Twitter │ Farcaster  │
                    │ Web UI  │ REST API   │
                    └──────────────────────┘

Key Components

AgentRuntime

The AgentRuntime is the central orchestrator managing the agent's lifecycle:

import { AgentRuntime } from "@elizaos/core";

// Core runtime responsibilities:
// - Plugin lifecycle management
// - Interaction orchestration
// - Component coordination (actions, providers, evaluators)
// - Memory and state management
// - Event processing and routing

const runtime = new AgentRuntime({
  character: myCharacter,
  plugins: [bootstrapPlugin, sqlPlugin],
  providers: [...],
  evaluators: [...],
  actions: [...],
  services: [...]
});

// Runtime provides unified access to all components
await runtime.initialize();
await runtime.processMessage(message, state);

Component Interfaces

// Action Interface - Tasks agents can execute
interface Action {
  name: string;                                    // Unique identifier
  description: string;                             // Purpose and triggers
  validate: (runtime, message) => Promise<boolean>; // Applicability check
  handler: (runtime, message) => Promise<Result>;   // Core logic
  examples: MessageExample[][];                    // Training examples
}

// Provider Interface - Real-time data sources
interface Provider {
  name: string;
  get: (runtime, message) => Promise<string>;  // Fetch contextual data
}

// Evaluator Interface - Decision mechanisms
interface Evaluator {
  name: string;
  evaluate: (runtime, message) => Promise<EvaluationResult>;
}

// Service Interface - Background processes
interface Service {
  name: string;
  start: (runtime) => Promise<void>;
  stop: (runtime) => Promise<void>;
}

Installation

Prerequisites

• Bun (recommended) or Node.js 18+
• Git
• API keys for LLM providers (OpenAI, Anthropic, etc.)

Quick Start (4 Steps)

# 1. Install ElizaOS CLI globally
bun install -g @elizaos/cli

# 2. Create a new project
elizaos create my-agent

# 3. Configure environment (API keys)
cd my-agent
elizaos env edit-local

# 4. Start the agent
elizaos start

The agent runs on

http://localhost:3000

/api

Alternative Installation (npm)

npm install -g @elizaos/cli
elizaos create my-agent
cd my-agent
npm install
elizaos start

Development Mode

# Hot-reloading during development
elizaos dev

# With debug logging
LOG_LEVEL=debug elizaos start

# Run tests
elizaos test

CLI Reference

Core Commands

elizaos create

elizaos create my-agent

elizaos start

elizaos start

elizaos dev

elizaos dev

elizaos env

elizaos env edit-local

elizaos agent

elizaos agent list

elizaos plugins

elizaos plugins add discord

elizaos test

elizaos test

elizaos update

elizaos update

elizaos publish

elizaos publish

Project Management

# Create different project types
elizaos create my-agent          # Full agent project
elizaos create my-plugin --plugin  # Plugin project

# Environment configuration
elizaos env list                 # List env vars
elizaos env edit-local           # Edit local .env
elizaos env set OPENAI_API_KEY=sk-xxx

# Plugin management
elizaos plugins list             # Available plugins
elizaos plugins add @elizaos/plugin-discord
elizaos plugins remove @elizaos/plugin-discord

Deployment Commands

# Deploy to AWS ECS
elizaos deploy

# TEE (Trusted Execution Environment) deployment
elizaos tee deploy

# Cloud container management
elizaos containers list
elizaos containers create
elizaos containers start
elizaos containers stop

Character Configuration

Characters define agent identity, personality, and behavior.

Character File Structure

// character.json or character.ts
{
  "name": "TradingBot",
  "bio": [
    "Expert cryptocurrency trader with 5 years experience",
    "Specializes in DeFi protocols and yield strategies",
    "Always provides risk disclaimers with advice"
  ],
  "lore": [
    "Started trading during the 2020 DeFi summer",
    "Lost a fortune on Terra Luna, learned hard lessons",
    "Now focuses on sustainable yield strategies"
  ],
  "knowledge": [
    "Uniswap V3 concentrated liquidity mechanics",
    "Aave lending and borrowing protocols",
    "MEV protection strategies"
  ],
  "messageExamples": [
    [
      { "user": "user1", "content": { "text": "Should I ape into this new token?" } },
      { "user": "TradingBot", "content": { "text": "I'd recommend checking the contract audit first. What's the liquidity depth and who are the team members? Never invest more than you can afford to lose." } }
    ]
  ],
  "postExamples": [
    "Just spotted an interesting arbitrage opportunity between Uniswap and SushiSwap. Remember: by the time you read this, it's probably gone. That's how fast DeFi moves.",
    "PSA: Always double-check contract addresses before approving. Scammers are getting more sophisticated every day."
  ],
  "topics": ["DeFi", "trading", "yield farming", "risk management"],
  "style": {
    "all": ["analytical", "cautious", "educational"],
    "chat": ["conversational", "helpful", "warning-oriented"],
    "post": ["informative", "concise", "timely"]
  },
  "adjectives": ["analytical", "experienced", "cautious", "helpful"],
  "plugins": [
    "@elizaos/plugin-bootstrap",
    "@elizaos/plugin-sql",
    "@elizaos/plugin-solana"
  ],
  "settings": {
    "voice": { "model": "en_US-male-medium" }
  }
}

Character TypeScript Definition

import { Character } from "@elizaos/core";

export const myAgent: Character = {
  name: "AssistantBot",
  bio: "A helpful AI assistant specialized in coding",
  lore: ["Created to help developers ship faster"],
  knowledge: ["TypeScript", "React", "Node.js best practices"],
  messageExamples: [],
  postExamples: [],
  topics: ["programming", "web development"],
  style: {
    all: ["professional", "concise"],
    chat: ["helpful", "patient"],
    post: ["informative"]
  },
  adjectives: ["helpful", "knowledgeable"],
  plugins: ["@elizaos/plugin-bootstrap"],
  settings: {}
};

Plugin Architecture

Plugins extend agent capabilities through modular components.

Plugin Structure

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

export const myPlugin: Plugin = {
  name: "my-custom-plugin",
  description: "Adds custom functionality to agents",

  // Actions: Tasks agents can perform
  actions: [
    {
      name: "SEND_EMAIL",
      description: "Send an email to a recipient",
      validate: async (runtime, message) => {
        // Validation logic
        return true;
      },
      handler: async (runtime, message) => {
        // Action implementation
        return { success: true };
      },
      examples: [
        [
          { user: "user", content: { text: "Send an email to john@example.com" } },
          { user: "agent", content: { text: "I'll send that email now." } }
        ]
      ]
    }
  ],

  // Providers: Real-time data sources
  providers: [
    {
      name: "weather",
      get: async (runtime, message) => {
        // Fetch weather data
        return "Current weather: 72°F, sunny";
      }
    }
  ],

  // Evaluators: Decision mechanisms
  evaluators: [
    {
      name: "sentiment",
      evaluate: async (runtime, message) => {
        // Analyze sentiment
        return { sentiment: "positive", confidence: 0.85 };
      }
    }
  ],

  // Services: Long-running processes
  services: [
    {
      name: "price-monitor",
      start: async (runtime) => {
        // Start background monitoring
      },
      stop: async (runtime) => {
        // Cleanup
      }
    }
  ]
};

Core Plugins

@elizaos/plugin-bootstrap

@elizaos/plugin-sql

@elizaos/plugin-knowledge

Bootstrap Plugin Components (Required)

The bootstrap plugin provides foundational components that most agents need:

Actions (14 built-in):

choice

followRoom

unfollowRoom

ignore

imageGeneration

muteRoom

unmuteRoom

none

reply

roles

sendMessage

settings

updateEntity

Providers (18 built-in):

actionState

actions

anxiety

attachments

capabilities

character

choice

entities

evaluators

facts

providers

recentMessages

relationships

roles

settings

time

world

Evaluators (2 built-in):

reflection

Services (3 built-in):

embedding

task

Platform Plugins

@elizaos/plugin-discord

@elizaos/plugin-telegram

@elizaos/plugin-twitter

@elizaos/plugin-farcaster

Blockchain Plugins

@elizaos/plugin-solana

@elizaos/plugin-evm

LLM Provider Plugins

@elizaos/plugin-openai

@elizaos/plugin-anthropic

@elizaos/plugin-google-genai

@elizaos/plugin-ollama

@elizaos/plugin-openrouter

Memory System

ElizaOS agents maintain persistent memory for context and learning.

Memory Types

// Memory structure
interface Memory {
  id: string;
  userId: string;
  agentId: string;
  roomId: string;
  content: {
    text: string;
    action?: string;
    source?: string;
  };
  embedding?: number[];  // Vector for semantic search
  createdAt: number;
}

// Runtime memory operations
await runtime.messageManager.createMemory({
  content: { text: "User prefers dark mode" },
  userId: userId,
  roomId: roomId
});

// Retrieve memories
const memories = await runtime.messageManager.getMemories({
  roomId: roomId,
  count: 10
});

// Search by semantic similarity
const similar = await runtime.messageManager.searchMemoriesByEmbedding(
  embedding,
  { match_threshold: 0.8, count: 5 }
);

State Management

// Agent state object
interface State {
  bio: string;
  lore: string;
  messageDirections: string;
  postDirections: string;
  actors: string;
  actorsData: Actor[];
  recentMessages: string;
  recentMessagesData: Memory[];
  goals: string;
  goalsData: Goal[];
  actions: string;
  actionNames: string;
  providers: string;
}

// Access state in actions
const handler = async (runtime, message, state) => {
  const recentContext = state.recentMessages;
  const currentGoals = state.goalsData;
  // Use context for decision making
};

Multi-Agent Orchestration

ElizaOS supports coordinating multiple specialized agents.

Agent Configuration

// agents.config.ts
export const agents = [
  {
    character: "./characters/analyst.json",
    plugins: ["@elizaos/plugin-knowledge"],
    settings: { role: "research" }
  },
  {
    character: "./characters/trader.json",
    plugins: ["@elizaos/plugin-solana"],
    settings: { role: "execution" }
  },
  {
    character: "./characters/coordinator.json",
    plugins: ["@elizaos/plugin-bootstrap"],
    settings: { role: "orchestration" }
  }
];

Inter-Agent Communication

// Send message to another agent
await runtime.sendMessage({
  targetAgentId: "trader-agent-id",
  content: {
    text: "Execute buy order for SOL",
    action: "TRADE",
    data: { token: "SOL", amount: 100 }
  }
});

// Subscribe to agent events
runtime.on("agent:message", (message) => {
  if (message.sourceAgentId === "analyst-agent-id") {
    // Process research updates
  }
});

REST API

ElizaOS exposes a REST API for external integrations.

Endpoints

/api/agents

/api/agents/:id

/api/agents/:id/messages

/api/agents/:id/messages

/api/agents/:id/memory

/api/health

Example Usage

# List agents
curl http://localhost:3000/api/agents

# Send message
curl -X POST http://localhost:3000/api/agents/my-agent/messages \
  -H "Content-Type: application/json" \
  -d '{"text": "What is the current ETH price?"}'

# Get conversation history
curl http://localhost:3000/api/agents/my-agent/messages?limit=10

WebSocket Connection

import { io } from "socket.io-client";

const socket = io("http://localhost:3000");

socket.on("connect", () => {
  socket.emit("join", { agentId: "my-agent", roomId: "room-1" });
});

socket.on("message", (data) => {
  console.log("Agent response:", data.text);
});

socket.emit("message", {
  agentId: "my-agent",
  roomId: "room-1",
  text: "Hello agent!"
});

Environment Configuration

Required Variables

# .env file

# LLM Provider (at least one required)
OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=sk-ant-...
GOOGLE_GENERATIVE_AI_API_KEY=...

# Database (PGLite default, PostgreSQL for production)
DATABASE_URL=postgresql://user:pass@localhost:5432/eliza

# Platform tokens (as needed)
DISCORD_BOT_TOKEN=...
TELEGRAM_BOT_TOKEN=...
TWITTER_API_KEY=...
TWITTER_API_SECRET=...
TWITTER_ACCESS_TOKEN=...
TWITTER_ACCESS_SECRET=...

# Blockchain (as needed)
SOLANA_PRIVATE_KEY=...
SOLANA_RPC_URL=https://api.mainnet-beta.solana.com
EVM_PRIVATE_KEY=0x...
EVM_RPC_URL=https://eth-mainnet.g.alchemy.com/v2/...

Configuration Management

# View all environment variables
elizaos env list

# Edit local environment
elizaos env edit-local

# Set specific variable
elizaos env set OPENAI_API_KEY=sk-xxx

# Use specific environment
elizaos start --env production

Deployment

Local Production

# Build and start
elizaos build
elizaos start --production

Docker

FROM oven/bun:latest

WORKDIR /app
COPY . .
RUN bun install
RUN bun run build

EXPOSE 3000
CMD ["bun", "run", "start"]

docker build -t my-agent .
docker run -p 3000:3000 --env-file .env my-agent

AWS ECS

# Deploy to AWS ECS
elizaos deploy --platform aws-ecs

# Configure deployment
elizaos deploy configure

TEE (Trusted Execution Environment)

# Deploy to TEE for enhanced security
elizaos tee deploy
elizaos tee status

Troubleshooting

Common Issues

Agent not responding:

# Check logs with debug level
LOG_LEVEL=debug elizaos start

# Verify API key configuration
elizaos env list | grep API_KEY

Plugin not loading:

# Reinstall plugins
elizaos plugins remove @elizaos/plugin-discord
elizaos plugins add @elizaos/plugin-discord

# Check plugin compatibility
elizaos plugins list --check-versions

Memory/database issues:

# Reset database (development only!)
elizaos db reset

# Check database connection
elizaos db status

Platform connection errors:

# Test Discord connection
elizaos test discord

# Verify bot token
elizaos env check DISCORD_BOT_TOKEN

ElizaOS Ecosystem

The ElizaOS organization maintains 56+ repositories for specialized use cases:

Specialized Agents

eliza

otaku

spartan

SWEagent

the-org

Infrastructure & Tools

knowledge

mcp-gateway

x402.elizaos.ai

mobile

LiveVideoChat

Templates & Starters

eliza-plugin-starter

eliza-nextjs-starter

eliza-3d-hyperfy-starter

project-starter

project-tee-starter

Community & Documentation

docs

elizaos.github.io

elizas-list

workgroups

plugins-automation

Spartan: DeFi Trading Agent

Spartan is a production-ready DeFi trading agent built on ElizaOS, demonstrating advanced multi-chain trading capabilities with AI-driven decision-making.

Spartan Features

Spartan Plugin Architecture

spartan/src/plugins/
├── account/          # User registration and notifications
├── analytics/        # Token analysis with 14+ technical indicators
├── autofunTrader/    # auto.fun protocol with 5-min buy/sell signals
├── autonomous-trader/ # Core trading utilities, holder verification
├── coin_marketing/   # Promotion and campaign tools
├── communityInvestor/ # Trust scoring, leaderboards, recommendations
├── degenIntel/       # Sentiment analysis, whale tracking, trending
├── kol/              # Key Opinion Leader framework
├── multiwallet/      # Jupiter swaps, wallet consolidation, transfers
└── trading/          # Multi-strategy engine (LLM, copy trading, manual)

Spartan Trading Strategies

// Spartan supports multiple trading strategy types:

// 1. LLM-Based Strategy - AI-powered decision making
const llmStrategy = {
  type: "llm",
  model: "anthropic", // or "openai"
  riskLevel: "medium",
  positionSize: "dynamic" // based on confidence
};

// 2. Copy Trading - Mirror established traders
const copyStrategy = {
  type: "copy",
  targetWallets: ["whale-address-1", "whale-address-2"],
  mirrorDelay: 30, // seconds
  maxPositionRatio: 0.5
};

// 3. Manual Strategy - User-directed with agent execution
const manualStrategy = {
  type: "manual",
  confirmationRequired: true,
  slippage: 0.01 // 1%
};

Spartan Environment Configuration

# Spartan-specific environment variables

# AI Models (at least one required)
ANTHROPIC_API_KEY=sk-ant-...
OPENAI_API_KEY=sk-...

# Blockchain RPC
SOLANA_RPC_URL=https://api.mainnet-beta.solana.com
SOLANA_PRIVATE_KEY=<base58-encoded-key>
EVM_PROVIDER_URL=https://eth-mainnet.g.alchemy.com/v2/...

# Market Data Providers
BIRDEYE_API_KEY=...
COINMARKETCAP_API_KEY=...

# DEX Integration
JUPITER_API_KEY=...
ZEROEX_API_KEY=...

# Database
MYSQL_HOST=localhost
MYSQL_USER=spartan
MYSQL_PASSWORD=...
MYSQL_DATABASE=spartan

Spartan Quick Start

# Clone and install
git clone https://github.com/elizaOS/spartan.git
cd spartan
npm install

# Configure environment
cp .env.example .env
# Edit .env with your API keys

# Run with Docker (recommended)
docker-compose up -d

# Or run directly
elizaos start

# Development mode with debug
DEBUG=elizaos:* npm run dev

Spartan Character Example

// Spartan agent personality configuration
{
  "name": "Spartan",
  "bio": [
    "DeFi trading warlord with no-BS attitude",
    "Combines alpha with tactical precision",
    "Result-oriented, direct communication style"
  ],
  "lore": [
    "Forged in the DeFi trenches of multiple market cycles",
    "Known for calling out rug pulls before they happen"
  ],
  "knowledge": [
    "Jupiter DEX aggregation mechanics",
    "On-chain whale activity patterns",
    "Technical analysis with 14+ indicators"
  ],
  "topics": ["trading", "DeFi", "analytics", "market intelligence"],
  "style": {
    "all": ["direct", "tactical", "analytical"],
    "chat": ["concise", "actionable", "data-driven"],
    "post": ["alpha-focused", "no-fluff"]
  },
  "plugins": [
    "@elizaos/plugin-bootstrap",
    "@elizaos/plugin-sql",
    "@elizaos/plugin-solana"
  ]
}

Monorepo Structure

packages/
├── core/              # Central framework (AgentRuntime, types)
├── cli/               # Command-line interface
├── client/            # Client-side implementation
├── server/            # Server-side implementation
├── app/               # Application layer
├── api-client/        # API client interface
├── config/            # Configuration management
├── service-interfaces/ # Service definitions and contracts
├── test-utils/        # Testing utilities
├── elizaos/           # Main package export
│
├── plugin-bootstrap/  # Core communication plugin (required)
├── plugin-sql/        # Database integration
├── plugin-starter/    # Plugin template
├── plugin-quick-starter/ # Rapid development template
├── plugin-dummy-services/ # Mock services for testing
│
├── project-starter/   # Standard project template
└── project-tee-starter/ # TEE project template

Resources

Official Documentation

• ElizaOS Docs
• GitHub Repository
• Plugin Registry

Community

• Discord - 17,000+ members
• Twitter/X
• GitHub Discussions

Examples & Templates

• Official Examples
• Plugin Templates
• Character Examples

Version History

• 1.2.0 (2026-01-11): Added Spartan DeFi trading agent documentation

  • Complete Spartan plugin architecture (10 plugins)
  • Trading strategies: LLM-based, copy trading, manual
  • Technical analysis with 14+ indicators
  • Multi-wallet management and Jupiter/0x DEX integration
  • Spartan-specific environment configuration
  • Character configuration example for trading agents
  • Quick start guide with Docker deployment

• 1.1.0 (2026-01-11): Enhanced with GitHub ecosystem details

  • Added Bootstrap plugin component details (14 actions, 18 providers, 2 evaluators, 3 services)
  • Added ElizaOS ecosystem section (56+ repositories)
  • Added monorepo structure documentation
  • Added AgentRuntime and component interfaces
  • Added specialized agents (otaku, spartan, SWEagent)
  • Added infrastructure tools (MCP gateway, knowledge base, mobile app)
  • Enhanced core concepts with Services component

• 1.0.0 (2026-01-11): Initial skill release

  • Complete ElizaOS framework documentation
  • CLI reference with all commands
  • Character configuration guide
  • Plugin architecture and examples
  • Memory system documentation
  • Multi-agent orchestration patterns
  • REST API and WebSocket integration
  • Deployment options (Docker, AWS ECS, TEE)