ssh root@your-vps-ip

# Check gateway status and running agents:
openclaw gateway status
openclaw agents list

# Verify HTTPS endpoint is working:
curl -I https://claw.yourdomain.com/health

# Check current memory and CPU usage:
free -h && nproc
top -bn1 | head -20

# Verify OpenClaw version:
openclaw --version

# Create multiple agents with different configurations:

# Agent 1: Personal assistant (already exists from previous guide)
openclaw agents list  # Verify existing agent

# Agent 2: Coding assistant
openclaw agents create --name coding-agent

# Agent 3: Content writer
openclaw agents create --name content-agent

# Agent 4: DevOps monitor
openclaw agents create --name devops-agent

# Verify all agents created:
openclaw agents list

# Each agent gets its own workspace directory:
ls ~/.openclaw/agents/
# coding-agent/
# content-agent/
# devops-agent/
# my-assistant/  (existing)

# Configure each agent to use a different model based on its purpose:
# Cheap/fast for content drafts:
openclaw agents config content-agent set model.name gpt-4o-mini

# Best for coding (reasoning model):
openclaw agents config coding-agent set model.name gpt-4o

# Local model for DevOps (data stays on-premise):
openclaw agents config devops-agent set model.provider ollama
openclaw agents config devops-agent set model.name llama3.1:8b

# Each agent's workspace contains identity files that shape its behavior
# Customize AGENTS.md (operational rules) and SOUL.md (personality)

# Coding agent identity:
cat > ~/.openclaw/agents/coding-agent/workspace/SOUL.md << 'EOF'
# SOUL.md

## Role
Senior software engineer assistant for Ali.

## Personality
- Precise and technical
- Shows code before explanations
- Flags potential issues proactively
- Asks clarifying questions about requirements before writing code

## Decision rules
- Always write working code, not pseudocode
- Prefer readability over cleverness
- Include error handling in all examples
- Suggest tests when writing functions

## Output
- Code blocks for all code
- Language-specific best practices
- Security considerations when relevant
EOF

# Coding agent operational rules:
cat > ~/.openclaw/agents/coding-agent/workspace/AGENTS.md << 'EOF'
# AGENTS.md

## Mission
Help write, review, and debug code across the stack.

## Tools
- Web search for documentation and Stack Overflow
- File write for saving code snippets to workspace
- GitHub/Gitea API for PR reviews and issue lookups

## Startup
On first message each session, check if any PR reviews are pending
and offer to review them.

## Guardrails
- Never commit code directly — always show diff first
- Never store API keys in code examples
- Flag security issues even if not asked
EOF

# Start all agents:
openclaw agents start coding-agent
openclaw agents start content-agent
openclaw agents start devops-agent

# Verify all are running:
openclaw agents status
openclaw gateway status

# Create separate Telegram bots for each agent
# Each bot token routes messages to a specific agent

# Step 1: Create 4 Telegram bots via @BotFather:
# - @ali_personal_bot → my-assistant agent
# - @ali_coding_bot → coding-agent
# - @ali_content_bot → content-agent
# - @ali_devops_bot → devops-agent

# Step 2: Configure each agent with its own bot token:
openclaw agents config coding-agent set plugins.telegram.token YOUR_CODING_BOT_TOKEN
openclaw agents config coding-agent set plugins.telegram.allowedUsers YOUR_TELEGRAM_USER_ID

openclaw agents config content-agent set plugins.telegram.token YOUR_CONTENT_BOT_TOKEN
openclaw agents config content-agent set plugins.telegram.allowedUsers YOUR_TELEGRAM_USER_ID

openclaw agents config devops-agent set plugins.telegram.token YOUR_DEVOPS_BOT_TOKEN
openclaw agents config devops-agent set plugins.telegram.allowedUsers YOUR_TELEGRAM_USER_ID

# Step 3: Register webhooks for each agent:
openclaw agents webhook register coding-agent telegram
openclaw agents webhook register content-agent telegram
openclaw agents webhook register devops-agent telegram

# Verify webhook registrations:
curl https://api.telegram.org/botYOUR_CODING_BOT_TOKEN/getWebhookInfo | jq .result.url
curl https://api.telegram.org/botYOUR_CONTENT_BOT_TOKEN/getWebhookInfo | jq .result.url
# Each should show a different webhook URL path

# Skills live in the openclaw skills directory:
# /usr/lib/node_modules/openclaw/skills/  (system skills)
# ~/.openclaw/skills/  (user-defined skills)

# Create a custom skill directory structure:
mkdir -p ~/.openclaw/skills/gitea-integration
cd ~/.openclaw/skills/gitea-integration

# A skill requires:
# SKILL.md  - Description and instructions for the agent
# index.js  - The actual tool implementation (TypeScript compiled to JS)
# package.json - Dependencies

# Create the skill package:
cat > package.json << 'EOF'
{
  "name": "openclaw-skill-gitea",
  "version": "1.0.0",
  "description": "Gitea integration for OpenClaw",
  "main": "index.js",
  "dependencies": {
    "node-fetch": "^3.0.0"
  }
}
EOF

npm install

# Create the SKILL.md that tells the agent how to use this skill:
cat > SKILL.md << 'EOF'
# Gitea Integration Skill

Provides tools to interact with your self-hosted Gitea instance.

## Available Tools

### list_repos
Lists all repositories the authenticated user has access to.
Use when: user asks about their repos, wants to see what projects exist.

### get_open_issues
Fetches open issues for a repository.
Parameters: owner (string), repo (string), limit (number, default 10)
Use when: user asks about issues, bugs, or tasks for a specific repo.

### create_issue
Creates a new issue in a repository.
Parameters: owner, repo, title, body, labels (array)
Use when: user wants to create a task, bug report, or feature request.

### list_pull_requests
Lists open pull requests for a repository.
Parameters: owner (string), repo (string)
Use when: user asks about PRs, code review queue, or pending merges.

## Configuration
Requires GITEA_URL and GITEA_TOKEN environment variables or agent config.
EOF

# ~/.openclaw/skills/gitea-integration/index.js

const fetch = (...args) => import('node-fetch').then(({default: f}) => f(...args));

const GITEA_URL = process.env.GITEA_URL || 'https://git.yourdomain.com';
const GITEA_TOKEN = process.env.GITEA_TOKEN;

const headers = {
  'Authorization': `token ${GITEA_TOKEN}`,
  'Content-Type': 'application/json',
  'Accept': 'application/json'
};

async function apiCall(path) {
  const resp = await fetch(`${GITEA_URL}/api/v1${path}`, { headers });
  if (!resp.ok) throw new Error(`Gitea API error: ${resp.status} ${await resp.text()}`);
  return resp.json();
}

// Tool: List repositories
export async function list_repos({ limit = 20 } = {}) {
  const repos = await apiCall(`/repos/search?limit=${limit}&sort=updated`);
  return repos.data.map(r => ({
    name: r.full_name,
    description: r.description,
    stars: r.stars_count,
    open_issues: r.open_issues_count,
    updated: r.updated
  }));
}

// Tool: Get open issues for a repo
export async function get_open_issues({ owner, repo, limit = 10 }) {
  if (!owner || !repo) throw new Error('owner and repo are required');
  const issues = await apiCall(`/repos/${owner}/${repo}/issues?state=open&limit=${limit}&type=issues`);
  return issues.map(i => ({
    number: i.number,
    title: i.title,
    state: i.state,
    labels: i.labels.map(l => l.name),
    created_by: i.user.login,
    created_at: i.created_at,
    url: i.html_url
  }));
}

// Tool: Create an issue
export async function create_issue({ owner, repo, title, body = '', labels = [] }) {
  if (!owner || !repo || !title) throw new Error('owner, repo, and title are required');
  const resp = await fetch(`${GITEA_URL}/api/v1/repos/${owner}/${repo}/issues`, {
    method: 'POST',
    headers,
    body: JSON.stringify({ title, body, labels })
  });
  if (!resp.ok) throw new Error(`Failed to create issue: ${await resp.text()}`);
  const issue = await resp.json();
  return {
    number: issue.number,
    title: issue.title,
    url: issue.html_url,
    created: true
  };
}

// Tool: List pull requests
export async function list_pull_requests({ owner, repo }) {
  if (!owner || !repo) throw new Error('owner and repo are required');
  const prs = await apiCall(`/repos/${owner}/${repo}/pulls?state=open&limit=20`);
  return prs.map(pr => ({
    number: pr.number,
    title: pr.title,
    author: pr.user.login,
    head_branch: pr.head.label,
    base_branch: pr.base.label,
    created_at: pr.created_at,
    url: pr.html_url
  }));
}

// Export skill manifest for OpenClaw to discover tools:
export const manifest = {
  name: 'gitea-integration',
  description: 'Tools for interacting with your self-hosted Gitea Git server',
  tools: [
    { name: 'list_repos', description: 'List accessible Gitea repositories', fn: list_repos },
    { name: 'get_open_issues', description: 'Get open issues for a repository', fn: get_open_issues },
    { name: 'create_issue', description: 'Create a new issue in a repository', fn: create_issue },
    { name: 'list_pull_requests', description: 'List open pull requests', fn: list_pull_requests }
  ]
};

# Install the Gitea skill for the coding agent:
openclaw agents skill install coding-agent gitea-integration

# Set skill environment variables for the agent:
openclaw agents config coding-agent set skills.gitea-integration.env.GITEA_URL https://git.yourdomain.com
openclaw agents config coding-agent set skills.gitea-integration.env.GITEA_TOKEN your-gitea-token

# Verify the skill is loaded:
openclaw agents skills list coding-agent
# Should show: gitea-integration (active)

# Test the skill by sending a message to the coding agent:
# "What repos do I have on Gitea?"
# The agent should call list_repos and return the results

# Check skill execution in agent logs:
openclaw agents logs coding-agent --tail 30 | grep -i 'gitea\|skill\|tool'

# Install multiple skills for different agents:
openclaw agents skill install devops-agent server-monitor   # System monitoring skill
openclaw agents skill install content-agent web-search      # Web search skill
openclaw agents skill install coding-agent gitea-integration

# List all available skills:
openclaw skills list

# OpenClaw's memory system writes to MEMORY.md in the agent workspace
# The agent reads this file on startup and during conversations

# Check current memory state for an agent:
cat ~/.openclaw/agents/my-assistant/workspace/MEMORY.md

# The memory file has two parts:
# 1. Static facts (manually written or agent-maintained)
# 2. Dynamic memories (added by the agent during conversations)

# Seed memory with important facts about the user:
cat > ~/.openclaw/agents/my-assistant/workspace/MEMORY.md << 'EOF'
# MEMORY.md

## User Profile
- Name: Ali
- Timezone: UTC+3
- Stack: TypeScript, Python, Docker, PostgreSQL
- Primary domains: yourdomain.com, company.com
- VPS: Hetzner, Frankfurt region

## Active Projects
- Project Alpha: E-commerce platform (main priority)
- Internal Tools: Replacing manual processes with n8n/Windmill
- Infrastructure: Migrating from AWS to self-hosted on Hetzner

## Preferences
- Prefers concise answers with code over long explanations
- Uses kebab-case for filenames
- Wants notifications at 9am UTC daily
- Timezone: EAT (UTC+3)

## Infrastructure
- Gitea: git.yourdomain.com
- Portainer: portainer.yourdomain.com
- Windmill: windmill.yourdomain.com
- n8n: n8n.yourdomain.com
- Monitoring: monitor.yourdomain.com

## Recent Decisions


## Notes

EOF

# Restart the agent to pick up the new memory:
openclaw agents restart my-assistant

# The agent will now reference this memory when responding
# to context-dependent questions

#!/bin/bash
# /opt/scripts/backup-openclaw-memory.sh
# Backs up all agent memory and workspace files to S3
# Run daily — memory is the most valuable persistent state

set -euo pipefail

OPENCLAW_DIR="$HOME/.openclaw"
BACKUP_DIR="/opt/backups/openclaw"
DATE=$(date +%Y-%m-%d)
S3_BUCKET="s3://your-backup-bucket/openclaw"

mkdir -p "$BACKUP_DIR"

# Backup all agent workspaces (contains MEMORY.md, SOUL.md, etc.):
tar czf "${BACKUP_DIR}/agents-${DATE}.tar.gz" \
  -C "$OPENCLAW_DIR" \
  agents/

# Backup the main config:
cp "${OPENCLAW_DIR}/config.json" "${BACKUP_DIR}/config-${DATE}.json" 2>/dev/null || true

# Upload to S3:
aws s3 cp "${BACKUP_DIR}/agents-${DATE}.tar.gz" \
  "${S3_BUCKET}/agents-${DATE}.tar.gz"

# Clean up local backups older than 7 days:
find "$BACKUP_DIR" -name 'agents-*.tar.gz' -mtime +7 -delete
find "$BACKUP_DIR" -name 'config-*.json' -mtime +7 -delete

echo "OpenClaw backup complete: agents-${DATE}.tar.gz"

# To restore:
# tar xzf agents-2026-04-09.tar.gz -C ~/.openclaw/
# openclaw gateway restart

# Add to crontab: crontab -e
# 0 2 * * * /opt/scripts/backup-openclaw-memory.sh >> /var/log/openclaw-backup.log 2>&1

# Allow multiple Telegram users to access specific agents:
# In agent config, allowedUsers accepts a comma-separated list of Telegram user IDs

# Get each team member's Telegram user ID:
# Have them message @userinfobot in Telegram

# Configure coding agent accessible to the dev team:
openclaw agents config coding-agent set plugins.telegram.allowedUsers "12345678,87654321,11223344"
# 12345678 = Alice (senior dev)
# 87654321 = Bob (junior dev)
# 11223344 = Carol (DevOps)

# Configure content agent for the content team:
openclaw agents config content-agent set plugins.telegram.allowedUsers "99887766,55443322"

# Configure DevOps agent for operations team only:
openclaw agents config devops-agent set plugins.telegram.allowedUsers "11223344,44332211"
# Only Carol and David from ops have access

# Restart agents to apply access changes:
openclaw agents restart coding-agent
openclaw agents restart content-agent
openclaw agents restart devops-agent

# Verify access configuration:
openclaw agents config coding-agent get plugins.telegram.allowedUsers

# Create a systemd service that starts ALL agents on boot:
sudo tee /etc/systemd/system/openclaw.service << 'EOF'
[Unit]
Description=OpenClaw AI Assistant Gateway
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
User=ubuntu
WorkingDirectory=/home/ubuntu
ExecStart=/usr/bin/openclaw gateway start
ExecStartPost=/usr/bin/openclaw agents start-all
Restart=always
RestartSec=15
Environment=NODE_ENV=production
EnvironmentFile=/home/ubuntu/.openclaw/.env
# Logging:
StandardOutput=journal
StandardError=journal
SyslogIdentifier=openclaw

[Install]
WantedBy=multi-user.target
EOF

# Create the environment file for secrets:
cat > ~/.openclaw/.env << 'EOF'
OPENAI_API_KEY=sk-your-openai-key
ANTHROPIC_API_KEY=sk-ant-your-anthropic-key
GITEA_TOKEN=your-gitea-token
SLACK_WEBHOOK=https://hooks.slack.com/...
EOF
chmod 600 ~/.openclaw/.env

# Enable and start:
sudo systemctl daemon-reload
sudo systemctl enable openclaw
sudo systemctl start openclaw

# Verify all agents are running:
sleep 5
openclaw agents status
openclaw gateway status

# Check logs:
journalctl -u openclaw -f --no-pager

# Add push monitors to Uptime Kuma for each agent
# Create a heartbeat script that runs every few minutes

#!/bin/bash
# /opt/scripts/openclaw-heartbeat.sh
# Checks that OpenClaw gateway and all configured agents are healthy
# and pushes status to Uptime Kuma push monitors

set -euo pipefail

# Gateway push monitor URL (create one in Uptime Kuma → Push type):
GATEWAY_PUSH="https://monitor.yourdomain.com/api/push/GATEWAY_PUSH_TOKEN"
CODING_PUSH="https://monitor.yourdomain.com/api/push/CODING_AGENT_PUSH_TOKEN"
CONTENT_PUSH="https://monitor.yourdomain.com/api/push/CONTENT_AGENT_PUSH_TOKEN"
DEVOPS_PUSH="https://monitor.yourdomain.com/api/push/DEVOPS_AGENT_PUSH_TOKEN"

# Check gateway health:
if curl -sf https://claw.yourdomain.com/health > /dev/null 2>&1; then
  curl -fsS "${GATEWAY_PUSH}?status=up&msg=Gateway+OK&ping=" > /dev/null
else
  curl -fsS "${GATEWAY_PUSH}?status=down&msg=Gateway+unreachable&ping=" > /dev/null
fi

# Check each agent status via OpenClaw CLI:
check_agent() {
  local agent_name="$1"
  local push_url="$2"

  STATUS=$(openclaw agents status "$agent_name" 2>/dev/null | grep -i 'running\|active\|online' | wc -l)
  if [ "$STATUS" -gt 0 ]; then
    curl -fsS "${push_url}?status=up&msg=${agent_name}+running&ping=" > /dev/null
  else
    curl -fsS "${push_url}?status=down&msg=${agent_name}+not+running&ping=" > /dev/null
    # Attempt auto-recovery:
    openclaw agents start "$agent_name" 2>/dev/null || true
  fi
}

check_agent "coding-agent"  "$CODING_PUSH"
check_agent "content-agent" "$CONTENT_PUSH"
check_agent "devops-agent"  "$DEVOPS_PUSH"

# Add to crontab: crontab -e
# */5 * * * * /opt/scripts/openclaw-heartbeat.sh >> /var/log/openclaw-heartbeat.log 2>&1

# Check per-agent memory usage:
ps aux | grep openclaw | awk '{print $2, $4, $11}'

# Or if using Docker:
docker stats --no-stream --format "table {{.Name}}\t{{.MemUsage}}\t{{.CPUPerc}}"

# Reduce memory usage strategies:

# 1. Stagger agent startup — don't start all agents simultaneously:
openclaw agents start my-assistant
sleep 5
openclaw agents start coding-agent
sleep 5
openclaw agents start content-agent

# 2. Use lighter models for less critical agents:
openclaw agents config content-agent set model.name gpt-4o-mini  # 10x cheaper, 3x lighter
openclaw agents config devops-agent set model.provider ollama
openclaw agents config devops-agent set model.name phi4  # Very small, fast model

# 3. Disable agents you don't use often and start on demand:
openclaw agents stop devops-agent
# Start it manually when needed:
openclaw agents start devops-agent

# 4. Check Node.js memory per process:
cat /proc/$(pgrep -f 'openclaw')/status | grep VmRSS
# If > 500MB per agent on a 2GB VPS, reduce concurrent agents

# If the agent isn't using your custom skill despite it being installed:

# 1. Check the skill is correctly listed:
openclaw agents skills list coding-agent
# Should show gitea-integration (active)

# 2. Verify SKILL.md has clear tool descriptions:
# The agent uses SKILL.md to understand WHEN to use each tool
# Vague descriptions = agent won't know when to invoke them
# Be specific: "Use when: user asks about their repos on Gitea"

# 3. Check for skill loading errors in agent logs:
openclaw agents logs coding-agent --tail 50 | grep -iE '(skill|error|load|gitea)'

# 4. Test skill invocation directly via CLI:
openclaw agents run coding-agent --message "List all my Gitea repositories"
# Watch the logs to see if the skill tool gets called

# 5. Verify environment variables are set:
openclaw agents config coding-agent get skills.gitea-integration.env
# Should show: {GITEA_URL: '...', GITEA_TOKEN: '...'}

# 6. Restart the agent after any skill or config changes:
openclaw agents restart coding-agent
openclaw agents status coding-agent

# If messages from one Telegram bot are being handled by the wrong agent:

# Check webhook registrations for each bot:
for agent in coding-agent content-agent devops-agent; do
  TOKEN=$(openclaw agents config $agent get plugins.telegram.token)
  WEBHOOK=$(curl -s "https://api.telegram.org/bot${TOKEN}/getWebhookInfo" | jq -r .result.url)
  echo "$agent → $WEBHOOK"
done

# Each agent should have a different webhook URL path
# If two agents share the same webhook URL, messages go to both (or neither)

# Re-register webhooks if they're wrong:
openclaw agents webhook deregister coding-agent telegram
openclaw agents webhook deregister content-agent telegram
openclaw agents webhook register coding-agent telegram
openclaw agents webhook register content-agent telegram

# Verify Nginx is routing webhook paths correctly:
# Check that your Nginx config proxies all /webhook/* paths to OpenClaw:
curl -I https://claw.yourdomain.com/webhook/telegram/coding-agent
# Should return a response from OpenClaw (not 404)

# Check OpenClaw gateway logs for webhook routing:
openclaw gateway logs --tail 30 | grep -i webhook