ClawdBot Skills Platform: Build, Share & Deploy Custom AI Agent Skills with ClawHub (2026)

Table of Contents

1. →From ClawdBot to OpenClaw
2. →Understanding the Skills Platform
3. →Building Your First Skill
4. →The SKILL.md Anatomy
5. →Advanced Skills with Scripts
6. →ClawHub Marketplace
7. →Messaging Platform Setup
8. →Multi-Agent Routing
9. →Developer Workflows
10. →Security Best Practices
11. →FAQ
12. →Key Takeaways

From ClawdBot to OpenClaw

ClawdBot — originally created by Peter Steinberger in November 2025 — has undergone rapid evolution. After renaming to Moltbot and then OpenClaw (due to trademark considerations), the project has grown to 100,000+ GitHub stars in under three months, making it one of the fastest-growing open-source AI projects ever.

While our OpenClaw Complete Guide covers the overall architecture, this article dives deep into the Skills Platform — the system that makes OpenClaw truly extensible and powerful.

Understanding the Skills Platform

What Are Skills?

Skills are modular instruction packages that teach your OpenClaw agent new capabilities. Think of them as "plugins" — but instead of code APIs, they use natural language instructions that the LLM reads and follows.

The AgentSkills Standard

Skills follow the AgentSkills standard, an open specification designed to be agent-agnostic:

Skill Directory Structure

~/.openclaw/skills/
├── weather-reporter/
│   └── SKILL.md                    # Simple skill — instructions only
├── git-workflow-manager/
│   ├── SKILL.md                    # Complex skill with scripts
│   ├── scripts/
│   │   ├── branch_analyzer.py
│   │   └── pr_template.sh
│   └── resources/
│       └── commit_conventions.md
├── api-tester/
│   ├── SKILL.md
│   └── scripts/
│       └── request_builder.js
└── daily-briefing/
    └── SKILL.md                    # Proactive skill

Building Your First Skill

Step 1: Create the Skill Directory

mkdir -p ~/.openclaw/skills/morning-briefing

Step 2: Create SKILL.md

touch ~/.openclaw/skills/morning-briefing/SKILL.md

Step 3: Write Your Skill

---
name: "Morning Briefing"
description: "Generates a personalized morning briefing with weather, 
calendar, and top news headlines. Use this skill when the user asks 
for a morning update, daily summary, or briefing."
---

# Morning Briefing Skill

## When to Activate
Activate this skill when the user:
- Asks for a "morning briefing" or "daily summary"
- Says "good morning" and expects an update
- Requests a "start of day" overview

## Instructions
1. Check the current weather for the user's configured location
2. Retrieve today's calendar events
3. Summarize top 3 news headlines relevant to the user's interests
4. Format everything in a clean, readable message

## Output Format

☀️ Good morning! Here's your briefing for [DATE]:

🌡️ WEATHER [Current conditions, high/low temperatures]

📅 TODAY'S SCHEDULE [List of calendar events with times]

📰 TOP HEADLINES

1. →[Headline 1]
2. →[Headline 2]
3. →[Headline 3]

Have a productive day! 🚀

## Preferences
- Keep the briefing concise — no more than 10 lines
- Use emojis for visual scanning
- Prioritize calendar events by time
- If no calendar events, say "No meetings today — focus time! 🎯"

Step 4: Test Your Skill

Restart OpenClaw (or reload skills) and send a message via your connected messaging platform:

"Give me my morning briefing"

The agent reads your SKILL.md, understands when to activate it, and follows the instructions to generate the output.

The SKILL.md Anatomy in Depth

YAML Frontmatter

---
name: "Git Workflow Manager"          # Human-readable name (max 64 chars)
description: "Manages Git branching    # Critical: tells the agent WHEN to use this skill
  strategies, enforces commit            
  conventions, and automates PR         
  creation. Activate when the user      
  discusses Git, branches, commits,     
  or pull requests."                   
dependencies:                          # Software dependencies (optional)
  - git
  - gh (GitHub CLI)
install: |                             # Setup commands (optional)
  npm install -g commitlint
  gh auth login
---

Markdown Body Structure

The body should be organized with clear sections that the LLM can parse:

Best Practices for Writing SKILL.md

1. →Be explicit about activation triggers — The AI should know exactly when to use this skill
2. →Write instructions as if explaining to a human colleague — Clear, step-by-step
3. →Include usage examples — Show realistic user prompts and expected agent responses
4. →Handle edge cases — What should the agent do when something goes wrong?
5. →Define output format — Consistent, readable output formats improve user experience
6. →Keep it focused — One skill = one capability. Don't bundle unrelated features

Advanced Skills with Scripts

Adding Executable Scripts

For skills that need to run actual code:

~/.openclaw/skills/api-tester/
├── SKILL.md
└── scripts/
    └── test_endpoint.py

SKILL.md:

---
name: "API Endpoint Tester"
description: "Tests REST API endpoints with custom headers, body, 
  and authentication. Use when the user asks to test an API, 
  check an endpoint, or debug HTTP requests."
dependencies:
  - python3
  - requests
install: |
  pip install requests
---

# API Endpoint Tester

## Instructions
1. Ask the user for: URL, method (GET/POST/PUT/DELETE), headers, body
2. Run the test script: `python scripts/test_endpoint.py`
3. Report results with status code, response time, and body preview

## Script Usage
```bash
python scripts/test_endpoint.py \
  --url "https://api.example.com/users" \
  --method POST \
  --header "Authorization: Bearer TOKEN" \
  --body '{"name": "test"}'

Output Format

🔗 API Test Results
━━━━━━━━━━━━━━━━━━
URL:         [URL]
Method:      [METHOD]
Status:      [STATUS CODE] [STATUS TEXT]
Response:    [TIME]ms
Body:        [First 500 chars of response]

**scripts/test_endpoint.py:**

```python
#!/usr/bin/env python3
"""API endpoint testing script for OpenClaw."""
import argparse
import json
import time
import requests

def main():
    parser = argparse.ArgumentParser(description='Test API endpoint')
    parser.add_argument('--url', required=True)
    parser.add_argument('--method', default='GET')
    parser.add_argument('--header', action='append', default=[])
    parser.add_argument('--body', default=None)
    args = parser.parse_args()

    headers = {}
    for h in args.header:
        key, val = h.split(':', 1)
        headers[key.strip()] = val.strip()

    body = json.loads(args.body) if args.body else None

    start = time.time()
    response = requests.request(
        method=args.method,
        url=args.url,
        headers=headers,
        json=body,
        timeout=30
    )
    elapsed = round((time.time() - start) * 1000)

    print(f"Status: {response.status_code} {response.reason}")
    print(f"Time: {elapsed}ms")
    print(f"Body: {response.text[:500]}")

if __name__ == '__main__':
    main()

ClawHub Marketplace

What Is ClawHub?

ClawHub is the community marketplace for sharing OpenClaw skills. Think of it as "npm for AI agent skills" — a centralized registry where developers publish, discover, and install skills.

Installing Skills from ClawHub

# Search for available skills
openclaw skills search "git"

# Install a skill
openclaw skills install git-workflow-manager

# List installed skills
openclaw skills list

# Update all skills
openclaw skills update

Publishing to ClawHub

# From your skill directory
cd ~/.openclaw/skills/my-awesome-skill

# Validate your SKILL.md
openclaw skills validate

# Publish to ClawHub
openclaw skills publish

Security — VirusTotal Integration

Security Checklist Before Installing Skills

1. →✅ Read the SKILL.md — Understand what the skill claims to do
2. →✅ Check the scripts/ — Review any executable code
3. →✅ Verify the publisher — Check GitHub profile and contribution history
4. →✅ Look at install commands — Watch for curl | bash or pip install from unknown sources
5. →✅ Check star count and reviews — Community validation helps
6. →❌ Don't install skills that request unrestricted shell access without understanding why

Messaging Platform Setup

WhatsApp Integration

WhatsApp is OpenClaw's most popular messaging channel:

# During OpenClaw setup (TUI wizard)
openclaw setup

# Select "WhatsApp" as your channel
# A QR code will appear in your terminal
# Scan the QR code with WhatsApp (like WhatsApp Web)
# Your agent is now connected to WhatsApp

How it works: OpenClaw creates a WhatsApp Web session, similar to how you connect your phone to WhatsApp Desktop. Messages sent to the agent's WhatsApp session are processed by OpenClaw.

Telegram Integration

# Step 1: Create a bot via @BotFather on Telegram
# → Send /newbot to BotFather
# → Choose a name and username  
# → Copy the bot token (format: 123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11)

# Step 2: Configure OpenClaw
openclaw setup
# Select "Telegram" as your channel
# Paste your BotFather token

# Step 3: Start chatting with your bot on Telegram

Discord & Slack

Multi-Agent Routing

What Is Multi-Agent Routing?

Multi-agent routing lets you run separate agent instances for different contexts. Each agent can have its own:

• →Skills — Different capabilities per context
• →Memory — Isolated conversation history
• →LLM configuration — Different models per agent
• →Messaging channel — Different platforms per agent

Configuration Example

# ~/.openclaw/config.yaml
agents:
  personal:
    channel: whatsapp
    llm: claude-opus-4-6
    skills:
      - morning-briefing
      - calendar-manager
      - shopping-list
    memory: local
    
  work:
    channel: slack
    llm: gpt-5.3
    skills:
      - git-workflow-manager
      - api-tester
      - jira-integration
      - code-reviewer
    memory: local
    
  creative:
    channel: telegram
    llm: claude-sonnet-4-5
    skills:
      - writing-assistant
      - image-generator
      - music-prompt-builder
    memory: local

Use Cases for Multi-Agent Routing

Developer Workflows

Git Workflow Automation

With the right skills, OpenClaw becomes a Git powerhouse:

You: "Create a feature branch for the login page redesign, 
     based on develop"

Agent: Created branch 'feature/login-redesign' from 'develop'.
       Switched to new branch. Ready for development.

You: "I'm done. Create a PR to develop with a summary 
     of my changes"

Agent: Analyzing 7 changed files (342 additions, 89 deletions)...
       PR #247 created: "Redesign login page with modern auth flow"
       Link: https://github.com/repo/pull/247

Proactive Agent Capabilities

One of OpenClaw's most powerful features — the agent can initiate communication without being prompted:

# In a proactive daily-briefing skill:
---
name: "Daily Briefing"
description: "Proactively sends a morning briefing at 8:00 AM. 
  This is a proactive skill - do not wait for user input."
---

## Proactive Trigger
- Send briefing at 8:00 AM local time every weekday
- Do not send on weekends unless user has events

## Content
1. Today's weather
2. Calendar summary
3. Pending notifications
4. Yesterday's unfinished tasks

Code Review Automation

You: "Review the latest commit on the auth-service branch"

Agent: Reviewing commit abc1234 on auth-service...

🔍 Code Review — commit abc1234
━━━━━━━━━━━━━━━━━━━━━━━━━━━━
✅ No security vulnerabilities detected
⚠️  auth/validator.js:42 — Input not sanitized before SQL query
⚠️  auth/session.js:18 — Session timeout set to 24h (consider 1h for sensitive ops)
✅ Test coverage: 87% (above 80% threshold)

Recommendation: Fix the SQL injection risk before merging.

Security Best Practices

Minimal Security Configuration

# ~/.openclaw/.env
# Recommended security settings

ENABLE_SHELL_EXECUTION=false    # Disable by default; enable per-skill
SKILL_SANDBOX=true              # Sandbox skill execution
LOG_ALL_ACTIONS=true            # Audit trail
MAX_FILE_ACCESS_DEPTH=2         # Limit directory traversal
ALLOWED_DOMAINS=github.com,api.example.com  # Whitelist network access

FAQ

Can I use skills built for Claude with OpenClaw?

Skills following the AgentSkills standard (SKILL.md format) are designed to be agent-agnostic. However, skills that rely on OpenClaw-specific features (messaging integration, proactive triggers) may need adaptation for other agents.

How many skills can I install?

There's no hard limit, but each skill's instructions consume context window tokens. If you install too many skills, the agent may struggle to select the right one. Recommended: 10-15 focused skills per agent instance.

Can skills communicate with each other?

Not directly. Each skill is independent. However, the LLM brain can chain skills together in a single workflow — for example, using a "Git" skill followed by a "Slack notification" skill in response to "Review my code and notify the team."

Related Articles

• →OpenClaw AI Complete Guide — Overall architecture and features
• →Building Skills for Claude — Anthropic's approach to agent skills
• →AI Agents ReAct Explained — How reasoning agents work
• →Multi-Agent Orchestration — Coordinating multiple AI agents
• →MCP Protocol Explained — The Model Context Protocol

Key Takeaways

1. →

   Skills are modular instruction packages defined by SKILL.md files that teach your AI agent new capabilities using natural language

2. →

   5-minute creation time — A basic skill requires only a directory with a SKILL.md file containing name, description, and plain-text instructions

3. →

   The description field is critical — It tells the LLM when to activate your skill; be specific about trigger conditions

4. →

   Advanced skills combine SKILL.md with scripts — Python, JavaScript, or Shell scripts extend capabilities beyond pure language instructions

5. →

   ClawHub marketplace lets you discover, install, and publish skills with VirusTotal security scanning

6. →

   Multi-agent routing enables separate agent configurations for personal, work, and creative contexts with isolated skills and memory

7. →

   Messaging integration (WhatsApp, Telegram, Discord, Slack) means you interact with your AI agent through apps you already use daily

8. →

   Security is non-negotiable — Review skill code before installation, keep OpenClaw updated, configure minimal permissions, and monitor agent activity logs

Build Your Own AI Agent Skills

Understanding how to design effective AI agent skills combines prompt engineering, software architecture, and workflow automation. The skills you build determine the practical utility of your autonomous agent.

In our Module 5 — AI Agents & Automation, you'll learn:

• →How to architect autonomous agent workflows
• →ReAct (Reasoning + Acting) patterns for reliable agent behavior
• →Designing robust skill instructions that minimize errors
• →Security and guardrails for agentic systems
• →When to use autonomous agents vs. traditional automation

→ Explore Module 5: AI Agents & Automation

Last Updated: February 20, 2026 Information compiled from official OpenClaw documentation, GitHub repository, ClawHub marketplace, and verified community guides.