Lobster

Lobster ist eine Workflow-Shell, die OpenClaw mehrstufige Tool-Sequenzen als einzelne, deterministische Operation mit expliziten Genehmigungs-Checkpoints ausführen lässt.

Aufhänger

Dein Assistent kann die Tools bauen, die ihn selbst verwalten. Frag nach einem Workflow, und 30 Minuten später hast du ein CLI plus Pipelines, die als ein einziger Aufruf laufen. Lobster ist das fehlende Puzzlestück: deterministische Pipelines, explizite Genehmigungen und fortsetzbarer State.

Warum

Heute erfordern komplexe Workflows viele Hin-und-Her-Tool-Calls. Jeder Call kostet Tokens, und das LLM muss jeden Schritt orchestrieren. Lobster verlagert diese Orchestrierung in eine typisierte Runtime:

Ein Call statt vieler: OpenClaw macht einen Lobster-Tool-Call und bekommt ein strukturiertes Ergebnis.
Eingebaute Genehmigungen: Seiteneffekte (E-Mail senden, Kommentar posten) halten den Workflow an, bis sie explizit genehmigt werden.
Fortsetzbar: Angehaltene Workflows geben ein Token zurück; genehmigen und fortsetzen, ohne alles neu auszuführen.

Warum eine DSL statt einfacher Programme?

Lobster ist bewusst klein. Das Ziel ist nicht “eine neue Sprache”, sondern eine vorhersagbare, KI-freundliche Pipeline-Spezifikation mit erstklassigen Genehmigungen und Resume-Tokens.

Approve/Resume eingebaut: Ein normales Programm kann einen Menschen befragen, aber es kann nicht pausieren und mit einem dauerhaften Token fortsetzen, ohne dass du diese Runtime selbst erfindest.
Determinismus + Nachvollziehbarkeit: Pipelines sind Daten, also leicht zu loggen, diffen, wiedergeben und reviewen.
Eingeschränkte Oberfläche für KI: Eine winzige Grammatik + JSON-Piping reduziert “kreative” Codepfade und macht Validierung realistisch.
Eingebaute Sicherheitsrichtlinie: Timeouts, Ausgabe-Caps, Sandbox-Checks und Allowlists werden von der Runtime durchgesetzt, nicht von jedem Skript.
Trotzdem programmierbar: Jeder Schritt kann jedes CLI oder Skript aufrufen. Wenn du JS/TS willst, generiere .lobster-Dateien aus Code.

Wie es funktioniert

OpenClaw startet das lokale lobster-CLI im Tool-Modus und parst einen JSON-Umschlag aus stdout. Wenn die Pipeline zur Genehmigung pausiert, gibt das Tool ein resumeToken zurück, damit du später fortfahren kannst.

Muster: kleines CLI + JSON-Pipes + Genehmigungen

Baue kleine Befehle, die JSON sprechen, und verkette sie in einen einzelnen Lobster-Aufruf. (Beispiel-Befehlsnamen unten — ersetze sie durch deine eigenen.)

inbox list --json
inbox categorize --json
inbox apply --json

{
  "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 Genehmigung anfordert, fahre mit dem Token fort:

{
  "action": "resume",
  "token": "<resumeToken>",
  "approve": true
}

Die KI löst den Workflow aus; Lobster führt die Schritte aus. Genehmigungs-Gates halten Seiteneffekte explizit und nachvollziehbar.

Beispiel: Eingabeelemente in Tool-Calls abbilden:

gog.gmail.search --query 'newer_than:1d' \
  | openclaw.invoke --tool message --action send --each --item-key message --args-json '{"provider":"telegram","to":"..."}'

JSON-only LLM-Schritte (llm-task)

Für Workflows, die einen strukturierten LLM-Schritt brauchen, aktiviere das optionale llm-task-Plugin-Tool und rufe es von Lobster aus auf. So bleibt der Workflow deterministisch, während du trotzdem mit einem Modell klassifizieren/zusammenfassen/entwerfen kannst.

Tool aktivieren:

{
  "plugins": {
    "entries": {
      "llm-task": { "enabled": true }
    }
  },
  "agents": {
    "list": [
      {
        "id": "main",
        "tools": { "allow": ["llm-task"] }
      }
    ]
  }
}

In einer Pipeline verwenden:

openclaw.invoke --tool llm-task --action json --args-json '{
  "prompt": "Given the input email, return intent and draft.",
  "thinking": "low",
  "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 für Details und Konfigurationsoptionen.

Workflow-Dateien (.lobster)

Lobster kann YAML/JSON-Workflow-Dateien mit name, args, steps, env, condition und approval-Feldern ausführen. Setze in OpenClaw-Tool-Calls pipeline auf den Dateipfad.

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 an $step.approved knüpfen.

Lobster installieren

Installiere das Lobster-CLI auf dem gleichen Host, auf dem das OpenClaw Gateway läuft (siehe das Lobster-Repo), und stelle sicher, dass lobster im PATH ist.

Tool aktivieren

Lobster ist ein optionales Plugin-Tool (standardmäßig nicht aktiviert).

Beispiel: E-Mail-Triage

Ohne Lobster:

User: "Check my email and draft replies"
→ openclaw calls gmail.list
→ LLM summarizes
→ User: "draft replies to #2 and #5"
→ LLM drafts
→ User: "send #2"
→ openclaw calls gmail.send
(repeat daily, no memory of what was triaged)

Mit Lobster:

{
  "action": "run",
  "pipeline": "email.triage --limit 20",
  "timeoutMs": 30000
}

Gibt einen JSON-Umschlag zurück (gekürzt):

{
  "ok": true,
  "status": "needs_approval",
  "output": [{ "summary": "5 need replies, 2 need action" }],
  "requiresApproval": {
    "type": "approval_request",
    "prompt": "Send 2 draft replies?",
    "items": [],
    "resumeToken": "..."
  }
}

Benutzer genehmigt → fortsetzen:

{
  "action": "resume",
  "token": "<resumeToken>",
  "approve": true
}

Ein Workflow. Deterministisch. Sicher.

Tool-Parameter

`run`

Eine Pipeline im Tool-Modus ausführen.

{
  "action": "run",
  "pipeline": "gog.gmail.search --query 'newer_than:1d' | email.triage",
  "cwd": "workspace",
  "timeoutMs": 30000,
  "maxStdoutBytes": 512000
}

Eine Workflow-Datei mit Argumenten ausführen:

{
  "action": "run",
  "pipeline": "/path/to/inbox-triage.lobster",
  "argsJson": "{\"tag\":\"family\"}"
}

`resume`

Einen angehaltenen Workflow nach Genehmigung fortsetzen.

{
  "action": "resume",
  "token": "<resumeToken>",
  "approve": true
}

Optionale Eingaben

cwd: Relatives Arbeitsverzeichnis für die Pipeline (muss innerhalb des aktuellen Prozess-Arbeitsverzeichnisses bleiben).
timeoutMs: Unterprozess beenden, wenn diese Dauer überschritten wird (Standard: 20000).
maxStdoutBytes: Unterprozess beenden, wenn stdout diese Größe überschreitet (Standard: 512000).
argsJson: JSON-String, der an lobster run --args-json übergeben wird (nur Workflow-Dateien).

Ausgabe-Umschlag

Lobster gibt einen JSON-Umschlag mit einem von drei Status zurück:

ok → erfolgreich abgeschlossen
needs_approval → pausiert; requiresApproval.resumeToken wird zum Fortsetzen benötigt
cancelled → explizit abgelehnt oder abgebrochen

Das Tool zeigt den Umschlag sowohl in content (formatiertes JSON) als auch in details (Roh-Objekt).

Genehmigungen

Wenn requiresApproval vorhanden ist, prüfe den Prompt und entscheide:

approve: true → fortsetzen und Seiteneffekte ausführen
approve: false → abbrechen und den Workflow finalisieren

Verwende approve --preview-from-stdin --limit N, um eine JSON-Vorschau an Genehmigungs-Anfragen anzuhängen, ohne eigenen jq/Heredoc-Klebstoff. Resume-Tokens sind jetzt kompakt: Lobster speichert den Workflow-Resume-State unter seinem State-Verzeichnis und gibt einen kleinen Token-Key zurück.

OpenProse

OpenProse passt gut zu Lobster: Verwende /prose, um Multi-Agent-Vorbereitung zu orchestrieren, und führe dann eine Lobster-Pipeline für deterministische Genehmigungen aus. Wenn ein Prose-Programm Lobster braucht, erlaube das lobster-Tool für Sub-Agents über tools.subagents.tools. Siehe OpenProse.

Sicherheit

Nur lokaler Unterprozess — keine Netzwerk-Aufrufe vom Plugin selbst.
Keine Secrets — Lobster verwaltet kein OAuth; es ruft OpenClaw-Tools auf, die das tun.
Sandbox-bewusst — deaktiviert, wenn der Tool-Kontext gesandboxt ist.
Gehärtet — fester ausführbarer Name (lobster) im PATH; Timeouts und Ausgabe-Caps werden durchgesetzt.

Fehlerbehebung

lobster subprocess timed out → erhöhe timeoutMs oder teile eine lange Pipeline auf.
lobster output exceeded maxStdoutBytes → erhöhe maxStdoutBytes oder reduziere die Ausgabegröße.
lobster returned invalid JSON → stelle sicher, dass die Pipeline im Tool-Modus läuft und nur JSON ausgibt.
lobster failed (code …) → führe die gleiche Pipeline in einem Terminal aus, um stderr zu inspizieren.

Mehr erfahren

Fallstudie: Community-Workflows

Ein öffentliches Beispiel: Ein “Second Brain”-CLI + Lobster-Pipelines, die drei Markdown-Vaults verwalten (persönlich, Partner, gemeinsam). Das CLI gibt JSON für Statistiken, Inbox-Listen und Stale-Scans aus; Lobster verkettet diese Befehle in Workflows wie weekly-review, inbox-triage, memory-consolidation und shared-task-sync, jeweils mit Genehmigungs-Gates. Die KI übernimmt das Urteil (Kategorisierung), wenn verfügbar, und fällt ansonsten auf deterministische Regeln zurück.