Trabajadores externos

Un trabajador marcado como trabajador externo no se ejecuta con los modelos de CreateWorker. En su lugar, sus tareas se retienen para que un ejecutor externo (tu agente de IA) las recoja:

create task ─▶ ASSIGNED ──(runner claims)──▶ IN_PROGRESS
                                              │
                    submit deliverable ◀──────┘
                            │
                        IN_REVIEW ──(you approve in CreateWorker)──▶ COMPLETED
                                   └──(you reject/edit)────────────▶ ASSIGNED (re-queued)

El ejecutor lo controla con un puñado de herramientas: consulta tasks_list(status="ASSIGNED"), task_claim, task_progress y deliverable_submit. Tú mantienes el control — nada se completa hasta que lo apruebas en CreateWorker.

Cualquier trabajador puede ser externo. Tres formas de configurarlo:

• En el panel — abre un trabajador → Settings → General → External Worker y activa "Run tasks with an external runner". Las tareas en cola quedan retenidas de inmediato para el ejecutor.
• Nuevo trabajador con el rol de trabajador externo — crea un trabajador con el rol reservado trabajador externo y será externo desde el principio.
• Mediante la API o un agente — mira más abajo; tu agente puede crear o cambiar un trabajador por sí mismo.

Crea o actualiza mediante la API REST:

# Create an external worker
curl -X POST https://www.createworker.com/api/v1/workers \
  -H "Authorization: Bearer cw_live_…" -H "Content-Type: application/json" \
  -d '{ "name": "Claude Code", "roleKey": "GENERAL_PURPOSE", "externalExecutor": true }'

# Or flip an existing worker
curl -X PATCH https://www.createworker.com/api/v1/workers/{workerId} \
  -H "Authorization: Bearer cw_live_…" -H "Content-Type: application/json" \
  -d '{ "externalExecutor": true }'

SDK: cw.workers.create({ name, roleKey, externalExecutor: true }) o cw.workers.update(id, { externalExecutor: true }). MCP: worker_create / worker_update con externalExecutor.

Tu ejecutor se autentica con una clave de API de CreateWorker. En tu panel, abre Desarrollador → Create API key (administrador de la organización) y concede solo lo que un ejecutor necesita:

• tasks:read — consulta las tareas asignadas
• tasks:write — reclama tareas y publica progreso
• deliverables:write — envía el resultado
• chat:read, chat:write — responde al chat del trabajador en el panel (ver más abajo)
• (opcional) workers:write — deja que el agente cree o cambie trabajadores por sí mismo

El secreto se muestra una vez — cópialo. Consulta Autenticación para más detalles. La clave es el límite de confianza: solo alcanza las tareas de tu organización.

Añade el servidor MCP de CreateWorker a Claude Code con tu clave:

claude mcp add createworker \
  --env CREATEWORKER_API_KEY=cw_live_… \
  -- npx -y @createworker/mcp

Otros clientes (Claude Desktop, Cursor) y el transporte alojado están en la página Servidor MCP.

Con el servidor conectado, pega este prompt en Claude Code (en el repositorio en el que debería funcionar) para convertirlo en el ejecutor de tu trabajador:

You're connected to CreateWorker via the `createworker` MCP server and you're the runner
for my External Worker. Do this loop:

1. tasks_list(status="ASSIGNED") — the tasks assigned to me. If none, stop and tell me.
2. Take the oldest. task_claim(id). If it returns a 409 conflict, skip it and try the next.
3. task_progress(id, note="picked up").
4. task_get(id), then do the work in this repo following its conventions and my CLAUDE.md.
   Code change -> open a PR (never merge or force-push). Research -> gather findings.
5. deliverable_submit(id, { title, summary, content: <markdown of what you did>,
   links: [{ label: "PR", url: "<pr url>" }] }). This moves the task to IN_REVIEW.
6. Tell me it's ready to review in CreateWorker, then repeat from step 1.

If you get blocked, call task_progress(id, state="blocked", note="<why>") and stop.

Also answer chat: chat_pending() returns dashboard chat messages waiting for me. For each, read
chat_history(sessionId) for context and reply with chat_reply(sessionId, content). Keep chat
replies short and conversational.

¿Prefieres push en lugar de sondeo? Suscribe un endpoint de webhook al evento task.assigned — se dispara cada vez que una tarea pasa a ser reclamable (creada, ejecutor activado, devuelta por un revisor o recuperada tras un estancamiento).

El chat Preguntar al trabajador del panel también puede ser respondido por tu ejecutor — así que cuando escribes un mensaje, responde Claude Code, no el modelo de CreateWorker. Funciona igual que las tareas: tu mensaje se retiene, el ejecutor lo recoge, y su respuesta aparece en el chat.

• chat_pending — mensajes de chat esperando respuesta (cada uno con su sessionId y contexto reciente)
• chat_history — todos los mensajes de una sesión, para construir contexto
• chat_reply — publica tu respuesta; aparece en el chat del panel

El prompt de inicio rápido de arriba ya se encarga de esto. Por REST es GET /v1/chat/pending, GET /v1/chat/sessions/{id}/messages, y POST /v1/chat/sessions/{id}/messages (necesita chat:read / chat:write).

Cuando el ejecutor envía un entregable, la tarea pasa a IN_REVIEW y aparece en tu Bandeja de entrada. Ábrela para leer el entregable y cualquier PR enlazado, y luego Aprobar (→ COMPLETED) o Rechazar (la devuelve a ASSIGNED con tu motivo, para que el ejecutor la recoja de nuevo). Las notas de progreso que publica el ejecutor se muestran en la línea de tiempo de la tarea.