The Practical Guide to OpenClaw: Your Self-Hosted AI Assistant

{/* Last updated: 2026-02-10 | OpenClaw v latest | Node.js 22+ | MIT License */}

Version note: This guide covers OpenClaw (formerly Clawdbot, then Moltbot) as of February 2026. The project has 185,000+ GitHub stars and is one of the fastest-growing open-source projects in history. OpenClaw is under active development — features and commands may change. Always check docs.openclaw.ai for the latest documentation.

What Is OpenClaw and Why It Matters

OpenClaw is a free, open-source, self-hosted personal AI assistant that runs on your own devices. Unlike cloud-based assistants like ChatGPT or Claude's web interface, OpenClaw keeps your data local and connects to the messaging platforms you already use — WhatsApp, Telegram, Slack, Discord, and 9 more channels.

But OpenClaw isn't just a chatbot. It's an AI agent platform — it can execute real tasks on your computer:

• Run shell commands and scripts
• Read, write, and edit files on your filesystem
• Control a browser (navigate, click, fill forms, screenshot)
• Schedule cron jobs and respond to webhooks
• Manage email, calendars, and workflows
• Automate anything you can describe in natural language

The Story Behind the Name

OpenClaw holds what may be the fastest triple rebrand in open-source history:

The project was created by Peter Steinberger (founder of PSPDFKit) and went viral in late January 2026, jumping from a personal project to 185,000+ GitHub stars in weeks.

OpenClaw vs Cloud AI Assistants

Architecture: How OpenClaw Works

OpenClaw uses a Gateway architecture — a local WebSocket-based control plane that coordinates everything:

┌─────────────────────────────────────────────────┐
│                    Gateway                       │
│              ws://127.0.0.1:18789                │
│                                                  │
│  ┌──────────┐ ┌──────────┐ ┌──────────┐        │
│  │ Sessions │ │ Channels │ │  Tools   │        │
│  └──────────┘ └──────────┘ └──────────┘        │
│  ┌──────────┐ ┌──────────┐ ┌──────────┐        │
│  │  Events  │ │  Cron    │ │  Skills  │        │
│  └──────────┘ └──────────┘ └──────────┘        │
└────────┬──────────┬───────────┬─────────────────┘
         │          │           │
    ┌────▼────┐ ┌──▼────┐ ┌───▼──────┐
    │WhatsApp │ │ Slack │ │ WebChat  │  ...13+ channels
    └─────────┘ └───────┘ └──────────┘
         │          │           │
    ┌────▼──────────▼───────────▼────┐
    │        AI Model (LLM)          │
    │  Claude / GPT-4 / Ollama       │
    └────────────────────────────────┘

Key Components

Tech Stack

• Language: TypeScript
• Runtime: Node.js 22+
• Package Manager: pnpm (preferred), npm, or bun
• Channel SDKs: Baileys (WhatsApp), grammY (Telegram), Bolt (Slack), discord.js (Discord), signal-cli (Signal)
• Browser Automation: OpenClaw-managed Chrome/Chromium via CDP
• License: MIT — fully free and open-source

Installation and Setup

Prerequisites

• Node.js 22 or newer (verify: node --version)
• macOS, Linux, or Windows (WSL2 required on Windows)

Quick Install

macOS / Linux:

curl -fsSL https://openclaw.ai/install.sh | bash

Windows (PowerShell):

iwr -useb https://openclaw.ai/install.ps1 | iex

Or via npm/pnpm:

npm install -g openclaw@latest
# or
pnpm add -g openclaw@latest

Onboarding

After installation, run the interactive setup wizard:

openclaw onboard --install-daemon

This walks you through:

1. Authentication — configuring your LLM API keys
2. Gateway settings — port, workspace directory
3. Channel setup — linking your first messaging platform
4. Daemon install — auto-start the gateway on boot

Verify Installation

# Check gateway status
openclaw gateway status

# Open the Control UI in your browser
openclaw dashboard
# Opens http://127.0.0.1:18789/

Configuration

The main config lives at ~/.openclaw/openclaw.json:

{
  agent: {
    // Recommended model for best results
    model: "anthropic/claude-opus-4-6",
  },
  gateway: {
    port: 18789,
  },
}

Using local models (fully offline):

{
  agent: {
    // Run with Ollama for complete privacy
    model: "ollama/llama3.1:70b",
  },
}

Environment Variables

From Source (Development)

git clone https://github.com/openclaw/openclaw.git
cd openclaw
pnpm install
pnpm ui:build
pnpm build
pnpm openclaw onboard --install-daemon

# Dev mode with auto-reload:
pnpm gateway:watch

Connecting Messaging Channels

OpenClaw supports 13+ messaging platforms out of the box:

Multi-Channel Setup

You can connect multiple channels simultaneously. Each channel can route to different agent configurations:

{
  channels: {
    whatsapp: {
      enabled: true,
      // Personal messages go to main agent
    },
    slack: {
      enabled: true,
      // Work Slack routes to a different agent with work-specific skills
      agent: {
        model: "anthropic/claude-opus-4-6",
        skills: ["jira-integration", "github-pr-review"],
      },
    },
  },
}

Multi-Agent Routing

OpenClaw supports routing different channels or accounts to isolated agents with different models, skills, and permissions. Your personal WhatsApp can have full system access, while a group Slack channel runs in a sandboxed environment.

Skills and ClawHub: Extending OpenClaw

What Are Skills?

Skills are plugins that extend what OpenClaw can do. They range from simple prompt templates to complex TypeScript integrations with external APIs.

ClawHub — The Skills Registry

ClawHub (clawhub.ai) is the community skills directory with thousands of skills across categories like:

• Productivity — Email management, calendar automation, note-taking
• DevOps — Git operations, CI/CD, server monitoring, deployment
• Finance — Expense tracking, trading automation, portfolio management
• Content Creation — Social media repurposing, blog writing, image generation
• Home Automation — IoT control, smart home routines, weather-based triggers
• Communication — Auto-replies, message scheduling, translation
• Development — Code review, documentation, debugging assistance
• Data — Web scraping, data analysis, report generation

Writing a Markdown Skill

The simplest skill is just a Markdown file with instructions:

---
name: daily-standup
description: Generate a daily standup update from git commits
---

# Daily Standup Generator

Look at the git log for the last 24 hours in the current project directory.
Summarize what was accomplished, what's in progress, and any blockers.

Format the output as:

**Done:**
- [completed items]

**In Progress:**
- [current work]

**Blockers:**
- [any issues]

Writing a TypeScript Skill

For more complex logic:

import { Skill, SkillContext } from "openclaw/skills";

export default class PriceChecker extends Skill {
  name = "price-checker";
  description = "Check and compare prices across shopping sites";

  async execute(ctx: SkillContext) {
    const { query } = ctx.params;

    // Use OpenClaw's built-in browser tool
    const results = await ctx.browser.navigate(
      `https://www.google.com/search?q=${encodeURIComponent(query)}&tbm=shop`
    );

    const prices = await ctx.browser.extract("price listings");

    return ctx.reply(`Found ${prices.length} results for "${query}":\n${
      prices.map(p => `- ${p.title}: ${p.price}`).join("\n")
    }`);
  }
}

Installing Skills

# From ClawHub
openclaw skill install daily-standup

# From a GitHub repo
openclaw skill install github:username/my-skill

# List installed skills
openclaw skill list

Practical Use Cases and Workflows

1. Email Inbox Management

Tell OpenClaw to process your inbox via WhatsApp:

You: "Check my email and clean up my inbox"

OpenClaw: I'll scan your inbox now...

Found 247 unread emails:
- 180 newsletters/promotions → Archived
- 12 spam → Reported and deleted
- 35 actionable emails → Here's a priority summary:

**Urgent (3):**
1. Client proposal deadline tomorrow
2. Server alert from monitoring
3. Tax document request

**This week (8):**
...

Want me to draft replies to any of these?

2. Content Repurposing

Give it a blog post and get platform-specific versions:

You: "Take my latest blog post at /posts/ai-agents.mdx and create
versions for Twitter, LinkedIn, and Instagram"

OpenClaw: Done! Here's what I prepared:

**Twitter thread (7 tweets):**
1/ AI agents are changing how we build software...
[thread continues]

**LinkedIn post:**
[professional tone, longer format]

**Instagram caption:**
[casual tone with relevant hashtags]

Shall I post them or save as drafts?

3. DevOps Automation

Manage deployments from your phone:

You: "Deploy the staging branch to production"

OpenClaw: Running pre-deploy checks...
✓ Tests passing (142/142)
✓ No security vulnerabilities
✓ Build successful

Ready to deploy main → production.
This will affect 3 services. Proceed? (yes/no)

You: "yes"

OpenClaw: Deploying...
✓ Service A: deployed (v2.4.1)
✓ Service B: deployed (v1.8.0)
✓ Service C: deployed (v3.1.2)
All health checks passing. Deployment complete.

4. Browser Automation

You: "Compare prices for AirPods Pro on Amazon, Best Buy, and Walmart"

OpenClaw: Opening browsers and checking prices...

| Store | Price | In Stock | Shipping |
|-------|-------|----------|----------|
| Amazon | $199.99 | Yes | Free (Prime) |
| Best Buy | $189.99 | Yes | Free |
| Walmart | $194.00 | Yes | Free |

Best Buy has the lowest price at $189.99.
Want me to open the checkout page?

5. Scheduled Workflows (Cron)

Set up recurring automations:

You: "Every morning at 8am, check my calendar, summarize today's
meetings, check the weather, and send me a briefing on WhatsApp"

OpenClaw: Done! I've set up a daily cron job:
- Trigger: 8:00 AM daily
- Actions: Calendar check → Weather → Meeting prep → Send briefing
- Channel: WhatsApp

Tomorrow's briefing will be your first one.

6. Private Document Assistant (Fully Offline)

With Ollama, your data never leaves your machine:

{
  agent: {
    model: "ollama/llama3.1:70b",
  },
}

You: "Summarize the contract at ~/Documents/vendor-agreement.pdf
and flag any concerning clauses"

OpenClaw: [processes locally with Ollama — no cloud API calls]

Summary of Vendor Agreement:
- Term: 24 months, auto-renewal
- Payment: Net 30

⚠️ Concerning clauses:
1. Section 4.2: Non-compete extends 2 years post-termination (unusual)
2. Section 7.1: Unlimited liability for data breaches (no cap)
3. Section 9.3: Vendor can change pricing with 30 days notice

Recommendation: Negotiate items 1 and 2 before signing.

Security, Privacy, and Sandboxing

Privacy Model

OpenClaw is local-first by design:

DM Pairing and Access Control

When someone messages your connected accounts, OpenClaw doesn't automatically respond to strangers:

• Pairing mode (default): Unknown senders must provide a pairing code you set
• Allowlist: Explicitly approve specific contacts
• Block: Reject all unknown senders

Sandboxing

For non-main sessions (group chats, shared channels), OpenClaw supports Docker sandboxing:

{
  agents: {
    defaults: {
      sandbox: {
        mode: "non-main",
        // Main (personal) sessions run on host
        // Group/channel sessions run in Docker containers
      },
    },
  },
}

This means your personal WhatsApp messages get full system access, while a shared Slack channel is isolated in a container with limited permissions.

Security Audit

Run the built-in security checker:

openclaw doctor

This scans your configuration for:

• Exposed ports or endpoints
• Missing authentication
• Overly permissive tool access
• Insecure channel configurations

Advanced Configuration and Production Tips

Running on a Remote Server

You can run the Gateway on a VPS or cloud VM while companion apps on your devices handle local actions:

┌─────────────────────┐     ┌──────────────┐
│  Remote Server (VPS) │     │  Your Mac    │
│  ┌───────────────┐  │     │  ┌────────┐  │
│  │   Gateway     │◄─┼─────┼──│ macOS  │  │
│  │   + Agent     │  │ SSH/ │  │  Node  │  │
│  └───────────────┘  │ Tail │  └────────┘  │
└─────────────────────┘ scale└──────────────┘
                              ┌──────────────┐
                              │  Your iPhone │
                              │  ┌────────┐  │
                              │  │  iOS   │  │
                              │  │  Node  │  │
                              │  └────────┘  │
                              └──────────────┘

Remote access options:

• Tailscale Serve/Funnel: Recommended — secure, zero-config networking
• SSH tunnel: Traditional approach, requires port forwarding
• Docker: Run the entire Gateway in a container

Docker Deployment

docker run -d \
  --name openclaw \
  -p 18789:18789 \
  -v ~/.openclaw:/root/.openclaw \
  openclaw/openclaw:latest

Multi-Agent Routing

Run different agent personalities for different contexts:

{
  agents: {
    personal: {
      model: "anthropic/claude-opus-4-6",
      skills: ["email-manager", "calendar", "meal-planner"],
      channels: ["whatsapp"],
    },
    work: {
      model: "anthropic/claude-opus-4-6",
      skills: ["jira", "github-pr", "slack-standup"],
      channels: ["slack"],
      sandbox: { mode: "always" },
    },
    family: {
      model: "ollama/llama3.1:8b",
      skills: ["recipes", "shopping-list"],
      channels: ["telegram"],
    },
  },
}

Voice Wake and Talk Mode

On macOS, iOS, and Android, OpenClaw supports always-on voice interaction:

• Voice Wake: Say the wake word to activate (uses ElevenLabs)
• Talk Mode: Continuous voice conversation, hands-free
• Push-to-Talk: Hold a key/button to speak (macOS menu bar app)

Live Canvas

The Live Canvas is an agent-driven visual workspace (A2UI — Agent-to-UI). The AI can create and manipulate visual interfaces on your device, going beyond text-only responses.

Performance Tips

Useful Commands

# Gateway management
openclaw gateway --port 18789 --verbose    # Start in foreground
openclaw gateway status                     # Check if running
openclaw dashboard                          # Open Control UI

# Messaging
openclaw message send --target +1234567890 --message "Hello"

# Agent interaction
openclaw agent --message "Ship checklist" --thinking high

# Skills
openclaw skill install <skill-name>
openclaw skill list
openclaw skill remove <skill-name>

# Security
openclaw doctor                             # Audit configuration

# Diagnostics
openclaw logs                               # View recent logs
openclaw version                            # Check version

Getting Started

Ready to set up your own AI assistant? Here's the path:

1. Install OpenClaw: Run the one-liner install script for your platform
2. Run onboarding: openclaw onboard --install-daemon walks you through everything
3. Connect WhatsApp or Telegram: Start with one channel you use daily
4. Try basic commands: Ask it to check your calendar, summarize a file, or search the web
5. Install skills: Browse clawhub.ai and install skills for your workflows
6. Set up automations: Create cron jobs for recurring tasks
7. Add more channels: Connect Slack for work, Discord for communities
8. Go advanced: Set up multi-agent routing, Docker sandboxing, or remote server deployment

OpenClaw turns your messaging apps into a command center. Instead of switching between a dozen browser tabs and tools, you type what you need in WhatsApp and your AI assistant handles the rest — on your hardware, with your data, under your control.