Remote Skill Engine
This skill enables you to discover, cache, and use skills directly from remote registries (ClawHub, GitHub, etc.). Skills are stored in ~/.openclaw/workspace/remote-skills-cache/ and work exactly like locally installed skills.
Core Capabilities
1. Skill Discovery & Search
Search across multiple registries:
# ClawHub search
clawhub search "<query>" --limit <n>
# GitHub skill search (via gh CLI)
gh search repos --language=markdown "skill openclaw" "<topic>"
When to use: User needs a skill for a specific task, wants to explore available skills, or needs to compare options.
2. Remote Skill Caching (KEY FEATURE)
Cache any remote skill to work EXACTLY like installed skills:
# Cache a skill from ClawHub
./scripts/cache-skill.sh clawhub://security-auditor
# Cache from GitHub
./scripts/cache-skill.sh github://owner/repo/branch
# Cache from direct URL
./scripts/cache-skill.sh https://raw.githubusercontent.com/.../SKILL.md
# List cached skills
clawhub list --cache
# Use cached skill (works like installed!)
# Just trigger it normally - it's in your skills path!
Cache Location: ~/.openclaw/workspace/remote-skills-cache/<skill-name>/
Cached skills are symlinked to skills/ folder so they work identically to installed skills.
3. Batch Cache Management
# Cache multiple skills at once
./scripts/cache-skills-batch.json skills-list.json
# Update all cached skills
./scripts/update-cached-skills.sh
# Remove cached skill
./scripts/uncache-skill.sh <skill-name>
# Show cache stats
./scripts/cache-stats.sh
4. Smart Sync & Updates
# Check for updates to cached skills
./scripts/check-updates.sh
# Sync specific skill to latest
./scripts/sync-skill.sh <skill-name>
# Auto-sync on skill trigger (configurable)
# Set in config.json: {"autoSync": true}
5. Offline Mode
Once cached, skills work WITHOUT internet:
- All scripts available locally
- References cached alongside SKILL.md
- Assets downloaded and stored
- No network calls needed
Workflows
NEW: Workflow 1 - Cache Remote Skill
Trigger: User says "Install/caching <skill-name>" or "Get <skill> from web"
# Step 1: Find the skill
clawhub search "<skill-name>" --limit 1
# Step 2: Cache it locally
python scripts/cache-skill.py <skill-name> <source-url>
# Step 3: Verify cache
ls ~/.openclaw/workspace/remote-skills-cache/<skill-name>/
# Step 4: Use it (works like installed!)
# Just use the skill normally - it auto-triggers from skills/
NEW: Workflow 2 - Batch Cache Skills List
Trigger: User wants multiple skills cached
// skills-to-cache.json
{
"skills": [
{"name": "security-auditor", "source": "clawhub://security-auditor"},
{"name": "coding-agent", "source": "github://user/repo/main"}
]
}
./scripts/batch-cache.sh skills-to-cache.json
Workflow 3: Compare Multiple Skills (Enhanced)
Trigger: User says "Which skill is better for X?"
- Fetch metadata for each skill
- Check if cached, cache if not
- Create comparison with SOURCE + CACHE STATUS:
| Skill | Version | Source | Cached | Last Sync |
|-------|---------|--------|--------|-----------|
| skill-a | 1.0.0 | ClawHub | ✅ | 2h ago |
| skill-b | 2.1.0 | GitHub | ❌ | - |
- Recommend + offer to cache
Workflow 4: Sync Cached Skills
Trigger: Heartbeat or user says "Update cached skills"
# Check all cached skills for updates
./scripts/check-updates.sh
# Update outdated skills
./scripts/update-cached-skills.sh --auto
# Update specific skill
./scripts/sync-skill.sh <skill-name>
Workflow 5: Use Cached Skill (Transparent)
Trigger: User triggers any cached skill normally
- Skill is already in
skills/ folder (symlinked)
- Works IDENTICALLY to installed skills
- No special handling needed
- All scripts/refs/assets available locally
Scripts
scripts/fetch-skill.py
Fetch a skill's SKILL.md and parse frontmatter without full download.
#!/usr/bin/env python3
"""Fetch remote skill metadata without full download."""
import requests
import yaml
import sys
def fetch_skill_frontmatter(skill_url):
"""Fetch only YAML frontmatter from SKILL.md"""
resp = requests.get(skill_url, stream=True)
content = ""
in_frontmatter = False
for line in resp.iter_lines():
line = line.decode('utf-8')
if line == '---':
if not in_frontmatter:
in_frontmatter = True
continue
else:
break
if in_frontmatter:
content += line + '\n'
try:
return yaml.safe_load(content)
except yaml.YAMLError as e:
print(f"Parse error: {e}", file=sys.stderr)
return None
if __name__ == "__main__":
if len(sys.argv) != 2:
print("Usage: fetch-skill.py <skill-url>")
sys.exit(1)
metadata = fetch_skill_frontmatter(sys.argv[1])
if metadata:
print(f"Name: {metadata.get('name', 'N/A')}")
print(f"Description: {metadata.get('description', 'N/A')}")
Usage:
python scripts/fetch-skill.py "https://raw.githubusercontent.com/repo/SKILL.md"
scripts/compare-skills.py
Compare multiple skills side-by-side.
#!/usr/bin/env python3
"""Compare multiple remote skills."""
import json
import sys
def compare_skills(skill_data_list):
"""Generate comparison table"""
print("| Skill | Version | Description | Requirements |")
print("|-------|---------|-------------|--------------|")
for skill in skill_data_list:
name = skill.get('name', 'N/A')
version = skill.get('version', 'N/A')
desc = skill.get('description', '')[:80] + '...' if len(skill.get('description', '')) > 80 else skill.get('description', 'N/A')
reqs = skill.get('requires', 'None')
print(f"| {name} | {version} | {desc} | {reqs} |")
if __name__ == "__main__":
# Read JSON from stdin
skills = json.load(sys.stdin)
compare_skills(skills)
References
references/registry-urls.md
Known skill registry endpoints:
ClawHub
- Search:
https://clawhub.com/api/skills/search?q=<query>
- Skill detail:
https://clawhub.com/api/skills/<name>
- Raw SKILL.md:
https://raw.githubusercontent.com/<owner>/<repo>/SKILL.md
GitHub
- Search API:
https://api.github.com/search/code?q=SKILL.md+openclaw
- Raw file:
https://raw.githubusercontent.com/<owner>/<repo>/<branch>/SKILL.md
Awesome Lists
https://raw.githubusercontent.com/openclaw/awesome-openclaw/main/README.md
references/skill-patterns.md
Common skill patterns to recognize:
Skill Types:
- Tool wrappers - Provide CLI access to external tools (nmap, sqlmap, etc.)
- Workflow engines - Multi-step processes (security audits, deployments)
- Knowledge bases - Domain expertise + reference docs
- Automation scripts - Repetitive task automation
- Integration layers - MCP servers, API connectors
Metadata Patterns:
metadata:
openclaw:
requires:
bins: ["tool-name"] # Required binaries
install:
- kind: node # or brew, apt, pip
package: package-name
Usage Examples
Example 1: Find and Use Security Skill
User: "Find me a skill for web security scanning"
You:
1. clawhub search "web security" --limit 5
2. Present results
3. User picks "security-audit-toolkit"
4. Fetch SKILL.md, read workflows
5. Follow the skill's security audit process
Example 2: Temporary Skill Usage
User: "Use the coding agent to review my repo, but don't install it"
You:
1. Fetch coding agent SKILL.md from ClawHub
2. Read its code review workflow
3. Execute the workflow steps manually
4. Report findings
Example 3: Batch Discovery
User: "Show me all available skills"
You:
1. clawhub search "" --limit 100
2. Categorize by keywords
3. Present organized list:
- Security (12 skills)
- Coding (8 skills)
- Automation (6 skills)
- etc.
Best Practices
- Cache metadata locally - Store skill descriptions in
memory/skills-cached.md to avoid repeated fetches
- Respect rate limits - Don't hammer ClawHub/GitHub APIs
- Verify skill sources - Only fetch from trusted registries
- Clean up temp files - Remove
/tmp/remote-skill-* after use
- Track skill usage - Log which remote skills work well for future reference
Trigger Examples
When this skill activates:
- "Find a skill for X"
- "What skills do Y?"
- "Use <skill-name> without installing"
- "Compare skills for X"
- "Show me available skills"
- "What does <skill> do?"
- "Is there a skill for X?"
Remote Skill Engine - Stream skills, don't install them. 🌐⚡
