Build a Self-Hosted AI Agent: Shell Commands, GitHub PRs from Chat

The Real Problem: Tab Hell + AI with Extra Steps

Every engineer knows this morning. You wake up, an alert fired at 2AM. Now you need to:

Open Slack — read the alert thread

Someone already pinged. The staging env is down. You need context. You scroll 40 messages.

SSH into the server — check logs manually

grep, tail, awk. You're hunting for the error. 3 different log files. You copy a snippet.

Paste into ChatGPT — ask what's wrong

ChatGPT gives you a fix. You copy the command, paste it back into terminal. That's not AI-powered engineering. That's clipboard management.

Manually raise a GitHub PR + update Jira

You've now switched between 6 tools. The actual fix took 3 minutes. The context-switching overhead took 45.

The Tab Hell Problem — Where Your Day Actually Goes

  Your Brain (limited context)
         │
         ▼
  ┌─────────────────────────────────────────────────────────┐
  │  Tab 1      Tab 2      Tab 3      Tab 4      Tab 5      │
  │  Slack      GitHub     Jira       Grafana    Terminal   │
  │  (context)  (PRs)      (tickets)  (metrics)  (logs)     │
  └──────┬──────────┬──────────┬──────────┬──────────┬──────┘
         │          │          │          │          │
         ▼          ▼          ▼          ▼          ▼
      context    context    context    context    context
      switch     switch     switch     switch     switch

  Every switch costs ~23 minutes to regain deep focus.
  You do this 15–20 times a day.

ChatGPT is not an AI agent. It's a very smart clipboard. You copy context in, copy commands out, paste them manually. The grunt work is still 100% on you. That's AI with extra steps — not AI automation.

What is OpenClaw?

OpenClaw is an open-source, self-hosted AI agent framework. Instead of you acting as the bridge between AI and your tools, OpenClaw closes that loop. You give it a natural language command — it executes the full workflow autonomously.

CapabilityChatGPTOpenClaw

Run shell commands on your server❌ No✅ Yes

Read live logs from your infra❌ No✅ Yes

Raise GitHub PRs automatically❌ No✅ Yes

Respond to Discord/Slack messages❌ No✅ Yes

Runs on your machine, your data❌ Cloud only✅ Self-hosted

Open source — customise everything❌ Closed✅ Fully open

Self-hosted = your data never leaves your machine. Your logs, code, credentials — none of it goes to a third-party AI provider's servers. OpenClaw runs the LLM calls against whichever model you configure (local Ollama, OpenAI, Claude — your choice).

Architecture Overview

OpenClaw has three core concepts: Triggers, Skills, and the Agent Loop. Understanding these three unlocks the whole system.

OpenClaw — High-Level Architecture

  ┌─────────────────────────────────────────────────────────────┐
  │                        YOU                                   │
  │   Discord: "debug staging"   Slack: "deploy main to prod"   │
  └────────────────┬───────────────────────┬────────────────────┘
                   │                       │
                   ▼                       ▼
  ┌─────────────────────────────────────────────────────────────┐
  │                    TRIGGER LAYER                             │
  │   Discord Bot   │   Slack Bot   │   Cron   │   Webhook      │
  └───────────────────────────┬─────────────────────────────────┘
                               │  raw message
                               ▼
  ┌─────────────────────────────────────────────────────────────┐
  │                    AGENT LOOP (LLM)                          │
  │                                                              │
  │   1. Parse intent from message                               │
  │   2. Select the right Skill                                  │
  │   3. Execute skill → get result                              │
  │   4. Reason about result → next step?                        │
  │   5. Repeat until task is done                               │
  └───────────────────────────┬─────────────────────────────────┘
                               │  skill calls
                               ▼
  ┌─────────────────────────────────────────────────────────────┐
  │                      SKILL LAYER                             │
  │                                                              │
  │   shell_exec   │   read_logs   │   github_pr   │  jira_ticket│
  │   docker_ps    │   k8s_deploy  │   db_query    │  alert_page │
  └───────────┬────────────┬───────────────┬────────────────────┘
              │            │               │
              ▼            ▼               ▼
         Your Server   Your Infra      GitHub API

Skill Anatomy — What a Skill Looks Like

  ┌─────────────────────────────────────────────┐
  │                  SKILL                       │
  │                                              │
  │  name:        "read_logs"                    │
  │  description: "Read last N lines from a      │
  │                service log file"             │
  │                                              │
  │  parameters:                                 │
  │    - service: string   ← which service       │
  │    - lines:   number   ← how many lines      │
  │                                              │
  │  execute():                                  │
  │    → runs: tail -n {lines} /logs/{service}   │
  │    → returns: log output as string           │
  └──────────────────────┬──────────────────────┘
                         │
                         ▼
            LLM reads the output, decides
            if it has enough to answer or
            needs to call another skill

How the Agent Loop Works

The magic of OpenClaw is the ReAct loop — Reason + Act. The LLM doesn't just generate text. It generates a thought, decides on an action (skill call), observes the result, then reasons again. This repeats until the task is complete.

ReAct Loop — "debug staging" Example

  You: "debug staging"
        │
        ▼
  ┌─────────────────────────────────────────────────────────┐
  │  THOUGHT: User wants to debug staging env.               │
  │  I should first check what services are running.         │
  │  ACTION: shell_exec("docker ps --filter status=exited")  │
  └──────────────────────────────┬──────────────────────────┘
                                 │
                                 ▼ result
  ┌─────────────────────────────────────────────────────────┐
  │  OBSERVE: api-server container exited 12 mins ago.       │
  │  THOUGHT: I should check its logs to find the error.     │
  │  ACTION: read_logs(service="api-server", lines=50)       │
  └──────────────────────────────┬──────────────────────────┘
                                 │
                                 ▼ result
  ┌─────────────────────────────────────────────────────────┐
  │  OBSERVE: OOMKilled — container ran out of memory.       │
  │  THOUGHT: Memory limit is too low. I can fix this        │
  │  in docker-compose and restart.                          │
  │  ACTION: shell_exec("sed -i 's/mem_limit: 256m/         │
  │           mem_limit: 512m/' docker-compose.yml &&        │
  │           docker-compose up -d api-server")              │
  └──────────────────────────────┬──────────────────────────┘
                                 │
                                 ▼ result
  ┌─────────────────────────────────────────────────────────┐
  │  OBSERVE: Container restarted successfully.              │
  │  THOUGHT: Task complete. Report back to user.            │
  │  FINAL: "api-server was OOMKilled. Increased memory      │
  │          limit to 512m and restarted. Now healthy. ✅"   │
  └─────────────────────────────────────────────────────────┘

  Total human actions: 1 message.
  Total manual steps replaced: 6 terminal commands + log analysis.

Real Use Cases

Deploy Automation One message → full deploy pipeline

Discord: "deploy main to production"

OpenClaw: runs tests → builds Docker image → pushes to registry → updates k8s deployment → posts deploy summary with commit hash and diff link.

Incident Response Alert fires → agent investigates automatically

Grafana webhook triggers OpenClaw when error rate spikes.

Agent: checks logs → identifies root cause → creates Jira incident ticket → posts summary in #incidents Slack channel. All before you've opened your laptop.

PR Automation Feature → PR → review request in one command

Discord: "raise PR for the auth fix on branch feature/jwt-refresh"

Agent: reads branch diff → writes PR description → sets reviewers → adds labels → posts PR link back to Discord. Jira ticket updated automatically.

Database Health Checks Scheduled DB audits on autopilot

Cron trigger every morning at 9AM: agent runs slow query analysis → checks index usage → posts top 5 problematic queries to #db-health Slack channel with suggested fixes.

Integration: Step-by-Step

Full Setup Flow — From Zero to Running Agent

  ┌──────────────────────────────────────────────────────────────┐
  │  STEP 1 — Install                                             │
  │  npm install -g openclaw                                      │
  │  openclaw init                                                │
  └───────────────────────────────┬──────────────────────────────┘
                                  │
                                  ▼
  ┌──────────────────────────────────────────────────────────────┐
  │  STEP 2 — Configure LLM Provider                             │
  │  openclaw.config.js                                          │
  │    llm: { provider: "openai", model: "gpt-4o" }              │
  │       OR { provider: "ollama", model: "llama3" }  ← local    │
  └───────────────────────────────┬──────────────────────────────┘
                                  │
                                  ▼
  ┌──────────────────────────────────────────────────────────────┐
  │  STEP 3 — Connect a Trigger (Discord/Slack/Webhook)          │
  │  triggers: [{ type: "discord", botToken: "...",              │
  │               listenChannel: "dev-ops" }]                    │
  └───────────────────────────────┬──────────────────────────────┘
                                  │
                                  ▼
  ┌──────────────────────────────────────────────────────────────┐
  │  STEP 4 — Register Built-in Skills                           │
  │  skills: ["shell", "github", "docker", "kubernetes"]         │
  └───────────────────────────────┬──────────────────────────────┘
                                  │
                                  ▼
  ┌──────────────────────────────────────────────────────────────┐
  │  STEP 5 — Write Custom Skills (optional)                     │
  │  skills/deploy.js  ← your own deployment workflow            │
  └───────────────────────────────┬──────────────────────────────┘
                                  │
                                  ▼
  ┌──────────────────────────────────────────────────────────────┐
  │  STEP 6 — Start the Agent                                    │
  │  openclaw start                                              │
  │  ✅ Listening on #dev-ops                                    │
  │  ✅ 7 skills loaded                                          │
  │  ✅ Agent ready                                              │
  └──────────────────────────────────────────────────────────────┘

Requirements: Node.js 18+, npm.
What this does: Installs OpenClaw globally and scaffolds a project with the default config, a skills/ directory, and an example Discord trigger.

# 1. Install globally
npm install -g openclaw

# 2. Create a new project
mkdir my-agent && cd my-agent
openclaw init

# Output:
✅ Created openclaw.config.js
✅ Created skills/ directory
✅ Created skills/example-skill.js
📝 Edit openclaw.config.js to add your LLM key and trigger

# 3. Install project dependencies
npm install

# 4. Start the agent
openclaw start

File: openclaw.config.js — the single source of truth for your agent.
Key decisions: Which LLM to use (local Ollama = no API cost, no data leaving your machine), which triggers to listen on, and which skills to load.

// openclaw.config.js
module.exports = {

  // ── LLM Provider ─────────────────────────────────────────
  llm: {
    provider: 'openai',          // or 'ollama', 'anthropic'
    model: 'gpt-4o',
    apiKey: process.env.OPENAI_API_KEY,
  },

  // ── Triggers — where the agent listens ───────────────────
  triggers: [
    {
      type: 'discord',
      botToken: process.env.DISCORD_BOT_TOKEN,
      listenChannel: 'dev-ops',       // channel name to watch
      mentionOnly: true,              // only respond when @mentioned
    },
    {
      type: 'cron',
      schedule: '0 9 * * 1-5',       // 9AM Mon–Fri
      task: 'run daily db health check and post to #db-health',
    },
  ],

  // ── Built-in skills to enable ─────────────────────────────
  skills: [
    'shell',       // run shell commands (sandboxed)
    'github',      // PRs, issues, comments
    'docker',      // ps, logs, restart, exec
    'kubernetes',  // kubectl wrapper
    './skills/deploy.js',   // ← your custom skill
  ],

  // ── Security: restrict shell commands ────────────────────
  security: {
    allowedCommands: ['docker', 'kubectl', 'git', 'npm'],
    blockedPatterns: ['rm -rf', 'DROP TABLE', 'format'],
  },
};

Discord Bot Setup: Create a bot at discord.com/developers, give it MESSAGE_CONTENT intent, and add it to your server.
Permissions needed: Read Messages, Send Messages, Read Message History — that's it.

# 1. Create Discord bot at discord.com/developers/applications
#    → New Application → Bot → Reset Token → copy token
#    → Privileged Gateway Intents → enable MESSAGE_CONTENT

# 2. Generate invite URL
#    → OAuth2 → URL Generator
#    → Scopes: bot
#    → Permissions: Read Messages, Send Messages, Read History

# 3. Add token to .env
DISCORD_BOT_TOKEN=your_bot_token_here
OPENAI_API_KEY=your_openai_key_here
GITHUB_TOKEN=your_github_pat_here

# 4. Start agent
openclaw start

# 5. Go to Discord, type in #dev-ops channel:
@YourBot debug staging

# Agent responds in the same channel with full execution log

Custom Skill: A skill is just a JS object with a name, description (used by the LLM to decide when to call it), parameters schema, and an execute function.
Keep descriptions clear — the LLM reads them to decide which skill to use. Be specific about what the skill does and when.

// skills/deploy.js
const { exec } = require('child_process');
const { promisify } = require('util');
const execAsync = promisify(exec);

module.exports = {
  name: 'deploy_service',

  // LLM reads this to decide when to call this skill
  description: `Deploy a service to production or staging.
    Use this when the user asks to deploy, release, or push
    a branch/service to an environment.`,

  parameters: {
    service: {
      type: 'string',
      description: 'Name of the service to deploy (e.g. api-server)',
    },
    environment: {
      type: 'string',
      enum: ['staging', 'production'],
      description: 'Target environment',
    },
    branch: {
      type: 'string',
      default: 'main',
      description: 'Git branch to deploy',
    },
  },

  async execute({ service, environment, branch }) {
    // 1. Run tests first
    await execAsync(`npm test --workspace=${service}`);

    // 2. Build Docker image
    const tag = `${service}:${branch}-${Date.now()}`;
    await execAsync(`docker build -t ${tag} ./${service}`);

    // 3. Push to registry
    await execAsync(`docker push registry.mycompany.com/${tag}`);

    // 4. Update Kubernetes deployment
    await execAsync(
      `kubectl set image deployment/${service} ` +
      `${service}=registry.mycompany.com/${tag} ` +
      `--namespace=${environment}`
    );

    return `✅ Deployed ${service}@${branch} to ${environment}. Image: ${tag}`;
  },
};

Build Your First Skill — End to End

Let's build something real: a log monitor skill that detects errors in any service log and explains them in plain English.

Create

Create skills/log-monitor.js

Define the skill with a clear description so the LLM knows when to use it. Add parameters for service name and how many lines to read.

Add './skills/log-monitor.js' to the skills array. OpenClaw auto-loads it on next start.

Test

Test with openclaw test-skill log-monitor

OpenClaw's test runner invokes your skill directly with dummy parameters — no Discord needed. Verify output before going live.

Use

Type in Discord: "check api-server logs"

Agent detects intent → calls your skill → reads logs → explains errors in plain English → posts summary. Full loop, zero manual steps.

// skills/log-monitor.js — Complete implementation
const fs = require('fs');
const path = require('path');

const LOG_DIR = process.env.LOG_DIR || '/var/log/services';

module.exports = {
  name: 'read_service_logs',
  description: `Read recent logs from a service and identify errors.
    Use when user asks to check logs, debug a service,
    or investigate why something is down.`,

  parameters: {
    service: { type: 'string', description: 'Service name' },
    lines:   { type: 'number', default: 100, description: 'Lines to read' },
  },

  async execute({ service, lines = 100 }) {
    const logFile = path.join(LOG_DIR, `${service}.log`);

    if (!fs.existsSync(logFile)) {
      return `❌ No log file found for service: ${service}`;
    }

    // Read last N lines
    const content = fs.readFileSync(logFile, 'utf8');
    const allLines = content.split('\n');
    const recent = allLines.slice(-lines).join('\n');

    // Extract errors for the LLM to focus on
    const errors = allLines
      .filter(l => /ERROR|FATAL|Exception|OOMKilled/i.test(l))
      .slice(-20);

    return JSON.stringify({
      service,
      totalLines: allLines.length,
      recentLogs: recent,
      errorLines: errors,
      errorCount: errors.length,
    });
  },
};

Pro tip: Return structured JSON from your skills — not plain text. The LLM handles unstructured text poorly when it needs to reason about specific fields. JSON lets it reliably extract errorCount, service, etc. for follow-up decisions.

Key Takeaways

ChatGPT is not an AI agent — it's a smart clipboard. You're still the bridge between AI and your tools. OpenClaw closes that loop.
OpenClaw = Triggers + Skills + Agent Loop. Trigger catches your message. Agent loop reasons about it. Skills execute the actual work on your infra.
The ReAct loop (Reason → Act → Observe) is what makes it feel autonomous. The LLM chains skill calls until the task is fully done, not just partially answered.
Self-hosted means your data stays local. Logs, secrets, code — none of it leaves your machine. You pick the LLM (local Ollama or cloud).
Skills are just plain JS functions with a description the LLM reads. If you can write a Node.js function, you can build an agent skill.
Start with: npm install -g openclaw → openclaw init → connect Discord → write one skill → openclaw start. You're running in under 30 minutes.

The Real Problem: Tab Hell + AI with Extra Steps

What is OpenClaw?

Architecture Overview

How the Agent Loop Works

Real Use Cases

Integration: Step-by-Step

Build Your First Skill — End to End

Decode More Systems