Skip to main content

​
Creating Skill Packs

Skill packs bundle related services and skills into reusable configurations. They allow users to quickly set up complete workflows like “Video Creator,” “Research Agent,” or “DevOps Stack.”

​
What is a Skill Pack?

A skill pack is a curated collection of:
  • Required Services: Docker containers or native services needed for the workflow
  • Skills: AI agent instructions (SKILL.md files) that teach OpenClaw how to use those services
  • Metadata: Name, description, icon, and tags for discovery

​
Skill Pack Structure

Skill packs are defined in packages/core/src/skills/registry.ts: 
{
  id: "my-pack",
  name: "My Pack",
  description: "What this pack enables",
  requiredServices: ["service-a", "service-b"],
  skills: ["skill-a", "skill-b"],
  icon: "🎯",
  tags: ["relevant", "tags"]
}

​
Creating a Skill Pack

1

Identify the Workflow

Define the use case your skill pack will solve. Examples:
  • Video processing pipeline
  • Research and web scraping
  • Social media content management
  • DevOps monitoring stack
2

Select Required Services

Choose the services needed for your workflow. For example, a “Video Creator” pack might need:
  • ffmpeg for video processing
  • remotion for programmatic rendering
  • minio for object storage
3

Create or Reference Skills

Each service should have an associated skill file (skills/<skill-id>/SKILL.md) that teaches the AI agent how to use it. If skills don’t exist yet, create them (see Creating Skills below).
4

Add to Registry

Edit packages/core/src/skills/registry.ts and add your skill pack to the skillPacks array:
{
  id: "video-creator",
  name: "Video Creator",
  description: "Create and process videos programmatically with FFmpeg, Remotion, and MinIO storage",
  requiredServices: ["ffmpeg", "remotion", "minio"],
  skills: ["ffmpeg-process", "remotion-render", "minio-storage"],
  icon: "🎬",
  tags: ["video", "media", "rendering"]
}
5

Test the Pack

Run tests to ensure your skill pack is valid:
pnpm test

​
Real-World Examples

​
Example 1: Research Agent

A skill pack for web research, scraping, and knowledge storage: 
{
  id: "research-agent",
  name: "Research Agent",
  description: "Research the web, store findings in vector memory, and scrape full pages",
  requiredServices: ["qdrant", "searxng", "browserless"],
  skills: ["qdrant-memory", "searxng-search", "browserless-browse"],
  icon: "🔬",
  tags: ["research", "rag", "web-scraping"]
}
Required Services:
  • qdrant: Vector database for semantic search
  • searxng: Privacy-respecting metasearch engine
  • browserless: Headless browser for web scraping
Skills:
  • qdrant-memory: Store and retrieve embeddings
  • searxng-search: Search the web
  • browserless-browse: Scrape and interact with web pages

​
Example 2: DevOps Stack

A complete monitoring and automation stack: 
{
  id: "dev-ops",
  name: "DevOps",
  description: "Monitor services, automate workflows, and manage infrastructure alerts",
  requiredServices: ["n8n", "redis", "uptime-kuma", "grafana", "prometheus"],
  skills: [
    "n8n-trigger",
    "redis-cache",
    "grafana-dashboard",
    "prometheus-query",
    "uptime-kuma-monitor"
  ],
  icon: "⚙️",
  tags: ["devops", "monitoring", "automation"]
}

​
Example 3: Knowledge Base

Document indexing with vector and full-text search: 
{
  id: "knowledge-base",
  name: "Knowledge Base",
  description: "Index documents with vector search and full-text search for comprehensive retrieval",
  requiredServices: ["qdrant", "postgresql", "meilisearch"],
  skills: ["qdrant-memory", "postgresql-query", "meilisearch-index"],
  icon: "📚",
  tags: ["knowledge", "search", "indexing"]
}

​
Creating Skills

Skills are markdown files that teach AI agents how to use services. They live in skills/<skill-id>/SKILL.md.

​
Skill File Format

A skill file has:
  1. YAML frontmatter with metadata
  2. Markdown content with instructions and examples
  3. Environment variable placeholders (e.g., {{REDIS_HOST}})

​
Example: Redis Cache Skill

---
name: redis-cache
description: "Cache data, manage sessions, and use pub/sub messaging via Redis at {{REDIS_HOST}}:{{REDIS_PORT}}"
metadata:
  openclaw:
    emoji: "🔴"
---

# Redis Cache Skill

Redis is available at `{{REDIS_HOST}}:{{REDIS_PORT}}` within the Docker network.

## Caching

To cache a value:

```bash
redis-cli -h {{REDIS_HOST}} -p {{REDIS_PORT}} -a $REDIS_PASSWORD SET mykey "myvalue" EX 3600
redis-cli -h {{REDIS_HOST}} -p {{REDIS_PORT}} -a $REDIS_PASSWORD GET mykey

​
Pub/Sub

Publish messages to channels: 
redis-cli -h {{REDIS_HOST}} -p {{REDIS_PORT}} -a $REDIS_PASSWORD PUBLISH channel "message"

​
Tips for AI Agents

  • Always set a TTL on cache keys to avoid memory leaks
  • Use SETNX for distributed locking
  • Check connectivity with PING before complex operations

### Skill Writing Best Practices

<Note>
- **Use clear headers**: Organize content with ## and ### headings
- **Provide code examples**: Show exact commands the AI should run
- **Include error handling**: Explain what to do when commands fail
- **Use environment variables**: Reference `{{VAR_NAME}}` for dynamic values
- **Add "Tips for AI Agents"**: Give context-specific advice
</Note>

<Warning>
- Avoid hardcoding hostnames or ports; always use environment variables
- Test all code examples before publishing
- Keep instructions concise and actionable
</Warning>

## Skill Pack Guidelines

### Naming Conventions

- **Skill Pack IDs**: `lowercase-with-hyphens`
- **Names**: Title Case (e.g., "Research Agent")
- **Icons**: Use a single emoji that represents the workflow

### Choosing Tags

Tags help users discover skill packs. Use descriptive, searchable terms:

| Category | Example Tags |
|----------|-------------|
| Purpose | `research`, `monitoring`, `video`, `automation` |
| Technology | `docker`, `ai`, `database`, `api` |
| Maturity | `stable`, `beta`, `experimental` |

### Testing Compatibility

Before submitting a skill pack, verify:

1. All `requiredServices` exist in the service registry
2. All `skills` reference valid SKILL.md files
3. Services don't conflict with each other
4. Memory requirements are reasonable

Test by generating a stack:

```bash
pnpm --filter cli start
# Select your skill pack and generate

​
Advanced: Multi-Service Dependencies

Some skill packs require services that depend on each other. For example, n8n requires PostgreSQL: 
{
  id: "automation-hub",
  name: "Automation Hub",
  description: "Workflow automation with n8n, Redis caching, and PostgreSQL storage",
  requiredServices: ["n8n", "redis", "postgresql"],
  skills: ["n8n-trigger", "redis-cache", "postgresql-query"],
  icon: "🔄",
  tags: ["automation", "workflow"]
}
The resolver will automatically include PostgreSQL because n8n has requires: ["postgresql"] in its service definition.

​
Submitting Your Skill Pack

Once complete:
1

Run Tests

pnpm test
pnpm typecheck
pnpm lint
2

Create a Changeset

pnpm changeset
Describe your changes and select the appropriate version bump.
3

Submit PR

Submit a pull request with:
  • Skill pack definition in registry.ts
  • All referenced SKILL.md files
  • Test coverage
  • Documentation explaining the use case
See CONTRIBUTING.md for detailed guidelines.

​
Skill Pack Ideas

Looking for inspiration? Here are some skill pack ideas:
  • AI Coding Team: Multiple AI agents (Claude Code, Codex, Gemini) with Git hosting
  • Smart Home: Home Assistant automation with event-driven workflows
  • Content Platform: CMS, newsletter management, and analytics
  • Security Ops: SSO, secrets management, VPN, and intrusion detection
  • Observability Stack: Logs, APM, error tracking, and health checks
  • Backend Platform: BaaS with database, API gateway, and message queue

​
Getting Help

If you need help creating a skill pack:
  • Check existing skill packs in packages/core/src/skills/registry.ts
  • Review SKILL.md examples in the skills/ directory
  • Ask questions in the GitHub Discussions
  • Open an issue for bugs or feature requests

Build docs developers (and LLMs) love

Get started for freeTalk to us