SOP: Loop Engineering en Hermes Agent — De Prompts Manuales a Loops Autónomos

Loop Engineering es el paradigma que está reemplazando al prompt engineering manual. En vez de sentarte a escribir prompts uno por uno y leer respuestas turno a turno, diseñás un sistema que lo hace por vos. El loop encuentra trabajo, lo distribuye, lo verifica, documenta lo hecho y decide el próximo paso — solo, mientras no estás mirando.

El concepto viene de Addy Osmani (Google Cloud AI), Boris Cherny (Claude Code), y Peter Steinberger (Codex). La tesis es simple: "Ya no deberías estar prompeteando agentes de código. Deberías estar diseñando loops que prompetean a tus agentes."

Este SOP te lleva de cero a un loop completo funcionando en tu stack: Hermes Agent como runtime, ADMP Triage como memoria externa (Google Sheets), y Agent OS como orquestador de worktrees y sub-agentes.

Un loop necesita cinco capacidades y un lugar donde recordar entre ejecuciones:

1. Automatizaciones — se disparan en un schedule y hacen discovery y triage solas.
2. Worktrees — para que dos agentes trabajando en paralelo no se pisen los archivos.
3. Skills — conocimiento del proyecto escrito una vez, leído por el agente en cada ejecución.
4. Plugins y Conectores (MCP) — para enchufar al agente en tus herramientas reales.
5. Sub-agentes — para que uno haga y otro distinto verifique (maker/checker split).

Y la sexta pieza: la memoria. En nuestro stack, ADMP Triage actúa como la memoria externa — una Google Sheet que persiste entre sesiones y le dice al loop qué está hecho, qué falló, y qué sigue.

Antes de arrancar, asegurate de tener:

• [ ] Hermes Agent v0.14+ instalado y funcionando
• [ ] Python 3.11+
• [ ] Git 2.40+ (para worktrees)
• [ ] Acceso al Google Sheet admp_triage configurado como MCP o skill
• [ ] Node.js ≥ 18 (para servidores MCP basados en npx)
• [ ] API key configurada en ~/.hermes/.env
• [ ] Telegram bot token (recomendado para recibir resultados)
• [ ] Al menos un repo de trabajo con git inicializado

`bash hermes --version

git worktree list

hermes chat --toolsets skills -q "Listá mis skills instaladas"

cat ~/.hermes/config.yaml | grep -A 20 "mcp_servers" `

Las automatizaciones son lo que convierte una ejecución manual en un loop de verdad. En Hermes Agent usamos el sistema de cron jobs para scheduled tasks que corren aunque la laptop esté cerrada.

### 1.1 Crear el cron job de triage diario

Este es el corazón del loop: cada mañana, un cron job revisa qué hay nuevo, clasifica, y dispara acciones.

`bash hermes cron create "0 9 1-5" \ "Leé la Google Sheet admp_triage, buscá filas con status='pending' o status='triaged', y para cada una: 1. Analizá el contenido contra las skills del proyecto. 2. Determiná si requiere acción (fix, artículo, investigación). 3. Actualizá el status en la sheet. 4. Si encontrás algo accionable, avisame por Telegram con un resumen." \ --name "ADMP Morning Triage" \ --skill admp-triage \ --deliver telegram

hermes cron create "0 /3 " \ "Revisá la sheet admp_triage, columna status. Para items en 'in_progress' hace más de 6 horas, chequeá si el sub-agente sigue vivo. Si está trabado, reassigneá o marcá como 'stalled'." \ --name "Loop Watchdog" \ --skill admp-triage \ --deliver telegram `

### 1.2 Cron con skills — la forma mantenible

En vez de incrustar instrucciones largas en el cron, referenciá un skill. El skill se actualiza en un solo lugar y todos los crons que lo usan se benefician.

`bash mkdir -p ~/.hermes/skills/admp-triage-loop

cat > ~/.hermes/skills/admp-triage-loop/SKILL.md << 'SKILLEOF'

name: admp-triage-loop description: Loop diario de triage ADMP — clasifica contenido nuevo y dispara acciones version: 1.0.0 metadata: hermes: tags: [admp, triage, automation, loop] category: operations

1. Leer admp_triage, filtrar status = 'pending'.
2. Para cada item:
3. Actualizar status a 'triaged' o 'in_progress' según corresponda.
4. Escribir resumen en Telegram.

• No procesar items con status = 'discarded'.
• Si la sheet no responde, loguear y reintentar en la próxima ejecución.

hermes cron create "0 9 1-5" \ "Ejecutá el loop de triage diario" \ --name "ADMP Morning Triage v2" \ --skill admp-triage-loop \ --deliver telegram `

### 1.3 Cron sin agente (no-agent mode) para tareas livianas

Para tareas que no necesitan razonamiento (solo ejecutar un script y reportar), usá el modo sin agente. Cero tokens de LLM.

`bash hermes cron create "0 /6 " \ "curl -s https://api.github.com/repos/tu-repo/commits | jq '.[0].commit.message'" \ --name "Latest Commit Check" \ --no-agent \ --deliver telegram `

### 1.4 /goal — el loop in-session

Para tareas que necesitan iterar hasta una condición verificable sin que vos estés presente:

`bash /goal Corregí todos los errores de lint en src/ y verificá que ruff check pase limpio. Cuando termines, actualizá la sheet admp_triage con el resultado.

/subgoal Agregá tests de regresión para cada fix que hagas /subgoal Actualizá el CHANGELOG.md con los cambios

/goal pause /goal resume /goal clear `

Dos agentes escribiendo el mismo archivo es caos. Los git worktrees resuelven esto: cada agente trabaja en su propio checkout aislado, en su propia rama, compartiendo el historial del repo.

### 2.1 Estructura de worktrees para Agent OS

`bash cd ~/work git clone git@github.com:arieldistefano/tu-repo.git main-checkout cd main-checkout

git worktree add ../agent-maker -b agent/maker-$(date +%Y%m%d-%H%M)

git worktree add ../agent-checker -b agent/checker-$(date +%Y%m%d-%H%M)

git worktree add ../agent-researcher -b agent/research-$(date +%Y%m%d-%H%M)

git worktree list `

### 2.2 Script de creación automática de worktrees

Creá un script para que el loop genere worktrees on-demand:

`bash cat > ~/scripts/hermes-worktree-spawn.sh << 'EOF' #!/bin/bash

TIPO="${1:-maker}" REPO="${2:-~/work/main-checkout}" TIMESTAMP=$(date +%Y%m%d-%H%M%S) BRANCH="agent/${TIPO}-${TIMESTAMP}" WORKTREE_DIR="${REPO%/main-checkout}/agent-${TIPO}-${TIMESTAMP}"

cd "$REPO" || exit 1 git fetch origin git worktree add "$WORKTREE_DIR" -b "$BRANCH" echo "WORKTREE=$WORKTREE_DIR" echo "BRANCH=$BRANCH" EOF

chmod +x ~/scripts/hermes-worktree-spawn.sh `

### 2.3 Limpieza de worktrees

Los worktrees viejos acumulan disco. Agregá limpieza al loop:

`bash hermes cron create "0 3 0" \ "Listá los git worktrees en ~/work/. Para los branches 'agent/*' mergeados a main hace más de 7 días, eliminá el worktree con 'git worktree remove --force' y borrá el branch remoto si existe." \ --name "Worktree Cleanup" \ --no-agent \ --deliver telegram `

### 2.4 Worktree en el contexto de Hermes

Cuando delegás un sub-agente, le pasás el path del worktree en el campo context:

` delegate_task( goal="Implementar fix para el bug #42", context="Trabajá en el worktree ~/work/agent-maker-20260609-0900. El bug está en src/auth/login.py línea 147. Rama: agent/maker-20260609-0900. Cuando termines, pusheá la rama y creá un PR.", toolsets=["terminal", "file", "github"] ) `

Un skill es cómo dejás de re-explicar el contexto del proyecto en cada sesión. Las convenciones, los pasos de build, el "no hacemos esto así por ese incidente" se escriben una vez donde el agente lo lee cada ejecución.

Sin skills, el loop re-deriva todo tu proyecto desde cero en cada ciclo. Con skills, compone.

### 3.1 Crear el skill de conocimiento del proyecto

`bash mkdir -p ~/.hermes/skills/admp-project-context

cat > ~/.hermes/skills/admp-project-context/SKILL.md << 'SKILLEOF'

name: admp-project-context description: Contexto completo del proyecto ADMP — convenciones, stack, y reglas de la casa version: 1.0.0 metadata: hermes: tags: [admp, context, conventions] category: operations

• Runtime: Hermes Agent (v0.14+)
• Memoria externa: Google Sheets (admp_triage)
• Hosting: Railway / macOS local
• Frontend: MD-HTML pipeline para contenido público
• Notificaciones: Telegram
• Orquestación: Agent OS con worktrees

• Siempre usar type hints en Python.
• Tests antes del código (TDD ligero — al menos tests de integración).
• Commits en inglés, mensajes en formato conventional commits: feat:, fix:, docs:, chore:.
• Branches: agent/-.

• NO pushear a main directamente. Siempre PR con revisión (sub-agente checker).
• Las skills van en ~/.hermes/skills/, no en el repo.
• Los outputs públicos van a ~/MD-HTML/ con nombre YYYY-MM-DD-.md.
• El estado global del loop vive en admp_triage, no en archivos sueltos.
• Si algo falla tres veces, se marca stalled y se notifica por Telegram.

1. ADMP Triage recibe input → clasifica → escribe en admp_triage.
2. Loop de automatización detecta status = 'triaged' → dispara skill correspondiente.
3. Skill genera contenido → escribe en ~/MD-HTML/.
4. Sub-agente checker revisa → aprueba o rechaza.
5. Si aprueba → pipeline de publicación (MD→HTML→deploy).
6. Loop actualiza admp_triage con resultado.

• La sheet admp_triage es la fuente de verdad. Si no responde, todo el loop se detiene.
• Los worktrees acumulan disco si no se limpian semanalmente.
• Las skills se cargan al inicio de la sesión. Si cambiás una skill, el agente en vuelo no la ve hasta la próxima ejecución.

### 3.2 Crear skills para cada output type

`bash mkdir -p ~/.hermes/skills/sop-generator

cat > ~/.hermes/skills/sop-generator/SKILL.md << 'SKILLEOF'

name: sop-generator description: Genera documentos SOP (Standard Operating Procedure) desde items triageados version: 1.0.0 metadata: hermes: tags: [sop, content, documentation] category: content

Cuando un item en admp_triage tiene selected_output = 'sop' y status = 'triaged'.

1. Leer el item de la sheet: título, keyword, url, notas de triage.
2. Si hay URL, fetchear el contenido fuente.
3. Cargar el skill admp-project-context para convenciones.
4. Estructurar el SOP con: hero/intro, prerequisitos, pasos numerados con comandos reales, verificación, troubleshooting.
5. Guardar en ~/MD-HTML/YYYY-MM-DD-sop-.md.
6. Actualizar admp_triage: status = 'draft', output_file = .
7. Notificar por Telegram: "SOP draft listo para revisión: ".

• Markdown con frontmatter YAML (título, fecha, stack, complejidad).
• Comandos en bloques `bash.
• Checklist de verificación con checkboxes.
• Tabla de troubleshooting con columnas: Problema | Causa | Solución.
• En español argentino (vos, no tú).

• No inventar comandos de Hermes. Solo usar comandos documentados.
• Si el source URL no carga, trabajar con las notas de triage como fuente.

mkdir -p ~/.hermes/skills/article-writer

cat > ~/.hermes/skills/article-writer/SKILL.md << 'SKILLEOF'

name: article-writer description: Escribe artículos editoriales desde items triageados version: 1.0.0 metadata: hermes: tags: [article, content, editorial] category: content

Cuando un item en admp_triage tiene selected_output = 'articulo' y status = 'triaged'.

1. Leer el item de la sheet.
2. Fetchear fuente si hay URL.
3. Escribir artículo editorial en español argentino.
4. Estructura: título magnético, bajada, cuerpo con secciones, cierre con call to action.
5. Guardar en ~/MD-HTML/articulo-.md.
6. Actualizar sheet.

• Tono profesional pero cercano. Sin buzzwords vacías.
• Analogías argentinas donde sumen.
• Entre 800 y 2000 palabras según el tema.

### 3.3 Verificar skills instaladas

`bash hermes chat --toolsets skills -q "Listá mis skills, mostrame nombres y descripciones"

hermes chat --toolsets skills -q "Mostrame la skill admp-triage-loop"

hermes chat -q "/admp-project-context" -v `

Un loop que solo ve el filesystem es un loop chiquito. Los conectores MCP dejan que el agente lea tu Google Sheet, abra PRs en GitHub, mande mensajes por Slack, o consulte APIs externas.

### 4.1 Configurar MCP para Google Sheets (memoria del loop)

`bash cd ~/.hermes/hermes-agent uv pip install -e ".[mcp]"

cat >> ~/.hermes/config.yaml << 'EOF'

mcp_servers: # Conexión a Google Sheets — la memoria externa del loop gsheets: command: "npx" args: - "-y" - "@modelcontextprotocol/server-google-sheets" env: GOOGLE_SERVICE_ACCOUNT_KEY: "${GOOGLE_SERVICE_ACCOUNT_KEY}" GOOGLE_SPREADSHEET_ID: "${ADMP_SPREADSHEET_ID}"

# Conexión a GitHub para PRs automatizados github: command: "npx" args: - "-y" - "@modelcontextprotocol/server-github" env: GITHUB_PERSONAL_ACCESS_TOKEN: "${GITHUB_PAT}" EOF `

### 4.2 Verificar conectividad MCP

`bash hermes chat -q "Intentá leer la sheet admp_triage y decime cuántas filas tiene con status='pending'"

hermes chat -q "Listá los PRs abiertos en mi repo principal" `

### 4.3 MCP para notificaciones multicanal

`bash cat >> ~/.hermes/config.yaml << 'EOF'

slack: command: "npx" args: - "-y" - "@modelcontextprotocol/server-slack" env: SLACK_BOT_TOKEN: "${SLACK_BOT_TOKEN}" EOF `

### 4.4 Crear un connector custom vía MCP (ejemplo: Linear)

`bash cat >> ~/.hermes/config.yaml << 'EOF'

linear: command: "npx" args: - "-y" - "@linear/mcp-server" env: LINEAR_API_KEY: "${LINEAR_API_KEY}" EOF `

Lo más importante en un loop que corre sin supervisión: el modelo que escribió el código no puede ser el mismo que decide si está bien. Un segundo agente con instrucciones distintas — y a veces un modelo distinto — atrapa las cosas de las que el primero se convenció solo.

### 5.1 El patrón maker/checker

`text ┌─────────────────────────────────────────────────────┐ │ LOOP PRINCIPAL │ │ (Cron job: ADMP Morning Triage) │ │ │ │ 1. Detecta item en admp_triage status='triaged' │ │ 2. Spawnea worktree aislado │ │ 3. Delega a sub-agente MAKER │ │ 4. Espera resultado │ │ 5. Delega a sub-agente CHECKER │ │ 6. Si CHECKER aprueba → publicar │ │ Si CHECKER rechaza → volver a MAKER con feedback │ │ 7. Actualiza admp_triage │ │ 8. Notifica por Telegram │ └─────────────────────────────────────────────────────┘ `

### 5.2 Definir sub-agentes especializados

En Hermes, los sub-agentes se invocan con delegate_task. El agente principal (el que corre en el cron) es el orquestador.

Sub-agente Maker (implementador):

` delegate_task( goal="Escribir SOP completo sobre {tema} basado en el contenido de {url}", context="Usá la skill sop-generator. Worktree: ~/work/agent-maker-{timestamp}. Output: ~/MD-HTML/{fecha}-sop-{slug}.md. El contenido fuente está en la URL {url}. Las convenciones del proyecto están en la skill admp-project-context.", toolsets=["terminal", "file", "web", "skills"] ) `

Sub-agente Checker (verificador):

` delegate_task( goal="Revisar el SOP generado en ~/MD-HTML/{fecha}-sop-{slug}.md", context="Verificá contra la skill admp-project-context: 1. ¿Los comandos de Hermes son reales? (no inventados) 2. ¿Cubre los 5 bloques de Loop Engineering? 3. ¿Está en español argentino? 4. ¿Tiene checklist de verificación? 5. ¿La tabla de troubleshooting es completa? 6. ¿Los paths y comandos son correctos para macOS?

Respondé con APPROVED o REJECTED + lista de correcciones necesarias.", toolsets=["file", "skills"] ) `

### 5.3 Sub-agente investigador (para discovery)

` delegate_task( goal="Investigar el estado del arte sobre {tema}", context="Buscá fuentes primarias: papers, repos oficiales, documentación. No uses resúmenes de terceros. Priorizá profundidad sobre amplitud. Output: brief ejecutable con hallazgos, fuentes, y recomendaciones. Guardar en ~/MD-HTML/{fecha}-research-{slug}.md.", toolsets=["web", "file"] ) `

### 5.4 Sub-agentes en paralelo

Para tareas independientes, corré varios en paralelo:

` delegate_task(tasks=[ { "goal": "Investigar tendencias en AI agents 2026", "context": "Worktree: ~/work/agent-researcher-001. Foco: herramientas, frameworks, adopción enterprise.", "toolsets": ["web", "file"] }, { "goal": "Investigar tendencias en content automation 2026", "context": "Worktree: ~/work/agent-researcher-002. Foco: SEO, content pipelines, AI writing tools.", "toolsets": ["web", "file"] } ]) `

### 5.5 Verificador adversarial

El checker debería usar un modelo distinto o al menos instrucciones opuestas:

`bash

`

El modelo olvida todo entre ejecuciones. La memoria tiene que estar en disco, no en el contexto. En nuestro stack, la Google Sheet admp_triage es la memoria externa del loop.

### 6.1 Estructura de la sheet admp_triage

### 6.2 El loop lee y escribe estado

Cada ejecución del loop:

1. Lee admp_triage para saber qué está pendiente.
2. Decide qué acción tomar basado en selected_output.
3. Ejecuta la acción (delega a sub-agentes).
4. Escribe el resultado de vuelta en la sheet.
5. Notifica por Telegram.

Esto es lo que permite que la ejecución de mañana retome exactamente donde hoy paró.

### Paso final: Integrar todo

`bash

cat > ~/.hermes/skills/admp-loop-orchestrator/SKILL.md << 'SKILLEOF'

name: admp-loop-orchestrator description: Orquestador principal del loop ADMP — coordina triage, worktrees, sub-agentes y publicación version: 1.0.0 metadata: hermes: tags: [admp, loop, orchestration] category: operations

Coordinar el ciclo completo: triage → worktree → maker → checker → publish → update state.

### Fase 1: Discovery 1. Leer admp_triage, filtrar status = 'triaged' o status = 'draft' WHERE checker_verdict = 'REJECTED' AND retry_count < 3. 2. Para cada item, determinar selected_output.

### Fase 2: Worktree Spawn 3. Para cada item, crear un worktree aislado: ` git worktree add ~/work/agent-{tipo}-{timestamp} -b agent/{tipo}-{timestamp} `

### Fase 3: Maker 4. Delegar a sub-agente maker con delegate_task: - goal: "Generar {selected_output} sobre {title}" - context: worktree path, URL fuente, skill a usar - toolsets: [terminal, file, web, skills] 5. Esperar resultado del maker. 6. Actualizar admp_triage: status = 'draft', output_file = , maker_verdict = .

### Fase 4: Checker 7. Delegar a sub-agente checker con delegate_task: - goal: "Verificar output en {output_file}" - context: path del archivo, criterios de la skill admp-project-context - toolsets: [file, skills] 8. Si APPROVED: - Actualizar status = 'review', checker_verdict = 'APPROVED'. - Notificar: "✅ {title} — listo para revisión humana". 9. Si REJECTED: - Incrementar retry_count. - Si retry_count < 3: volver a Fase 3 con feedback del checker. - Si retry_count >= 3: status = 'stalled', notificar: "⚠️ {title} — rechazado 3 veces, revisión manual requerida".

### Fase 5: Cleanup 10. Eliminar worktrees de items completados o descartados.

• No spaw near worktrees si el item ya tiene uno activo.
• Si un sub-agente no responde en 10 minutos, marcarlo como stalled.
• Siempre verificar que la sheet aceptó la escritura antes de continuar.

hermes cron create "0 9 1-5" \ "Ejecutá el loop completo de ADMP usando la skill admp-loop-orchestrator" \ --name "ADMP Full Loop" \ --skill admp-loop-orchestrator \ --deliver telegram

hermes cron create "0 22 *" \ "Revisá todos los items en admp_triage con status='draft' y checker_verdict vacío. Para cada uno, ejecutá solo el checker (Fase 4 del loop)." \ --name "Nightly Checker Sweep" \ --skill admp-loop-orchestrator \ --deliver telegram

hermes cron list `

Corré esta checklist después de completar el setup para confirmar que todo funciona.

### Bloque 1 — Automatizaciones - [ ] hermes cron list muestra al menos 2 jobs activos - [ ] El cron de triage matutino tiene --skill admp-triage-loop - [ ] Probaste /goal con una tarea simple y completó correctamente - [ ] El cron watchdog cada 3 horas está configurado

### Bloque 2 — Worktrees - [ ] git worktree list en el repo principal muestra la estructura base - [ ] El script hermes-worktree-spawn.sh crea worktrees correctamente - [ ] El cron de limpieza semanal está configurado - [ ] Probaste crear y eliminar un worktree manualmente

### Bloque 3 — Skills - [ ] admp-project-context está instalado y carga con /admp-project-context - [ ] sop-generator está instalado - [ ] article-writer está instalado - [ ] admp-loop-orchestrator está instalado - [ ] Cada skill tiene su SKILL.md con frontmatter YAML correcto

### Bloque 4 — MCP - [ ] ~/.hermes/config.yaml tiene la sección mcp_servers - [ ] El servidor de Google Sheets se conecta sin errores - [ ] Hermes puede leer y escribir en admp_triage - [ ] El servidor de GitHub está configurado (si aplica)

### Bloque 5 — Sub-agentes - [ ] Probaste delegate_task con un goal simple y devolvió resultado - [ ] El maker generó un archivo en el path esperado - [ ] El checker revisó el archivo y dio veredicto (APPROVED o REJECTED) - [ ] El loop orquestador completo corrió al menos una vez

### Memoria — ADMP Triage - [ ] La sheet admp_triage tiene todas las columnas necesarias - [ ] El loop lee correctamente el estado de la sheet - [ ] El loop escribe correctamente actualizaciones en la sheet - [ ] Los items stalled se notifican por Telegram

### End-to-End - [ ] Un item nuevo en admp_triage con status='triaged' disparó el loop completo - [ ] El loop generó output, lo verificó, y actualizó la sheet - [ ] Recibiste la notificación de Telegram al terminar - [ ] El archivo de output está en ~/MD-HTML/ con el naming correcto

Loop Engineering no te elimina del trabajo. Te cambia el trabajo. Tres riesgos se vuelven más filosos:

### 1. Deuda de Comprensión (Comprehension Debt) Cuanto más rápido el loop shippea contenido que no escribiste, más grande es la brecha entre lo que existe y lo que realmente entendés.

Mitigación: Leé todo lo que el loop produce. Aunque el checker lo apruebe, la revisión humana final es tuya. No delegues el criterio.

### 2. Brecha de Verificación (Verification Gap) Un loop corriendo sin supervisión es también un loop cometiendo errores sin supervisión. "Está hecho" es una afirmación del agente, no una prueba.

Mitigación: El checker es una red de seguridad, no una garantía. Hacé spot-checks manuales periódicos. Si el checker aprueba todo siempre, probablemente no está siendo lo suficientemente adversarial.

### 3. Rendición Cognitiva (Cognitive Surrender) Cuando el loop corre solo, es muy tentador dejar de tener opinión y simplemente aceptar lo que devuelve.

Mitigación: Diseñá el loop con criterio, no para evitar pensar. Si notás que estás aceptando outputs sin leerlos, frená el loop una semana y re-evaluá.

### Diario - Revisar notificaciones de Telegram del loop matutino - Spot-check de 1-2 outputs aleatorios

### Semanal - Verificar que los crons están corriendo: hermes cron list - Limpiar worktrees viejos: git worktree prune - Revisar la sheet admp_triage para items stalled - Actualizar skills si cambiaron convenciones

### Mensual - Auditar costo de tokens (revisar uso contra presupuesto) - Rotar API keys si corresponde - Revisar y ajustar instrucciones del checker - Evaluar si el loop está generando valor neto o solo volumen - Backup de la sheet admp_triage