Lobster

Lobster ist eine Workflow-Shell, mit der OpenClaw mehrstufige Tool-Sequenzen als einzelne, deterministische Operation mit expliziten Freigabe-Checkpoints ausführen kann.

Hook

Dein Assistant 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 Teil: deterministische Pipelines, explizite Freigaben und wiederaufnehmbarer Zustand.

Warum

Heute erfordern komplexe Workflows viele Hin-und-Her-Tool-Aufrufe. Jeder Aufruf kostet Token, und das LLM muss jeden Schritt orchestrieren. Lobster verschiebt 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: Seiteneffekte (E-Mail senden, Kommentar posten) halten den Workflow an, bis er explizit freigegeben wird.
Wiederaufnehmbar: Angehaltene Workflows geben einen Token zurück; freigeben und fortsetzen, ohne alles neu auszuführen.

Warum eine DSL statt normaler Programme?

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

Approve/Resume ist eingebaut: Ein normales Programm kann einen Menschen fragen, aber es kann nicht pausieren und fortsetzen mit einem dauerhaften Token, ohne dass du diese Runtime selbst erfindest.
Determinismus + Nachvollziehbarkeit: Pipelines sind Daten, daher sind sie einfach zu loggen, zu vergleichen, wiederzugeben und zu überprüfen.
Eingeschränkte Oberfläche für KI: Eine winzige Grammatik + JSON-Piping reduziert „kreative” Code-Pfade und macht Validierung realistisch.
Sicherheitsrichtlinie eingebacken: Timeouts, Output-Limits, Sandbox-Checks und Allowlists werden von der Runtime erzwungen, 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 ein JSON-Envelope von stdout. Wenn die Pipeline für eine Freigabe pausiert, gibt das Tool einen resumeToken zurück, damit du später fortfahren kannst.

Pattern: kleines CLI + JSON-Pipes + Freigaben

Baue winzige Befehle, die JSON sprechen, und verkette sie dann zu einem einzigen Lobster-Aufruf. (Beispiel-Befehlsnamen unten — tausche deine eigenen ein.)

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 Freigabe anfordert, setze mit dem Token fort:

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

KI triggert den Workflow; Lobster führt die Schritte aus. Freigabe-Gates halten Seiteneffekte explizit und nachvollziehbar.

Beispiel: Input-Items in Tool-Aufrufe mappen:

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. Das hält den 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.",
  "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. In OpenClaw-Tool-Aufrufen setze 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 binden.

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. Wenn du einen benutzerdefinierten Binary-Speicherort verwenden willst, übergib einen absoluten lobsterPath im Tool-Aufruf.

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 ein JSON-Envelope 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": "..."
  }
}

User genehmigt → fortsetzen:

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

Ein Workflow. Deterministisch. Sicher.

Tool-Parameter

`run`

Führe eine Pipeline im Tool-Modus aus.

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

Führe eine Workflow-Datei mit Argumenten aus:

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

`resume`

Setze einen angehaltenen Workflow nach Freigabe fort.

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

Optionale Eingaben

lobsterPath: Absoluter Pfad zum Lobster-Binary (weglassen, um PATH zu verwenden).
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, der an lobster run --args-json übergeben wird (nur Workflow-Dateien).

Output-Envelope

Lobster gibt ein JSON-Envelope mit einem von drei Status zurück:

ok → erfolgreich abgeschlossen
needs_approval → pausiert; requiresApproval.resumeToken ist erforderlich zum Fortsetzen
cancelled → explizit abgelehnt oder abgebrochen

Das Tool zeigt das Envelope sowohl in content (hübsches JSON) als auch details (rohes Objekt).

Freigaben

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

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

Verwende approve --preview-from-stdin --limit N, um eine JSON-Vorschau an Freigabe-Anfragen anzuhängen, ohne eigenen jq/heredoc-Glue. Resume-Tokens sind jetzt kompakt: Lobster speichert 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, dann führe eine Lobster-Pipeline für deterministische Freigaben aus. Wenn ein Prose-Programm Lobster braucht, erlaube das lobster-Tool für Sub-Agents über tools.subagents.tools. Siehe OpenProse.

Sicherheit

Nur lokaler Subprocess — keine Netzwerk-Aufrufe vom Plugin selbst.
Keine Secrets — Lobster verwaltet kein OAuth; es ruft OpenClaw-Tools auf, die das tun.
Sandbox-aware — deaktiviert, wenn der Tool-Kontext sandboxed ist.
Gehärtet — lobsterPath muss absolut sein, wenn angegeben; Timeouts und Output-Caps werden erzwungen.

Troubleshooting

lobster subprocess timed out → erhöhe timeoutMs oder teile eine lange Pipeline auf.
lobster output exceeded maxStdoutBytes → erhöhe maxStdoutBytes oder reduziere die Output-Größ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

Case Study: Community-Workflows

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