An OpenClaw agent without skills is a chatbot. It can answer questions, summarize text, and hold a conversation — but it can’t actually do anything. Skills are what turn it into an agent: the ability to search the web, read your calendar, manage files, send messages, run terminal commands, and call external APIs. OpenClaw ships with a handful of built-in skills, but the real value comes from adding more — either from the community registry (ClawHub), through MCP tool servers, or by writing your own.
This guide covers all three approaches.
:::note[TL;DR]
- Built-in skills ship with OpenClaw: file operations, web search, shell access, memory management
- ClawHub is the community registry — install skills with
openclaw skill install <name> - MCP tools connect external services (databases, APIs, Brave Search, Google Drive) via the Model Context Protocol
- Custom skills are Markdown files in your agent’s
skills/directory — no code required for simple ones - Skills are sandboxed by default; you grant permissions explicitly in
config.yaml:::
Prerequisites
- OpenClaw installed and an agent created — see the install guide and first agent tutorial if you haven’t done this yet
- Basic comfort with YAML — skill configuration lives in your agent’s
config.yaml
What skills ship with OpenClaw?
Every new agent starts with a set of built-in skills. These cover the operations most people need on day one:
| Skill | What it does |
|---|---|
file_read / file_write | Read and write files in the agent’s workspace |
shell_exec | Run terminal commands |
web_search | Search the web (requires a search API key) |
memory_store / memory_recall | Save and retrieve information across sessions |
http_request | Make HTTP calls to APIs |
schedule | Run tasks at specific times or intervals |
These are always available. You don’t need to install or configure them — they’re part of the base agent. But they’re intentionally limited in scope. OpenClaw doesn’t give a fresh agent access to your email, your calendar, or your cloud storage by default. You add those capabilities through skills.
The scenario: You set up a new agent and ask it to “check my Google Calendar for tomorrow’s meetings.” It tells you it can’t — no calendar skill is installed. Fair enough. You’d rather explicitly grant that access than have every new agent automatically poking around your accounts.
How do I install skills from ClawHub?
ClawHub is OpenClaw’s community skill registry. It’s a collection of pre-built skills contributed by other users — web scrapers, email senders, RSS readers, code formatters, translation tools, and more.
Browse what’s available:
openclaw skill search calendarThis returns a list of matching skills with descriptions, authors, and install counts. When you find one you want:
openclaw skill install google-calendarThe skill downloads to your agent’s skills/ directory and registers itself in the config. Most skills print a setup prompt after installation — usually asking for an API key or an OAuth token.
After installing, verify it’s active:
openclaw skill listYou should see the new skill in the output alongside the built-ins.
The scenario: Your boss asks you to build an agent that monitors an RSS feed and posts summaries to Slack every morning. You search ClawHub, find
rss-readerandslack-post, install both in under a minute, wire them together in the schedule config, and it’s done before lunch. Two weeks ago that would’ve been a custom script.
How ClawHub skills are structured
Each ClawHub skill is a directory containing:
google-calendar/
├── SKILL.md # Instructions the agent follows
├── config.schema.yaml # Required configuration fields
├── tools/ # Any executable scripts or binaries
└── README.md # Human-readable docsThe SKILL.md file is the core — it tells the agent what the skill does, when to use it, and what rules to follow. This is plain Markdown, which means you can open it and edit the instructions if the defaults don’t match your needs. There’s no compiled code to reverse-engineer.
How do I add MCP tools?
The Model Context Protocol (MCP) is a standard for connecting AI agents to external tools and data sources. If a service has an MCP server, OpenClaw can talk to it directly.
Common MCP servers include Brave Search, Google Drive, GitHub, PostgreSQL, Slack, and dozens of others. The ecosystem is growing fast — see the MCP server directory for what’s available.
To add an MCP tool, edit the mcp section of your agent’s config.yaml:
mcp:
servers:
- name: brave-search
command: "npx"
args: ["-y", "@anthropic/mcp-server-brave-search"]
env:
BRAVE_API_KEY: "${BRAVE_API_KEY}"
- name: filesystem
command: "npx"
args: ["-y", "@anthropic/mcp-server-filesystem", "/home/user/documents"]Each MCP server runs as a subprocess. OpenClaw starts them when the agent launches and shuts them down when it stops. The env block passes environment variables — use the ${} syntax to keep secrets out of the config file, the same pattern as API key handling in the DeepSeek guide.
After adding an MCP server, restart your agent and ask it what tools are available. It should list the new MCP tools alongside the built-in skills.
The scenario: You need your agent to search the web without sending queries through Google. You add the Brave Search MCP server — four lines of config, one environment variable. The agent now uses Brave for all web lookups. No ClawHub skill, no custom code, just a standard protocol connecting two things that already exist.
:::tip
MCP tools and ClawHub skills can coexist. If you install a ClawHub web-search skill and also configure a Brave Search MCP server, the agent has two ways to search the web. It’ll pick the most appropriate one based on context, or you can set a preference in your SKILL.md instructions.
:::
How do I write a custom skill from scratch?
For anything not covered by ClawHub or MCP, you write a custom skill. At minimum, a skill is a single SKILL.md file dropped into your agent’s skills/ directory.
A simple skill: meeting notes formatter
Create the directory and file:
mkdir -p ~/.openclaw/agents/myagent/skills/meeting-notes
touch ~/.openclaw/agents/myagent/skills/meeting-notes/SKILL.mdWrite the instructions in SKILL.md:
---
name: meeting-notes-formatter
description: Formats raw meeting transcripts into structured notes with action items.
---
# Meeting notes formatter
## When to use this skill
- When the user pastes a meeting transcript or asks you to "clean up" meeting notes
- When a voice transcription file (.txt or .md) appears in the workspace
## Rules
1. Extract all action items and list them at the top under "Action Items"
2. Group discussion points by topic, not by speaker
3. Remove filler words and false starts — keep only substantive content
4. If a deadline is mentioned, format it as: **[Action] — Due: [Date]**
5. Keep the summary under 500 words unless the user asks for more detail
## Output format
```markdown
# Meeting: [Topic] — [Date]
## Action items
- [ ] [Person]: [Task] — Due: [Date]
## Discussion summary
### [Topic 1]
[Summary]
### [Topic 2]
[Summary]
That's a complete skill. No Python, no JavaScript — just instructions. The agent reads the `SKILL.md` file and follows the rules whenever the trigger conditions match.
### A skill with a tool script
For skills that need to execute code — calling an API, processing a file, running a calculation — add a script to the `tools/` directory:
```bash
mkdir -p ~/.openclaw/agents/myagent/skills/weather/toolsWrite the tool script (Python, Bash, Node.js — anything executable):
#!/usr/bin/env python3
"""Fetch current weather for a given city."""
import sys
import json
import urllib.request
city = sys.argv[1] if len(sys.argv) > 1 else "London"
api_key = os.environ.get("WEATHER_API_KEY", "")
url = f"https://api.openweathermap.org/data/2.5/weather?q={city}&appid={api_key}&units=metric"
response = urllib.request.urlopen(url)
data = json.loads(response.read())
print(json.dumps({
"city": data["name"],
"temp": data["main"]["temp"],
"description": data["weather"][0]["description"]
}))Then reference it in your SKILL.md:
---
name: weather-lookup
description: Fetches current weather data for any city.
tools:
- name: get_weather
command: "python3 tools/weather.py"
args: ["{{city}}"]
env:
WEATHER_API_KEY: "${WEATHER_API_KEY}"
---
# Weather lookup
## When to use this skill
- When the user asks about weather, temperature, or forecast
- When another skill needs weather data as input
## Rules
1. Always confirm the city name before calling the tool
2. Report temperature in Celsius and Fahrenheit
3. If the city is ambiguous (e.g., "Portland"), ask which oneThe tools block in the frontmatter registers the script as a callable tool. The {{city}} placeholder gets filled by the agent at runtime.
How do skill permissions work?
Skills don’t get unlimited access by default. OpenClaw uses a permission model where you explicitly grant what each skill can do in config.yaml:
skills:
permissions:
meeting-notes-formatter:
- file_read
- file_write
weather-lookup:
- http_request
- shell_exec
google-calendar:
- http_request
- memory_storeIf a skill tries to use a permission it hasn’t been granted, the agent blocks the action and logs a warning. You’ll see it in the terminal:
[skills] Permission denied: "weather-lookup" attempted "file_write" (not granted)This matters most for ClawHub skills you didn’t write yourself. Before granting shell_exec to a community skill, read its SKILL.md and check what commands it runs.
:::warning
The shell_exec permission is the most dangerous. A skill with shell access can run any command on your machine. Only grant it to skills you’ve reviewed or written yourself.
:::
How do I manage and update skills?
A few useful commands:
# List all installed skills (built-in + ClawHub + custom)
openclaw skill list
# Update a ClawHub skill to the latest version
openclaw skill update google-calendar
# Update all ClawHub skills at once
openclaw skill update --all
# Remove a skill
openclaw skill remove rss-reader
# Show details about a specific skill
openclaw skill info weather-lookupCustom skills (in your agent’s skills/ directory) aren’t managed by the CLI — you edit and delete them directly on disk.
Frequently asked questions
What’s the difference between a skill and an MCP tool?
A skill is an OpenClaw-native concept — a SKILL.md file with instructions and optional tool scripts, living in your agent’s directory. An MCP tool is an external server that speaks the Model Context Protocol. Skills are simpler to write; MCP tools are better when the service already has an MCP server published. You can use both in the same agent. For more on how skills and tools relate in the broader agent ecosystem, see our agents vs skills vs rules breakdown.
Can I share my custom skill on ClawHub?
Yes. Package your skill directory (with SKILL.md, config.schema.yaml, and any tools/) and publish it:
openclaw skill publish ./skills/meeting-notesYou’ll need a ClawHub account. The review process is light — mostly checking that the skill has a description, valid schema, and no hardcoded secrets.
Do skills persist across agent restarts?
Yes. Installed ClawHub skills and custom skills stay in the agent’s skills/ directory permanently. MCP servers restart automatically when the agent starts. Nothing resets on reboot.
Can one skill call another skill?
Not directly. Skills don’t invoke each other — the agent orchestrates them. If you ask the agent to “check my calendar and then send a Slack summary,” it calls the calendar skill first, gets the result, then calls the Slack skill. The agent is the coordinator, not the skills. For more complex orchestration patterns, the multi-agent guide covers how to chain agents together.
How many skills can one agent have?
There’s no hard limit. In practice, agents with 15–20 skills work fine. Beyond that, the agent’s context window starts filling up with skill instructions, which can reduce response quality. If you need a large number of skills, consider splitting them across multiple specialized agents instead.
What to read next
- OpenClaw first agent tutorial — If you skipped straight to skills and need to set up a basic agent first.
- OpenClaw multi-agent setup — When one agent with many skills isn’t enough and you need specialized agents working together.
- How to use OpenClaw with DeepSeek — Pair your skill-heavy agent with a cheaper model to keep API costs under control.
