elizaos

name	elizaos
version	1.2.0
description	ElizaOS - TypeScript framework for building autonomous AI agents with multi-platform support (Discord, Telegram, Twitter, Farcaster), blockchain integration (EVM, Solana), plugin architecture, multi-agent orchestration, and 90+ community plugins

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

Component	Purpose	Description
Character	Identity	Defines agent personality, knowledge, behaviors, and capabilities
Runtime	Execution	Manages agent lifecycle, memory, providers, and event processing
Plugins	Extensions	Modular functionality (platforms, blockchains, actions, services)
Actions	Tasks	Discrete operations agents can perform (message, trade, analyze)
Providers	Data	Real-time information sources for agent context
Evaluators	Assessment	Decision-making mechanisms for agent responses
Memory	State	Persistent storage of interactions and learned context
Services	Background	Long-running processes (embedding, tasks, monitoring)

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: ;
  :  <>;
  :  <>;
}

---

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 with REST API at /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

Command	Description	Example
elizaos create	Create new project/plugin/agent	elizaos create my-agent
elizaos start	Launch in production mode	elizaos start
elizaos dev	Development mode with hot-reload	elizaos dev
elizaos env	Manage environment variables	elizaos env edit-local
elizaos agent	Manage agents (list/start/stop)	elizaos agent list
elizaos plugins	Manage plugins	elizaos plugins add discord
elizaos test	Run project tests	elizaos test
elizaos update	Update dependencies	elizaos update
elizaos publish	Publish plugin to registry	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"],
    : [, , ],
    : [, , ]
  },
  : [, , , ],
  : [
    ,
    ,
    
  ],
  : {
    : { :  }
  }
}

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 [e-mail]" } },
          { user: "agent", content: { text: "I'll send that email now." } }
        ]
      ]
    }
  ],

  // Providers: Real-time data sources
  providers: [
    {
      name: "weather",
      :  (runtime, message) => {
        
         ;
      }
    }
  ],

  
  : [
    {
      : ,
      :  (runtime, message) => {
        
         { : , :  };
      }
    }
  ],

  
  : [
    {
      : ,
      :  (runtime) => {
        
      },
      :  (runtime) => {
        
      }
    }
  ]
};

Core Plugins

Plugin	Package	Purpose
Bootstrap	@elizaos/plugin-bootstrap	Essential message processing (required)
SQL	@elizaos/plugin-sql	Database operations (PostgreSQL/PGLite)
Knowledge	@elizaos/plugin-knowledge	RAG document ingestion and retrieval

Bootstrap Plugin Components (Required)

The bootstrap plugin provides foundational components that most agents need:

Actions (14 built-in):

Action	Description
choice	Decision-making between options
followRoom	Subscribe to room updates
unfollowRoom	Unsubscribe from room
ignore	Ignore specific messages/users
imageGeneration	Generate images via AI models
muteRoom / unmuteRoom	Room notification control
none	No-action placeholder
reply	Send response messages
roles	Manage agent roles
sendMessage	Direct message sending
settings	Configuration management
updateEntity	Update entity records

Providers (18 built-in):

Provider	Description
actionState	Current action context
actions	Available actions list
anxiety	Agent anxiety/confidence levels
attachments	File/media attachments
capabilities	Agent capability registry
character	Character/personality data
choice	Decision options
entities	Entity relationship data
evaluators	Available evaluators
facts	Known facts database
providers	Provider registry
recentMessages	Conversation history
relationships	Entity relationships
roles	Role assignments
settings	Configuration values
time	Current time context
world	World state information

Evaluators (2 built-in):

Evaluator	Description
reflection	Self-reflection and learning from interactions

Services (3 built-in):

Service	Description
embedding	Text embedding generation
task	Background task management

Platform Plugins

Plugin	Package	Purpose
Discord	@elizaos/plugin-discord	Discord bot integration
Telegram	@elizaos/plugin-telegram	Telegram bot integration
Twitter	@elizaos/plugin-twitter	Twitter/X automation
Farcaster	@elizaos/plugin-farcaster	Farcaster social protocol

Blockchain Plugins

Plugin	Package	Purpose
Solana	@elizaos/plugin-solana	Solana DeFi operations
EVM	@elizaos/plugin-evm	Ethereum/EVM chain interactions

LLM Provider Plugins

Plugin	Package	Purpose
OpenAI	@elizaos/plugin-openai	GPT-4, GPT-3.5 models
Anthropic	@elizaos/plugin-anthropic	Claude models
Google GenAI	@elizaos/plugin-google-genai	Gemini models
Ollama	@elizaos/plugin-ollama	Local model inference
OpenRouter	@elizaos/plugin-openrouter	Multi-provider routing

---

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

Endpoint	Method	Description
/api/agents	GET	List all agents
/api/agents/:id	GET	Get agent details
/api/agents/:id/messages	POST	Send message to agent
/api/agents/:id/messages	GET	Get conversation history
/api/agents/:id/memory	GET	Retrieve agent memories
/api/health	GET	Service health check

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

Repository	Description
eliza	Core autonomous agent framework (17k+ stars)
otaku	Autonomous DeFi trading and research agent
spartan	Quantitative trading agent
SWEagent	Autonomous software engineering agent
the-org	Agents for organizations

Infrastructure & Tools

Repository	Description
knowledge	Ecosystem news, GitHub updates, discussion summaries for RAG
mcp-gateway	MCP (Model Context Protocol) gateway
x402.elizaos.ai	Dynamic x402 routing with intelligent content negotiation
mobile	ElizaOS Cloud app with Privy React Native starter
LiveVideoChat	Live video chat integration

Templates & Starters

Repository	Description
eliza-plugin-starter	Plugin development template
eliza-nextjs-starter	Eliza v2 Document Chat Demo on Next.js
eliza-3d-hyperfy-starter	3D agent with Hyperfy plugin
project-starter	Standard project template
project-tee-starter	TEE (Trusted Execution Environment) template

Community & Documentation

Repository	Description
docs	Official documentation
elizaos.github.io	Contributor leaderboard
elizas-list	Community project directory
workgroups	Ecosystem acceleration workgroups
plugins-automation	Automation for 150+ plugins management

---

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

Feature	Description
Multi-Chain Trading	Solana, Ethereum, Base with Jupiter and 0x integration
Technical Analysis	14+ indicators (RSI, MACD, Bollinger Bands, Stochastic, ATR, ADX)
Autonomous Trading	AI-driven position management with risk controls
Multi-Wallet	User-specific custody with cross-wallet transfers
Market Intelligence	Real-time sentiment, whale tracking, trending tokens
Community Investing	Trust-scored recommendations with leaderboards

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)