← Volver al blog
Aiaprox. 8 min de lectura

agent-autoloop guarda la espera de un humano como una fila en la base de datos

Publicado 15 nov 2026
agent-autoloop guarda la espera de un humano como una fila en la base de datos

Cada pocas semanas veo la misma escena: alguien arranca un agente de código en una terminal, se levanta a por un café y vuelve para encontrarlo parado en una pregunta que nadie vio. La solución habitual es subir el volumen de la notificación. agent-autoloop ataca el desperdicio que hay debajo: un proceso y una ventana de contexto abiertos, sin hacer nada, mientras la persona está lejos del teclado.

Es un hub local, 5,459 estrellas de GitHub a 15 de noviembre de 2026, licencia MIT. Vigila eventos, se los pasa al agente de línea de comandos que ya usas y se aparta. El agente termina una ronda, escribe su respuesta, sale. Cuando necesita una decisión, el hub manda una tarjeta a tu escritorio, o a Feishu, DingTalk, WeCom, Slack o Discord. Eliges una opción. El agente retoma la conversación.

Sin máquina en la nube, sin puerto abierto, sin dashboard.

Instalar, y el único comando que demuestra que funciona

Requisitos: Node 24 o superior, Git y un agente de línea de comandos ya instalado y con sesión iniciada. En macOS y Linux también necesitas curl.

irm https://raw.githubusercontent.com/KKKKhazix/agent-autoloop/main/install.ps1 | iex
curl -fsSL https://raw.githubusercontent.com/KKKKhazix/agent-autoloop/main/install.sh | sh

Después ejecuta agent-autoloop try. Un script de instalación que imprime un número de versión no demuestra nada sobre si los flags y el inicio de sesión de tu agente funcionan. try recorre con tu propio agente un ciclo real de preguntar, esperar, responder, continuar: sale un evento, el agente trabaja, se detiene, hace una pregunta con opciones, sale y espera. Respondes y el hub reanuda la sesión y termina. Si algo está mal configurado, lo sabes en dos minutos, no a las 2 de la mañana cuando una regla cron falla.

Una frase de contrato, un archivo de reglas

La interfaz entre el hub y el agente es una sola convención: poner el resultado en la respuesta final. Sin SDK, sin wrapper, sin binario parcheado. Cualquier cosa que acepte un prompt y imprima un último mensaje se puede conectar, y por eso un adaptador de comandos genérico convive con Claude Code, Codex, ACP, DeepSeek Harness y ZCode.

Preguntar es un añadido. El agente termina su respuesta con un bloque delimitado llamado agent-autoloop que contiene JSON: un array ask con un título, un texto, opciones y una clave, más notice, resolve, later y events para los otros verbos. Ese es todo el protocolo que un autor de agentes tiene que aprender.

Las reglas viven en ~/.agent-autoloop/rules.json. Una regla responde tres preguntas: qué pasó, qué agente lo recibe, en qué directorio se ejecuta.

{
  "when": { "cron": "0 9 * * *" },
  "to": "codex",
  "cwd": "~/notes"
}

Una regla de evento cambia el reloj por una fuente: hacer coincidir issues.opened de GitHub, añadir parallel: 3 y una skill, la misma forma. Dos archivos guardan la configuración, este y el que tu agente ya lee. Me gusta que sea inspeccionable y fácil de diff.

Cuatro mecanismos tomados del trabajo de sistemas

El kernel es donde el diseño empieza a ser interesante. En aislamiento, casi nada es nuevo.

Primero, la suspensión sin coste. Mientras espera, el proceso sale y el estado pasa a una base de datos. Tres días de silencio cuestan tres días sin tokens y sin agente corriendo. Solo el hub sigue en pie, que es poca cosa para dejarla encendida.

Segundo, event sourcing. Cada pieza de estado se deriva de un log de solo añadir, y el log se escribe en la misma transacción que el índice antes de que el hub responda. Mata el proceso y el trabajo confirmado sobrevive. Cualquier ronda se puede explicar después por su número. Un cambio de esquema se reconstruye desde el log, sin scripts de migración.

Tercero, separación de instrucciones y datos. El texto externo, como el título de un issue, se guarda como material en un archivo y nunca se concatena en el prompt. El prompt solo lleva tipo, id y enlace ya validados. Qué agente corre, en qué directorio, con qué acceso, viene entero de tus reglas locales. Un evento que llegue con cwd, agent o access se rechaza.

Cuarto, el hop fuse, mi favorito. Los eventos que genera un agente y se despachan de vuelta a agentes acumulan profundidad, como un paquete acumula un TTL. Las preguntas humanas y las revisiones programadas no reinician el contador, y el agente no puede editarlo. Pasados 8 niveles, el hub deja de despachar, registra el evento y te manda una tarjeta en su lugar.

Los números, y dónde dejo de creérmelos

Su tabla de benchmark viene de un Apple M5 Pro con 24 GB y Node 24.21.0, con cada escritura confirmada por separado y la transacción en disco antes de la respuesta. Arranque en frío 88.78 ms. Memoria en reposo 59.94 MB RSS. Mil long polls simultáneos a 170.49 MB. 2,394 escrituras duraderas por segundo. p99 de despacho de 1.82 ms, y un p99 de heartbeat de 1.66 ms con 5,000 elementos en la cola. Arranque sobre 1.1 millones de hechos en 99.8 ms. Cero dependencias en tiempo de ejecución.

Son números de cola, no de aplicación, y ahí está el punto. Un hub que guarda la espera como fila y el trabajo como evento debería comportarse como una cola.

Mi escepticismo: una máquina, un operador, una caché de páginas caliente y un harness escrito por quien escribió el kernel. El benchmark nunca se ejecuta en un portátil con una videollamada y un build en segundo plano, así que léelo como cota inferior, no como promesa. La cifra de 1.1 millones de hechos también va acompañada en otro sitio de un coste honesto. El README dice que el primer arranque tras un cambio de formato se reconstruye desde el log, y que eso tardó 43.1 segundos. Bien para un portátil, incómodo si suponías otra cosa.

Dos sitios donde la autonomía puede hacerte daño, y lo que heredas

La seguridad es donde los autores fueron menos listos, y lo digo como elogio. La separación de instrucciones y datos significa que un título de issue hostil no puede redirigir una ejecución a otro directorio o a otro agente, porque esos campos se rechazan en la puerta. El hop fuse significa que un conjunto de agentes que se pasan trabajo no puede girar para siempre, porque la profundidad la incrementa el hub y no los participantes.

Ninguna de las dos es una prueba. El fuse es una política a 8 niveles. Si un flujo legítimo necesita 9, tienes un problema, y si el caso peligroso es un bucle lento de dos niveles que hace daño real en cada salto, el fuse nunca se dispara. La separación protege la decisión de despacho, no lo que hace el agente una vez que tiene un shell en el directorio que le diste.

La simulación es más fuerte que en la mayoría. node sim/random.ts 24301 200000 ejecuta 200,000 pasos de conexiones caídas, paquetes perdidos, caídas y envíos duplicados bajo una semilla fija, así que un fallo se puede reproducir. node sim/crash.ts 1000 12648430 mata el proceso 1,000 veces y comprueba que no desaparece ningún registro confirmado. Luego el README añade que el corte de corriente de toda la máquina no se probó. Respeto esa frase, y me hace preguntar qué más no se probó. Las plantillas de webhook solo se ejecutaron contra servidores mock locales. El webhook de GitLab se comprobó contra su formato documentado y nunca contra un GitLab real. Los scripts de receta se validaron contra un CLI de Feishu falso. Cada uno es un punto donde "probado" significa menos de lo que un lector va a suponer.

Lo que heredas con un kernel escrito a mano y cero dependencias en tiempo de ejecución es el mantenimiento. Un árbol de dependencias pequeño envejece bien cuando alguien presta atención y mal cuando el autor se va. Ese es el precio de un arranque en frío de 88 ms.

Un detalle de facturación queda fuera del diseño por completo. El hub maneja las herramientas CLI ya instaladas y con sesión iniciada en tu máquina, así que el uso cae en tu propia cuenta o suscripción. El README señala que los proveedores prefieren claves de API para la automatización de alta frecuencia, porque los planes personales están pensados para una interacción al ritmo humano. Lee eso dos veces antes de apuntar una regla cron a tu sesión de Claude Code e irte a dormir.

Un riesgo sobrevive a todos los mecanismos anteriores. Un bucle que puede abrir issues en GitHub, y con el pipeline de entrega fusionar pull requests que llevan una etiqueta deliver, es un actor de la cadena de suministro con tus credenciales. Todo lo anterior lo hace fiable y le pone una correa corta. El paso de review que configuraste es lo único que hay entre él y una mala fusión, y ninguna cantidad de event sourcing mejora una review que no leíste.

Artículos relacionados