Hermes Autopilot

00en conjunto

Una tarea, de punta a punta, con todo junto

Hermes son las manos, el modelo es la capa inteligente y el arnés es lo que no se negocia. Mirá la corrida (arranca sola al llegar): se enciende quién trabaja en cada paso, la consola muestra lo que pasa y la barra del arnés se pone roja, ámbar o verde según lo que decide.

Equipochat · correo

Modelo localcapa inteligente

Hermesmanos · rama aislada

Claudecódigo y revisión

IntegracionesMCP · mínimo privilegio

Gateverde o rojo

Seniorjuzga y firma

Arnéscada llamada pasa por los frenosesperando…

~/repo — issue #42 · de la petición al PR

corrida de ejemplo: el agente sigue un guion; los frenos, el gate y el loop son los reales

capa inteligente · local

El modelo de la caja

Conversa y resume
Explora el repo y prepara el plan
Trabajo diario: los datos no salen

capa inteligente · Claude

El modelo para lo pesado

Escribe y refactoriza código
Revisa el diff antes de la firma
Se llama por la terminal, con tope

El enrutamiento es una política tuya, en el config: el modelo es intercambiable y el arnés no. Cambiás de modelo y las reglas, el gate y los niveles siguen igual.

Ver el mapa 22 casos replicables Sus corridas completas

0amapa

Un compañero digital con alma, cerebro, manos y empresa

Pensalo como una persona. El alma es su identidad y su oficio. El cerebro es el modelo, y se cambia. Las manos son Hermes Agent: terminal, archivos, navegador, correo. Y la empresa que la rodea es el arnés: reglas que se cumplen solas, sin depender de que alguien se acuerde.

lo que definís vos (el arnés)personasservicios de afueralo que viene hecho (Hermes, modelo)

qué puede hacer

Trabajar solo, con tarea y tope

Toma una tarea de la cola, trabaja en una rama aislada, corre el gate y repite hasta verde o hasta que el tope lo frene. El resultado queda en un pull request.

qué puede tocar

Herramientas, una por una

Terminal, archivos, correo, Drive, repos. Cada integración arranca con mínimo privilegio y el arnés gobierna cada herramienta, no el servicio entero.

qué nunca hace solo

Fusionar, firmarse, ampliarse

Ni en el nivel más alto: fusionar a main, firmar su propio ascenso o cambiar sus permisos. Eso lo hace una persona.

0bacción

Qué pasa entre «el agente quiere» y «el agente hizo»

El modelo propone; el arnés dispone. Los frenos corren fuera del modelo, en cada llamada a una herramienta: no dependen de que el modelo se porte bien. Cuatro ejemplos reales, tal cual los devuelve el plugin:

Reescribir historia remotaEl agente quiere forzar un push a main.

terminal · git push origin main --force✗ bloqueareescribe historia remota. Usá --force-with-lease y pedí confirmación.

Leer los secretosPara diagnosticar, quiere abrir el .env.

read_file · .env✗ bloquealeé .env.example; si falta una variable, pedíla al humano.

Publicar su trabajoEmpujar una rama es legítimo, pero publica.

terminal · git push origin feat/x? pide aprobaciónempujar publica el trabajo: se confirma con el humano. En cron no hay a quién preguntarle: no se empuja.

Lo inocente pasaUn freno que muerde de más no sirve.

terminal · git commit -m 'docs: por qué git push --force está prohibido'✓ pasaningún freno tiene nada que decir

El agente decide
Elige una herramienta y sus argumentos: terminal, patch, memory, un MCP.
Freno · antes
El plugin decide con funciones puras, en milisegundos:
pasapide aprobaciónbloquea + el porqué
Ejecuta · después
Se cuenta lo aprobado, se tapa un secreto en la respuesta y se anota el evento para el panel.
Gate · al terminar
Un comando decide «terminado»: self-test, lint, tests del repo. Verde o rojo; no hay opinión.
Loop · la tarea
Verde: un humano lo revisa. Rojo distinto: reintenta con el rojo en mano. El mismo rojo dos veces, o el tope: escala.

Las corridas completas de los 22 casos están en casos/CORRIDAS.md.

0cniveles

El agente no arranca confiable: arranca observando

La autonomía se gana por repo y con evidencia que imprime un comando, no con una promesa. Sube un nivel solo cuando una persona lo firma; baja solo, sin pedir permiso, cuando intenta salirse.

Observador

Lee y explica. No escribe nada.

para subir3 sesiones limpias

Recomienda

Propone cambios, pero los hace una persona.

para subir5 recomendaciones, ≥ 80 % aceptadas

Con aprobación

Escribe, y cada escritura la aprueba un humano.

para subir10 cambios aprobados · ≤ 10 % denegados · gates ≥ 90 % en verde

Autonomía en el loop

Trabaja solo dentro del loop, con gate, tope y freno de mano.

sigue vigiladoun senior juzga y firma cada PR

Bajar es automático. En las pruebas, un agente en L3 intentó algo que una regla crítica veda y bajó a L2; después tocó archivos que no debía y bajó a L1. El panel en vivo lo mostró como alerta, con el motivo. El nivel vive bajo .git/ (en producción, en un volumen), donde el agente no escribe: no se firma a sí mismo.

Desde L2, el porqué se comprueba. Aprobar «reiniciar el servicio» es aprobar una conclusión. La propuesta puede traer un certificado —hechos, reglas, deducción— que verifica un programa que no comparte código con el agente. Una conclusión sesgada o editada no verifica, y el ascenso puede exigir que las propuestas vengan certificadas.

Ni en L3, solo:fusionar a mainfirmar su ascensocambiar sus permisos

Autonomía por niveles Workshop del agente que se gana la autonomía

0dproducción

Probado en producción: un SRE que se gana la autonomía

El primer repo que instaló el arnés y salió a producción es un agente SRE de solo lectura: observa una plataforma real, abre incidentes con reglas y avisa por Telegram, desatendido, en un contenedor sin .git ni terminal. En una semana mostró qué supuestos del arnés sólo valían en un repo de desarrollo, y los cerró.

sesiones limpias30/30conversaciones reales con el modelo en L0 sin un solo intento fuera del nivel, en la ventana del 27-oct-2026.cli.py nivel

bloqueos que no eran suyos2los de la ventana anterior: una herramienta nueva sin clasificar y la revisión de skills en segundo plano de Hermes. Ahora no le restan evidencia.origen: config · doctor.py

red team por correo3/3correos de ataque reales: avisó por Telegram, no obedeció, no abrió el enlace ni respondió.mail.spoof_suspect · mail.injection_suspect

autonomia.firmadas

Firmar es mergear

En producción no hay terminal para firmar. Un PR revisado agrega la transición a un archivo versionado y el arranque la aplica una vez, en orden. subir sigue exigiendo la evidencia: el PR firma, no regala. El agente no puede editar ese archivo.

falla: un nivel que no se puede ganar porque firmar pedía una shell

recomendacion · hallazgo juzgar

Se juzga donde la gente ya mira

Una etiqueta en el issue del tablero registra el juicio de una propuesta o de una alerta, con la firma de quien la puso, una vez por issue. Los falsos positivos también son evidencia: acertar, no sólo obedecer.

falla: evidencia que sólo existe si alguien abre una terminal en el contenedor

autonomia.certificados

Un porqué que no hay que creer

El piloto certifica la causa raíz de cada incidente investigado con oo-horn, el verificador en Lean 4 de open-ontologies. Quien aprueba, o un auditor meses después, comprueba la deducción sin confiar en el agente ni en el modelo.

falla: aprobar una conclusión dictada por un correo plantado

huellas.json · .hermes/integraciones/

Lo del repo no se pisa

El piloto tuvo que parchar su copia del arnés; un --upgrade la habría borrado sin avisar. Ahora el instalador sabe qué escribió y frena lo que el repo cambió, y las herramientas propias viven fuera del código del arnés.

falla: un arreglo local que desaparece en la próxima actualización

Lo que enseñó el piloto (ADR 0014) Autonomía en producción Certificados

01tesis

La autonomía se construye con lazos de control, no con un modelo mejor

Un modelo se equivoca a veces; un agente autónomo repite ese error sin que nadie mire, y en un agente que aprende, lo vuelve permanente. Lo que lo hace confiable es lo que lo rodea.

Tres clases de control, en tres momentos: guías que orientan antes de decidir (AGENTS.md, el estado del repo al abrir, pistas por pedido), frenos que deciden entre la acción elegida y la ejecutada (terminal, archivos, memoria, skills, cron, integraciones, la respuesta) y sensores que miran después (lint, gate, loop, panel, revisor medido). El loop cierra el lazo: tarea → agente → gate, hasta verde o hasta escalar a un humano con el motivo.

La parte nueva respecto de un arnés para un asistente de código: Hermes escribe su propia memoria, crea skills y corre en cron y en el gateway. Un secreto en MEMORY.md no se filtra una vez: entra en cada sesión futura. Una skill que enseña --no-verify apaga un freno cada vez que alguien la carga. Y en un cron no hay a quién preguntar. Por eso lo aprendido y lo desatendido pasan por los mismos frenos que lo ejecutado.

La tesis se sostiene con evidencia que se puede repetir: cada freno trae un ejemplo que tiene que morder y uno que no; cada prueba tiene una mutación que la tiene que poner roja; cada caso replicable es un agente que toma un atajo real; y lo que el arnés no puede prometer está escrito en una lista de huecos, abiertos y cerrados. Está verificado contra el código de Hermes, no contra su documentación, y es el hermano de agent-harness (hecho para Claude Code).

02autonomía

Autonomía es un loop con salida, tope y freno de mano

Un agente autónomo no es un modelo bueno: es un modelo metido en lazos de control bien hechos. El arnés gobierna el turno; el loop gobierna la tarea; el panel deja ver los dos.

scripts/loop.py

tarea ──▶ agente (Hermes) ──▶ gate ──▶ verde ──▶ [x] y la próxima
              ▲                     │
              └── reintento con ◀───┤ rojo distinto
                  el rojo en mano   │
                                    └ mismo rojo 2× · tope · stopFile ──▶ [!] escala a un humano

scripts/loop.py

El loop autónomo

Toma la próxima tarea de .hermes/loop/tasks.md, se la da a Hermes y corre el gate. La salida es el gate, no lo que el agente dice. El mismo rojo dos veces seguidas escala (P16 hecho mecanismo). Nunca empuja: lo verde queda en una rama.

falla: un agente que reintenta a ciegas, o que se declara terminado solo

scripts/cli.py

La CLI que prueba antes de escribir

rule add pasa la regla nueva por el mismo camino que el plugin: el ejemplo frena, ningún inocente ni el gate quedan frenados, el config pasa el lint. Recién entonces, con --apply, la escribe.

falla: una regla editada a mano que frena el gate y deja al loop sin salida

scripts/panel.py

El panel en vivo

Gate, loop, tareas, frenos y cada evento —bloqueo, escalada, lint, gate— en el momento en que pasa. http.server y Server-Sent Events, sólo en 127.0.0.1, sin dependencias.

falla: lo que el arnés frena sólo se ve dentro del chat que lo provocó

docs/workshop/

El workshop

Tres horas y media en un sandbox propio, con un agente de juguete determinista (sin API key): guías, frenos, gate, el loop que llega a verde, el que escala, el panel y de un incidente a una regla.

falla: un arnés que sólo entiende quien lo escribió

loop.aislar · plugin/guardia

Lo desatendido, aislado

Cada tarea corre en su git worktree: el .env y lo ignorado por git no existen ahí. Y cada proceso Python del agente carga una guardia (audit hook, PEP 578) que ve la ruta real de lo que abre, aunque se arme por partes.

falla: un script o un test del agente que lee un secreto sin nombrarlo

L0 · L1 · L2 · L3

La autonomía se gana con evidencia

El agente arranca observando. Después recomienda, después cambia con tu aprobación, y recién al final trabaja solo. Sube un nivel cuando lo que hizo en el anterior alcanza y una persona lo firma; baja solo si hace algo que contradice esa confianza. El panel muestra en qué nivel está y cuánto le falta.

falla: confiarle todo a un agente el primer día, o no confiarle nada nunca

taint

La sesión contaminada

La inyección de prompt no se detecta: se corta su daño. Después de leer una web, un ticket o un correo, publicar, hablar con otro servidor o escribir AGENTS.md, CI o memoria escala a un humano; en el loop, se niega.

falla: un ticket que le dicta al agente una regla permanente

Ingeniería de loops Operar el loop CLI y panel Autonomía por niveles Workshop: el agente que se gana la autonomía

03prueba

Cada número de esta página lo imprime un comando

Y cada freno tiene una prueba de que muerde, otra de que no muerde de más, y una tercera de que la prueba misma muerde.

señales del gate14con Hermes real (CI, job hermes-real). Sin un modelo configurado, el revisor inferencial sale omitido — y omitido no es verde.python3 scripts/gate.py

verificaciones1347del self-test, generadas desde el example de cada regla, pasando por el callback real del plugin.python3 scripts/selftest.py

mutaciones160/160rompen un freno a propósito en una copia del repo; todas tienen que poner rojo el self-test.python3 scripts/mutations.py

dentro de Hermes209verificaciones con el despacho real de Hermes: directivas, aprobaciones contadas, la respuesta tapada, pre_verify, ruteo, lint tras escribir, sección del prompt.python3 scripts/hermes_e2e.py

casos replicables22programación, infraestructura, oficina, datos, soporte y operación: un agente con un atajo real, de punta a punta, en un repo instalado de cero.python3 scripts/casos.py

perfiles de stack8python, node, front, go, rust, .NET, Maven, Gradle — cada uno instalado en un repo temporal con su gate.self-test §11

revisor inferencial100 %de los atajos cazados por el revisor con un modelo real, con 91 % de precisión, contra 16 diffs etiquetados salidos de los casos. Un sensor inferencial se mide con una tasa.python3 scripts/evals.py inferential

dependencias0Python de la biblioteca estándar. Donde hay Hermes, hay todo lo que el arnés necesita.regla patterns[dependencia]

04evaluación

Los frenos, medidos con lo que no está en sus ejemplos

El self-test prueba que cada regla caza su propio ejemplo: tautológico. La evaluación determinista pasa 180 casos independientes, en inglés y en español, por un copiloto recién instalado en ocho stacks, y da cada tasa con su intervalo de confianza del 95 %.

reglas · ataques85/85frenados o escalados a un humano, sin contar los huecos conocidos. Con este tamaño, el recall real está por encima de 95.7 % con un 95 % de confianza.python3 scripts/evals.py deterministic

variantes de evasión54/54el mismo ataque por otro camino: cat app/../.env, git commit -nm, un patch V4A, un scp.rules · variant: evasion

falsos positivos0/32inocentes que se parecen a un ataque y no lo son. Con cero eventos, la cota superior del IC95 es 10.7 %.rules · variant: innocent

guías · señales23/23 · 37/37si el AGENTS.md llega al agente y si cada freno dice qué hacer; si el fin del turno, la respuesta, el resultado y el commit avisan.guides · signals

inglés · español41/41 · 41/41el mismo chequeo en los dos idiomas: encontró una memoria con «saltearse el gate» y un cron que «desplegá a producción» que pasaban.--lang es

rúbrica43/48doce dimensiones de 1 a 4, calculadas con los datos. Las dos de IA quedan bajas porque todavía no se midieron con un modelo en los dos idiomas.python3 scripts/evals_page.py

Stacks en verde: 8/8, con resultados idénticos. La parte inferencial (un modelo que revisa diffs y un modelo como agente en el loop) tiene su propia suite y corre cuando hay un modelo configurado.

Ver el informe completo: gráficos, intervalos y rúbrica Cómo se evalúa

05huecos

Lo que el arnés no puede prometer, escrito

Un hueco es algo que un agente puede hacer y que el arnés dice que no pasa. 40 se cerraron con un mecanismo y su prueba; 5 siguen abiertos, con su mitigación, para que nadie los dé por cubiertos.

abierto · fuera del loop

Un programa que no es Python

En una sesión interactiva, un binario o un script de node que lee el .env sin nombrarlo no lo ve ningún regex. Python ya está cerrado (la guardia de sesión), y en el loop no hay .env donde trabaja el agente.

mitigación: guardia de sesión · pre-commit · secretos fuera del disco

abierto · inyección

Si la respuesta obedeció

Ningún freno sabe si un texto es dato o instrucción. Lo que tiene efecto afuera escala tras leer a un tercero, y la respuesta de esa sesión lleva al pie de qué fuente leyó, también después de un reinicio. Desde L2, una conclusión certificada que fue sesgada no verifica.

mitigación: sesión contaminada · aviso en la respuesta · certificados · gate de la tarea

abierto · medición

El loop con un modelo de verdad

Los casos prueban el arnés con un agente determinista; en el loop, cuánto obedece un modelo el motivo de un freno no está medido. Fuera del loop ya hay datos: el piloto en producción, 30 de 30 sesiones sin salirse del nivel. El revisor inferencial se midió con un modelo real.

mitigación: contrato con Hermes real en cada PR · piloto en producción · pipeline nocturno

abierto · integraciones

Si un mensaje permitido es correcto

A quién, cuánto, desde qué tarea, después de leer qué, y que no lleve un secreto ni un {{hueco}} de plantilla: eso se decide. Si el dato es de otro cliente o la promesa es falsa, no.

mitigación: lista de destinatarios · borrador en vez de envío

Cerrado hace poco	Mecanismo	Prueba
en producción (sin `.git` ni shell) la autonomía no se podía ganar ni firmar	estado en un volumen, transiciones firmadas por PR, juicios desde el tablero	self-test §15 y dos mutaciones
dos bloqueos que no eran del agente le costaron la evidencia	herramienta fuera de `toolNames` → `origen: config`; `doctor.py` avisa lo de Hermes	self-test §15 y una mutación
`MEDIA:/ruta` citado en la respuesta adjunta el archivo al chat	`output.defang` rompe el marcador	self-test con el `example` y una mutación
el aviso de terceros se perdía en cada deploy	la marca se reconstruye del registro de eventos	self-test §15 y una mutación
`install.py --upgrade` borraba un parche local	`huellas.json`, marca `!` y `--pisar`	self-test §11 y §16, y una mutación

Auditoría completa de huecos

06onboarding

De cero a un agente autónomo, en ocho pasos

Cada paso dice qué tiene que salir. Si no sale, el tablero de problemas tiene la causa: cada fila es un tropiezo real.

Requisitos
Python ≥ 3.11, git y Hermes Agent. En Windows, la terminal de Git for Windows o WSL2 (y sin el alias de python3 de la Microsoft Store).
python3 --version && git --version && hermes --version
Instalar Hermes
Con el instalador oficial. Bajá el script y leelo antes de correrlo: es la misma regla que el arnés le aplica al agente.
hermes doctor # → sin errores rojos
Traer el arnés y ver el gate verde
Tiene que terminar en GATE VERDE — 14 señales, con OMITIDAS donde falte con qué correrlas (Hermes en el PATH, un modelo para el revisor).
git clone https://github.com/raalzate/hermes-autopilot.git cd hermes-autopilot && python3 scripts/gate.py
Instalar en tu repo, primero en seco
Sin --apply sólo muestra la lista. + es nuevo, = ya existía y no se toca: nunca sobreescribe.
python3 scripts/install.py ~/code/mi-repo --profile python python3 scripts/install.py ~/code/mi-repo --profile python --apply
Conectarlo a Hermes (lo hace el humano)
El instalador no toca tu config.yaml: qué frenos existen lo decidís vos.
cd ~/code/mi-repo python3 .hermes/harness/scripts/githooks.py install hermes skills trust . python3 .hermes/harness/scripts/install.py . --link-plugin --apply hermes plugins enable repo-harness
Verificar que quedó vivo
doctor.py encuentra el "instalado y muerto": plugin sin habilitar, skills sin confiar, un .hermes.md que tapa a AGENTS.md, secretos ya guardados en la memoria.
python3 .hermes/harness/scripts/gate.py python3 .hermes/harness/scripts/doctor.py # → 0 rojo(s)
La prueba de humo con el agente
Pedile a Hermes un git reset --hard, escribir en .env y guardar una key en su memoria: las tres tienen que frenar con el motivo. Después /harness para ver los frenos activos. Y desde ahí, las reglas de tu repo se escriben con tus incidentes (/lesson, /new-guardrail) o con cli.py rule add, que las prueba antes de escribirlas.
Dejarlo trabajar solo
Una tarea chica que el gate pueda verificar, el loop y el panel en otra pestaña. Tiene que salir ✓ VERDE — gate verde en el intento N o ✗ ESCALAR con el motivo.
python3 .hermes/harness/scripts/cli.py panel # http://127.0.0.1:8765 python3 .hermes/harness/scripts/cli.py task add "…" python3 .hermes/harness/scripts/cli.py loop --apply

Onboarding completo

07piezas

Seis piezas, cada una contra una falla concreta

plugin/

El plugin `repo-harness`

Frena en pre_tool_call la terminal, la escritura (incluido el patch V4A), la memoria, las skills, los cron y las integraciones. Después cuenta lo aprobado (post_tool_call) y tapa secretos en la respuesta (transform_llm_output). Corre en proceso: una llamada de función, no un proceso.

falla: el agente hace lo que la regla en prosa decía que no

.hermes/harness.config.json

Un solo archivo de reglas

Reglas, rutas y hasta los nombres de las herramientas de Hermes. Cada regla trae su example: el self-test lo pasa por el plugin y es rojo si no frena.

falla: reglas cableadas en el código que nadie se anima a tocar

scripts/gate.py

El gate

La única definición de "terminado", declarativa, igual en CI. pre_verify no deja cerrar el turno con código editado y el gate pendiente.

falla: "listo" dicho por el agente, no impreso por un comando

regla CONTEXTO

El lint que conoce el escáner de Hermes

Si una línea de AGENTS.md parece inyección, Hermes descarta el archivo entero. El lint te dice la línea antes de que pase, y el tope de 20 000 caracteres antes de que trunque.

falla: el agente arranca sin reglas y nadie se entera

.hermes/skills/

Seis skills

/gate, /lesson, /new-guardrail, /harness-audit, /harness-review (el revisor, vía delegate_task) y /harness-port.

falla: el método vive en la cabeza de quien lo inventó

doctor · e2e · mutaciones

Los sensores del propio arnés

doctor.py mira tu máquina; hermes_e2e.py corre cada ejemplo dentro de Hermes; mutations.py prueba que el self-test muerde.

falla: instalado y muerto

08freno

Editás JSON. El agente lee el motivo.

El reason es lo único que el agente ve cuando lo frenás. Es la diferencia entre que entienda y que reintente con otra forma.

.hermes/harness.config.json

"terminal": { "deny": [{
  "id": "force-push",
  "pattern": "git(?:\\s+-[Cc]\\s+\\S+)*\\s+push\\b…",
  "example": "git push origin main --force",
  "moreExamples": ["git -C . push --force",
                   "git push -f origin main",
                   "git push origin +main"],
  "reason": "reescribe historia remota. Usá
    --force-with-lease y pedí confirmación."
}]}

lo que Hermes le devuelve al modelo

{"action": "block", "message":
COMANDO BLOQUEADO por el arnés del repo:
`git push origin main --force`
Motivo: reescribe historia remota. Usá
--force-with-lease y pedí confirmación.
Reformulá el comando o pedí confirmación
explícita al humano. No lo reintentes igual.}

Y el example más cada moreExamples se prueban solos: en el self-test contra el plugin, y en el e2e contra el despacho real de Hermes. Una regla sin ejemplo no entra.

09contrato

Lo que Hermes promete, leído en su código

La diferencia que más importa: en Hermes, un pre_tool_call que lanza una excepción bloquea la herramienta. Un arnés con un bug no "deja de frenar": frena todo. Por eso ningún callback del plugin lanza, y el self-test lo prueba con un freno que divide por cero.

Necesidad	Punto de Hermes	Contrato
frenar una herramienta	`pre_tool_call`	`{"action":"block","message"}` — sin mensaje, Hermes lo ignora
pedir aprobación humana	`pre_tool_call`	`{"action":"approve"}` → el gate de aprobación de Hermes; en cron se niega solo
no cerrar con el gate pendiente	`pre_verify`	`{"action":"continue","message"}`, sólo si el turno editó archivos, máx. 3
contar lo que un humano aprobó	`post_tool_call`	observador, después de ejecutar; `status="blocked"` si se negó
tapar un secreto en la respuesta	`transform_llm_output`	el primer `str` reemplaza la respuesta antes de mostrarla y guardarla — no se encadena: un plugin que carga antes y devuelve texto descarta el del arnés (`doctor.py` lo avisa)
que un resultado OK no parezca fallo	`_detect_tool_failure`	`"error"` o `"failed"` en los primeros 500 caracteres cuentan como fallo, aunque la herramienta haya salido bien
mandar un mensaje sin adjuntar nada	`hermes send`	`MEDIA:<ruta>` en cualquier parte del texto adjunta ese archivo: `output.defang` lo rompe
lint del archivo recién escrito	`transform_tool_result`	el primer `str` reemplaza el resultado que ve el modelo
estado del repo al abrir	`register_system_prompt_section`	≤ 4000 caracteres, congelada por sesión
pistas según el pedido	`pre_llm_call`	`{"context"}` se suma al mensaje del usuario
el directorio correcto	`_authoritative_workspace_root`	el cwd de la sesión, no el del proceso (gateway, cron, Desktop)

10aprende

Lo aprendido pasa por los mismos frenos que lo ejecutado

Tres familias de frenos que un arnés para Claude Code no necesitaba.

memory

La memoria

Filtra secretos y "reglas" que contradicen a un freno. Mira sólo lo que se guarda: sacar un secreto que ya estaba tiene que poder hacerse. doctor.py encuentra lo que se guardó antes de instalar el arnés.

skill_manage

Las skills

Una skill que enseña un paso prohibido es un freno apagado en todas las sesiones que la carguen. Se le aplica terminal.deny a lo que escribe, dentro de operations[].

cronjob_manage

Lo desatendido

Sin humano, la aprobación no tiene a quién preguntar. El freno decide al crear: nada que publique, y un intervalo mínimo (entiende 30s, listas y rangos de cron).

11cicatrices

Lo que costó aprenderlo

Cada una terminó en un mecanismo (y en docs/gotchas.md), no en una advertencia.

El plugin pasaba el self-test y en Hermes no importaba

Causa: Hermes copia el directorio del plugin para validarlo e instalarlo; el núcleo vivía afuera. Mecanismo: núcleo dentro del plugin, self-test que carga desde una copia, y hermes plugins doctor en el gate.

Un `patch` en modo V4A se salteaba los frenos de escritura

Causa: ese modo no trae path; las rutas van en encabezados dentro del texto. Mecanismo: la gramática V4A va al config; el freno evalúa cada ruta y cada línea agregada.

El arnés se apagaba en el gateway y en cron

Causa: buscaba el repo desde el cwd del proceso, no desde el de la sesión. Mecanismo: el plugin le pregunta a Hermes el cwd de la sesión; caso en el e2e con el proceso afuera y la sesión adentro.

En Windows el gate no fallaba: desaparecía

Causa: consola cp1252; imprimir ✓ reventaba antes de verificar nada. Mecanismo: salida UTF-8 forzada y un caso del self-test que emula cp1252 — lo cazó la matriz de CI.

En producción, la autonomía no se podía ganar

Causa: el nivel vivía en .git/ y la imagen no lo tiene: los días en el nivel quedaban en 0 para siempre, y firmar pedía una shell. Mecanismo: estado en un volumen, evidencia desde el primer evento y transiciones firmadas por PR — lo cazó el piloto doctiling-sre.

Una línea de log podía mandar los secretos al chat

Causa: Hermes adjunta el archivo de MEDIA:<ruta>, y una respuesta cita logs de terceros. Mecanismo: output.defang rompe el marcador antes de que la respuesta salga, con su ejemplo en el self-test.

12portar

Plugin o shell hook: el mismo núcleo, dos adaptadores

El plugin es el camino recomendado. El shell hook existe para quien no puede habilitar plugins.

	Plugin	Shell hook
dónde	`$HERMES_HOME/plugins/repo-harness` + `plugins.enabled`	`hooks:` en `config.yaml`
costo	una llamada de función	un proceso de Python por herramienta
si revienta	`_seguro` → deja pasar	exit ≠ 2 → deja pasar; nunca `exit 1`
cwd de la sesión	se lo pide a Hermes	`workdir` o `TERMINAL_CWD`
lint tras escribir	se inyecta en el resultado	queda en el log

Perfil	Qué es código	Qué es derivado	Señal de tests
python	`.py .pyi`	`uv.lock poetry.lock .venv/`	`pytest -q`
node · front	`.ts .tsx .js .vue .svelte…`	`package-lock.json node_modules/ dist/`	`npm test` (+ build)
go	`.go`	`go.sum vendor/`	`go vet` + `go test`
rust	`.rs`	`Cargo.lock target/`	`cargo clippy` + `cargo test`
dotnet	`.cs .fs .csproj .razor`	`bin/ obj/ packages.lock.json`	`dotnet test`
jvm-maven · jvm-gradle	`.java .kt .scala…`	`target/ build/`	`mvn verify` · `gradlew check`

Un perfil trae hechos del stack, nunca reglas de otro repo: las reglas se escriben con tus incidentes.

13workspace

Varios repos, un orquestador

Un repo de gestión sin código, donde Hermes parte épicas y las despacha, y codificadores con su repo, su tablero, su cola y su agente (Claude Code o Hermes), cada uno con su arnés. Lo que los une es la épica.

gestión · Hermes orquesta

Épicas, milestones, tablero y wiki

Una épica es un issue con un checklist de hijos, una línea por tarea: - [ ] [api] Endpoint de login. dispatch crea un issue hijo por línea en el repo de ese proyecto, vinculado al padre, y lo encola en el loop del codificador. Es todo o nada, y despachar dos veces no repite.

workspace.py init · epic · dispatch · status · wiki

codificador · su agente

Su repo, su tablero, su cola

El hijo llega con «Part of gestion#12» y a la cola como [issue: org/api#5]: el loop le pasa al agente qué issue cierra su PR. status marca en la épica [x] lo cerrado y [!] lo que el loop escaló a un humano.

workspace.py add --profile python --agent claude-code

Forja	CLI	Padre → hijo	Tablero	Pipeline	Estado
GitHub	`gh`	sub-issue, también entre repos	GitHub Projects	Actions	probado en vivo: repos, milestones, épica, sub-issues, tableros, `status`
GitLab	`glab`	issue link	board del proyecto	`.gitlab-ci.yml`	adaptador, en seco
Azure DevOps	`az`	Parent	Azure Boards	`azure-pipelines.yml`	adaptador, en seco

Una forja es un manifiesto (plantillas/forges/<id>.json, con su esquema): agregar una es agregar un archivo. Sin --apply todo corre en seco, y con --apply publicar lo aprueba un humano: el loop nunca publica.

El workspace, de cero ADR 0013

14principios

29 principios, cada uno con su comando

Un principio que dice BLOCKING nombra el comando que falla. Los nuevos respecto de agent-harness están marcados.

Nada se entrega sin gate verde. Omitido no es verde.
Todo freno prueba que muerde — con su example.
Todo freno prueba que no muerde de más — con sus inocentes.
La especificidad va en el config, incluidos los nombres de herramientas de Hermes.
El contrato del plugin se respeta: ningún callback lanza.
Cada señal del gate declara qué error atrapa.
El arnés no escribe en el árbol de fuentes.
Rutas protegidas, incluidas las de ~/.hermes/ — y los secretos tampoco se leen.
Acciones amplias: dry-run y reversibilidad.
La documentación no apunta a la nada.
El trabajo queda registrado en cada commit.
Lo que el agente aprende pasa por los mismos frenos.nuevo
Lo desatendido se decide al crearlo.nuevo
El contexto tiene presupuesto.nuevo
Cada incidente deja infraestructura.
Conducta ante el error: dos intentos, al tercero se escala — y dentro del loop, es mecanismo.review
Lo que viaja son los principios, no las reglas ajenas.review
Guía y freno no se contradicen — regla COHERENCIA.
El arnés tiene presupuesto de latencia — timing.py en el gate.
Lo que no cabe en el gate igual está vivo — deriva programada y mapa.
El loop autónomo tiene salida, tope y freno de mano, y nunca publica.nuevo
Lo que el arnés hace se ve fuera de la conversación — eventos y panel.nuevo
Lo que el arnés promete se reproduce de punta a punta — 22 casos replicables en el gate.nuevo
Lo que entra de un tercero no sale solo — tras leer una web o un ticket, publicar o persistir escala a un humano.nuevo
Un sensor inferencial se mide con una tasa — recall y precisión del revisor contra atajos reales.nuevo
Lo que el agente hace afuera tiene clase, destinatario y tope — integraciones: correo, WhatsApp, navegador, Google, Microsoft, GitHub, bases.nuevo

15docs

Todo lo que esta página resume, en largo

empezá acá