OpenClaw noch nicht installiert? Klicken Sie hier fuer die Ein-Klick-Installationsanleitung
curl -fsSL https://openclaw.ai/install.sh | bash
iwr -useb https://openclaw.ai/install.ps1 | iex
curl -fsSL https://openclaw.ai/install.cmd -o install.cmd && install.cmd && del install.cmd
Bedenken wegen Ihres Computers? ClawTank laeuft in der Cloud ohne Installation und eliminiert das Risiko versehentlicher Loeschungen
Key Findings
  • OpenClaw Skills ist ein modulares Faehigkeitssystem mit skill.md als Spezifikationskern. Der offizielle Store umfasst derzeit ueber 100 Skills in den Hauptkategorien Browser-Automatisierung, Dateisystem, Kalenderintegration, Shell-Ausfuehrung und weiteren.
  • skill.md verwendet ein Mischformat aus YAML-Frontmatter und Markdown-Beschreibung. Durch die drei Schluesselfelder capabilities, permissions und inputs kann der OpenClaw Tutorial-Agent bereits vor der Ausfuehrung die Skill-Grenzen vollstaendig verstehen.
  • BlogWatcher und Supermemory sind die zwei am haeufigsten genutzten Skills in der Community: Ersterer ueberwacht periodisch Web-Inhalte, Letzterer bietet sitzungsuebergreifende Langzeitspeicherung mittels Vektordatenbank.
  • Ein Bericht von The Register im Februar 2026 deckte auf, dass einige von der Community eingereichte Skills API-Schluessel in Log-Ausgaben preisgaben. Sicherheitsteams sollten verbindliche Richtlinien fuer Eingabevalidierung und Schluessel-Management festlegen.[4]
  • Fuer Unternehmenseinsaetze wird empfohlen, eine Private Skill Registry einzurichten und diese mit Genehmigungsworkflows sowie Versionssperrmechanismen zu kombinieren, um Stabilitaet und Compliance in Produktionsumgebungen sicherzustellen.

OpenClaw trat Ende 2025 als „Open-Source-Superagent" in das oeffentliche Bewusstsein und entwickelte sich rasch von einem Nischen-Entwicklertool zu einem ernstzunehmenden Mitbewerber im Bereich der Enterprise-KI-Automatisierungsplattformen.[5] Einer der Schluessel zu diesem Erfolg war das Design eines Skill-Erweiterungssystems, das Flexibilitaet und Sicherheit vereint und es jedem Entwickler ermoeglicht, dem Agenten auf standardisierte Weise neue Faehigkeiten hinzuzufuegen, ohne den Kerncode zu aendern.[6]

Dieser Artikel nimmt die Entwicklerperspektive ein und analysiert den vollstaendigen Lebenszyklus von OpenClaw Skills: vom Verstaendnis der skill.md-Spezifikationssyntax ueber die schrittweise Erstellung eines ersten benutzerdefinierten Skills, die Untersuchung von Implementierungsmustern beliebter offizieller Skills bis hin zur sicheren Veroeffentlichung im Skills Store sowie dem Management privater Skill-Oekosysteme in Unternehmensumgebungen. Ob Sie ein Ingenieur sind, der massgeschneiderte Automatisierungstools fuer Ihr Team entwickeln moechte, oder ein unabhaengiger Entwickler mit Interesse an der Kommerzialisierung von Skills -- dieser Leitfaden liefert direkt anwendbares technisches Wissen.[1]

1. Ueberblick ueber das Skills-Oekosystem

1.1 Was ist ein OpenClaw Skill?

In der OpenClaw-Architektur ist ein Skill ein eigenstaendiges Faehigkeitsmodul, das dem Agenten ueber eine standardisierte Schnittstelle mitteilt, „was es kann" und „welche Ressourcen es dafuer benoetigt". Im Gegensatz zu herkoemmlichen Plugin-Systemen, die das Einbinden spezifischer APIs in das Hostprogramm erfordern, setzt OpenClaw Skills auf ein deklaratives Design: Entwickler beschreiben die Skill-Faehigkeiten in einer skill.md-Datei in einem fuer Menschen lesbaren Format, und die OpenClaw-Engine liest diese Beschreibungen dynamisch bei der Aufgabenplanung, um zu entscheiden, wann welcher Skill aufgerufen werden soll.[2]

Dieses Design bietet zwei wesentliche Vorteile: Erstens kann der Agent bereits vor der Ausfuehrung die Faehigkeitsgrenzen jedes Skills verstehen und vermeidet so Trial-and-Error-Aufrufe. Zweitens koennen Menschen die skill.md direkt lesen, um das Skill-Verhalten zu pruefen, ohne Code reverse-engineeren zu muessen. Dies ist besonders wichtig fuer die Compliance-Pruefung in Unternehmen.

Jeder Skill wird im Dateisystem als eigenstaendiges Verzeichnis dargestellt, mit folgender Struktur:

my-skill/
├── skill.md          # Skill-Spezifikation (erforderlich)
├── index.js          # Hauptlogik-Einstiegspunkt (erforderlich)
├── package.json      # npm-Abhaengigkeitsdeklaration (optional)
├── tests/            # Unit-Test-Verzeichnis (empfohlen)
│   └── skill.test.js
└── README.md         # Zusaetzliche Dokumentation (optional)

1.2 Aktueller Stand des offiziellen Skills Store

Stand Februar 2026 umfasst der offizielle OpenClaw Skills Store (Skills Marketplace) ueber 100 Skills, die gemeinsam vom offiziellen Kernteam, verifizierten Partnern und Community-Entwicklern beigetragen wurden.[3] Die Verteilung nach Funktionskategorien sieht wie folgt aus:

Darueber hinaus steigt die Zahl der monatlich neu hinzukommenden Skills stetig an, und die Lebendigkeit des Community-Oekosystems ist zu einem wichtigen Differenzierungsfaktor von OpenClaw gegenueber der Konkurrenz geworden.

1.3 Aufrufmechanismus von Skills

Wenn ein Benutzer eine Anfrage an OpenClaw stellt, fuehrt der Agent den folgenden Prozess aus: Zunaechst scannt er die skill.md aller installierten Skills und erstellt einen Faehigkeitsindex; dann gleicht er die am besten geeigneten Skills basierend auf der Aufgabensemantik ab; erst nachdem bestaetigt wurde, dass die erforderlichen Berechtigungen vom Benutzer erteilt wurden, wird die index.js-Logik des Skills tatsaechlich ausgefuehrt. Der gesamte Prozess ist fuer den Benutzer nahezu transparent, aber das Verstaendnis dieses Ablaufs ist fuer Entwickler entscheidend, um gut gestaltete Skill-Beschreibungen zu erstellen.[9]

2. Detaillierte skill.md-Spezifikation

2.1 Gesamtstruktur

skill.md verwendet ein Mischformat aus YAML-Frontmatter und Markdown-Haupttext, wobei der YAML-Block maschinenlesbare strukturierte Metadaten enthaelt und der Markdown-Haupttext detaillierte Erlaeuterungen fuer KI-Modelle und menschliche Entwickler bietet. Beide sind unverzichtbar: YAML bestimmt die Auffindbarkeit und Ausfuehrungsgrenzen des Skills, waehrend Markdown bestimmt, ob der Agent den richtigen Einsatzzeitpunkt und die richtige Verwendungsweise des Skills verstehen kann.[2]

Im Folgenden finden Sie ein vollstaendiges skill.md-Strukturbeispiel:

---
name: my-custom-skill
version: 1.2.0
description: "Einzeilige Beschreibung der Kernfunktionalitaet dieses Skills"
author: your-username
license: MIT

capabilities:
  - id: fetch-webpage
    description: "Webseiteninhalte einer angegebenen URL abrufen"
  - id: extract-text
    description: "Reintextabschnitte aus HTML extrahieren"

permissions:
  network: true
  filesystem: false
  shell: false
  env:
    - MY_API_KEY

inputs:
  - name: url
    type: string
    required: true
    description: "Vollstaendige URL der Zielwebseite"
  - name: selector
    type: string
    required: false
    default: "body"
    description: "CSS-Selektor zur Angabe des Extraktionsbereichs"

outputs:
  - name: text
    type: string
    description: "Extrahierter Reintextinhalt"
  - name: wordCount
    type: number
    description: "Wortanzahlstatistik"

tags:
  - browser
  - scraping
  - text-extraction

minOpenClawVersion: "2.1.0"
---

## Skill-Beschreibung

Dieser Skill dient zum Extrahieren von Textinhalten von angegebenen Webseiten und
eignet sich fuer Szenarien, in denen schnell Webseiteninformationen abgerufen,
Inhaltsanalysen durchgefuehrt oder Datenpipelines aufgebaut werden muessen.

## Verwendungsbeispiel

Bitte extrahieren Sie den Haupttext von https://example.com und zaehlen Sie die Woerter.

## Hinweise

- Seiten mit erforderlicher Anmeldung werden nicht unterstuetzt
- Durch JavaScript dynamisch gerenderte Inhalte koennen moeglicherweise nicht vollstaendig extrahiert werden
- Bitte beachten Sie die robots.txt-Richtlinien der Zielwebseite

2.2 Detaillierte Beschreibung der Pflichtfelder

name: Der eindeutige Identifikationsname des Skills im kebab-case-Format (z.B. blog-watcher). Innerhalb einer OpenClaw-Instanz darf der Name nicht doppelt vorkommen. Bei der Veroeffentlichung im Store wird dem Namen ein Autorpraefix vorangestellt, z.B. @username/blog-watcher.

version: Folgt der Semantic-Versioning-Spezifikation im Format MAJOR.MINOR.PATCH. Eine Aenderung der Hauptversionsnummer bedeutet eine Breaking-API-Aenderung, die Nebenversionsnummer zeigt neue Funktionen an und die Patchnummer steht fuer Fehlerbehebungen.

capabilities: Dies ist das wichtigste Feld in skill.md und bestimmt direkt, ob der OpenClaw-Agent diesen Skill zum richtigen Zeitpunkt aufrufen kann. Jede Capability benoetigt eine id (maschinenlesbare Kennung) und eine description (natuerlichsprachliche Beschreibung, die fuer die KI-Schlussfolgerung verwendet wird). Die Beschreibung sollte moeglichst spezifisch sein -- vermeiden Sie vage Begriffe wie „verarbeiten" oder „verwalten" und verwenden Sie stattdessen eine Verb-Objekt-Struktur wie „Slack-Nachricht an angegebenen Kanal senden".

permissions: Deklariert die Systemressourcen-Zugriffsberechtigungen, die der Skill zur Ausfuehrung benoetigt. OpenClaw wendet das Prinzip der minimalen Berechtigung an -- nur hier deklarierte Berechtigungen koennen bei der Ausfuehrung genutzt werden. Die wichtigsten Berechtigungstypen umfassen:

2.3 Ein-/Ausgabe-Spezifikation

Das inputs-Feld definiert die vom Skill akzeptierten Parameter, wobei jeder Parameter Folgendes umfasst: name (Parametername), type (Datentyp: string, number, boolean, array, object), required (ob erforderlich), default (Standardwert) und description (Beschreibung). Klare Input-Definitionen ermoeglichen es dem Agenten, Parameter automatisch aus dem Gespraech zu extrahieren und die Haeufigkeit zu reduzieren, mit der Benutzer Parameter explizit angeben muessen.

Das outputs-Feld beschreibt die vom Skill zurueckgegebene Datenstruktur und hilft dem Agenten bei der Planung mehrstufiger Aufgaben, die Ausgabe dieses Skills korrekt an den naechsten Schritt weiterzuleiten.

2.4 Versionskompatibilitaetsverwaltung

Das Feld minOpenClawVersion gibt die minimal erforderliche OpenClaw-Version fuer den Skill an. Dies ist besonders wichtig fuer Skills, die neuere API-Funktionen verwenden. Wenn die OpenClaw-Version des Benutzers die Anforderung nicht erfuellt, zeigt das System vor der Installation eine Warnung an, anstatt den Skill zur Laufzeit stillschweigend scheitern zu lassen.

3. Einen ersten benutzerdefinierten Skill von Grund auf erstellen

3.1 Umgebungsvorbereitung

Stellen Sie vor Beginn der Entwicklung sicher, dass in Ihrer Umgebung OpenClaw 2.1.0 oder hoeher sowie Node.js 20.0.0 oder hoeher installiert sind. OpenClaw bietet offizielle CLI-Tools zur Unterstuetzung der Skill-Entwicklung:[9]

# OpenClaw CLI installieren (falls noch nicht installiert)
npm install -g @openclaw/cli

# Version ueberpruefen
openclaw --version

# Installierte Skills anzeigen
openclaw skills list

3.2 Skill-Verzeichnis erstellen

In diesem Tutorial erstellen wir einen „Taegliche Wetterzusammenfassung"-Skill (daily-weather), der basierend auf einer vom Benutzer angegebenen Stadt die Wetterinformationen des aktuellen Tages abruft und eine kurze Zusammenfassung erstellt.

# Skill-Verzeichnisstruktur manuell erstellen
mkdir daily-weather && cd daily-weather

# Folgende Struktur erstellen:
# daily-weather/
# ├── skill.md
# ├── index.js
# ├── package.json
# └── tests/
#     └── skill.test.js

3.3 skill.md verfassen

Oeffnen Sie die automatisch generierte skill.md und tragen Sie die vollstaendige Skill-Spezifikation ein:

---
name: daily-weather
version: 1.0.0
description: "Wetterinformationen einer angegebenen Stadt fuer den aktuellen Tag abrufen und einen menschenlesbaren Wetterzusammenfassungsbericht erstellen"
author: your-username
license: MIT

capabilities:
  - id: get-weather-summary
    description: "Aktuelle Wetterbedingungen einer angegebenen Stadt abrufen, einschliesslich Temperatur, Luftfeuchtigkeit, Regenwahrscheinlichkeit und Windgeschwindigkeit"
  - id: format-weather-report
    description: "Wetterdaten in eine natuerlichsprachliche Zusammenfassung formatieren, geeignet fuer die direkte Wiedergabe im Gespraech"

permissions:
  network: true
  filesystem: false
  shell: false
  env:
    - OPENWEATHER_API_KEY

inputs:
  - name: city
    type: string
    required: true
    description: "Stadtname, unterstuetzt Deutsch oder Englisch, z.B. 'Berlin' oder 'Munich'"
  - name: language
    type: string
    required: false
    default: "de"
    description: "Sprachcode fuer die Zusammenfassung, Standard ist Deutsch"
  - name: units
    type: string
    required: false
    default: "metric"
    description: "Temperatureinheit, metric (Celsius) oder imperial (Fahrenheit)"

outputs:
  - name: summary
    type: string
    description: "Wetterzusammenfassungstext, geeignet fuer die direkte Darstellung im Gespraech"
  - name: rawData
    type: object
    description: "Rohdaten der Wetter-API-Antwort"
  - name: city
    type: string
    description: "Von der API bestaetigter standardisierter Stadtname"

tags:
  - weather
  - data-fetching
  - productivity

minOpenClawVersion: "2.1.0"
---

## Skill-Beschreibung

Der daily-weather Skill kann Wetterinformationen globaler Grossstaedte in Echtzeit
abrufen und technische Wetterdaten in natuerlichsprachliche Zusammenfassungen
umwandeln, die bequem direkt in der OpenClaw-Dialogoberflaeche gelesen werden koennen.

## Verwendungsbeispiele

- „Wie ist das Wetter heute in Berlin?"
- „Pruefe das Wetter in Tokio heute, antworte auf Englisch"
- „Wie viel Grad hat es gerade in Singapur? Wie hoch ist die Luftfeuchtigkeit?"

## Voraussetzungen

Die Umgebungsvariable `OPENWEATHER_API_KEY` muss gesetzt werden.
Einen kostenlosen API-Schluessel koennen Sie unter https://openweathermap.org/api beantragen.

## Hinweise

- Wetterdaten werden alle 10 Minuten aktualisiert
- Im kostenlosen Tarif sind maximal 60 API-Aufrufe pro Minute moeglich
- Fuer einige abgelegene Staedte sind moeglicherweise keine genauen Daten verfuegbar

3.4 Skill-Logik implementieren

Implementieren Sie anschliessend die Kernlogik in index.js. Das Hauptprogramm von OpenClaw Skills muss eine standardisierte asynchrone Ausfuehrungsfunktion exportieren:

// index.js
import { SkillContext } from '@openclaw/skill-sdk';

/**
 * @param {Object} inputs - Eingabeparameter gemaess skill.md-Definition
 * @param {SkillContext} context - Von OpenClaw bereitgestellter Ausfuehrungskontext
 * @returns {Promise<Object>} Rueckgabeobjekt gemaess skill.md outputs-Definition
 */
export async function execute(inputs, context) {
const { city, language = 'de', units = 'metric' } = inputs;

// API-Schluessel aus sicherer Umgebungsvariable lesen
// Hinweis: Geben Sie niemals den apiKey-Wert in Logs aus
const apiKey = context.env.get('OPENWEATHER_API_KEY');

if (!apiKey) {
throw new Error(
'Erforderliche Umgebungsvariable OPENWEATHER_API_KEY fehlt. ' +
'Bitte fuegen Sie diese Umgebungsvariable in den OpenClaw-Einstellungen hinzu.'
);
}

context.log.info(`Wetterabfrage fuer Stadt: ${city}`);

const url = new URL('https://api.openweathermap.org/data/2.5/weather');
url.searchParams.set('q', city);
url.searchParams.set('appid', apiKey);
url.searchParams.set('units', units);
url.searchParams.set('lang', language === 'de' ? 'de' : 'en');

const response = await context.fetch(url.toString());

if (!response.ok) {
if (response.status === 404) {
throw new Error(`Keine Wetterdaten fuer die Stadt "${city}" gefunden. Bitte ueberpruefen Sie den Stadtnamen.`);
}
throw new Error(`Wetter-API-Anfrage fehlgeschlagen, Statuscode: ${response.status}`);
}

const data = await response.json();

const tempUnit = units === 'metric' ? '°C' : '°F';
const summary = formatWeatherSummary(data, tempUnit, language);

return {
summary,
rawData: data,
city: data.name,
};
}

function formatWeatherSummary(data, tempUnit, language) {
const temp = Math.round(data.main.temp);
const feelsLike = Math.round(data.main.feels_like);
const humidity = data.main.humidity;
const description = data.weather[0].description;
const windSpeed = data.wind.speed;

if (language === 'de') {
return (
`${data.name} Wetter heute: ${description}. ` +
`Temperatur ${temp}${tempUnit}, gefuehlte Temperatur ${feelsLike}${tempUnit}, ` +
`Luftfeuchtigkeit ${humidity}%, Windgeschwindigkeit ${windSpeed} m/s.`
);
}

return (
`${data.name} today: ${description}. ` +
`Temperature ${temp}${tempUnit}, feels like ${feelsLike}${tempUnit}, ` +
`humidity ${humidity}%, wind speed ${windSpeed} m/s.`
);
}

3.5 Lokales Testen

OpenClaw bietet eine Skill-Sandbox-Testumgebung, in der Entwickler das Skill-Verhalten validieren koennen, ohne den eigentlichen Agenten-Workflow zu beeintraechtigen:

# Unit-Tests ausfuehren
cd daily-weather && npm test

# Skill-Anforderungen ueberpruefen
openclaw skills check

Nachdem die Tests bestanden wurden, installieren Sie den Skill in der lokalen OpenClaw-Instanz fuer Integrationstests:

# Lokalen Skill ueber plugins install installieren
openclaw plugins install ./daily-weather

# In der OpenClaw-Dialogoberflaeche testen
# Eingabe: „Wie ist das Wetter heute in Berlin?"

4. Tiefgehende Analyse beliebter offizieller Skills

4.1 Browser-Automatisierungs-Skill

Browser-Automatisierungs-Skills sind die am haeufigsten heruntergeladene Kategorie im OpenClaw Skills Store. Der Kern-Skill @openclaw/browser basiert auf Playwright und bietet vollstaendige Headless-Browser-Steuerungsfaehigkeiten.[1]

Die in der skill.md deklarierten Haupt-Capabilities umfassen:

Bemerkenswert ist, dass der Browser-Skill standardmaessig nach jeder Aufgabe Cookies und Session-Daten loescht. Wenn Sie fuer mehrstufige Aufgaben eingeloggt bleiben muessen, uebergeben Sie den Parameter persistSession: true beim Aufruf und stellen Sie sicher, dass Sie die damit verbundenen Sicherheitsimplikationen verstehen.

4.2 BlogWatcher Skill

BlogWatcher (@openclaw/blog-watcher) ist einer der beliebtesten Ueberwachungs-Skills in der OpenClaw-Community. Er ist dafuer konzipiert, angegebene Websites oder RSS-Quellen periodisch auf neue Inhalte zu ueberwachen und bei neuen Artikeln Benachrichtigungen oder Folgeaktionen auszuloesen.

Die technische Besonderheit von BlogWatcher liegt in der Kombination zweier fortgeschrittener Muster: Scheduled Skill (zeitgesteuerte Ausfuehrung) und Event Emission (Ereignisausloesung). Die wichtigsten Abschnitte der skill.md lauten:

capabilities:
  - id: watch-blog
    description: "Angegebenen Blog oder RSS-Quelle ueberwachen und bei Veroeffentlichung neuer Artikel Benachrichtigung ausloesen"
  - id: list-watched-sources
    description: "Alle derzeit ueberwachten Quellen und deren letzten Pruefzeitpunkt auflisten"
  - id: unwatch-source
    description: "Ueberwachung einer angegebenen Quelle beenden"
  - id: get-latest-posts
    description: "Sofort die neueste Artikelliste einer angegebenen Quelle abrufen"

schedule:
  type: interval
  intervalMinutes: 30
  capability: check-for-updates

events:
  - id: new-post-detected
    description: "Wird ausgeloest, wenn bei einer ueberwachten Quelle ein neuer Artikel erscheint"
    payload:
      - name: sourceUrl
        type: string
      - name: postTitle
        type: string
      - name: postUrl
        type: string
      - name: publishedAt
        type: string

Typische Anwendungsfaelle fuer BlogWatcher umfassen: Wettbewerbsbeobachtung, Ueberwachung von Forschungs-Preprints, Benachrichtigungen ueber Updates technischer Blogs sowie automatische Zusammenfassung neuer Inhalte und Push-Benachrichtigung an Slack-Kanaele.

4.3 Supermemory Skill

Supermemory (@openclaw/supermemory) loest eine der grundlegendsten Einschraenkungen von KI-Agenten: die Begrenztheit des Kontextfensters. Es bietet OpenClaw ueber eine Vektordatenbank sitzungsuebergreifende Langzeitgedaechtnisfaehigkeiten, sodass der Agent sich an Praeferenzen des Benutzers, abgeschlossene Aufgaben und gelernte Informationen „erinnern" kann.[1]

Das Capabilities-Design von Supermemory ist aeusserst detailliert:

Auf der technischen Implementierungsebene verwendet Supermemory ein lokales Embedding-Modell (standardmaessig nomic-embed-text), um Erinnerungsinhalte zu vektorisieren. Die Speicherung erfolgt in SQLite mit Vektorindex im OpenClaw-Datenverzeichnis, wodurch sichergestellt wird, dass alle Erinnerungsdaten lokal bleiben und nicht an externe Dienste uebertragen werden.

4.4 Send Message Skills

Im OpenClaw Skills Store gibt es eine wichtige Skill-Unterkategorie: Send-Message-Skills. Diese Skills ermoeglichen es dem Agenten, im Namen des Benutzers plattformuebergreifend Benachrichtigungen und Nachrichten zu versenden. Zu den wichtigsten Skills gehoeren:

@openclaw/send-slack: Unterstuetzt das Senden von Nachrichten an Slack-Kanaele oder Direktnachrichten, mit der Moeglichkeit, strukturierte Inhalte im Block-Kit-Format anzuhaengen. Die Capability-Deklaration lautet „Slack-Nachricht an einen Kanal oder Benutzer im angegebenen Workspace senden".

@openclaw/send-email: Integriert SMTP oder die SendGrid-API und kann Reintext- oder HTML-formatierte E-Mails senden.

@openclaw/send-telegram: Sendet Nachrichten an Personen oder Gruppen ueber die Telegram Bot API.

@openclaw/send-discord: Unterstuetzt sowohl den Discord-Webhook- als auch den Bot-API-Sendemodus.

Alle Send-Message-Skills deklarieren in ihrer skill.md explizit requiresUserConfirmation: true, was bedeutet, dass der Agent vor dem tatsaechlichen Senden die Bestaetigung des Benutzers einholen muss, um versehentlichen Massenversand zu verhindern.

4.5 Shell Execution Skill

@openclaw/shell ist ein leistungsstarker, aber mit Vorsicht zu verwendender Systemausfuehrungs-Skill, der es dem Agenten ermoeglicht, Shell-Befehle in einer kontrollierten Umgebung auszufuehren. Da die Deklaration permissions.shell: true dieses Skills erhoehten Systemzugriff gewaehrt, zeigt OpenClaw bei der Installation dieses Skills eine zusaetzliche Sicherheitswarnung an und verlangt eine explizite Bestaetigung des Benutzers.[7]

Der Shell-Skill beschraenkt die ausfuehrbaren Befehlskategorien durch einen Whitelist-Mechanismus. Standardmaessig erlaubte Befehle umfassen: ls, cat, grep, find, git, npm, python3 und weitere gaengige Entwicklungstools, waehrend Hochrisikobefehle wie rm -rf, sudo und Netzwerkkonfigurationsbefehle in der Standardkonfiguration gesperrt sind.

5. Fortgeschrittene Skill-Entwicklungsmuster

5.1 Zustandsbehaftete Skills (Stateful Skills)

Die meisten Skills sind zustandslos: Jede Ausfuehrung ist unabhaengig und bewahrt keine Daten aus vorherigen Aufrufen. Bestimmte Szenarien erfordern jedoch, dass Skills ihren Zustand ueber mehrere Aufrufe hinweg beibehalten -- beispielsweise muss BlogWatcher den „zuletzt geprueften neuesten Artikel" aufzeichnen, um feststellen zu koennen, ob es Aktualisierungen gibt.

Das OpenClaw Skill SDK bietet die context.state-API fuer sichere Zustandspersistenz:

export async function execute(inputs, context) {
// Vorherig gespeicherten Zustand lesen
const prevState = await context.state.get('lastCheck') || {
lastPostId: null,
lastCheckedAt: null,
};

// Logik ausfuehren...
const latestPosts = await fetchLatestPosts(inputs.sourceUrl);
const newPosts = latestPosts.filter(
post => post.id !== prevState.lastPostId
);

// Zustand aktualisieren (automatisch in verschluesseltem Speicher persistiert)
await context.state.set('lastCheck', {
lastPostId: latestPosts[0]?.id,
lastCheckedAt: new Date().toISOString(),
});

return { newPosts };
}

Zustandsdaten werden im verschluesselten Datenverzeichnis von OpenClaw gespeichert, an den Skill-Namen gebunden und sitzungsuebergreifend persistent gehalten.

5.2 Skill-zu-Skill-Kommunikation (Skill-to-Skill Communication)

In fortgeschrittenen Anwendungsszenarien muss ein Skill moeglicherweise die Faehigkeiten eines anderen Skills aufrufen. OpenClaw bietet die context.skills.invoke-API fuer die Zusammenarbeit zwischen Skills:

export async function execute(inputs, context) {
// Browser-Skill zum Extrahieren der Seite verwenden
const pageContent = await context.skills.invoke(
'@openclaw/browser',
'extract-content',
{ url: inputs.targetUrl, selector: 'article' }
);

// Supermemory-Skill zum Speichern der extrahierten Informationen verwenden
await context.skills.invoke(
'@openclaw/supermemory',
'remember-fact',
{
content: pageContent.text,
tags: ['web-research', inputs.topic],
}
);

return { status: 'saved', contentLength: pageContent.text.length };
}

In der skill.md muessen Abhaengigkeitsbeziehungen deklariert werden, um sicherzustellen, dass Benutzer bei der Installation des Haupt-Skills darauf hingewiesen werden:

dependencies:
  skills:
    - name: "@openclaw/browser"
      minVersion: "3.0.0"
    - name: "@openclaw/supermemory"
      minVersion: "2.0.0"

5.3 Geplante Skills (Scheduled Skills)

Das von BlogWatcher repraesentierte Muster der zeitgesteuerten Ausfuehrung ermoeglicht es Skills, periodisch im Hintergrund zu laufen, ohne dass der Benutzer sie aktiv ausloesen muss. Die Zeitplaneinstellungen werden in der skill.md deklariert:

schedule:
  type: cron
  expression: "0 9 * * 1-5"  # Jeden Werktag um 9 Uhr morgens
  capability: generate-daily-report
  timezone: "Europe/Berlin"

Geplante Skills laufen im OpenClaw-Hintergrund-Daemon-Prozess. Selbst wenn der Benutzer kein Dialogfenster geoeffnet hat, wird der Skill zum angegebenen Zeitpunkt automatisch ausgefuehrt. Die Ausfuehrungsergebnisse werden in einer Benachrichtigungswarteschlange gespeichert und dem Benutzer beim naechsten Oeffnen von OpenClaw praesentiert.

5.4 Asynchrone Langzeit-Skills

Wenn ein Skill Aufgaben ausfuehren muss, die laenger als 30 Sekunden dauern, sollte der asynchrone Langzeit-Modus verwendet werden, um die Dialogoberflaeche nicht zu blockieren:

export async function execute(inputs, context) {
// Als Langzeitaufgabe markieren
context.setLongRunning(true);

// Erste Bestaetigung senden, damit der Benutzer weiss, dass die Aufgabe gestartet wurde
context.sendProgressUpdate('Verarbeitung gestartet, voraussichtlich 2-5 Minuten...');

// Langzeitaufgabe ausfuehren
const result = await processLargeDataset(inputs.dataPath, {
onProgress: (percent) => {
context.sendProgressUpdate(`Verarbeitungsfortschritt: ${percent}%`);
}
});

return { result, completedAt: new Date().toISOString() };
}

6. Veroeffentlichungsprozess im Skills Store

6.1 Vorbereitung vor der Veroeffentlichung

Vor der Einreichung eines Skills im Skills Store muessen Entwickler folgende Checkliste abarbeiten:[3]

6.2 Paketierung und Einreichung

Verwenden Sie die OpenClaw CLI, um den Skill zu paketieren und zur Pruefung einzureichen:

# Im Skill-Verzeichnis als Tarball paketieren
npm pack

# Dies erzeugt die Paketdatei daily-weather-1.0.0.tgz

# Sicherheitsaudit ausfuehren
openclaw security audit

# Ueber npm veroeffentlichen (erfordert verifiziertes npm-Konto)
npm publish --access public

openclaw security audit fuehrt einen lokalen Sicherheitsscan durch und prueft insbesondere: ob Konfigurationsdateiberechtigungen korrekt sind, ob bekannte Sicherheitsluecken vorhanden sind und ob package.json-Abhaengigkeiten bekannte Schwachstellen aufweisen.

6.3 Pruefungsprozess

Nach der Einreichung durchlaeuft der Skill den offiziellen OpenClaw-Pruefungsprozess, der in der Regel 3-7 Werktage dauert:

  1. Automatischer Scan (sofort): Sicherheitsluecken, Schadcode, Abhaengigkeits-Compliance
  2. Manuelle Pruefung (1-3 Tage): Genauigkeit der Skill-Funktionsbeschreibung, Bewertung der Benutzererfahrung
  3. Sandbox-Test (1-2 Tage): Tatsaechliche Ausfuehrung des Skills in isolierter Umgebung, Verifizierung, dass das Verhalten mit der Deklaration uebereinstimmt
  4. Freigabe oder Ruecksendung: Bei bestandener Pruefung wird der Skill im Store veroeffentlicht; bei Problemen wird er an den Entwickler mit detaillierter Erklaerung zurueckgesendet

6.4 Versionsaktualisierungsmechanismus

Versionsaktualisierungen veroeffentlichter Skills folgen diesen Regeln: Patchversionen (PATCH) erfordern keine erneute Pruefung und werden direkt veroeffentlicht; Nebenversionen (MINOR) koennen nach bestandenem automatischem Scan veroeffentlicht werden; Hauptversionen (MAJOR) beinhalten Breaking-API-Aenderungen und erfordern eine vollstaendige erneute Pruefung. Alte Versionen werden im Store als „veraltet" markiert, bleiben aber 90 Tage lang erhalten, damit Benutzer Zeit zur Migration haben.

# Patchversion veroeffentlichen
npm version patch
npm publish

# Hauptversion veroeffentlichen (Versionsnummer in skill.md synchron aktualisieren)
npm version major
npm publish

7. Sicherheitspruefung und Best Practices

7.1 Risiko der API-Schluessel-Preisgabe

Im Februar 2026 berichtete The Register ueber ein schwerwiegendes Sicherheitsproblem: Einige im Skills Store gelistete Community-Skills gaben API-Schluessel im Klartext in den Ausfuehrungsprotokollen aus, sodass jeder mit Zugriff auf die OpenClaw-Logdateien diese Schluessel leicht erhalten konnte.[4] Dieses Problem legte das verbreitete mangelnde Sicherheitsbewusstsein unter Skill-Entwicklern offen.

Der Sicherheitsforschungsbericht von CrowdStrike wies ferner darauf hin, dass einige boeswillige Skills sogar Umgebungsvariablenwerte in Log- oder Fehlermeldungen einbetteten, um API-Schluessel an von Angreifern kontrollierte Server weiterzuleiten.[7] Auch Ciscos Forschung betonte, dass die Abhaengigkeit persoenlicher KI-Agentensysteme von API-Schluesseln diese zu hochwertigen Angriffszielen macht.[10]

Im Folgenden finden Sie typische Anti-Patterns, die zu Datenlecks fuehren und die Entwickler vermeiden sollten:

// Gefaehrlich: Tun Sie dies niemals
export async function execute(inputs, context) {
const apiKey = context.env.get('MY_API_KEY');

// Fehler 1: Schluessel im Log ausgeben
context.log.info(`Verwende API-Schluessel: ${apiKey}`);

// Fehler 2: Schluessel in Fehlermeldung einschliessen
throw new Error(`API-Aufruf fehlgeschlagen, Schluessel ${apiKey} ungueltig`);

// Fehler 3: Schluessel im Rueckgabewert einschliessen
return { status: 'ok', usedKey: apiKey };
}

Der korrekte Umgang mit Schluesseln:

// Sicher: Korrekter Umgang mit API-Schluesseln
export async function execute(inputs, context) {
const apiKey = context.env.get('MY_API_KEY');

if (!apiKey) {
// Fehlermeldung sagt nur „fehlt", gibt keine Schluesselinformationen preis
throw new Error('Erforderliche Umgebungsvariable MY_API_KEY fehlt');
}

// Log zeichnet nur die ersten 4 Zeichen des Schluessels auf (zur Debug-Identifikation)
const keyPrefix = apiKey.substring(0, 4) + '****';
context.log.info(`Verwende API-Schluessel: ${keyPrefix}`);

// Bei tatsaechlicher Verwendung direkt uebergeben, nicht an sichtbarer Stelle speichern
const result = await callExternalAPI(inputs.data, apiKey);

// Rueckgabewert enthaelt niemals den Schluessel
return { status: 'ok', result };
}

7.2 Eingabevalidierung

Obwohl skill.md den Typ und die Pflichtanforderungen der Eingaben definiert, sollten sich Entwickler nicht auf die automatische Framework-Validierung verlassen, sondern in index.js eine aktive Eingabevalidierung implementieren, um Injection-Angriffe und unerwartetes Verhalten zu verhindern:

export async function execute(inputs, context) {
// URL-Format explizit validieren
let targetUrl;
try {
targetUrl = new URL(inputs.url);
} catch {
throw new Error('Ungueltiges URL-Format. Bitte geben Sie eine vollstaendige URL mit https:// an');
}

// Nur HTTPS zulassen
if (targetUrl.protocol !== 'https:') {
throw new Error('Aus Sicherheitsgruenden werden nur URLs mit HTTPS-Protokoll unterstuetzt');
}

// String-Laenge validieren, um uebergrosse Eingaben zu verhindern
if (inputs.query && inputs.query.length > 1000) {
throw new Error('Abfragestring zu lang, maximal 1000 Zeichen unterstuetzt');
}

// Ausfuehrung fortsetzen...
}

7.3 Verstaendnis der Sandbox-Einschraenkungen

Die Skill-Sandbox von OpenClaw ist keine vollstaendig isolierte Container-Umgebung, sondern eine weiche Isolierung basierend auf dem Node.js-Modulsystem. Das bedeutet, dass boeswillige Skills theoretisch immer noch auf einige Systemressourcen zugreifen koennen. Bei der Bewertung von Drittanbieter-Skills sollten Entwickler bevorzugt waehlen: Skills, die die offizielle Pruefung bestanden haben, Skills mit vollstaendigem Open-Source-Code, Skills mit aktiver Wartungshistorie auf GitHub sowie Skills mit ueber 1000 Installationen und positiven Bewertungen.[7]

7.4 Prinzip der minimalen Berechtigung

Skill-Entwickler sollten das Prinzip der minimalen Berechtigung strikt einhalten und nur Berechtigungen deklarieren, die der Skill tatsaechlich benoetigt:

8. Unternehmensinternes Skill-Management

8.1 Private Skill Registry

In Unternehmensumgebungen birgt es Sicherheits- und Compliance-Risiken, Mitarbeitern die Installation beliebiger Skills aus dem oeffentlichen Store zu gestatten. Es wird empfohlen, eine Private Skill Registry einzurichten. Als Backend kann eine private npm-Registry (wie Verdaccio oder GitHub Packages) verwendet werden:[8]

# Private Registry in der Unternehmens-OpenClaw-Konfiguration angeben
# openclaw.config.json
{
"skillRegistry": {
"primary": "https://skills.internal.company.com",
"fallback": null,
"allowPublicMarketplace": false
},
"skillApproval": {
"required": true,
"approvers": ["[email protected]"]
}
}

Wenn allowPublicMarketplace auf false gesetzt ist, muessen alle Skill-Installationsanfragen auf die private Registry verweisen, wodurch effektiv verhindert wird, dass Mitarbeiter ungeprueftete oeffentliche Skills installieren.

8.2 Genehmigungsworkflow fuer Unternehmens-Skills

Etablieren Sie einen standardisierten Skill-Genehmigungsprozess, um sicherzustellen, dass jeder Skill, der in die Unternehmensumgebung gelangt, einer Sicherheitsbewertung unterzogen wird:

  1. Antragsphase: Mitarbeiter reichen einen Skill-Installationsantrag ein, der den geschaeftlichen Bedarf und die Skill-Quelle erlaeutert
  2. Sicherheitsscan: Automatische Ausfuehrung von openclaw skills audit und Erstellung eines Scan-Berichts
  3. Code-Review: Das Sicherheitsteam prueft die skill.md und index.js des Skills, mit Schwerpunkt auf Berechtigungsdeklarationen und externen Aufrufen
  4. Sandbox-Test: Tatsaechliche Ausfuehrung des Skills in einer isolierten Testumgebung zur Bestaetigung, dass das Verhalten der Beschreibung entspricht
  5. Veroeffentlichung in der privaten Registry: Nach bestandener Pruefung wird die Skill-Version gesperrt und in der privaten Unternehmens-Registry veroeffentlicht
  6. Regelmaessige Nachpruefung: Vierteljährliche routinemaessige Sicherheitsnachpruefung aller genehmigten Skills

8.3 Versionskontrolle und Abhaengigkeitsverwaltung

In Unternehmens-Produktionsumgebungen sollten Skill-Versionen gesperrt werden, um zu verhindern, dass Upstream-Aktualisierungen unerwartetes Verhalten einfuehren:

# Konfiguration fuer Unternehmens-Skill-Sperren
# skills.lock.json (sollte in die Versionskontrolle aufgenommen werden)
{
"@openclaw/browser": {
"version": "3.2.1",
"integrity": "sha512-abc123...",
"approvedAt": "2026-01-15",
"approvedBy": "security-team"
},
"@company/internal-crm-skill": {
"version": "2.0.0",
"integrity": "sha512-def456...",
"approvedAt": "2026-02-01",
"approvedBy": "it-team"
}
}

8.4 Interne Skill-Entwicklungsrichtlinien

Fuer intern entwickelte benutzerdefinierte Skills wird empfohlen, folgende Entwicklungsrichtlinien festzulegen:

9. Haeufige Entwicklungsprobleme und Fehlerbehebung

9.1 Skill wird vom Agenten nicht korrekt aufgerufen

Eines der haeufigsten Probleme ist, dass Entwickler nach der Fertigstellung der Skill-Implementierung feststellen, dass der Agent den Skill bei relevanten Aufgaben nicht automatisch aufruft. Die Hauptursache liegt in der Regel darin, dass die capabilities.description in der skill.md nicht spezifisch genug ist oder zu stark von der tatsaechlichen Ausdrucksweise der Benutzer abweicht.

Fehlerbehebungsmethode:

# Skill-Bereitschaftsstatus anzeigen
openclaw skills check

# Detaillierte Informationen zu einem bestimmten Skill anzeigen
openclaw skills info daily-weather

Wenn der Matching-Score niedrig ist (unter 0,6), versuchen Sie, die Capability-Beschreibung zu aendern: Verwenden Sie Formulierungen, die naeher an der natuerlichen Sprache der Benutzer sind, und fuegen Sie konkrete Verben („abfragen", „abrufen", „extrahieren") und Objekte („Wetterinformationen", „Temperaturdaten") hinzu.

9.2 Umgebungsvariable kann nicht gelesen werden

Der Skill hat in der skill.md unter permissions.env eine Umgebungsvariable deklariert, aber context.env.get() gibt zur Laufzeit undefined zurueck. Haeufige Ursachen:

# Skill-Anforderungsstatus pruefen
openclaw skills check

# Detaillierte Informationen und Anforderungen eines bestimmten Skills anzeigen
openclaw skills info daily-weather

9.3 Netzwerkanfragen werden blockiert

Der Skill hat network: true deklariert, aber die gesendeten Netzwerkanfragen werden von OpenClaw abgefangen. Moegliche Ursachen:

# context.fetch im Skill korrekt verwenden (nicht globales fetch)
// Falsch: Globales fetch direkt verwenden, koennte Sicherheitspruefungen umgehen
const response = await fetch(url);

// Richtig: context.fetch verwenden, stellt sicher, dass Sicherheitsabfangung wirksam ist
const response = await context.fetch(url);

9.4 Skill-Ausfuehrungstimeout

Der Standard-Ausfuehrungstimeout fuer OpenClaw Skills betraegt 30 Sekunden. Wenn ein Skill mehr Zeit benoetigt, sollte dies in der skill.md explizit deklariert werden:

execution:
  timeout: 120        # Sekunden, maximal 600 erlaubt
  longRunning: true   # Als Langzeitaufgabe markieren, aktiviert Fortschrittsberichtsmechanismus

9.5 Beschaedigter Skill-Zustand

Zustandsbehaftete Skills koennen nach abnormaler Beendigung inkonsistente Zustandsdaten hinterlassen, die zu Fehlern bei nachfolgenden Ausfuehrungen fuehren. Es wird empfohlen, defensives Zustandslesen zu implementieren:

export async function execute(inputs, context) {
let state;
try {
state = await context.state.get('myState');
// Zustandsdatenstruktur auf Integritaet pruefen
if (!state || typeof state.lastId !== 'string') {
context.log.warn('Zustandsdatenformat fehlerhaft, wird auf Initialwert zurueckgesetzt');
state = getInitialState();
}
} catch (error) {
context.log.error('Zustand konnte nicht gelesen werden, wird auf Initialwert zurueckgesetzt', error.message);
state = getInitialState();
}

// Ausfuehrung fortsetzen...
}

function getInitialState() {
return { lastId: null, lastCheckedAt: null };
}

9.6 Performance-Analyse

Wenn ein Skill zu langsam ausgefuehrt wird, verwenden Sie die Performance-Analyse-Tools von OpenClaw, um Engpaesse zu identifizieren:

# Gateway-Logs zur Verfolgung der Skill-Ausfuehrung anzeigen
openclaw logs --follow

Haeufige Performance-Probleme umfassen: Sequenzielle API-Anfragen in Schleifen (sollten auf parallele Ausfuehrung mit Promise.all umgestellt werden), fehlende Zwischenspeicherung wiederholter externer Anfragen sowie zu haeufiges Lesen und Schreiben des Zustands (sollte als Batch-Aktualisierung erfolgen).

Fazit: Ein vertrauenswuerdiges Skills-Oekosystem aufbauen

Das OpenClaw Skills System repraesentiert ein neues Paradigma fuer die Erweiterung von KI-Agenten-Faehigkeiten: Die deklarative skill.md-Spezifikation ersetzt herkoemmliche Plugin-APIs und macht die Faehigkeitsgrenzen von Skills sowohl fuer Menschen als auch fuer Maschinen klar lesbar. Dieses Design senkt nicht nur die Entwicklungsschwelle, sondern bietet auch einen klaren Ansatzpunkt fuer Sicherheitspruefungen.[1]

Dennoch erinnert uns der von The Register aufgedeckte Vorfall der API-Schluessel-Preisgabe daran, dass die guten Absichten des technischen Designs durch strenge Sicherheitsschulung fuer Entwickler und Store-Pruefungsmechanismen unterstuetzt werden muessen.[4] Ob Einzelentwickler oder Unternehmens-Engineering-Teams -- alle sollten Sicherheit als oberste Prioritaet bei der Skill-Entwicklung betrachten und nicht als nachtraegliche Massnahme.

Mit der fortlaufenden Erweiterung des OpenClaw Skills Store, der zunehmenden Reife von Kern-Skills wie BlogWatcher und Supermemory sowie dem schrittweisen Aufbau unternehmenseigener privater Skill-Oekosysteme beobachten wir die Entstehung eines Marktes fuer Agenten-Faehigkeiten mit Skills als atomarer Einheit. Das Verstaendnis und die Beherrschung dieses Skill-Entwicklungsparadigmas wird 2026 zu den Kernkompetenzen von KI-Agent-Ingenieuren gehoeren.