OpenClaw verschlingt derzeit mehr meiner Zeit, als ich zugeben möchte – wohl auch aufgrund der Limitierungen, die man bei der Verwendung lokaler LLMs wie Qwen 3 Coder Next naturgemäß hat. Da ich persönlich dem offiziellen Skill-Store von OpenClaw (ClawHub) nicht über den Weg traue, arbeite ich gerade daran, die gewünschten Funktionen selbst umzusetzen.
Ein Beispiel: Ich möchte meinem Assistenten die Möglichkeit geben, Links zu besuchen, um mir Zusammenfassungen des Inhalts zu erstellen. Fragt man OpenClaw direkt danach, verfängt man sich schnell in Diskussionen über Brave-APIs für die Suche oder darüber, dass curl nicht funktioniert hat. Hier helfen uns Skills weiter.
Was genau sind Skills?
Skills sind im Grunde kleine, in .md-Files abgelegte Anleitungen, die dem Sprachmodell beim Start als Kontext mitgegeben werden. Wichtig zu wissen: Jeder Skill vergrößert den benötigten Kontext des Modells. Wir sollten unsere Skills also so schlank und aussagekräftig wie möglich halten.
Ein entscheidender Punkt: Skills sind keine Skripte. Wir reden hier von Anleitungen mit YAML-Frontmatter-Formatierung. Diese sind so formuliert, dass sie theoretisch auch an einen Menschen gerichtet sein könnten. Das Frontmatter dient dabei als „Trigger“: OpenClaw liest zuerst Name und Beschreibung, um zu entscheiden, ob der Skill für die aktuelle Aufgabe relevant ist, und lädt erst dann die vollständigen Instruktionen.
Praxisbeispiel: Der Browser-Skill
Kommen wir zurück zu unserem Beispiel: Wir möchten OpenClaw die Fähigkeit verleihen, Webseiten zu besuchen. Dafür habe ich mit meinem Agenten Docker installiert und Browserless in einer Standard-Konfiguration per Docker Compose aufgesetzt. Das hat erstaunlich gut geklappt. Direkt nach der Installation konnte das Modell die Verbindung testen, Seiten besuchen und sogar Screenshots erstellen.
Dann passierte das Übliche: Nach ein paar anderen Themen, die ich mit dem Agenten durchgekaut hatte, wollte ich wieder eine Seite auswerten lassen. Doch OpenClaw wusste nicht mehr, wie es Webseiten öffnen kann – die Installation von Docker hatte es nicht in das Langzeitgedächtnis geschafft. An dieser Stelle merkt man schnell: Ein Assistent mit dem Kurzzeitgedächtnis eines Goldfisches ist ein Problem. Man könnte zwar mit Memory-Einträgen gegensteuern, um der LLM den Software-Stack ständig vor Augen zu halten, aber das ufert schnell aus.
Abhilfe schaffen hier Skills. Sie dienen als feste Leitplanken, die unabhängig vom Gesprächsverlauf definieren, welche Werkzeuge zur Verfügung stehen.
Wo werden OpenClaw-Skills abgelegt und wie sehen sie aus?
Skills werden bei OpenClaw unter workspace/skills/{skillname}/SKILL.md abgelegt. Jeder Skill bekommt seinen eigenen Ordner und sein eigenes Markdown-File. Die offizielle Dokumentation erklärt das System im Detail unter docs.openclaw.ai/tools/skills.
Meine SKILL.md für den Browserless-Skill sieht wie folgt aus:
---
name: web-suche
description: Lokaler Browserless-Dienst (Chrome in Docker) für Web-Scraping, Screenshots, PDFs und Browser-Automatisierung. Bietet REST-Endpoints für Inhal>
metadata: {"openclaw":{"emoji":"🌐","requires":{"bins":["curl","docker"]},"homepage":"https://www.browserless.io/docs/start"}}
---
# Web-Suche Skill (Browserless)
Nutze die lokale Browserless-Instanz in Docker unter `http://localhost:3000` für browserbasierte Aufgaben. Kein API-Token erforderlich.
## Schnellcheck
Prüfe ob der Dienst läuft:
```bash
curl -s http://localhost:3000/status
```
Wenn HTML zurückkommt, läuft Browserless. Falls nicht, starte den Container:
```bash
docker run -d --name browserless -p 3000:3000 ghcr.io/browserless/chromium
```
## Endpoints
### 1. Inhaltsextraktion (`/content`)
Extrahiert den sichtbaren Textinhalt einer Seite.
```bash
curl -X POST http://localhost:3000/content \
-H 'Content-Type: application/json' \
-d '{"url": "https://example.com"}'
```
**Verwende für:** Artikeltexte, Seiteninhalte, lesbare Zusammenfassungen.
### 2. Strukturiertes Scraping (`/scrape`)
Extrahiert strukturierte Daten mittels CSS-Selektoren.
```bash
curl -X POST http://localhost:3000/scrape \
-H 'Content-Type: application/json' \
-d '{
"url": "https://example.com",
"elements": [
{"selector": "h1"},
{"selector": ".article-body p"}
]
}'
```
**Verwende für:** Gezielte Elemente wie Überschriften, Preise, Tabellen.
### 3. Screenshots (`/screenshot`)
Erstellt einen Screenshot einer Seite (gibt PNG zurück).
```bash
curl -X POST http://localhost:3000/screenshot \
-H 'Content-Type: application/json' \
-d '{"url": "https://example.com", "options": {"fullPage": true}}' \
--output screenshot.png
```
Optionen: `fullPage` (boolean), `type` (`png`|`jpeg`), `quality` (1-100 für jpeg).
**Verwende für:** Visuelle Schnappschüsse, UI-Prüfung, Seiten archivieren.
### 4. PDF-Export (`/pdf`)
Generiert ein PDF einer Webseite.
```bash
curl -X POST http://localhost:3000/pdf \
-H 'Content-Type: application/json' \
-d '{"url": "https://example.com", "options": {"printBackground": true, "format": "A4"}}' \
--output seite.pdf
```
Optionen: `format` (`A4`, `Letter`, etc.), `printBackground` (boolean), `landscape` (boolean), `margin` (`{top, right, bottom, left}`).
**Verwende für:** Seiten als PDF speichern, druckbare Dokumente erstellen.
### 5. Benutzerdefiniertes JavaScript (`/function`)
Führt eigenes JavaScript im Browser-Kontext aus.
```bash
curl -X POST http://localhost:3000/function \
-H 'Content-Type: application/json' \
-d '{
"code": "module.exports = async ({ page }) => { await page.goto(\"https://example.com\"); return await page.title(); }"
}'
```
Die Funktion erhält `{ page, context }` — `page` ist ein Puppeteer-Page-Objekt.
**Verwende für:** Komplexe Interaktionen, Formular-Eingaben, mehrstufiges Scraping, alles was die anderen Endpoints nicht abdecken.
## Entscheidungshilfe
| Aufgabe | Empfohlener Ansatz |
|---------|-------------------|
| Artikeltext lesen | `web_fetch` Tool (einfacher) oder `/content` |
| Bestimmte Daten mit Selektoren extrahieren | `/scrape` |
| Screenshot erstellen | `/screenshot` oder `browser`-Tool |
| Seite als PDF speichern | `/pdf` |
| Komplexe mehrstufige Automatisierung | `browser`-Tool mit `profile="chrome"` |
| Eigenes JS auf einer Seite ausführen | `/function` |
**Bevorzuge `web_fetch`** für einfaches Abrufen von Inhalten — schneller, braucht keine Session.
**Bevorzuge das `browser`-Tool** für interaktive UI-Automatisierung (Klicks, Formulare, Navigationsabläufe).
**Nutze Browserless-Endpoints direkt** wenn du spezifische Ausgabeformate brauchst (PDF, Screenshot) oder strukturiertes CSS-Selektor-Scraping.
## Wichtige Hinweise
- Alle Endpoints verwenden `POST` mit `Content-Type: application/json`.
- **Verwende NICHT** `GET /new?url=...` — das ist der WebSocket-Debugger, kein REST-Endpoint.
- Binäre Antworten (Screenshots, PDFs) mit `--output dateiname` speichern.
- Der Dienst läuft lokal — kein Internetzugang nötig, keine Authentifizierung.
Ein Tipp aus der Praxis: Claude konnte mir bei der Erstellung des Skills fast die komplette Arbeit abnehmen. Nach einer kurzen Erklärung, welche Dienste wo laufen, sowie der Verlinkung der Doku, kam direkt ein nutzbares Resultat heraus.
Bitte ich meinen Assistenten jetzt darum, eine Website zu besuchen, greift er sofort auf die Anleitung zurück, sendet die Anfrage brav in Richtung Browserless und erstellt anschließend mit Bordmitteln die Zusammenfassung. Es darf geklatscht werden!
Hinweis: Bei größeren Änderungen an den Skills musste ich ab und zu mittels openclaw gateway restart alles neu laden, damit die Anpassungen korrekt übernommen wurden.
Ein bisschen Erwartungsmanagement
Bevor ihr jetzt loslegt: Skills sind kein Wundermittel. Sie machen aus einem 3B-Modell keinen Senior Developer. Wenn das Modell zu „dumm“ für eine komplexe Logik ist, hilft auch die beste Anleitung nichts. Die Direktiven sind eher wie Leitplanken, die verhindern, dass das Modell in den Graben fährt.
Außerdem müsst ihr ein Auge auf euer Context Window haben. Da Skills in den Kontext geladen werden, kosten sie Tokens. Bei einem kleinen Kontext-Limit müsst ihr also strikt priorisieren, welche Skills ihr aktiv lasst.
Fazit
Die „bösen“ OpenClaw-Skills, die in den letzten Tagen durch das Internet geisterten, sind im Grunde einfache Anleitungen. Umso verrückter ist der Fakt, dass sich darin Malware verstecken konnte, die von Hunderttausenden blind installiert wurde. Hier sieht man einfach, wie neu das Thema OpenClaw noch ist und dass der Enthusiasmus manchmal schneller ist als der Verstand.
Wir leben in Bezug auf KI in spannenden Zeiten – im neuen „Digitalen Wilden Westen“ – und nicht jeder führt Gutes im Schilde. Lokale, selbst geschriebene Skills sind daher aktuell der sicherste Weg.
