ELIZAOS Setup - Comput3 Network

Deploy ELIZAOS on Comput3 Network to start building and running multi-agent AI systems with distributed GPU computing power.

Deployment Options

Managed ELIZAOS

Recommended for most users

Pre-configured ELIZAOS environment
Automatic updates and maintenance
Integrated monitoring and logging
Enterprise support included

Self-Managed

For advanced customization

Full control over ELIZAOS configuration
Custom agent development environment
Direct GPU instance management
Flexible resource allocation

Quick Start: Managed ELIZAOS

Launch ELIZAOS Instance

Deploy a managed ELIZAOS environment from your Comput3 dashboard.

Single Agent Setup
Multi-Agent Setup
Enterprise Setup

Best for: Getting started, small projects

GPU: RTX 4090 48GB or A100 40GB
RAM: 16GB
Storage: 100GB SSD
Cost: ~$1.20-2.50/hour

Access ELIZAOS Interface

Connect to your ELIZAOS deployment through the web interface.

# ELIZAOS web interface runs on port 3000
https://<your-instance-ip>:3000

The managed deployment automatically configures networking and security settings.

Create Your First Agent

Use the ELIZAOS interface to create and configure your first AI agent.

ELIZAOS agent creation interface showing configuration options

Deploy and Monitor

Deploy your agent and monitor its performance through the dashboard.

Your agent will start running immediately and appear in the active agents list.

Self-Managed Installation

Prerequisites

GPU instance with ELIZAOS template or manual setup capability
Basic knowledge of Docker and container orchestration
Understanding of AI agent concepts and workflows

Installation Process

Launch GPU Instance

Deploy a GPU instance suitable for ELIZAOS workloads.Recommended Specifications:

Minimum: RTX 4090 48GB with 16GB RAM
Recommended: A100 40GB with 32GB RAM
Optimal: A100 80GB, H100, H200, or B200 with 64GB+ RAM

Install ELIZAOS

Install ELIZAOS on your GPU instance.

Docker Installation
Manual Installation
Kubernetes

# Pull ELIZAOS Docker image
docker pull elizaos/elizaos:latest

# Create ELIZAOS directory
mkdir -p /opt/elizaos
cd /opt/elizaos

# Download configuration template
wget https://raw.githubusercontent.com/elizaos/elizaos/main/docker-compose.yml

# Start ELIZAOS
docker-compose up -d

# Clone ELIZAOS repository
git clone https://github.com/elizaos/elizaos.git
cd elizaos

# Install dependencies
npm install

# Configure environment
cp .env.example .env
nano .env

# Start ELIZAOS
npm run start:production

# elizaos-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: elizaos
spec:
  replicas: 1
  selector:
    matchLabels:
      app: elizaos
  template:
    metadata:
      labels:
        app: elizaos
    spec:
      containers:
      - name: elizaos
        image: elizaos/elizaos:latest
        resources:
          requests:
            nvidia.com/gpu: 1
            memory: "16Gi"
          limits:
            nvidia.com/gpu: 1
            memory: "32Gi"

Configure Comput3 Integration

Connect ELIZAOS to Comput3 Network services.

{
  "comput3": {
    "api_key": "YOUR_COMPUT3_API_KEY",
    "base_url": "https://api.comput3.ai/v1",
    "default_model": "hermes4:70b",
    "gpu_instance_id": "i-1234567890abcdef0"
  }
}

Verify Installation

Test that ELIZAOS is running correctly and connected to Comput3.

# Check ELIZAOS status
curl http://localhost:3000/health

# Test Comput3 connection
curl http://localhost:3000/api/test-comput3

Configuration

Environment Configuration

Basic Configuration

Essential ELIZAOS settings

# .env file
ELIZAOS_PORT=3000
ELIZAOS_ENV=production
LOG_LEVEL=info

# Comput3 Integration
COMPUT3_API_KEY=your_api_key_here
COMPUT3_BASE_URL=https://api.comput3.ai/v1
COMPUT3_DEFAULT_MODEL=hermes4:70b

# Database
DATABASE_URL=postgresql://user:pass@localhost:5432/elizaos
REDIS_URL=redis://localhost:6379

# Security
JWT_SECRET=your_jwt_secret_here
ENCRYPTION_KEY=your_encryption_key_here

GPU Configuration

GPU resource allocation settings

{
  "gpu": {
    "enabled": true,
    "devices": ["0"],
    "memory_fraction": 0.8,
    "allow_growth": true
  },
  "agents": {
    "max_concurrent": 4,
    "default_gpu_memory": "4GB",
    "memory_limit": "8GB"
  }
}

Network Configuration

Networking and communication settings

{
  "network": {
    "bind_address": "0.0.0.0",
    "port": 3000,
    "ssl_enabled": true,
    "cors_origins": ["https://app.comput3.ai"]
  },
  "communication": {
    "message_queue": "redis",
    "event_bus": "nats",
    "discovery_service": "consul"
  }
}

Agent Configuration Templates

{
  "name": "document-analyzer",
  "type": "task_agent",
  "config": {
    "model": "hermes4:70b",
    "max_tokens": 4096,
    "temperature": 0.3,
    "tools": ["file_reader", "text_analyzer"],
    "resources": {
      "gpu_memory": "2GB",
      "cpu_cores": 2,
      "ram": "4GB"
    }
  },
  "triggers": [
    {
      "type": "file_upload",
      "pattern": "*.pdf",
      "action": "analyze_document"
    }
  ]
}

{
  "name": "code-reviewer",
  "type": "collaborative_agent",
  "config": {
    "model": "hermes4:70b",
    "specialization": "code_review",
    "collaboration": {
      "can_delegate": true,
      "accepts_delegation": true,
      "team_agents": ["test-generator", "doc-writer"]
    },
    "tools": ["git_client", "code_analyzer", "test_runner"],
    "resources": {
      "gpu_memory": "8GB",
      "cpu_cores": 4,
      "ram": "16GB"
    }
  }
}

{
  "name": "system-monitor",
  "type": "monitoring_agent",
  "config": {
    "model": "hermes4:70b",
    "monitoring": {
      "interval": "30s",
      "metrics": ["cpu", "memory", "gpu", "network"],
      "thresholds": {
        "cpu_usage": 80,
        "memory_usage": 85,
        "gpu_utilization": 90
      }
    },
    "actions": [
      {
        "trigger": "high_cpu",
        "action": "scale_resources"
      },
      {
        "trigger": "agent_failure", 
        "action": "restart_agent"
      }
    ]
  }
}

Monitoring and Management

ELIZAOS Dashboard

ELIZAOS management dashboard showing active agents, resource usage, and system metrics

Dashboard Features:

Active Agents: Real-time status of all running agents
Resource Usage: GPU, CPU, and memory utilization
Performance Metrics: Agent efficiency and response times
Cost Tracking: Real-time cost monitoring and projections

Agent Lifecycle Management

Agent States
State Transitions
Auto-Management

Understanding agent lifecycle states

Created: Agent configured but not deployed
Starting: Agent initialization in progress
Running: Agent actively processing tasks
Paused: Agent temporarily suspended
Stopped: Agent terminated but configuration preserved
Failed: Agent encountered unrecoverable error

Managing agent state changes

# Start an agent
elizaos agent start document-analyzer

# Pause an agent
elizaos agent pause document-analyzer

# Resume a paused agent
elizaos agent resume document-analyzer

# Stop an agent
elizaos agent stop document-analyzer

# View agent logs
elizaos agent logs document-analyzer --tail 100

Troubleshooting

Installation Issues

Common installation problemsGPU Driver Issues:

# Check GPU status
nvidia-smi

# Reinstall NVIDIA drivers if needed
sudo apt update
sudo apt install nvidia-driver-525
sudo reboot

Docker Issues:

# Check Docker status
docker version

# Install Docker if missing
curl -fsSL https://get.docker.com -o get-docker.sh
sh get-docker.sh

# Add user to docker group
sudo usermod -aG docker $USER

Agent Startup Failures

Agents failing to start or crashingCommon Causes:

Insufficient GPU memory allocation
Model loading failures
Configuration syntax errors
Network connectivity issues

Debugging Steps:

# Check agent logs
elizaos agent logs <agent-name> --level debug

# Verify configuration
elizaos config validate <agent-config.json>

# Test model connectivity
elizaos test model hermes4:70b

# Check resource availability
elizaos system resources

Performance Issues

Slow agent response or high resource usageOptimization Strategies:

Adjust agent resource allocations
Optimize model parameters (temperature, max_tokens)
Implement request batching
Use agent specialization to reduce model switching
Monitor and tune GPU memory usage

Security Configuration

Access Controls

Authentication

Secure access to ELIZAOS interface

JWT-based authentication
OAuth integration support
Multi-factor authentication
Session management and timeouts

Authorization

Role-based access control

Admin, developer, and viewer roles
Agent-specific permissions
Resource access controls
Audit logging for all actions

Network Security

TLS Configuration

Secure communications

{
  "tls": {
    "enabled": true,
    "cert_file": "/etc/ssl/certs/elizaos.crt",
    "key_file": "/etc/ssl/private/elizaos.key",
    "min_version": "1.3"
  }
}

Firewall Rules

Network access controls

# Allow ELIZAOS web interface
sudo ufw allow 3000/tcp

# Allow agent communication ports
sudo ufw allow 8000:8100/tcp

# Allow SSH for management
sudo ufw allow 22/tcp

# Enable firewall
sudo ufw enable

Agent Isolation

Secure agent execution environment

Process isolation between agents
Network namespace separation
Resource quota enforcement
Secure inter-agent communication

Performance Optimization

Resource Allocation

GPU Optimization
Memory Management
Network Optimization

Maximize GPU utilization

{
  "gpu_config": {
    "memory_pool": "dynamic",
    "sharing_strategy": "time_slicing",
    "max_agents_per_gpu": 4,
    "memory_reservation": "2GB"
  }
}

Efficient memory usage

{
  "memory_config": {
    "agent_memory_limit": "4GB",
    "shared_model_cache": true,
    "garbage_collection": "aggressive",
    "swap_enabled": false
  }
}

Optimize inter-agent communication

{
  "network_config": {
    "message_compression": true,
    "connection_pooling": true,
    "max_connections": 100,
    "timeout": 30000
  }
}

Scaling Strategies

Vertical Scaling

Scale up individual instances

Upgrade to more powerful GPU instances
Increase RAM and storage allocation
Optimize agent resource distribution
Monitor performance metrics for scaling decisions

Horizontal Scaling

Scale out across multiple instances

# Kubernetes scaling configuration
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: elizaos-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: elizaos
  minReplicas: 1
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70

Auto-Scaling

Automatic resource adjustment

Agent-based scaling triggers
Resource utilization monitoring
Cost-aware scaling decisions
Predictive scaling based on usage patterns

Backup and Recovery

Data Backup

Agent Configurations

Backup agent definitions and configurations

# Export all agent configurations
elizaos export agents --output /backup/agents.json

# Export system configuration
elizaos export config --output /backup/elizaos-config.json

Agent State

Backup agent memory and state

# Create agent state snapshot
elizaos snapshot create --agent document-analyzer

# List available snapshots
elizaos snapshot list

# Export snapshots to storage
elizaos snapshot export --destination s3://backups/elizaos/

System Data

Backup logs, metrics, and system data

# Archive logs
tar -czf /backup/logs.tar.gz /var/log/elizaos/

# Export metrics database
pg_dump elizaos_metrics > /backup/metrics.sql

# Sync to cloud storage
aws s3 sync /backup/ s3://elizaos-backups/$(date +%Y%m%d)/

Disaster Recovery

Recovery Planning

Prepare for system failures

Document recovery procedures
Test backup restoration regularly
Maintain off-site backup copies
Plan for different failure scenarios

Quick Recovery

Rapid system restoration

# Restore from backup
elizaos restore --backup-file /backup/elizaos-backup.tar.gz

# Restart all agents
elizaos agent start-all

# Verify system health
elizaos system health-check

Integration with Comput3 Services

API Integration

import elizaos
from comput3 import Comput3Client

# Initialize ELIZAOS client
elizaos_client = elizaos.Client(
    base_url="http://localhost:3000",
    api_key="your-elizaos-api-key"
)

# Initialize Comput3 client  
comput3_client = Comput3Client(
    api_key="your-comput3-api-key",
    base_url="https://api.comput3.ai/v1"
)

# Create agent with Comput3 integration
agent_config = {
    "name": "data-processor",
    "model": "hermes4:70b",
    "comput3_integration": {
        "client": comput3_client,
        "auto_scale": True,
        "cost_limit": 100  # USD per day
    }
}

agent = elizaos_client.create_agent(agent_config)

const { ElizaOSClient } = require('elizaos-sdk');
const { Comput3Client } = require('comput3-sdk');

// Initialize clients
const elizaos = new ElizaOSClient({
  baseURL: 'http://localhost:3000',
  apiKey: process.env.ELIZAOS_API_KEY
});

const comput3 = new Comput3Client({
  apiKey: process.env.COMPUT3_API_KEY,
  baseURL: 'https://api.comput3.ai/v1'
});

// Create integrated agent
const agent = await elizaos.createAgent({
  name: 'content-creator',
  model: 'hermes4:70b',
  comput3Integration: {
    client: comput3,
    autoScale: true,
    resourceLimits: {
      maxGPUHours: 10,
      maxCostPerDay: 50
    }
  }
});

Next Steps

Agent Integration

Learn how to integrate ELIZAOS agents with your existing systems.

GPU Instances

Explore GPU instance options optimized for ELIZAOS workloads.

MCP Integration

Connect external data sources and tools to your ELIZAOS agents.

​Deployment Options

Managed ELIZAOS

Self-Managed

​Quick Start: Managed ELIZAOS

​Self-Managed Installation

​Prerequisites

​Installation Process

​Configuration

​Environment Configuration

​Agent Configuration Templates

​Monitoring and Management

​ELIZAOS Dashboard

​Agent Lifecycle Management

​Troubleshooting

​Security Configuration

​Access Controls

Authentication

Authorization

​Network Security

​Performance Optimization

​Resource Allocation

​Scaling Strategies

​Backup and Recovery

​Data Backup

​Disaster Recovery

​Integration with Comput3 Services

​API Integration

​Next Steps

Agent Integration

GPU Instances

MCP Integration

Deployment Options

Quick Start: Managed ELIZAOS

Self-Managed Installation

Prerequisites

Installation Process

Configuration

Environment Configuration

Agent Configuration Templates

Monitoring and Management

ELIZAOS Dashboard

Agent Lifecycle Management

Troubleshooting

Security Configuration

Access Controls

Network Security

Performance Optimization

Resource Allocation

Scaling Strategies

Backup and Recovery

Data Backup

Disaster Recovery

Integration with Comput3 Services

API Integration

Next Steps