Reelier

---

Tu agente vuelve a derivar el mismo flujo de trabajo en cada ejecución — quemando tokens y desviándose silenciosamente. Reelier compila una ejecución que funcionó en un archivo SKILL.md que se reproduce de forma determinista (sin LLM, 0 tokens, cada paso verificado en un recibo), luego compara ejecuciones para detectar el día en que deja de coincidir. Para agentes en flujos de trabajo de producción recurrentes — donde "se ejecutó" no es una prueba.

Instalar → tu primer recibo en 60 segundos

npm i -g reelier && reelier init

reelier init primero escanea el trabajo que ya has hecho — en Claude Code, Codex, Windsurf y OpenClaw — y ofrece convertir una sesión pasada real en una habilidad reproducible. ¿No tienes ese historial? Ejecuta una demo sin configuración y termina con un recibo real:

Your receipt:
  skill:        reelier-init-demo
  steps:        2 total, 2 passed, 0 unchecked, 0 failed
  replay time:  44ms  [measured]
  LLM tokens:   0     [measured]

  An agent doing a comparable task re-reasons every run (~2.8s, ~18k tokens on
  our benchmark). Your replay: 44ms, 0 tokens.

O ejecútalo con Docker — sin instalar Node

docker run --rm ghcr.io/seldonframe/reelier --help

# Replay a skill from the current directory:
docker run --rm -v "$PWD:/work" -w /work ghcr.io/seldonframe/reelier run my.skill.md

# Record from your agent history (mount it read-only):
docker run --rm -v "$HOME/.claude:/root/.claude:ro" -v "$PWD:/work" -w /work \
  ghcr.io/seldonframe/reelier scan

Por qué

• Tu agente reaprende el trabajo en cada ejecución — y luego se desvía silenciosamente. Cada ejecución vuelve a derivar el flujo de trabajo, y cada pequeña corrección "racional" se acumula — lo que los operadores de larga duración llaman tejido cicatricial. Una habilidad compilada nunca reaprende y no puede desviarse.
• El verdadero problema es la factura. "¿Cuánto costó eso?" es la primera respuesta que recibe cada ejecución larga de un agente. Reelier reproduce por 0 tokens, con un recibo.
• No es RPA frágil. Reproduce llamadas a herramientas (JSON tipado de entrada/salida), no píxeles — y cada paso lleva su propia aserción, por lo que un paso roto falla estrepitosamente, nunca pasa silenciosamente.
• ¿Actualizaste el modelo? Una reproducción está fijada — vuelve a grabar con el nuevo modelo y reelier diff contra tu línea base congelada: IGUAL o DESVIADO, por paso, antes de que llegue a producción.
• "Cualquier cosa determinista debería ser simplemente código." De acuerdo — tu agente ya lo escribió. Reelier captura su ejecución real y funcional en un archivo probado. Determinismo sin la codificación manual.

Cómo funciona — grabar → compilar → reproducir → comparar → recibo

reelier init                        # 60s: record → compile → replay → your receipt
reelier run  <name>.skill.md        # replay deterministically — 0 tokens (read-only by default)
reelier diff <name>                 # SAME or DRIFTED, per step — exit 1 on drift
reelier push <name>.skill.md        # sync receipts to your ledger (opt-in)

1. Grabar — tres formas: reelier mcp --wrap "<your mcp server>" (un proxy sin pérdidas frente a las herramientas de tu agente), directamente desde una sesión existente (reelier scan / reelier from-session), o el reelier init guiado.
2. Compilar — reelier compile convierte una traza en un SKILL.md de forma determinista (0 llamadas al LLM) — una receta con una aserción en cada paso, y las brechas honestas del compilador se imprimen como Preguntas abiertas (incluyendo fechas literales, UUIDs y marcas de tiempo que señala como "¿debería ser esto una variable?") en lugar de adivinarlas.
3. Reproducir — reelier run lo ejecuta en Nivel 0: sin LLM, milisegundos, idéntico a nivel de bytes. Solo lectura por defecto — un paso de escritura (idempotent-write) nunca se vuelve a ejecutar a menos que pases --allow-writes.
4. Comparar — reelier diff compara dos ejecuciones de una habilidad e informa IGUAL o DESVIADO por paso, con la aserción fallida como el porqué. Código de salida 1 en caso de desviación, por lo que controla una reproducción programada.
5. Recibo — cada ejecución es un recibo (resultados por paso, tiempos, 0 tokens). reelier push opcionalmente los sincroniza con un libro de recibos para un enlace permanente compartible + una insignia de reproducción verificada incrustable.

Convertir una habilidad de agente

Convierte una habilidad de instrucción + una ejecución grabada en una reproducción determinista — tu habilidad, menos el modelo:

reelier mcp --wrap "<your mcp server>"                 # record: agent runs the skill's task once
reelier compile trace.jsonl --from-skill ./my-skill/SKILL.md
# → my-skill.skill.md — name + description carried from your SKILL.md,
#   steps ONLY from the recorded run (never generated from instruction text)

Importar sesiones desde cualquier agente

Ya tienes flujos de trabajo reproducibles en los registros de sesión de tu propio agente. reelier scan los encuentra; reelier from-session convierte uno en una habilidad. El formato se detecta del contenido del archivo — no se necesita bandera para los agentes soportados:

reelier scan                                          # discovers sessions from every known agent under your home dir
reelier from-session ~/.claude/projects/*/*.jsonl      # Claude Code
reelier from-session ~/.codex/sessions/**/rollout-*.jsonl   # Codex CLI
reelier from-session ~/.openclaw/agents/*/sessions/*.jsonl  # OpenClaw

Agente	Ubicación de la sesión	Estado
Claude Code	~/.claude/projects/<project>/<uuid>.jsonl	soportado
Codex CLI	~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl	soportado
OpenClaw	~/.openclaw/agents/<agentId>/sessions/<sessionId>.jsonl	soportado
Cursor	.../User/globalStorage/state.vscdb (SQLite, no documentado)	detectado, aún no analizable
Windsurf	.../User/globalStorage/state.vscdb (SQLite, no documentado)	detectado, aún no analizable

Solo las llamadas reproducibles (las propias funciones integradas de Reelier, o las llamadas mcp__<server>__<tool>) se compilan en una habilidad — las acciones nativas de archivo/shell/búsqueda se reportan como omitidas, nunca se fabrican en un paso. Pasa --agent <claude-code|codex|openclaw> para forzar un formato en lugar de la detección automática; reelier scan / reelier from-session --agent cursor (o --agent windsurf) informan lo que hay en el disco honestamente en lugar de adivinar un formato binario no documentado.

Tres pruebas, una habilidad

Una habilidad grabada te da tres preguntas diferentes que hacerle, no una:

• Determinismo — reelier run <skill.md> reproduce contra las aserciones que grabaste. Mismos pasos, mismas aserciones, 0 tokens. Responde: ¿esto todavía hace lo que hacía?
• Recuperación — reelier run <skill.md> --fail N[=status] inyecta un fallo sintético en el paso N (estado predeterminado 500; sobrescribir con --fail N=429, repetible) en lugar de despachar la llamada a la herramienta real de ese paso, luego ejecuta la MISMA escalera de escalamiento que alcanzaría un fallo real. Nada fuera de la red sucede realmente — un paso simulado nunca llama a su herramienta, por lo que puedes probar la recuperación de un paso de escritura sin --allow-writes y sin efecto secundario. Responde: si esto se rompiera, ¿la habilidad lo notaría y se recuperaría? (Una ejecución simulada es solo una prueba local — reelier push se niega a publicar una; ver más abajo.)
• Desviación — reelier run <skill.md> --wrap "<your mcp server>" reproduce contra tus dependencias en vivo y de solo lectura en lugar de la traza grabada. Combinado con reelier manifest (abajo), así es como detectas que el esquema de una herramienta se mueve debajo de ti antes de que lo haga una reproducción real.

Taxonomía gracias a la revisión de Mads Hansen de la publicación de lanzamiento.

Desviación del esquema de herramienta: reelier manifest

Los pasos de una habilidad llaman a herramientas específicas con formas de argumentos específicas. Si el esquema de herramienta de un servidor MCP envuelto cambia desde que grabaste contra él, la reproducción debe negarse estrepitosamente, no llenar silenciosamente los argumentos incorrectos. reelier manifest estampa un resumen del esquema para cada herramienta que los pasos de la habilidad realmente usan:

reelier manifest <skill.md> --wrap "<your mcp server>"   # stamp/refresh the manifest from live servers
reelier run <skill.md> --wrap "<your mcp server>"         # preflight checks the manifest BEFORE step 1 runs

Si el esquema de una herramienta estampada se ha desviado (o la herramienta desapareció), reelier run falla de forma cerrada — MANIFEST DRIFT — refusing to replay — antes de que algo se ejecute. --ignore-manifest es la anulación explícita de emergencia para cuando sabes que la desviación es aceptable; todavía se registra en la ejecución (manifestIgnored: true), por lo que nunca es una omisión silenciosa. Una habilidad sin manifiesto simplemente recibe una nota informativa — cada habilidad anterior al manifiesto sigue funcionando sin modificaciones.

Aprobación de escritura por paso: reelier approve

--allow-writes/--yes son banderas generales — dicen "esta ejecución puede escribir", no "esta escritura exacta está revisada". reelier approve vincula mediante hash la aprobación a la plantilla de herramienta + argumentos de un paso específico:

reelier approve <skill.md>          # walk each write/destructive step, y/N to approve
reelier approve <skill.md> --all    # approve every write step non-interactively

Un paso aprobado cuya herramienta/args todavía coinciden con su hash estampado se ejecuta sin banderas en absoluto. Si la herramienta o los args del paso han cambiado desde la aprobación, la reproducción falla de forma cerrada — Approval mismatch — y ninguna bandera la anula; vuelves a revisar y reapruebas. Un paso de escritura sin campo approve: mantiene el comportamiento exacto actual de --allow-writes/--yes, sin cambios.

Afirmar el valor, no solo la forma

Las aserciones de una habilidad son lo que hace que una reproducción sea una prueba. La gramática verifica estado, estructura, y valor:

- assert: status == 200
- assert: json.results is array
- assert: json.count >= 1              # numeric range
- assert: json.plan is string          # type
- assert: json.id matches /^usr_/      # value pattern
- assert: body contains "ok"

Úsalo dentro de tu agente de codificación (MCP)

reelier serve expone los propios comandos de Reelier como herramientas MCP, para que Claude Code / Cursor / Windsurf / Codex puedan llamarlo en mitad de la sesión:

{ "mcpServers": { "reelier": { "command": "npx", "args": ["-y", "reelier", "serve"] } } }

El agente obtiene reelier_scan, reelier_from_session, reelier_replay, reelier_diff y reelier_push — con descripciones que le dicen exactamente cuándo usar cada una (y cuándo no). Graba una tarea determinista una vez, luego reproduce en lugar de volver a razonar.

Herramientas

• reelier_scan — escanea el historial de sesiones del agente (Claude Code, Codex, Windsurf, OpenClaw) en busca de flujos de trabajo de llamadas a herramientas reproducibles
• reelier_from_session — compila una sesión grabada en un SKILL.md reproducible con una aserción en cada paso
• reelier_replay — reproduce una habilidad de forma determinista con 0 tokens de LLM (solo lectura por defecto; escrituras controladas por --allow-writes)
• reelier_diff — compara dos ejecuciones: IGUAL o DESVIADO por paso, con la aserción fallida como el porqué; sale con 1 en caso de desviación
• reelier_push — sincroniza un recibo de ejecución con el libro mayor para un enlace permanente compartible (opcional)

La prueba medida

De una comparativa real en vivo (agente vs. Reelier, misma tarea, mismos datos) — tablas completas + metodología en examples/benchmark:

• 1,000 / 1,000 reproducciones idénticas a nivel de bytes (prueba de varianza de cola N=1000)
• 0 tokens por reproducción — verificado del registro de ejecución, no asumido
• ~50× más barato ($0.000000/reproducción vs. $0.019068/ejecución promediado sobre el brazo del agente)
• ~59× más rápido (48ms vs. 2,842ms de latencia promedio)
• una desviación real se auto-reparó por ~$0.001, una vez, luego gratis en cada reproducción posterior

La latencia varía según la red — la reproducción de Nivel 0 vuelve a ejecutar las llamadas a herramientas de la habilidad, por lo que el tiempo real depende de tu conexión. Lo que no varía: 0 tokens de LLM, los mismos pasos en cada ejecución y el recibo. Corroborado independientemente — arXiv 2605.14237 encontró una reducción de tokens del 93.3–99.98% para el mismo patrón de grabar y reproducir.

Funciona con cualquier modelo (BYOK)

La reproducción de Nivel 0 (la predeterminada) nunca llama a un modelo — 0 tokens, por construcción. El escalamiento (--max-level 1|2) es opcional y se comunica a través de una superficie BYOK estrecha (--llm-base-url + --llm-model): un adaptador nativo de Mensajes de Anthropic, y un adaptador compatible con OpenAI para todo lo demás (OpenRouter, Ollama, el endpoint OpenAI de Gemini, Groq, vLLM, LM Studio, Kimi, …). Apúntalo a un modelo más fuerte y la próxima auto-reparación de cada habilidad se vuelve más inteligente gratis.

Hazlo tuyo — MIT, BYOK, local-first

Úsalo en cualquier lugar, incrústalo en cualquier cosa — sin ataduras de copyleft, sin necesidad de revisión legal. Tus habilidades, trazas y registros de ejecución son tus datos — irse es copiar una carpeta. Los formatos están especificados en SPEC.md, una referencia normativa estilo RFC para que cualquiera pueda emitirlos o consumirlos sin leer el código fuente.

Contribuir

Issues y PRs bienvenidos — consulta SPEC.md para los formatos (la especificación prevalece sobre el código; arregla el código, no la especificación). npm test ejecuta la suite completa; npm run build && npx tsc --noEmit antes de un PR.

git clone https://github.com/seldonframe/reelier && cd reelier
npm install && npm test

Historial de estrellas

Licencia

MIT — libre para bifurcar, incrustar, auditar y autoalojar para siempre. (Las versiones ≤0.16.0 se lanzaron bajo AGPL-3.0 y permanecen así.)