> ## Documentation Index
> Vollständigen Dokumentationsindex abrufen unter: /llms.txt
> Diese Datei nutzen, um alle verfügbaren Seiten zu entdecken, bevor du weiter suchst.
# Lobster
> Typisierte Workflow-Runtime für OpenClaw — kombinierbare Pipelines mit Freigabe-Gates.
# Lobster
Lobster ist eine Workflow-Shell, mit der OpenClaw mehrstufige Tool-Sequenzen als eine einzige, deterministische Operation mit expliziten Freigabe-Punkten ausführen kann.
## Hook
Dein Assistent kann die Tools bauen, die ihn selbst verwalten. Einen Workflow anfragen, und 30 Minuten später hast du eine CLI plus Pipelines, die als ein Aufruf laufen. Lobster ist das fehlende Stück: deterministische Pipelines, explizite Freigaben und wiederaufnehmbarer State.
## Warum
Komplexe Workflows erfordern heute viele Hin-und-her-Tool-Aufrufe. Jeder Aufruf kostet Tokens, und das LLM muss jeden Schritt orchestrieren. Lobster verlagert diese Orchestrierung in eine typisierte Runtime:
* **Ein Aufruf statt vieler**: OpenClaw führt einen Lobster-Tool-Aufruf aus und erhält ein strukturiertes Ergebnis.
* **Freigaben eingebaut**: Nebenwirkungen (E-Mail senden, Kommentar posten) halten den Workflow an, bis explizit freigegeben.
* **Wiederaufnehmbar**: Angehaltene Workflows liefern einen Token; freigeben und fortsetzen ohne alles neu auszuführen.
## Warum eine DSL statt normaler Programme?
Lobster ist bewusst klein. Das Ziel ist nicht „eine neue Sprache“, sondern eine vorhersehbare, KI-freundliche Pipeline-Spec mit Freigaben und Resume-Tokens erster Klasse.
* **Approve/Resume eingebaut**: Ein normales Programm kann einen Menschen abfragen, kann aber nicht *pausieren und mit dauerhaftem Token fortsetzen*, ohne dass du diese Runtime selbst erfindest.
* **Determinismus + Nachvollziehbarkeit**: Pipelines sind Daten, also leicht zu loggen, diffen, replayen und prüfen.
* **Begrenzte Fläche für KI**: Kleine Grammatik + JSON-Piping reduziert „kreative“ Codepfade und macht Validierung realistisch.
* **Sicherheitsrichtlinie eingebaut**: Timeouts, Output-Caps, Sandbox-Checks und Allowlists werden von der Runtime durchgesetzt, nicht von jedem Skript.
* **Trotzdem programmierbar**: Jeder Schritt kann jede CLI oder jedes Skript aufrufen. Für JS/TS: `.lobster`-Dateien aus Code erzeugen.
## So funktioniert es
OpenClaw startet die lokale `lobster`-CLI im **Tool-Modus** und parst ein JSON-Envelope von stdout. Pausiert die Pipeline für eine Freigabe, gibt das Tool einen `resumeToken` zurück, damit du später fortfahren kannst.
## Muster: kleine CLI + JSON-Pipes + Freigaben
Kleine Befehle bauen, die JSON sprechen, dann in einen einzigen Lobster-Aufruf ketten. (Beispiel-Befehlsnamen unten — durch eigene ersetzen.)
```bash theme={null}
inbox list --json
inbox categorize --json
inbox apply --json
```
```json theme={null}
{
"action": "run",
"pipeline": "exec --json --shell 'inbox list --json' | exec --stdin json --shell 'inbox categorize --json' | exec --stdin json --shell 'inbox apply --json' | approve --preview-from-stdin --limit 5 --prompt 'Apply changes?'",
"timeoutMs": 30000
}
```
Wenn die Pipeline eine Freigabe anfordert, mit dem Token fortsetzen:
```json theme={null}
{
"action": "resume",
"token": "<resumeToken>",
"approve": true
}
```
Die KI löst den Workflow aus; Lobster führt die Schritte aus. Freigabe-Gates halten Nebenwirkungen explizit und nachvollziehbar.
Beispiel: Eingabe-Items in Tool-Aufrufe mappen:
```bash theme={null}
gog.gmail.search --query 'newer_than:1d' \
| clawd.invoke --tool message --action send --each --item-key message --args-json '{"provider":"telegram","to":"..."}'
```
## Nur-JSON-LLM-Schritte (llm-task)
Für Workflows mit einem **strukturierten LLM-Schritt** das optionale Plugin-Tool `llm-task` aktivieren und aus Lobster aufrufen. So bleibt der Workflow deterministisch, während du trotzdem mit einem Modell klassifizieren/zusammenfassen/entwerfen kannst.
Tool aktivieren:
```json theme={null}
{
"plugins": {
"entries": {
"llm-task": { "enabled": true }
}
},
"agents": {
"list": [\
{\
"id": "main",\
"tools": { "allow": ["llm-task"] }\
}\
]
}
}
```
In einer Pipeline nutzen:
```lobster theme={null}
clawd.invoke --tool llm-task --action json --args-json '{
"prompt": "Given the input email, return intent and draft.",
"input": { "subject": "Hello", "body": "Can you help?" },
"schema": {
"type": "object",
"properties": {
"intent": { "type": "string" },
"draft": { "type": "string" }
},
"required": ["intent", "draft"],
"additionalProperties": false
}
}'
```
Siehe [LLM Task](/de/tools/llm-task) für Details und Konfigurationsoptionen.
## Workflow-Dateien (.lobster)
Lobster kann YAML/JSON-Workflow-Dateien mit Feldern `name`, `args`, `steps`, `env`, `condition` und `approval` ausführen. In OpenClaw-Tool-Aufrufen `pipeline` auf den Dateipfad setzen.
```yaml theme={null}
name: inbox-triage
args:
tag:
default: "family"
steps:
- id: collect
command: inbox list --json
- id: categorize
command: inbox categorize --json
stdin: $collect.stdout
- id: approve
command: inbox apply --approve
stdin: $categorize.stdout
approval: required
- id: execute
command: inbox apply --execute
stdin: $categorize.stdout
condition: $approve.approved
```
Hinweise:
* `stdin: $step.stdout` und `stdin: $step.json` übergeben die Ausgabe eines vorherigen Schritts.
* `condition` (oder `when`) kann Schritte von `$step.approved` abhängig machen.
## Lobster installieren
Lobster-CLI auf dem **gleichen Host** installieren, auf dem das OpenClaw-Gateway läuft (siehe [Lobster-Repo](https://github.com/openclaw/lobster)), und sicherstellen, dass `lobster` im `PATH` ist. Für eine eigene Binary-Position einen **absoluten** `lobsterPath` im Tool-Aufruf übergeben.
## Tool aktivieren
Lobster ist ein **optionales** Plugin-Tool (standardmäßig nicht aktiviert).
Empfohlen (additiv, sicher):
```json theme={null}
{
"tools": {
"alsoAllow": ["lobster"]
}
}
```
Oder pro Agent:
```json theme={null}
{
"agents": {
"list": [\
{\
"id": "main",\
"tools": {\
"alsoAllow": ["lobster"]\
}\
}\
]
}
}
```
`tools.allow: ["lobster"]` nur nutzen, wenn du im restriktiven Allowlist-Modus laufen willst.
Hinweis: Allowlists sind für optionale Plugins Opt-in. Benennt deine Allowlist nur Plugin-Tools (wie `lobster`), hält OpenClaw die Core-Tools aktiv. Um Core-Tools einzuschränken, die gewünschten Core-Tools oder -Gruppen ebenfalls in die Allowlist aufnehmen.
## Beispiel: E-Mail-Triage
Ohne Lobster:
```
User: "Check my email and draft replies"
→ clawd ruft gmail.list auf
→ LLM fasst zusammen
→ User: "draft replies to #2 and #5"
→ LLM entwirft
→ User: "send #2"
→ clawd ruft gmail.send auf
(täglich wiederholen, kein Gedächtnis der Triage)
```
Mit Lobster:
```json theme={null}
{
"action": "run",
"pipeline": "email.triage --limit 20",
"timeoutMs": 30000
}
```
Liefert ein JSON-Envelope (gekürzt):
```json theme={null}
{
"ok": true,
"status": "needs_approval",
"output": [{ "summary": "5 need replies, 2 need action" }],
"requiresApproval": {
"type": "approval_request",
"prompt": "Send 2 draft replies?",
"items": [],
"resumeToken": "..."
}
}
```
Nutzer gibt frei → resume:
```json theme={null}
{
"action": "resume",
"token": "<resumeToken>",
"approve": true
}
```
Ein Workflow. Deterministic. Safe.
## Tool-Parameter
### `run`
Pipeline im Tool-Modus ausführen.
```json theme={null}
{
"action": "run",
"pipeline": "gog.gmail.search --query 'newer_than:1d' | email.triage",
"cwd": "/path/to/workspace",
"timeoutMs": 30000,
"maxStdoutBytes": 512000
}
```
Workflow-Datei mit Args ausführen:
```json theme={null}
{
"action": "run",
"pipeline": "/path/to/inbox-triage.lobster",
"argsJson": "{\"tag\":\"family\"}"
}
```
### `resume`
Angehaltenen Workflow nach Freigabe fortsetzen.
```json theme={null}
{
"action": "resume",
"token": "<resumeToken>",
"approve": true
}
```
### Optionale Eingaben
* `lobsterPath`: Absoluter Pfad zur Lobster-Binary (weglassen für `PATH`).
* `cwd`: Arbeitsverzeichnis für die Pipeline (Standard: aktuelles Prozess-Arbeitsverzeichnis).
* `timeoutMs`: Subprocess beenden, wenn diese Dauer überschritten wird (Standard: 20000).
* `maxStdoutBytes`: Subprocess beenden, wenn stdout diese Größe überschreitet (Standard: 512000).
* `argsJson`: JSON-String für `lobster run --args-json` (nur Workflow-Dateien).
## Output-Envelope
Lobster liefert ein JSON-Envelope mit einem von drei Statuswerten:
* `ok` → erfolgreich beendet
* `needs_approval` → pausiert; `requiresApproval.resumeToken` wird zum Fortsetzen benötigt
* `cancelled` → explizit abgelehnt oder abgebrochen
Das Tool liefert das Envelope sowohl in `content` (pretty JSON) als auch in `details` (rohes Objekt).
## Freigaben
Wenn `requiresApproval` vorhanden ist, Prompt prüfen und entscheiden:
* `approve: true` → fortsetzen und Nebenwirkungen ausführen
* `approve: false` → abbrechen und Workflow abschließen
`approve --preview-from-stdin --limit N` nutzen, um einer Freigabe-Anfrage eine JSON-Vorschau anzuhängen, ohne eigenes jq/Heredoc. Resume-Tokens sind jetzt kompakt: Lobster speichert den Workflow-Resume-State unter seinem State-Dir und gibt einen kleinen Token-Key zurück.
## OpenProse
OpenProse passt gut zu Lobster: `/prose` für Multi-Agent-Vorbereitung nutzen, dann eine Lobster-Pipeline für deterministische Freigaben ausführen. Braucht ein Prose-Programm Lobster, das `lobster`-Tool für Subagenten über `tools.subagents.tools` erlauben. Siehe [OpenProse](/de/prose).
## Sicherheit
* **Nur lokaler Subprocess** — keine Netzwerkaufrufe vom Plugin selbst.
* **Keine Secrets** — Lobster verwaltet kein OAuth; es ruft clawd-Tools auf, die das tun.
* **Sandbox-aware** — deaktiviert, wenn der Tool-Kontext sandboxed ist.
* **Gehärtet** — `lobsterPath` muss bei Angabe absolut sein; Timeouts und Output-Caps werden durchgesetzt.
## Fehlerbehebung
* **`lobster subprocess timed out`** → `timeoutMs` erhöhen oder lange Pipeline aufteilen.
* **`lobster output exceeded maxStdoutBytes`** → `maxStdoutBytes` erhöhen oder Ausgabegröße reduzieren.
* **`lobster returned invalid JSON`** → sicherstellen, dass die Pipeline im Tool-Modus läuft und nur JSON ausgibt.
* **`lobster failed (code …)`** → dieselbe Pipeline im Terminal ausführen und stderr prüfen.
## Weiterführende Links
* [Plugins](/de/plugin)
* [Plugin-Tool-Autoren](/de/plugins/agent-tools)
## Fallstudie: Community-Workflows
Ein öffentliches Beispiel: eine „Second Brain“-CLI + Lobster-Pipelines, die drei Markdown-Vaults verwalten (persönlich, Partner, geteilt). Die CLI gibt JSON für Stats, Inbox-Listen und Stale-Scans aus; Lobster kettet diese Befehle in Workflows wie `weekly-review`, `inbox-triage`, `memory-consolidation` und `shared-task-sync`, jeweils mit Freigabe-Gates. Die KI übernimmt die Bewertung (Kategorisierung), wenn verfügbar, und fällt auf deterministische Regeln zurück, wenn nicht.
* Thread: [https://x.com/plattenschieber/status/2014508656335770033](https://x.com/plattenschieber/status/2014508656335770033)
* Repo: [https://github.com/bloomedai/brain-cli](https://github.com/bloomedai/brain-cli)Zuletzt aktualisiert am: