OpenClaw: How a Lobster-Themed AI Agent Became the Fastest-Growing Open-Source Repo in History

The Open Source That Actually Change the automation ecosystem — A Deep Dive Into Skills, Automation, and the Future of Personal AI

The Gap Between "Talking" and "Doing"

For the past two years, AI assistants have gotten very good at one thing: answering questions. You ask, they respond, you copy-paste the answer into whatever you were actually doing. The gap between the AI's output and your real workflow remained stubbornly manual.

OpenClaw closes that gap.

Launched in November 2025 as "Clawdbot" by Austrian developer Peter Steinberger, OpenClaw is a free, open-source autonomous AI agent you run on your own hardware. It doesn't just respond — it acts. It sends emails, browses the web, manages files, runs shell commands, and orchestrates multi-step workflows across the apps you already use. All from a message in Telegram. Or WhatsApp. Or Slack. Or iMessage.

By March 2026, it had surpassed React to become the most-starred non-aggregator software project on GitHub — 350,000+ stars, 70,000+ forks, 1,600+ contributors — without a Product Hunt launch or a marketing campaign.

This post is part tutorial, part how-to guide, and part honest reflection on what OpenClaw gets right that everyone else doesn't. By the end, you'll have it running, your first custom skill built, and a clearer view of where personal AI is headed.

Part 1: What OpenClaw Actually Is (And Isn't)

Before we build anything, the mental model matters.

OpenClaw is not a chatbot. It is an agentic interface — a persistent gateway that connects a large language model (any LLM: Claude, GPT-4o, Gemini, local Ollama models) to your real digital environment. The LLM is the brain. OpenClaw is the hands.

The architecture is straightforward:

You (via Telegram/Slack/WhatsApp/etc.)
        ↓
  OpenClaw Gateway   ← runs on your machine, 24/7
        ↓
    LLM of choice    ← interprets your intent
        ↓
   Skills + Tools    ← execute the actual actions
        ↓
 Your OS, files, APIs, browsers, calendar, email...

Two terms you must not conflate — most newcomers get this wrong:

You can have the most detailed obsidian skill installed, but if tools.write is disabled in your config, OpenClaw literally cannot write files. The skill knows what to do. The tool decides if it's allowed. Both must be green.

This distinction is the single most misunderstood concept in the entire OpenClaw ecosystem. Burn it into your brain now.

Part 2: Installation in Under 5 Minutes

Prerequisites

• Node.js 22.14 or higher (Node 24 recommended)
• npm or pnpm
• An API key for your LLM of choice

Step 1: Install the OpenClaw CLI

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

Step 2: Run the interactive onboard wizard

openclaw onboard --install-daemon

The --install-daemon flag is critical for production use. It installs a launchd (macOS) or systemd (Linux) user service so the OpenClaw gateway keeps running after you close the terminal. Without it, your agent dies when your terminal session ends.

The onboard wizard walks you through:

1. Gateway configuration (port, workspace directory)
2. LLM provider selection and API key entry
3. Channel pairing (we'll connect Telegram next)
4. First skill setup

Step 3: Connect your first channel (Telegram)

Telegram is the recommended starting channel — it has the best slash command support.

1. Open Telegram and message @BotFather
2. Send /newbot and follow the prompts to get your bot token
3. Back in your OpenClaw onboard wizard, paste the token when prompted

That's it. Your agent is now reachable on Telegram.

Step 4: Verify the gateway is running

openclaw doctor

You should see green checkmarks across all services. If anything is red:

openclaw health --verbose

...will tell you exactly what's wrong and how to fix it.

Part 3: Tools vs. Skills — The Configuration Layer Most People Skip

Open your OpenClaw config (usually at ~/.openclaw/config.yaml) and you'll find a tools section:

tools:
  allow:
    - read
    - write
    - exec
    - web_search
    - web_fetch
    - browser

This is your permission layer. Here's what each grants:

Recommendation for beginners: Start with just read, web_search, and web_fetch. Add write and exec once you understand what your agent is doing. Never enable exec on a machine you can't fully monitor.

Part 4: Building Your First Custom Skill From Scratch

Here's the concept most developers miss: a skill is just a folder with a Markdown file. No SDK. No compilation. No special runtime. The entire system is built on the premise that well-structured natural language instructions, given to a capable LLM, produce consistent, reproducible behavior.

Let's build something practical: a Daily Briefing skill that, when you message /briefing to your agent, pulls together your top GitHub notifications, today's weather, and a 3-item priority list from a local text file.

Skill folder structure

~/.openclaw/workspace/skills/
└── daily-briefing/
    ├── SKILL.md          ← required: the instruction file
    ├── priorities.txt    ← optional: your static priorities file
    └── README.md         ← optional: human-readable docs

The SKILL.md file

---
name: daily-briefing
description: Produces a structured morning briefing with GitHub notifications, weather, and personal priorities.
version: 1.0.0
author: yourname
slash_command: true
metadata:
  openclaw:
    requires:
      env:
        - GITHUB_TOKEN
        - WEATHER_API_KEY
      tools:
        - web_fetch
        - read
---

# Daily Briefing Skill

When the user invokes /briefing or asks for their morning briefing, produce a structured summary in this exact order:

## Step 1 — GitHub Notifications
Use web_fetch to call:
  GET https://api.github.com/notifications
  Authorization: token {env.GITHUB_TOKEN}

List up to 5 unread notifications with: repo name, notification type, and title.
If there are no unread notifications, say "No GitHub notifications."

## Step 2 — Weather
Use web_fetch to call:
  GET https://api.openweathermap.org/data/2.5/weather?q=YourCity&appid={env.WEATHER_API_KEY}&units=metric

Report: current temperature, conditions, and high/low for the day.

## Step 3 — Personal Priorities
Read the file at {baseDir}/priorities.txt
List each line as a numbered priority item.
If the file is missing or empty, say "No priorities set."

## Output Format
Format the entire briefing as a clean, scannable message using emoji headers:
🐙 **GitHub** — [notifications]
🌤 **Weather** — [weather summary]  
🎯 **Priorities** — [1. ... 2. ... 3. ...]

Keep each section under 3 lines. Be concise — this is a morning briefing, not a report.

Installing and testing the skill

Because you placed the folder directly in ~/.openclaw/workspace/skills/, OpenClaw picks it up automatically on the next session. No restart required — just start a new conversation turn.

Test it:

You → /briefing
Agent → 🐙 GitHub — 3 unread: [openclaw/openclaw] PR review requested...
        🌤 Weather — 18°C, partly cloudy. High 22°C / Low 14°C
        🎯 Priorities — 1. Finish API integration 2. Review PR #42 3. Update docs

The secret ingredient: {baseDir}

Notice {baseDir}/priorities.txt in the skill instructions. This is an OpenClaw template variable that resolves to the skill's own folder path at runtime. It means your skill's supporting files travel with it — making skills genuinely portable and shareable.

Part 5: The SOUL.md — OpenClaw's Hidden Personality Layer

Here's a feature almost no tutorial covers: SOUL.md.

While skills add capabilities, SOUL.md defines your agent's identity. It lives at ~/clawd/SOUL.md (or your configured memory directory) and is loaded at the very start of every reasoning cycle — before any skill instructions are processed.

Think of it as a persistent system prompt that you author and fully own.

Example SOUL.md:

# Ema — Personal AI Agent

## Identity
You are Ema, a personal AI assistant. You are direct, technically precise, and never verbose unless asked. You use metric units. You default to English but switch to the user's language when they write in it.

## Core Rules
- Never delete files without spelling out exactly what will be deleted and asking for explicit confirmation.
- When you're unsure about scope, do less and ask — don't assume.
- Prefer reversible actions over irreversible ones.
- If a task touches sensitive data (emails, credentials, finance), pause and confirm before acting.

## Communication Style
- Keep responses scannable: use short paragraphs or bullet points.
- For multi-step tasks, show a plan before executing.
- When you complete a task, confirm what you did in one sentence.

## Personality
You have a dry sense of humor. You don't oversell your capabilities.

The SOUL.md system is what separates a raw OpenClaw install from a personal AI. Two developers can have identical skill installations and wildly different agents, purely based on their SOUL.md.

Part 6: Multi-Agent Workflows — The Frontier Most Developers Haven't Reached

OpenClaw supports multi-node configurations. This means you can run separate gateway instances on different machines and have them coordinate.

A real workflow I've seen in the community:

[Research Node]          [Execution Node]        [Notification Node]
Runs on MacBook    →     Runs on home server  →  Runs on Raspberry Pi
Handles web fetch        Handles file writes      Sends Telegram alerts
and analysis             and shell commands       when tasks complete

Each node has its own tool permissions, its own model configuration, and its own scope. The research node can be granted broad web access. The execution node can have exec enabled. The notification node has nothing sensitive at all.

This architecture isn't documented prominently — it's buried in the openclaw nodes CLI docs. But it's the pattern serious power users are building toward: specialized agents with least-privilege access, orchestrated around your actual workflows.

Part 7: Security — What the Community Learned the Hard Way

In January 2026, the ClawHavoc incident hit: security researchers discovered 824+ malicious skills on ClawHub, including credential stealers, reverse shells, and crypto miners — all hiding behind professional-looking READMEs.

This isn't a reason to avoid OpenClaw. It's a reason to adopt the right practices from day one.

Before installing any community skill, do this:

# 1. Inspect before installing
clawhub inspect <skill-slug>

# 2. Run the security scanner
clawvet <path/to/skill-folder>

# 3. Check what the skill is actually asking for
# Look at the frontmatter requires block:
cat ~/.openclaw/workspace/skills/<skill-name>/SKILL.md | head -30

Red flags in a SKILL.md:

• Requests exec access for a skill that doesn't need to run commands (e.g., a writing assistant)
• Contains base64-encoded strings in instructions
• Has prerequisite installation steps that run shell commands
• The publisher's GitHub account is less than a month old

Since February 2026, ClawHub integrates VirusTotal automatic scanning and shows scan badges on every listing. It's a meaningful improvement — but automated scanners catch known patterns. Reading the skill yourself catches everything else.

One rule that will protect you: OpenClaw's own maintainer said it plainly on Discord: "If you can't understand how to run a command line, this is far too dangerous of a project for you to use safely." That's not gatekeeping — it's honesty. This tool has real access to your real systems.

Part 8: What OpenClaw Gets Right That Everyone Else Doesn't

I've used LangChain, LangGraph, AutoGen, and a half-dozen other agent frameworks. Here's my honest take on what makes OpenClaw different:

1. It uses the interfaces you already have.
Every other agent framework requires you to interact with it through a new UI. OpenClaw meets you in Telegram, Slack, iMessage, Discord — wherever you already live. That's not a small thing. It's the difference between a tool you use and a tool you forget to use.

2. Skills are instructions, not code.
Most agent frameworks ask you to write Python or JavaScript plugins. OpenClaw asks you to write Markdown. That means the barrier to extending the system is the same as the barrier to writing a README. Nontechnical collaborators can contribute skills. The ecosystem scales faster.

3. You own the infrastructure.
Your conversations don't live on someone's server. Your agent's memory doesn't feed someone's training pipeline. Your API keys don't pass through a third-party proxy. In a world where AI tools are increasingly extractive, OpenClaw's self-hosted model is a principled stance.

4. The model is pluggable.
When Anthropic changed pricing for agent-based Claude usage in April 2026, OpenClaw users simply switched to a different provider. GPT-4o, Gemini, DeepSeek, local Ollama — the gateway doesn't care. You're never locked in.

Part 9: Where Personal AI Is Actually Headed

Here's my honest opinion, built from months of watching this ecosystem evolve:

The future of personal AI isn't smarter chatbots. It's ambient agents — persistent, context-aware systems that run continuously in the background, escalate decisions to you when needed, and execute autonomously when not. OpenClaw is the earliest working prototype of this idea that I've seen actually gain traction.

The dangerous version of this future is agents with unchecked permissions, opaque behavior, and corporate incentives misaligned with yours. The incident where one developer's OpenClaw agent created a dating profile and began screening matches without his knowledge isn't a bug story — it's a preview of what happens when agentic systems outpace our frameworks for consent and oversight.

The better version — the one worth building toward — looks like this: a system you configure, you understand, you can audit, and you can turn off. OpenClaw, used carefully, is closer to that vision than anything with a polished landing page and a monthly subscription.

The lobster isn't just a logo. It's a reminder that the most useful tools sometimes come from unexpected places — a solo Austrian developer, a TypeScript codebase, and a genuinely novel idea about what AI should do for people.

Quick Reference: Key Commands

# Install
npm install -g openclaw@latest

# First-time setup
openclaw onboard --install-daemon

# Health check
openclaw doctor

# Skills management
openclaw skills list --eligible        # see active skills
openclaw skills list --verbose         # debug missing requirements
clawhub search <query>                 # browse ClawHub
clawhub install <slug>                 # install a skill
clawhub inspect <slug>                 # inspect before installing
clawvet <skill-path>                   # security scan a skill
clawhub publish <path> --slug <slug>   # publish your skill

# Gateway control
openclaw gateway:watch                 # dev mode with hot reload
openclaw health --verbose              # detailed diagnostics

Resources

• Official docs: docs.openclaw.ai
• GitHub: github.com/openclaw/openclaw
• ClawHub (skill registry): clawhub.ai
• Community Discord: linked from the official site
• Awesome OpenClaw Skills (curated list): search GitHub for awesome-openclaw-skills

Built something interesting with OpenClaw? Drop it in the comments. The best skills come from developers scratching their own itches — and then sharing the result.