Welcome back to another GitHub deep dive! Today we’re looking at OpenClaw, a personal AI assistant you run on your own devices. It answers you on the channels you already use—WhatsApp, Telegram, Slack, Discord, Google Chat, Signal, iMessage, Microsoft Teams, Matrix, Zalo, and even WebChat—all from a single local gateway.

If you’ve ever wished for a Jarvis-style assistant that lives on your machine, not someone else’s cloud, this is it.

Part 1: Foundations (The Mental Model)

Think of the cloud-based AI assistants (ChatGPT, Google Gemini, etc.) like renting an apartment. Someone else owns the building, sets the rules, and can look through your stuff anytime.

OpenClaw is like building your own house. You own the foundation, choose the furniture, and pick who gets a key. The “house” is a lightweight gateway service running on your machine, and the “rooms” are your messaging channels.

The Mental Model: OpenClaw = Local-First WebSocket Gateway + Multi-Channel Messaging Adapter + Pluggable AI Agent Runtime.

The gateway is the brain. It doesn’t care if a message comes from WhatsApp or Discord—it normalizes everything, routes it to an AI agent (powered by Claude, GPT, or any model you choose), and sends the response back through the same channel.

Part 2: The Investigation

Under the hood, OpenClaw is a TypeScript monorepo built on Node.js ≥22, designed as a WebSocket-based control plane. Here are the key architectural pillars:

The Gateway (Control Plane)

A single WebSocket server (ws://127.0.0.1:18789) that manages:

• Sessions: isolated conversation contexts per user/group/channel
• Channels: 14+ adapters (Baileys for WhatsApp, grammY for Telegram, Bolt for Slack, discord.js for Discord, signal-cli for Signal, etc.)
• Tools: browser control, canvas, cron jobs, webhooks, and more
• Events: real-time presence, typing indicators, and usage tracking

The Agent Runtime (Pi Agent)

OpenClaw uses the Pi agent in RPC mode with full tool streaming and block streaming. It supports:

• Model failover: rotate between OAuth subscriptions (Anthropic Pro/Max, OpenAI ChatGPT) and API keys with automatic fallback
• Session pruning: intelligent context management to keep conversations fresh
• Multi-agent routing: route different channels/accounts to isolated agents with separate workspaces

The Channel Adapters

Each messaging platform has a dedicated adapter:

1
2
3
4
5
6
7
8

WhatsApp  → @whiskeysockets/baileys
Telegram  → grammy
Slack     → @slack/bolt
Discord   → discord.js (via @buape/carbon)
Signal    → signal-cli bridge
iMessage  → BlueBubbles (recommended) or legacy imsg
MS Teams  → Bot Framework extension
Matrix    → matrix-sdk extension

Companion Apps & Nodes

• macOS app: menu bar control, Voice Wake, push-to-talk, WebChat
• iOS node: Canvas surface, Voice Wake, camera, screen recording
• Android node: Canvas, camera, screen capture, optional SMS

Devices connect as “nodes” via the gateway WebSocket, enabling device-local actions like system.run, camera.snap, or screen.record while the heavy AI processing stays on the gateway host.

Part 3: The Diagnosis

What does this actually mean for developers? Let’s look at real use-cases.

Use-Case 1: Personal AI Across All Your Apps

Instead of switching between ChatGPT in a browser, a Telegram bot, and a Slack app, you get one assistant that follows you everywhere. Send it a question on WhatsApp during your commute, continue the conversation on Slack at work, and pick it up on iMessage at home—all using the same session context.

Use-Case 2: The CLI-Native Workflow

OpenClaw is CLI-first. You can interact with your AI without ever opening a chat app:

1
2
3
4
5
6
7
8

# Send a message to someone via any connected channel
openclaw message send --to +1234567890 --message "Reminder: deploy at 5pm"

# Talk directly to the agent with extended thinking
openclaw agent --message "Review my PR and suggest improvements" --thinking high

# Health check your setup
openclaw doctor

Use-Case 3: Skills & Automation

OpenClaw has a skills system similar to IDE plugins. Skills live in ~/.openclaw/workspace/skills/ and follow a simple SKILL.md format. There’s even a ClawHub registry where the agent can search for and install skills autonomously:

1
2
3
4
5
6
7
8
9

~/.openclaw/workspace/
├── AGENTS.md        # Agent personality/instructions
├── SOUL.md          # Soul/identity prompts
├── TOOLS.md         # Available tools description
└── skills/
    ├── web-search/
    │   └── SKILL.md
    └── code-review/
        └── SKILL.md

Use-Case 4: Cron Jobs & Webhooks

Schedule recurring tasks or react to external events:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

{
  cron: {
    jobs: [
      {
        schedule: "0 9 * * 1-5",  // Every weekday at 9am
        message: "Good morning! Here's my daily briefing.",
        session: "main"
      }
    ]
  }
}

External webhooks can trigger the agent too—connect it to GitHub events, Gmail via Pub/Sub, or any service that can POST to a URL.

Use-Case 5: Browser Control

OpenClaw can launch and control a dedicated Chromium instance via CDP:

1
2
3
4
5
6

{
  browser: {
    enabled: true,
    color: "#FF4500",  // custom highlight color
  },
}

The agent can browse websites, take snapshots, fill forms, and extract data—all orchestrated through natural language commands.

Part 4: The Resolution

Getting started takes about 5 minutes:

1. Install globally:

1
2

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

2. Run the onboarding wizard:

1

openclaw onboard --install-daemon

The wizard walks you through setting up your AI model (Anthropic, OpenAI, or local via Ollama), configuring channels, and installing the gateway as a background service (launchd on macOS, systemd on Linux).

3. Start the gateway:

1

openclaw gateway --port 18789 --verbose

4. Connect a channel (e.g., Telegram):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// ~/.openclaw/openclaw.json
{
  agent: {
    model: "anthropic/claude-opus-4-6",
  },
  channels: {
    telegram: {
      botToken: "YOUR_BOT_TOKEN",
    },
  },
}

5. Send a test message:

1

openclaw agent --message "Hello from OpenClaw!"

For remote access, OpenClaw integrates with Tailscale Serve/Funnel out of the box—no port forwarding or reverse proxy needed.

Final Mental Model

OpenClaw transforms the “AI chatbot” concept from a scattered collection of vendor-locked apps into a unified, self-hosted, privacy-first AI control plane. For developers who value ownership and extensibility, it’s the most comprehensive personal AI gateway available today.