ClawHub is the registry and marketplace for OpenClaw skills. It hosts community-published skills (Todoist, GitHub, Notion, Linear, browser automation, dozens more), handles auth and telemetry, exposes a v1 HTTP API, and is the source the CLI talks to when you run openclaw skill add . It is to OpenClaw what npm is to Node — same publish / install / update flow, but for agent capabilities instead of code packages.

How do I install a skill in OpenClaw?

From the CLI: openclaw skill add pulls the skill from ClawHub and installs it into your workdir's .clawhub/lock.json. List installed skills with openclaw skill list. Remove with openclaw skill remove . The CLI also supports installing from a local folder or a GitHub URL — useful when developing your own skill before publishing.

How do I write my own OpenClaw skill?

Create a folder, add a SKILL.md with YAML frontmatter declaring name, description, version, and the metadata.openclaw block (requires.env for env vars, requires.bins for CLI tools, primaryEnv for the main credential). Write the skill body as Markdown explaining what the agent should do when the skill is invoked, with concrete examples. Test locally with openclaw skill add ./my-skill, then openclaw skill publish to push to ClawHub. The skill format docs at docs.openclaw.ai/clawhub/skill-format have the full field reference.

June 15, 2026 · 11 min read · AI Agents · OpenClaw

OpenClaw Skills & ClawHub: The Plugin Marketplace for Agent Capabilities (2026)

Q: What is an OpenClaw skill?

An OpenClaw skill is a folder containing a SKILL.md file plus optional supporting files. The SKILL.md is Markdown with a YAML frontmatter block declaring metadata: name, description, version, and a runtime requirements block under metadata.openclaw that lists env vars, binaries, and config files the skill needs. The folder is the entire skill — no separate manifest, no code-gen step. The OpenClaw agent loads the SKILL.md, reads the frontmatter to check requirements, and the body becomes guidance the agent follows when the skill is invoked.

Q: What is the browser-automation skill?

The browser-automation skill is bundled with OpenClaw's browser tool and teaches the agent the recovery loop that makes long browser sessions stable: snapshot-first navigation, stable-tab tracking across re-renders, stale-reference repair, and a manual-blocker handoff when something needs a human. Without it, an LLM agent driving a browser dies on the third re-render. With it, multi-step browser tasks survive DOM drift, popups, and slow XHRs.

Robot arm browsing floating plugin tiles and skill cards next to a SKILL.md sheet — OpenClaw skill marketplace illustration

If you're reading this, you probably already know OpenClaw is the self-hosted personal AI assistant gateway by Peter Steinberger. The agent is excellent on day one. The thing that actually makes it production-grade over the second week is the skill ecosystem sitting on top — small Markdown files that teach the agent new capabilities without touching the core, and a marketplace (ClawHub) that distributes them. We've been integrating OpenClaw with our own product, Human Browser, and the skill format is the reason the integration was a one-evening project instead of a quarter.

What an OpenClaw skill is, structurally
ClawHub — the marketplace and the CLI
The bundled browser-automation skill
Writing your own skill
Skill patterns we see work in production
Pairing a skill with Human Browser
FAQ

What an OpenClaw skill is, structurally

A skill is a folder. The only required file is SKILL.md (lowercase skill.md also works). Everything else — supporting scripts, lookup tables, example payloads — is optional and lives next to it. There's no build step, no compile target, no separate manifest in JSON. The Markdown is the skill.

The top of SKILL.md is a YAML frontmatter block. The minimum is three fields:

---
name: my-skill
description: Short summary of what this skill does.
version: 1.0.0
---

# Body content — Markdown that the agent reads as guidance
# when this skill is active.

The interesting part is the runtime requirements block, declared under metadata.openclaw (the docs also accept metadata.clawdbot as a legacy alias). This is what tells the OpenClaw runtime — and the ClawHub security scanner — what the skill needs to function:

---
name: todoist-tasks
description: Manage tasks via the Todoist API.
version: 1.2.0
metadata:
  openclaw:
    requires:
      env:
        - TODOIST_API_KEY     # must be in environment before the skill runs
      bins:
        - curl                # CLI binary that must be installed
    primaryEnv: TODOIST_API_KEY
    homepage: https://github.com/example/openclaw-todoist
---

The fields are deliberately minimal. requires.env lists environment variables that must be present. requires.bins lists CLI binaries that must resolve on $PATH. requires.anyBins covers the "at least one of these" case (e.g. python3 OR uv). primaryEnv declares which env var carries the main credential — this is what shows up in the "Auth" section of the skill's ClawHub page so users know what to set before installing.

The whole skill format is one Markdown file and ten lines of YAML. That economy is exactly why the ecosystem is healthy.

Two more useful fields:

always: true — the skill is active without explicit invocation. Use sparingly; most skills should be opt-in.
install: — declarative dependency installation specs. If your skill needs a Python package or a Homebrew formula, you declare it here and OpenClaw resolves it on first activation.
os: ["macos", "linux"] — OS restrictions for skills that only make sense on certain platforms.

ClawHub — the marketplace and the CLI

ClawHub is to OpenClaw what npm is to Node. It's the registry where skills are published, the security analyser that scans them, the search surface where users find them, and the source the OpenClaw CLI talks to when it installs them. There's an HTTP API (v1, documented at docs.openclaw.ai/clawhub) and a web UI at clawhub.openclaw.ai.

From the CLI, the surface mirrors npm closely:

# search for skills mentioning 'browser' or 'github'
$ openclaw skill search browser
$ openclaw skill search github

# install a skill (pulls from ClawHub, records in workdir's .clawhub/lock.json)
$ openclaw skill add todoist-tasks
$ openclaw skill add @steipete/email-triage

# list what's installed in this workdir
$ openclaw skill list

# install from a local folder during development
$ openclaw skill add ./my-skill

# install directly from a GitHub repo (skips the registry)
$ openclaw skill add github:my-org/my-openclaw-skill

# update everything in the lockfile
$ openclaw skill update

# publish your own (you'll need a ClawHub auth token first)
$ openclaw skill publish

The lockfile at <workdir>/.clawhub/lock.json is per-workdir, so different projects can pin different skill versions — same idea as package-lock.json. If you've used npm or Cargo, the muscle memory transfers directly.

The bundled browser-automation skill

The single most useful skill for production agent work doesn't come from ClawHub — it ships bundled with OpenClaw's browser tool, and it's the reason long browser sessions don't fall over after the third re-render. The skill teaches the agent four things that an LLM tool-call won't do on its own:

Snapshot-first navigation. Before clicking, dump the current DOM snapshot so the agent reasons against a fresh state rather than a cached selector from two steps ago.
Stable-tab tracking. Pin the agent's logical "current tab" to a stable identifier (the tab GUID, not the index) so a sibling popup doesn't steal the focus without the agent noticing.
Stale-reference repair. When a selector returns "element not in DOM", automatically re-snapshot and retry against the new structure instead of error-ing the whole tool call.
Manual-blocker handoff. When a CAPTCHA, an OAuth modal, or a 2FA prompt appears, escalate to the human via the active chat channel rather than guessing through it.

These are not exotic — they're the basic moves any production browser-agent harness eventually re-discovers. The value of the skill is that it ships them day one, the agent learns them by reading one Markdown file, and your skill code (which calls into the browser tool) inherits the recovery loop for free.

Diagram of the bundled browser-automation skill: snapshot, stable-tab, stale-reference repair, manual-blocker handoff steps in a circular loop

Writing your own skill

The end-to-end loop is small enough to cover in one section. Create a folder, write a SKILL.md, install it locally, iterate against the agent until it does what you want, then publish.

# 1) bootstrap the folder
$ mkdir my-weather-skill && cd my-weather-skill
$ touch SKILL.md

Fill in SKILL.md with the structure the OpenClaw runtime expects:

---
name: weather-lookup
description: Look up the current weather and 7-day forecast for any city via the OpenWeatherMap API.
version: 0.1.0
metadata:
  openclaw:
    requires:
      env:
        - OPENWEATHERMAP_API_KEY
      bins:
        - curl
        - jq
    primaryEnv: OPENWEATHERMAP_API_KEY
    homepage: https://github.com/myhandle/openclaw-weather-skill
---

# Weather Lookup

When the user asks about weather, current conditions, or a forecast for a
named place, use this skill. Always confirm the city + country if ambiguous
(there are multiple "Springfields") before calling the API.

## Tool call

```bash
curl "https://api.openweathermap.org/data/2.5/forecast?q=$CITY&appid=$OPENWEATHERMAP_API_KEY&units=metric" | jq '.list[0:8]'
```

## Response

Summarise current conditions and the next 24-hour outlook in 2-3 short
lines. Include the temperature in both °C and °F. If the API returns an
error, surface the error message verbatim and ask the user to verify the
city name.

Now install it into your local OpenClaw workdir and start iterating:

# install from the local folder — no publish needed for dev
$ cd /path/to/your/openclaw-workdir
$ openclaw skill add /absolute/path/to/my-weather-skill

# verify it's loaded
$ openclaw skill list
  ✓ [email protected] (local: /absolute/path/to/my-weather-skill)

# talk to the agent from any channel — WhatsApp, Telegram, the Web UI —
# 'What's the weather in Bangkok?' — the agent picks up the skill and runs.

When the skill behaves the way you want, publish it. You'll need a ClawHub auth token (one-time, from the dashboard); after that:

# from the skill folder
$ openclaw skill publish

  ✓ uploaded [email protected]
  ✓ security scan passed
  ✓ now visible at https://clawhub.openclaw.ai/skills/weather-lookup

Other people's OpenClaw installs can now openclaw skill add weather-lookup and get the same behaviour.

Skill patterns we see work in production

After integrating OpenClaw with our own infrastructure (and watching the broader ecosystem), three skill shapes seem to dominate the actually-useful ones:

1. The credentialled-API wrapper

One primaryEnv credential, a couple of bins (almost always curl + jq), a short body explaining when to invoke and how to summarise the response. Todoist, Linear, GitHub Issues, Notion DB, Sentry, Stripe — all of these are 30-line skills.

2. The browser-flow recipe

No external API. Targets the bundled browser tool. The body of the SKILL.md is a step-by-step playbook: "open this URL, look for this label, click, fill the field, submit, screenshot the result." The browser-automation skill underneath handles the recovery; this skill encodes the domain knowledge. Examples: "file an expense in Concur," "create a new Calendly meeting," "refund a customer in Stripe Dashboard."

3. The shell-pipeline orchestrator

Several requires.bins, often a small Python or shell script in the same folder, and a SKILL.md that explains how the agent should call them. Useful for DevOps tasks like "tail logs from prod and summarise anomalies" or "run the deploy script and confirm green."

Pairing a skill with Human Browser

For the second pattern — browser-flow recipes — there's a class of targets where the local OpenClaw browser hits a wall: Cloudflare-, DataDome-, or PerimeterX-protected sites. The wall isn't in your skill or in OpenClaw; it's in the IP + the CDP fingerprint + the input cadence. The fix is to swap the browser profile your skill drives, not the skill itself.

OpenClaw's browser tool supports a remote multi-profile that connects to an external CDP endpoint. Human Browser is one of the things you can put on the other end of that connection — a stealth-patched Chromium on residential IPs across 75 countries, with CAPTCHA solving and human-paced input baked in. The skill doesn't change. Only the browser profile does.

# 1) get a Human Browser token (try it for $1 at /install)
$ export HB_CDP_ENDPOINT="wss://agent.humanbrowser.cloud/cdp?token=hb_live_..."

# 2) wire it into OpenClaw's remote profile
$ export OC_BROWSER_REMOTE_CDP="$HB_CDP_ENDPOINT"

# 3) tell your skill (or the agent invoking it) to use the remote profile
$ openclaw browser --browser-profile remote start

# 4) from any channel: invoke the skill against a protected target.
# The skill body is unchanged; the browser underneath ships from a
# residential IP with the CDP leaks patched and a humanization layer.

The deeper recipe is in our companion post: OpenClaw browser: the tool, the remote-CDP mode, and when to pair it with Human Browser.

Want a stealth browser behind your OpenClaw skills?

Human Browser exposes a remote CDP endpoint that drops directly into OpenClaw's remote browser profile. Pay-as-you-go: $0.10/hr browser time, $4/GB residential proxy, $0.005/captcha, $0.02 per agent step with the AI included. No subscription, unused balance never expires. Get started at humanbrowser.cloud.

FAQ

What is an OpenClaw skill?

A folder containing a SKILL.md Markdown file (and any supporting files). The frontmatter declares metadata and runtime requirements; the body is guidance the agent reads as authoritative instructions when the skill is invoked.

What is ClawHub?

The registry and marketplace for OpenClaw skills — same shape as npm for Node packages. It handles publishing, search, install, security scanning, and exposes a v1 HTTP API.

How do I install a skill?

openclaw skill add <name> from a workdir. The CLI also accepts a local folder path or a github:owner/repo spec for skills that aren't on ClawHub.

What is the browser-automation skill?

The bundled skill that teaches the agent the snapshot / stable-tab / stale-reference / manual-blocker recovery loop. It ships with the browser tool and is why long browser sessions stay stable across DOM drift.

How do I write my own skill?

Create a folder, add a SKILL.md with frontmatter (name, description, version, metadata.openclaw.requires), write the body as Markdown the agent will follow. Test with openclaw skill add ./my-skill, publish with openclaw skill publish.

Can a skill drive a remote browser like Human Browser?

Yes — a skill that targets the browser tool inherits whatever browser profile is active. Set the profile to remote and point it at a Human Browser CDP endpoint and your skill drives stealth Chromium on a residential IP with no code change.

OpenClaw Browser: The Tool, the Remote-CDP Mode, and When to Pair It With Human Browser (2026) — AI Agents
Browser Automation for AI Agents in 2026: OpenClaw + Playwright — AI Agents
What Is a Browser Agent? (2026) — Explainer
Best Residential Proxies for Scraping 2026 — Real Benchmarks — Pillar · Proxies