How to Add Skills to OpenClaw: Complete Installation and Configuration Guide

Adding skills to OpenClaw transforms your AI agent from a basic assistant into a specialized automation powerhouse. Whether you're installing pre-built skills from ClawHub or creating custom capabilities, this guide walks you through every method, configuration option, and troubleshooting step you need to know.

Quick Answer: To add skills to OpenClaw, use the ClawHub CLI with npx clawhub@latest install <skill-name>, install via the OpenClaw UI in the Skills section, or manually add skill folders to your ~/clawd/skills/ directory. Each method gives your agent new capabilities like GitHub integration, Docker management, or custom automations tailored to your workflow.

---

How Do You Add Skills to OpenClaw?

OpenClaw offers three distinct methods for adding skills, each suited to different use cases and experience levels.

The fastest way is using the ClawHub command-line tool. Open your terminal and run:

npx clawhub@latest install github

This single command downloads the GitHub skill from the public registry, validates its structure, and places it in your skills directory. The @latest flag ensures you're using the most recent version of the ClawHub installer.

For developers already working in an OpenClaw workspace, you can skip the npx prefix:

clawhub install docker-essentials

The graphical interface method works well if you prefer visual browsing. Launch your OpenClaw interface, navigate to the Skills section, search for the capability you need, and click the install button. This approach is particularly helpful when you're exploring what skills exist rather than looking for something specific.

Manual installation gives you complete control. Create a folder in your skills directory (typically ~/.openclaw/skills/ or <workspace>/skills/), add a properly formatted SKILL.md file, and OpenClaw will recognize it on the next restart. This method is essential when you're developing custom skills or working with skills not yet published to ClawHub.

Each installation method achieves the same result—adding new capabilities to your agent. The difference lies in convenience, speed, and how much control you need over the process. For a comprehensive overview of setting up your entire OpenClaw environment, check out our step-by-step setup guide.

---

What Is ClawHub and How Does It Work?

ClawHub serves as the central marketplace for OpenClaw skills—think of it as npm for AI agent capabilities. It's a free, public registry where developers share skills, and users discover pre-built automations.

As of March 2026, ClawHub hosts over 13,700 community-contributed skills. These range from simple utilities like file management to complex integrations with platforms like Slack, GitHub, and AWS. The registry is completely open, meaning anyone can publish skills and all code is publicly visible.

How the registry works: When you run clawhub install <skill-name>, the CLI connects to the ClawHub API, downloads the skill package, and extracts it to your configured skills directory. The process includes validation steps—checking the SKILL.md format, verifying required metadata, and ensuring the skill structure matches OpenClaw's expectations.

Security scanning happens automatically. Every skill uploaded to ClawHub passes through VirusTotal scanning, including Code Insight analysis. Skills flagged as benign are auto-approved and immediately available. Suspicious or malicious code gets blocked before it reaches the public registry. This doesn't mean you should blindly trust every skill, but it adds a baseline layer of protection.

Curated collections help you find quality skills faster. The awesome-openclaw-skills repository on GitHub maintains a filtered list of 5,494 skills, organized by category and vetted by the community. These collections are particularly useful when you're new to OpenClaw and unsure which skills to start with.

ClawHub also tracks skill versions, allowing you to update installed skills when maintainers release improvements or bug fixes. The command clawhub update <skill-name> pulls the latest version without requiring a full reinstall.

---

What Are the Different Ways to Install OpenClaw Skills?

Understanding your installation options helps you choose the right approach for your workflow and technical comfort level.

CLI Installation (Developer Method)

Command-line installation gives you precision and scriptability. The core commands you'll use:

Install a specific skill:

clawhub install web-scraping

Install with inspection first:

clawhub inspect postgres-management
clawhub install postgres-management

Install to a custom directory:

clawhub install --workdir /custom/path monitoring-tools

The CLI method shines when you're setting up multiple environments or scripting OpenClaw deployments. You can chain installations in a shell script, version-control your skill list, and quickly replicate configurations across machines.

One important detail: by default, ClawHub installs skills to ./skills in your current directory. If you've configured an OpenClaw workspace using the interactive setup wizard, the installer detects this and uses the workspace skills directory instead. You can override this behavior with the --workdir flag or CLAWHUB_WORKDIR environment variable.

UI Installation (Beginner-Friendly)

The graphical approach works through your OpenClaw web interface or desktop application. Navigate to Settings → Skills (or simply "Skills" in the sidebar), where you'll see:

• Installed Skills: Currently active capabilities with toggle switches to enable/disable them
• Available Skills: A searchable catalog of ClawHub skills you haven't installed yet
• Custom Skills: Manual installations you've added outside the UI

Click "Browse Skills" to explore the catalog. Each skill shows a description, required permissions, and user ratings. Click "Install" and OpenClaw handles the download and configuration automatically.

This method works best when you're exploring capabilities or making quick additions without leaving the interface. It's also safer for beginners because the UI clearly shows what permissions each skill needs before installation.

Manual Installation (Advanced Control)

Manual installation is necessary when:

• You're developing your own skills
• You have private skills not in the public registry
• You need to modify an existing skill's behavior
• You're working offline without ClawHub access

Basic manual installation steps:

1. Navigate to your skills directory (usually ~/.openclaw/skills/ or <workspace>/skills/)
2. Create a new folder with your skill name (use lowercase with hyphens: my-custom-skill)
3. Inside that folder, create a SKILL.md file
4. Add the required YAML frontmatter and skill instructions
5. Restart OpenClaw to load the new skill

The SKILL.md file needs specific structure. At minimum:

---
name: my-custom-skill
description: What this skill does
version: 1.0.0
---

# My Custom Skill

Instructions for the AI agent on when and how to use this skill...

Manual installation requires more technical knowledge but gives you complete flexibility. You can edit skills on the fly, test experimental capabilities, and maintain private automations that aren't appropriate for public sharing. If you're running OpenClaw as a service, understanding the agent gateway architecture helps you manage skills across distributed deployments.

---

How Do You Create Custom Skills for OpenClaw?

Creating custom skills lets you teach OpenClaw exactly what you need for your unique workflow. The process is more accessible than you might expect.

Understanding Skill Structure

Every skill is a directory containing at least one file: SKILL.md. This Markdown file combines structured metadata (in YAML frontmatter) with natural language instructions that tell the AI agent when and how to use the skill.

Minimal viable skill:

---
name: task-tracker
description: Track and manage project tasks
version: 1.0.0
---

# Task Tracker Skill

Use this skill when the user wants to create, list, or update project tasks.

## When to Use
- User says "add a task" or "create a todo"
- User asks "what tasks do I have?"
- User wants to mark tasks complete

## How to Use
Tasks are stored in ~/tasks.json as a JSON array. Read the file, modify it, and write it back.

Example task object:
```json
{
  "id": 1,
  "title": "Fix login bug",
  "status": "pending",
  "created": "2026-03-05"
}

This simple skill gives OpenClaw enough information to understand when it should manage tasks and how to interact with your task storage format.

### Adding Platform Requirements

Skills often need specific tools installed or environment variables configured. Declare these in the YAML frontmatter:

```yaml
---
name: aws-deployer
description: Deploy applications to AWS
version: 1.0.0
requires:
  bins:
    - aws
    - terraform
  env:
    - AWS_ACCESS_KEY_ID
    - AWS_SECRET_ACCESS_KEY
  config:
    - aws.defaultRegion
---

When OpenClaw loads this skill, it checks for the aws and terraform binaries in your PATH. If they're missing, the skill appears as "ineligible" when you run openclaw skills list --eligible. This prevents runtime errors from missing dependencies.

Adding Helper Scripts

Complex skills often include executable scripts that do the heavy lifting. Place these in your skill folder:

my-skill/
├── SKILL.md
├── deploy.sh
└── lib/
    └── utils.py

Reference these scripts in your SKILL.md instructions:

## Deployment Process

When the user requests a deployment:
1. Run `./deploy.sh production` from the skill directory
2. Monitor the output for errors
3. Report the deployment URL when complete

OpenClaw understands file paths relative to the skill directory, making it easy to organize complex automations.

Testing Your Custom Skill

Before deploying a custom skill broadly:

1. Start small: Create a minimal version that handles one task
2. Test eligibility: Run openclaw skills list --eligible to confirm OpenClaw recognizes it
3. Test in isolation: Try the skill with a simple prompt that should trigger it
4. Check logs: Review OpenClaw logs to see if the skill activated correctly
5. Iterate on instructions: Refine the natural language descriptions based on how well the agent understands when to use it

The most common mistake in custom skills is vague trigger conditions. Instead of "use this for database work," be specific: "use this skill when the user asks to query the production database, export data to CSV, or check table schemas."

---

How Do You List and Manage Installed Skills?

Knowing what skills you have installed and their current status is crucial for maintaining a well-functioning OpenClaw setup.

Listing All Skills

The primary command for checking your skills:

openclaw skills list

This shows every skill OpenClaw can find in your skills directories, including:

• Skill name
• Path to the SKILL.md file
• Enabled/disabled status
• Version number

Checking Eligible Skills

Not all installed skills can run in your current environment. Use the --eligible flag to filter:

openclaw skills list --eligible

This shows only skills that have all their dependencies met. If a skill requires the docker binary and you don't have Docker installed, it won't appear in this list.

Verbose Output for Troubleshooting

When skills aren't showing up as expected:

openclaw skills list --verbose

Verbose mode reveals:

• Missing binaries
• Undefined environment variables
• Platform incompatibilities (e.g., a macOS-only skill on Linux)
• Configuration requirements not met

This output is invaluable when debugging why a skill isn't working.

Managing Skills via Configuration

Your openclaw.json file (typically in ~/.openclaw/) controls which skills load:

{
  "skills": {
    "github-integration": {
      "enabled": true,
      "env": {
        "GITHUB_TOKEN": "ghp_your_token_here"
      }
    },
    "experimental-feature": {
      "enabled": false
    }
  }
}

Setting "enabled": false prevents a skill from loading without uninstalling it. This is useful when you want to temporarily disable capabilities or when troubleshooting conflicts between skills.

Updating Installed Skills

Keep your skills current with:

clawhub update

This updates all ClawHub-installed skills to their latest versions. For a specific skill:

clawhub update github-integration

Updates don't affect manual installations—you'll need to update those by hand or through your version control system.

Removing Skills

Via ClawHub:

clawhub uninstall skill-name

Manually: Simply delete the skill folder from your skills directory and restart OpenClaw.

Via UI: Navigate to the Skills section, find the skill, and click the "Uninstall" or "Remove" button.

Removing a skill doesn't delete any data it created. If a skill saved files or modified configurations, you'll need to clean those up separately.

---

What Are the Most Common Installation Errors and How Do You Fix Them?

Even with OpenClaw's streamlined installation process, you'll occasionally hit problems. Here's how to diagnose and fix the most frequent issues.

Permission and Scope Errors

Error message: missing scope: operator.read openclaw

This means the skill file exists on disk, but your OpenClaw runtime token doesn't have the necessary permissions to execute the skill's operations.

Fix:

1. Check your OpenClaw configuration's permission scopes
2. Ensure your user account has the operator.read scope (or whatever scope the error mentions)
3. Restart the OpenClaw gateway after updating permissions
4. For self-hosted setups, verify your authentication configuration

This error is common in team environments where different users have different permission levels. If you're managing OpenClaw in production, our guide on understanding the agent gateway provides detailed troubleshooting strategies.

Skill Not Recognized After Installation

You installed a skill, but openclaw skills list doesn't show it.

Fix:

1. Restart OpenClaw: Skills load at startup, not dynamically
2. Check the directory: Confirm the skill folder is in the right location (openclaw skills list --verbose shows search paths)
3. Verify SKILL.md format: Open the file and check that YAML frontmatter is properly formatted (three dashes above and below)
4. Check for allowlist restrictions: If your config has a skills.allowlist, the skill must be included there

Dependency Download Timeouts

Error message: Timeout downloading dependencies for skill 'xyz'

Some skills, especially those with Go or Rust components, need to compile dependencies on first install. This can take 5-10 minutes with slow connections.

Fix:

1. Increase timeout: Add CLAWHUB_TIMEOUT=600000 (10 minutes in milliseconds) as an environment variable
2. Check network: Ensure you can reach GitHub and npm registries
3. Try manual installation: Download the skill repository directly, install dependencies locally, then move it to your skills folder
4. Wait patiently: The first install is always slowest; subsequent updates are much faster

Skills Installed But Not Working

The skill appears in your list and shows as enabled, but doesn't activate when you expect it to.

Fix:

1. Check eligibility: Run openclaw skills list --eligible to see if dependencies are missing
2. Verify permissions: Some skills need API tokens or credentials in environment variables
3. Test the skill explicitly: Mention the skill by name in your prompt: "Use the github-integration skill to list my repositories"
4. Review logs: OpenClaw logs show when skills activate and why they might be skipped
5. Check for conflicts: Multiple skills handling similar tasks can cause confusion

For complex debugging scenarios, running OpenClaw as a service provides better logging and diagnostic capabilities compared to local installations.

Platform Compatibility Issues

Error message: Skill 'xyz' requires platform: darwin

The skill is designed for a specific operating system (darwin = macOS, linux, win32 = Windows).

Fix:

1. Check alternatives: Look for cross-platform versions of the same capability
2. Modify the skill: If you're comfortable with the code, you might be able to adapt it (remove the os restriction in SKILL.md frontmatter)
3. Use containers: Run OpenClaw in Docker to create a consistent environment regardless of host OS

---

How Do You Configure Skills in openclaw.json?

The openclaw.json configuration file gives you fine-grained control over skill behavior, loading order, and environment setup.

Basic Skill Configuration

Location: ~/.openclaw/openclaw.json or <workspace>/.openclaw/openclaw.json

Simple enable/disable:

{
  "skills": {
    "github": {
      "enabled": true
    },
    "experimental-api": {
      "enabled": false
    }
  }
}

This is the most common configuration—explicitly controlling which skills OpenClaw loads.

Skill-Specific Environment Variables

Many skills need API keys, tokens, or configuration values:

{
  "skills": {
    "slack-notifier": {
      "enabled": true,
      "env": {
        "SLACK_TOKEN": "xoxb-your-token",
        "SLACK_CHANNEL": "#notifications"
      }
    }
  }
}

These environment variables are available only to that specific skill, preventing accidental exposure across different capabilities.

Skill Loading Precedence

OpenClaw searches for skills in multiple locations with this precedence order (highest to lowest):

1. <workspace>/skills/ — Workspace-specific skills
2. ~/.openclaw/skills/ — User global skills
3. Bundled skills — Pre-installed with OpenClaw

You can add custom search paths:

{
  "skills": {
    "load": {
      "extraDirs": [
        "/opt/company-skills",
        "~/projects/my-skills"
      ]
    }
  }
}

If the same skill name exists in multiple locations, the highest-precedence directory wins. This lets you override default skills with custom versions.

Skill Allowlisting

In security-conscious environments, you might want to restrict which skills can load:

{
  "skills": {
    "allowlist": [
      "github",
      "docker-essentials",
      "company-internal-tools"
    ]
  }
}

With an allowlist in place, only explicitly listed skills will load, even if others are installed. This prevents users from adding unapproved capabilities.

Advanced Configuration Options

Timeout adjustments:

{
  "skills": {
    "long-running-task": {
      "enabled": true,
      "timeout": 300000
    }
  }
}

Skill-specific model settings:

Some skills work better with specific AI models:

{
  "skills": {
    "code-reviewer": {
      "enabled": true,
      "model": "claude-opus-4",
      "temperature": 0.3
    }
  }
}

These configurations override global defaults when that skill is active.

---

What Security Considerations Should You Know Before Installing Skills?

Skills run with the same permissions as your OpenClaw agent, which typically means full access to your files, environment variables, and any APIs you've authenticated. Understanding the security implications prevents costly mistakes.

The Trust Problem

When you install a skill from ClawHub, you're running someone else's code on your machine. Even with VirusTotal scanning, automated checks can't catch every malicious pattern. A skill could:

• Read sensitive files (SSH keys, configuration files with passwords)
• Exfiltrate data to external servers
• Modify or delete important files
• Use your API tokens to perform actions in your name

Best practice: Always inspect skills before installing them.

How to Inspect Skills Safely

Use the inspect command:

clawhub inspect suspicious-skill

This shows the skill's SKILL.md file and lists any executable scripts or binaries included. Review:

• What permissions does it request?
• What external services does it connect to?
• Does it include obfuscated code or suspicious patterns?
• Does the code match the skill's stated purpose?

Check the source repository: Most ClawHub skills link to a GitHub repository. Visit it and:

• Review recent commits for unexpected changes
• Check how many people have starred it (more stars = more community trust)
• Look for issues mentioning security concerns
• See if the maintainer is responsive to problems

Start with read-only skills: Skills that only read data or provide information are lower risk than those that modify files, execute commands, or make API calls.

Environment Variable Isolation

Never put sensitive credentials in your global environment. Instead, scope them to specific skills:

Risky approach:

export PRODUCTION_DB_PASSWORD="secret123"

Now every skill can read this password.

Safer approach:

{
  "skills": {
    "db-manager": {
      "enabled": true,
      "env": {
        "PRODUCTION_DB_PASSWORD": "secret123"
      }
    }
  }
}

Only the db-manager skill can access this credential.

Principle of Least Privilege

Install only the skills you actually need. Every additional skill increases your attack surface. When evaluating a new skill, ask:

• Does this solve a real problem I have right now?
• Can I accomplish the same thing with existing skills or manual commands?
• Does this skill request more permissions than necessary for its stated purpose?

Disable skills you're not actively using rather than leaving them enabled "just in case."

Update Regularly But Carefully

Skill updates can introduce new features—or new vulnerabilities. When updating:

1. Review the changelog if available
2. Check for new permission requests
3. Test in a non-production environment first
4. Have a rollback plan (keep the old version)

For critical production systems, consider pinning skill versions and manually reviewing updates before applying them. Organizations running OpenClaw as a service should implement a formal skill approval process.

Private Skills for Sensitive Operations

If a skill needs access to proprietary systems or confidential data, don't publish it to ClawHub. Keep it in a private repository and install it manually. This prevents accidental exposure and gives you complete control over who can access the code.

---

How Do You Update and Remove Skills?

Managing your skill library over time requires knowing how to update capabilities and remove ones you no longer need.

Updating All Skills

The simplest approach updates everything at once:

clawhub update

This checks every ClawHub-installed skill against the registry, downloads newer versions if available, and replaces the old files. The process preserves your configuration settings in openclaw.json.

Important: This doesn't update manually installed skills. For those, you need to pull updates from your version control system or re-download them from their source.

Updating Individual Skills

When you want surgical precision:

clawhub update github-integration

This updates only the specified skill, leaving others at their current versions. This approach is safer when you're concerned about breaking changes in other skills.

Checking for Available Updates

Before updating, see what's changed:

clawhub outdated

This lists skills with available updates, current versions, and latest versions. Review this output before running blanket updates.

Removing Skills Cleanly

Via ClawHub CLI:

clawhub uninstall web-scraping

This removes the skill files and cleans up ClawHub's internal tracking.

Manual removal:

1. Navigate to your skills directory
2. Delete the skill folder entirely
3. Restart OpenClaw

Via configuration (soft removal):

{
  "skills": {
    "web-scraping": {
      "enabled": false
    }
  }
}

This disables the skill without uninstalling it. Useful when you might need it again later.

What Gets Removed?

Uninstalling a skill removes:

• The skill directory and all its files
• ClawHub's record of the installation

It does NOT remove:

• Data the skill created or modified
• Environment variables you configured
• API integrations you set up
• Configuration in openclaw.json

You'll need to clean these up manually if they're no longer needed.

Batch Removal

If you need to remove multiple skills:

clawhub uninstall skill1 skill2 skill3

Or script it:

for skill in skill1 skill2 skill3; do
  clawhub uninstall "$skill"
done

Handling Failed Removals

If uninstall fails (corrupted files, permission issues):

1. Try manual deletion of the skill folder
2. Check file permissions
3. Close OpenClaw if it's running (it might lock skill files)
4. Use rm -rf ~/.openclaw/skills/problematic-skill as a last resort

---

Comparison: Installation Methods at a Glance

Method	Best For	Speed	Technical Level	Pros	Cons
ClawHub CLI	Developers, automation, scripts	Fast	Intermediate	Scriptable, precise, shows detailed errors	Requires terminal comfort
UI Installation	Beginners, exploration, quick adds	Fast	Beginner	Visual, easy to browse, clear permissions	Less control, harder to automate
Manual Installation	Custom skills, private code, offline work	Slow	Advanced	Complete control, works offline, full customization	Requires understanding skill structure, no auto-updates

---

Frequently Asked Questions

How many skills can I install? There's no hard limit, but performance degrades with hundreds of skills loaded simultaneously. OpenClaw needs to evaluate all active skills for every task, so 20-50 well-chosen skills is a practical sweet spot.

Do skills work offline? Once installed, most skills work offline unless they specifically need internet access (API integrations, web scraping, etc.). Installation requires internet to download from ClawHub.

Can I modify ClawHub skills after installing them? Yes. ClawHub skills are just files on your disk. Edit them as needed. However, updates will overwrite your changes unless you rename the skill or move it to a higher-precedence directory.

What happens if two skills conflict? OpenClaw tries to choose the most appropriate skill based on context. If skills overlap significantly, you might see unpredictable behavior. Disable one or improve the skill descriptions to clarify when each should activate.

Are skills sandboxed? No. Skills run in the same environment as OpenClaw with the same permissions. This is why security review before installation is critical.

Can I install skills in multiple workspaces? Yes. Each workspace can have its own skills directory with different installed capabilities. Global skills (in ~/.openclaw/skills/) are available to all workspaces unless overridden.

---

Final Thoughts

Adding skills to OpenClaw transforms it from a general-purpose AI assistant into a specialized automation engine tailored to your exact workflow. Whether you're pulling pre-built capabilities from ClawHub's extensive registry, fine-tuning installations through openclaw.json configuration, or building custom skills from scratch, you now have the complete picture of how skill management works.

Start with a few high-value skills from the ClawHub registry—GitHub integration, file management, or whatever matches your daily tasks. As you get comfortable with how skills work, experiment with custom creations that solve problems unique to your situation. And always remember: inspect before you install, and only enable what you actually use.

The flexibility of OpenClaw's skill system is one of its biggest strengths. Take advantage of it, but do so thoughtfully. Your future self will thank you for the time you spent organizing, securing, and maintaining a clean skill library.