Lobster

Lobster es un shell de flujo de trabajo que permite a OpenClaw ejecutar secuencias de herramientas de múltiples pasos como una sola operación determinista con puntos de control de aprobación explícitos.

Tu asistente puede construir las herramientas que lo gestionan a sí mismo. Pide un flujo de trabajo, y 30 minutos después tienes un CLI más pipelines que se ejecutan como una sola llamada. Lobster es la pieza que faltaba: pipelines deterministas, aprobaciones explícitas y estado reanudable.

Hoy, los flujos de trabajo complejos requieren muchas llamadas de herramientas de ida y vuelta. Cada llamada cuesta tokens, y el LLM tiene que orquestar cada paso. Lobster mueve esa orquestación a un runtime tipado:

- Una llamada en lugar de muchas: OpenClaw ejecuta una llamada de herramienta Lobster y obtiene un resultado estructurado.

- Aprobaciones integradas: Los efectos secundarios (enviar email, publicar comentario) detienen el flujo de trabajo hasta que se aprueben explícitamente.

- Reanudable: Los flujos de trabajo detenidos devuelven un token; aprueba y reanuda sin volver a ejecutar todo.

Lobster es intencionalmente pequeño. El objetivo no es "un nuevo lenguaje", es una especificación de pipeline predecible y amigable para AI con aprobaciones y tokens de reanudación de primera clase.

- Aprobar/reanudar está integrado: Un programa normal puede pedir a un humano, pero no puede _pausar y reanudar_ con un token duradero sin que inventes ese runtime tú mismo.

- Determinismo + auditabilidad: Los pipelines son datos, así que son fáciles de registrar, comparar, reproducir y revisar.

- Superficie restringida para AI: Una gramática pequeña + piping JSON reduce las rutas de código "creativas" y hace realista la validación.

- Política de seguridad integrada: Timeouts, límites de salida, verificaciones de sandbox y listas de permitidos son aplicados por el runtime, no por cada script.

- ''Todavía programable'': Cada paso puede llamar cualquier CLI o script. Si quieres JS/TS, genera archivos ''.lobster'' desde código.

OpenClaw lanza el CLI ''lobster'' local en ''modo herramienta'' y analiza un sobre JSON desde stdout.

Si el pipeline se pausa para aprobación, la herramienta devuelve un ''resumeToken'' para que puedas continuar más tarde.

Construye comandos pequeños que hablan JSON, luego encadénalos en una sola llamada Lobster. (Nombres de comandos de ejemplo abajo — cambia por los tuyos.)

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
}

Si el pipeline solicita aprobación, reanuda con el token:

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

AI dispara el flujo de trabajo; Lobster ejecuta los pasos. Las puertas de aprobación mantienen los efectos secundarios explícitos y auditables.

Ejemplo: mapear items de entrada en llamadas de herramienta:

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

Para flujos de trabajo que necesitan un paso LLM estructurado, habilita la herramienta de plugin opcional

''llm-task'' y llámala desde Lobster. Esto mantiene el flujo de trabajo

determinista mientras todavía te permite clasificar/resumir/redactar con un modelo.

Habilita la herramienta:

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

Úsala en un pipeline:

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
  }
}'

Ver ''Tarea LLM'' para detalles y opciones de configuración.

Lobster puede ejecutar archivos de flujo de trabajo YAML/JSON con campos ''name'', ''args'', ''steps'', ''env'', ''condition'', y ''approval''. En llamadas de herramienta OpenClaw, establece ''pipeline'' a la ruta del archivo.

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

Notas:

- ''stdin: $step.stdout'' y ''stdin: $step.json'' pasan la salida de un paso previo.

- ''condition'' (o ''when'') puede condicionar pasos en ''$step.approved''.

Instala el CLI de Lobster en el ''mismo host'' que ejecuta el Gateway de OpenClaw (ver el ''repositorio de Lobster''), y asegúrate que ''lobster'' esté en ''PATH''.

Si quieres usar una ubicación de binario personalizada, pasa un ''lobsterPath'' ''absoluto'' en la llamada de herramienta.

Lobster es una herramienta de plugin opcional (no habilitada por defecto).

Recomendado (aditivo, seguro):

{
  "tools": {
    "alsoAllow": ["lobster"]
  }
}

O por agente:

{
  "agents": {
    "list": [
      {
        "id": "main",
        "tools": {
          "alsoAllow": ["lobster"]
        }
      }
    ]
  }
}

Evita usar ''tools.allow: ["lobster"]'' a menos que intentes ejecutar en modo de lista de permitidos restrictiva.

Nota: las listas de permitidos son opt-in para plugins opcionales. Si tu lista de permitidos solo nombra

herramientas de plugin (como ''lobster''), OpenClaw mantiene las herramientas core habilitadas. Para restringir herramientas

core, incluye las herramientas core o grupos que quieres en la lista de permitidos también.

Sin 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)

Con Lobster:

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

Devuelve un sobre JSON (truncado):

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

Usuario aprueba → reanudar:

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

Un flujo de trabajo. Determinista. Seguro.

#

Ejecutar un pipeline en modo herramienta.

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

Ejecutar un archivo de flujo de trabajo con args:

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

#

Continuar un flujo de trabajo detenido después de aprobación.

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

#

- ''lobsterPath'': Ruta absoluta al binario de Lobster (omitir para usar ''PATH'').

- ''cwd'': Directorio de trabajo para el pipeline (predeterminado: directorio de trabajo del proceso actual).

- ''timeoutMs'': Matar el subproceso si excede esta duración (predeterminado: 20000).

- ''maxStdoutBytes'': Matar el subproceso si stdout excede este tamaño (predeterminado: 512000).

- ''argsJson'': String JSON pasado a ''lobster run --args-json'' (solo archivos de flujo de trabajo).

Lobster devuelve un sobre JSON con uno de tres estados:

- ''ok'' → terminó exitosamente

- ''needs_approval'' → pausado; ''requiresApproval.resumeToken'' es requerido para reanudar

- ''cancelled'' → explícitamente denegado o cancelado

La herramienta expone el sobre tanto en ''content'' (JSON bonito) como en ''details'' (objeto crudo).

Si ''requiresApproval'' está presente, inspecciona el prompt y decide:

- ''approve: true'' → reanudar y continuar efectos secundarios

- ''approve: false'' → cancelar y finalizar el flujo de trabajo

Usa ''approve --preview-from-stdin --limit N'' para adjuntar una vista previa JSON a solicitudes de aprobación sin pegamento jq/heredoc personalizado. Los tokens de reanudación ahora son compactos: Lobster almacena el estado de reanudación del flujo de trabajo bajo su directorio de estado y devuelve una pequeña clave de token.

OpenProse combina bien con Lobster: usa ''/prose'' para orquestar preparación multi-agente, luego ejecuta un pipeline Lobster para aprobaciones deterministas. Si un programa Prose necesita Lobster, permite la herramienta ''lobster'' para sub-agentes via ''tools.subagents.tools''. Ver ''OpenProse''.

- Solo subproceso local — sin llamadas de red desde el plugin mismo.

- Sin secretos — Lobster no gestiona OAuth; llama herramientas OpenClaw que lo hacen.

- Consciente de sandbox — deshabilitado cuando el contexto de la herramienta está en sandbox.

- ''Endurecido'' — ''lobsterPath'' debe ser absoluto si se especifica; timeouts y límites de salida aplicados.

- ''''lobster subprocess timed out'''' → aumenta ''timeoutMs'', o divide un pipeline largo.

- ''''lobster output exceeded maxStdoutBytes'''' → aumenta ''maxStdoutBytes'' o reduce el tamaño de salida.

- ''''lobster returned invalid JSON'''' → asegúrate que el pipeline se ejecuta en modo herramienta e imprime solo JSON.

- ''''lobster failed (code …)'''' → ejecuta el mismo pipeline en una terminal para inspeccionar stderr.

#