Cómo construir un sistema operativo agente con Fable 5 (Guía para desarrolladores)

Este es un desglose completo de la A a la Z sobre Claude Fable 5: qué es y cómo usarlo como un ingeniero 100x

Esto cambiará todo sobre cómo trabajas con Claude

Guarda estos 8 builds antes de que los olvides

Introducción

Tienes el modelo más capaz jamás creado disponible para el público general, y sigues escribiendo prompts uno por uno. Esta guía soluciona eso.

Esta es la situación a julio de 2026. Fable 5 puede ejecutarse durante horas sin supervisión, desplegar sus propios subagentes y hacer una semana de trabajo en una noche. También tiene medidor de uso ($10/M entrada, $50/M salida a través de créditos de uso), da resultados excesivos cuando el alcance no está delimitado, y defiende sus errores de manera más convincente que la mayoría de las personas defienden sus respuestas correctas.

Usado de manera casual, es una forma costosa de generar cosas impresionantemente incorrectas. Usado dentro de un sistema, es lo más parecido a un empleado que puedes alquilar por tres dólares al día.

Esta guía construye ese sistema. No una filosofía del mismo: los archivos reales, en orden, con un punto de control después de cada uno para que sepas que funciona antes de apilar la siguiente pieza encima.

Lo que tendrás al final:

• Un CLAUDE.md con el que el modelo no puede negociar (BUILD 1)
• Un bucle diario donde Fable 5 toma todas las decisiones pero escribe casi ningún token, los modelos baratos hacen el trabajo, un verificador independiente lo califica, y un script bash tiene el voto final (BUILDs 2-3)
• Un libro de confianza que otorga y revoca autonomía por habilidad, automáticamente, basado en tasas de aprobación medidas (BUILD 4)
• Un directorio de objetivos donde todo lo que alguna vez terminas sigue siendo verificado diariamente, para siempre, para que nada se pudra en silencio (BUILD 5)
• Un presupuesto que se hace cumplir a sí mismo en lugar de sorprenderte (BUILD 6)
• Cuatro bucles opcionales (quórum, trinquete, sparring, compostaje) cada uno con la condición que te dice cuándo instalarlo (BUILD 7)
• Un programa cron, un manual de operaciones para cada alarma que el sistema pueda generar, y un programa de confianza de 30 días que lo lleva de supervisado a autoextensible.

Para quién es esto. Cualquiera con un repositorio, una terminal y una suscripción a Claude Code o una clave API. Los ejemplos tienen sabor a código porque los bucles crecieron alrededor de bases de código, pero el sistema de objetivos y la mitad de los bucles funcionan igual de bien con facturas, informes y listas de lectura; los predicados son solo comandos de shell.

Cómo leerlo. En orden, haciendo las comprobaciones. BUILD 0 es la configuración oficial de Anthropic y el lenguaje de prompts; todo lo demás es el sistema construido sobre eso. Cada build toma de 10 a 20 minutos. Los 30 días al final no son tiempo de lectura; son el programa de confianza gradual durante el cual el sistema gana el derecho a ejecutarse sin ti. Tiempo práctico total: aproximadamente 2 horas.

Los tres principios que subyacen a todo, para que puedas predecir cualquier decisión de diseño antes de leerla:

1. Leyes, no consejos. Cada regla tiene un número, un "nunca" o un comando que la verifica. Cualquier cosa más suave se optimiza para desaparecer.
2. Nada califica su propia tarea. El planificador, el trabajador, el verificador y la puerta son cuatro partes diferentes, y la última es determinista.
3. Nada que haya pasado una vez queda sin vigilancia. El trabajo terminado se gradúa a un invariante que se verifica nuevamente. Un objetivo que solo verificas una vez es una suposición con una marca de tiempo.

Sin ensayos de aquí en adelante. Ocho builds, cada uno con archivos, comandos y un punto de control.

Requisitos previos

1CLI de Claude (Claude Code) con acceso a Fable 5     # créditos de uso habilitados, límite de /usage-credits establecido
2CLI de llm + clave de OpenRouter                      # llm install llm-openrouter
3jq, gh, git, make, cron
4un repositorio con un comando de prueba

Lo que estás construyendo

1tu-repositorio/
2  CLAUDE.md                    # BUILD 1: la constitución
3  loop/
4    loop.sh                    # BUILD 3: el latido
5    conductor.md               # BUILD 3: prompt de enrutamiento
6    triage.md                  # BUILD 3: prompt de lectura barata
7    contract.md                # BUILD 2: las tres listas
8    workers/implement.md       # BUILD 3
9    workers/verify.md          # BUILD 3
10    guardrails/verify.sh       # BUILD 2: puerta determinista
11    scripts/trust-log.sh       # BUILD 4
12    scripts/log-cost.sh        # BUILD 6
13    scripts/cost-check.sh      # BUILD 6
14    quorum.sh                  # BUILD 7 (opcional)
15    verify-goals.sh            # BUILD 5
16    goals/                     # BUILD 5: objetivos permanentes
17    skills/                    # BUILD 4: un archivo por empleado
18    memory/
19      STATE.md  trust.tsv  goal-ledger.tsv  dispatch.tsv  usage.log
20  Makefile                     # BUILD 8: tick / queue / trust / audit / dream

BUILD 0: Configurar el Motor (de la documentación oficial de Fable 5)

Todo en este build proviene de la documentación oficial de Anthropic. Establece esto antes de escribir cualquier archivo propio.

La hoja de especificaciones:

Configuración

Valor

Fuente

Cadena del modelo

claude-fable-5

descripción general de modelos

Contexto / salida

1M tokens / hasta 128k de salida por solicitud

documentos de introducción

Precio

$10/M entrada, $50/M salida

documentos de introducción

Pensamiento

adaptativo, siempre activo;

thinking: {type:"disabled"}

es RECHAZADO; la salida de pensamiento solo se resume

documentos de introducción + esfuerzo

Esfuerzo

bajo

medio

alto

muy alto

máximo

;

alto

= predeterminado = omitir el parámetro

documentos de esfuerzo

Forma de la API

output_config: {"effort": "..."}

en la API de Messages

documentos de esfuerzo

Cinco hechos oficiales que cambian cómo construyes:

1. max_tokens es un límite estricto para el pensamiento MÁS el texto de respuesta. En alto y muy alto, establécelo grande (comienza en 64k) o Fable se queda sin espacio a mitad del pensamiento. Se aplica a cada llamada claude -p en esta guía.
2. muy alto es oficialmente para "tareas agénticas de larga duración (más de 30 minutos) con presupuestos de tokens en millones". Ese es el asiento del conductor y nada más en este sistema. Los documentos también dicen que un esfuerzo menor en Fable 5 "a menudo supera el rendimiento muy alto en modelos anteriores", así que resiste la tentación de actualizar a los trabajadores.
3. Los rechazos son HTTP 200. Fable 5 ejecuta clasificadores de seguridad (cibernética ofensiva, biología/ciencias de la vida, extracción de razonamiento). Una solicitud rechazada devuelve stop_reason: "refusal" como una respuesta EXITOSA. Tus scripts deben verificar la razón de parada, no el código de salida. Remedio oficial: configura respaldos del lado del servidor o middleware del SDK para redirigir a Opus 4.8.
4. Nunca le pidas a Fable que repita su razonamiento. Los prompts o habilidades que dicen "muestra tu pensamiento" o "explica tu razonamiento en la respuesta" activan la categoría de rechazo reasoning_extraction y elevan los respaldos. Audita cada habilidad antigua para esto al migrar. Lee los bloques de pensamiento estructurados en su lugar.
5. Los turnos son largos por diseño. Las tareas difíciles toman muchos minutos por solicitud con mayor esfuerzo; las ejecuciones autónomas se extienden durante horas. Ajusta los tiempos de espera del cliente y verifica las ejecuciones de forma asíncrona (tareas programadas, no esperas bloqueantes). Esta es la razón por la que el latido es cron, no un bucle bloqueante.

El paquete de prompts oficial. Anthropic envía lenguaje de prompts probado para los comportamientos conocidos de Fable 5. Estos van en tus prompts textualmente; no los parafrasees para hacerlos más cortos:

1. Anti-sobreplanificación (para el conductor y cualquier sesión interactiva):

1Cuando tengas suficiente información para actuar, actúa. No vuelvas a derivar hechos ya
2establecidos en la conversación, no re-litiges una decisión que el usuario ya ha
3tomado, ni narres opciones que no vas a perseguir. Si estás sopesando una elección,
4da una recomendación, no un estudio exhaustivo.

2. Anti-sobreingeniería (para cada prompt de trabajador; esta es la valla oficial contra la entrega excesiva):

1No agregues funciones, refactorices ni introduzcas abstracciones más allá de lo que la tarea
2requiere. Una corrección de errores no necesita limpieza circundante. No diseñes para
3requisitos futuros hipotéticos: haz lo más simple que funcione bien.
4No agregues manejo de errores ni validación para escenarios que no pueden ocurrir.
5Solo valida en los límites del sistema.

1. Afirmaciones de progreso fundamentadas (para cualquier ejecución larga; en las pruebas de Anthropic esto eliminó casi por completo los informes de estado fabricados):

1Antes de informar el progreso, audita cada afirmación contra un resultado de herramienta de esta
2sesión. Solo informa trabajo del que puedas señalar evidencia; si algo aún no está
3verificado, dilo explícitamente. Si las pruebas fallan, dilo con la salida; si un
4paso se omitió, dilo.

1. Recordatorio de canalización autónoma (para cada prompt impulsado por cron; elimina la parada temprana "Ahora ejecutaré X"):

1Estás operando de forma autónoma. El usuario no está mirando y no puede responder preguntas
2a mitad de la tarea. Para acciones reversibles que se derivan de la solicitud
3original, procede sin preguntar. Antes de terminar tu turno, revisa tu último
4párrafo: si es un plan, una pregunta o una promesa sobre trabajo que no has
5hecho, haz ese trabajo ahora con llamadas a herramientas. Termina solo cuando la tarea esté
6completa o estés bloqueado por una entrada que solo el usuario puede proporcionar.

1. Formato de memoria oficial (para el soñador y memory/learnings/):

1Almacena una lección por archivo con un resumen de una línea en la parte superior. Registra
2correcciones y enfoques confirmados por igual, incluyendo por qué fueron importantes.
3No guardes lo que el repositorio ya registra; actualiza las notas existentes en lugar de
4duplicar; elimina las notas que resulten ser incorrectas.

1. Instrucción oficial del verificador (los documentos lo indican directamente: "los subagentes verificadores separados con contexto nuevo tienden a superar la autocrítica"):

1Establece un método para verificar tu propio trabajo en un intervalo de [X] mientras
2construyes. Ejecuta esto cada [intervalo X], verificando tu trabajo con subagentes
3contra la especificación.

Dos órdenes de andamiaje de los documentos que vale la pena obedecer: comienza en la parte superior de tu rango de dificultad (probar Fable solo en cargas de trabajo simples lo infravalora; dale el problema más difícil no resuelto y deja que lo delimite), y refactoriza habilidades antiguas (las instrucciones escritas para modelos anteriores son a menudo demasiado prescriptivas para Fable 5 y DEGRADAN la salida; si el rendimiento predeterminado es mejor sin una instrucción, elimina la instrucción).

CHECK 0: Cada llamada claude -p en tus scripts tiene un max_tokens grande explícito donde sea compatible; tus scripts verifican stop_reason: "refusal"; ningún prompt o habilidad en ningún lugar dice "muestra tu pensamiento".

BUILD 1: La Constitución (CLAUDE.md)

Por qué, en una línea: Fable sigue leyes y optimiza alrededor de consejos, por lo que cada línea necesita un número, un "nunca" o un comando que la verifique.

Reglas para el archivo: cuatro bloques, menos de 150 líneas, sin "piensa paso a paso" (el razonamiento siempre está activo; esos son tokens pagados), sin personas de agente predefinidas (Fable diseña mejores equipos de los que puedes predefinir), principalmente señales de alto.

Crea CLAUDE.md:

1# CLAUDE.md
2
3## NUNCA (leyes; las excepciones requieren preguntar primero)
4- Nunca excedas 200 líneas cambiadas en un solo commit sin preguntar.
5- Nunca toques src/auth/, src/billing/, migrations/ o la configuración de producción sin supervisión.
6- Nunca informes trabajo como hecho basándote en tu propia evaluación. Hecho = la comprobación pasó.
7- Nunca inventes un secreto, un endpoint o una convención. Detente y pregunta.
8- Nunca agregues una dependencia. Propónla en STATE.md y detente.
9- Nunca excedas el esfuerzo alto dentro de ningún bucle. Muy alto es solo para revisiones únicas.
10- Nunca edites ni elimines una prueba para que pase. Eso es un fallo, siempre.
11- Nunca repitas, transcribas ni expliques tu razonamiento interno en el texto de respuesta.
12  (Oficial: activa los rechazos de reasoning_extraction en Fable 5).
13- Cuando una condición de /goal pase, escribe goals/<nombre>.md con la condición como
14  su predicado antes de informar éxito.
15
16## DESPACHO (enruta cada tarea; la primera coincidencia gana; registra en memory/dispatch.tsv)
17| modelo           | marginal | apetito | inteligencia | gusto |
18|-----------------|----------|----------|--------------|-------|
19| claude-fable-5  | 2 (créditos) | 3     | 10           | 10    |
20| claude-opus-4-8 | 7 (sub)  | 6        | 8            | 9     |
21| claude-sonnet-5 | 9 (sub)  | 8        | 7            | 7     |
22| codex (2nd sub) | 9        | 10       | 9            | 5     |
231. Decisión (planificar/revisar/enrutar/punto muerto) -> fable-5, esfuerzo alto, solo lectura.
242. Lecturas >50k tokens (registros/PDFs/capturas de pantalla) -> codex. Nunca fable.
253. Se envía a usuarios (UI/API/copia) -> gusto >= 8 obtiene el pase final.
264. Especificación completa -> sonnet-5, esfuerzo medio.
275. Sino sonnet-5; escala un escalón en caso de fallo sin preguntar.
28
29## PALABRAS
30- "inteligencia" = el problema más difícil manejado sin supervisión
31- "gusto" = UI/UX, calidad del código, diseño de API, copia
32- "hecho" = el predicado pasa; nada más
33- "pequeño" = menos de 50 líneas cambiadas; "rápido" = menos de 10 minutos de tu tiempo
34- "limpieza" = comportamiento idéntico, verify.sh verde antes y después
35
36## HECHO
37- Cada tarea tiene un done_when comprobable por máquina antes de que comience el trabajo.
38- Un agente con contexto nuevo que no vio ni el plan ni el borrador verifica contra él.
39- guardrails/verify.sh tiene el voto final.
40- Desviaciones: opción conservadora, registra en IMPLEMENTATION.md, continúa.
41- Creador y verificador no están de acuerdo dos veces -> detente, pon en cola para un humano.

Edita los números y rutas a los tuyos. El material específico del flujo de trabajo (procedimiento de PR, lista de verificación de lanzamiento) va en skills/, no aquí.

CHECK 1: Para cada línea pregúntate: ¿podría el modelo cumplir al 80% y afirmar éxito? Si es así, reescríbela con un número o un "nunca". wc -l CLAUDE.md menos de 15

BUILD 2: Muros y Puerta

Por qué: el radio de explosión debe declararse antes del primer tick, y un script bash debe tener el voto final.

Crea loop/contract.md:

1## actúa solo
2PRs de borrador en ramas; corrige deuda de lint/pruebas; actualiza STATE.md; etiqueta issues
3
4## pone en cola para mí
5autenticación, pagos, migraciones; cualquier habilidad por debajo del nivel "auto"; cualquier diff > 400 líneas
6
7## me despierta
8la verificación falla dos veces en el mismo elemento
9el enrutador de salvaguarda cambió de modelos a mitad de ejecución
10el presupuesto diario se excedió
11cualquier cosa solicita un secreto
12un objetivo permanente es VIOLADO

Crea loop/guardrails/verify.sh (edítalo para tu stack):

1#!/usr/bin/env bash
2set -e
3npm run typecheck --if-present
4npm test --if-present
5npm run lint --if-present

CHECK 2: ./loop/guardrails/verify.sh se ejecuta y sale con 0 en tu repositorio actual. Si falla ahora, arréglalo primero; todo el sistema se basa en este script.

BUILD 3: El Latido

Por qué, en tres líneas: Fable como trabajador es una factura de cuatro cifras (sesiones de 500k-1M tokens a $50/M de salida); Fable como conductor emite el 10-20% de los tokens mientras toma el 100% de las decisiones. Un modelo de $0.01 lee los ticks silenciosos. Los agentes se pasan el testigo a través de un esquema JSON para que cualquier modelo encaje en cualquier asiento.

Crea loop/triage.md:

1Recibes commits recientes, issues abiertos y ejecuciones de CI. Genera SOLO hallazgos:
2- hallazgo: <una línea>
3  evidencia: <id de commit/issue/ejecución>
4  estado: procesable | informativo
5Sin correcciones, sin opiniones. Nada que informar = genera exactamente "estado: tranquilo".
6Cualquier cosa que toque autenticación, pagos, migraciones, secretos = siempre procesable,
7anotado "sensible-al-contrato".

Crea loop/conductor.md:

1Eres el conductor. No escribes código. No editas archivos.
21. Lee STATE, LIBRO DE CONFIANZA, CONTRATO a continuación. No confíes en la memoria de ellos.
32. Elige el ÚNICO elemento procesable de mayor valor.
4   sensible-al-contrato, ambiguo o probablemente diff >400 líneas -> acción: poner en cola
5   nada que valga la pena hacer -> acción: detener
63. Sino acción: ejecutar, con una especificación que un modelo mediocre pueda seguir.
7Genera SOLO este JSON:
8{ "action": "execute|queue|stop", "item": "...", "skill": "<kebab-case,
9estable entre ejecuciones>", "spec": "...", "done_when": ["<verificable>", ...] }
10Eres caro. Sé breve. Tu salida es una decisión, no un ensayo.

Crea loop/workers/implement.md:

1Recibes una orden de trabajo (JSON). Ejecuta la especificación exactamente.
2Da el ÚNICO siguiente paso hacia done_when. Los diffs pequeños ganan.
3Credencial faltante o decisión no documentada -> DETENTE, escribe la pregunta en
4IMPLEMENTATION.md. Nunca inventes secretos o convenciones.
5Registra lo que hiciste y por qué en IMPLEMENTATION.md (máximo 3 líneas).

Crea loop/workers/verify.md:

1Recibes una ESPECIFICACIÓN y un DIFF, nada más. Juzga solo lo que tienes delante.
21. ¿El diff satisface cada done_when? Cita líneas.
32. ¿Algo fuera del alcance de la especificación? Fracaso instantáneo. ¿Pruebas eliminadas/saltadas? Fracaso instantáneo.
4Genera exactamente una línea: "PASS: <razón>" o "FAIL: <razón>".
5El creador estaba seguro. Eso no es evidencia.

Crea loop/loop.sh:

1#!/usr/bin/env bash
2set -euo pipefail
3cd "$(dirname "$0")"
4MAX_ITERS="${MAX_ITERS:-10}"
5DAILY_BUDGET_USD="${DAILY_BUDGET_USD:-5}"
6CHEAP="${CHEAP:-openrouter/deepseek/deepseek-v4-flash}"
7WORKER="${WORKER:-openrouter/moonshotai/kimi-k2.6}"
8
9./scripts/cost-check.sh --budget "$DAILY_BUDGET_USD" || exit 3
10
11for ((i=1; i<=MAX_ITERS; i++)); do
12  # 1 TRIAGE: puerta de tick silencioso, ~$0.01
13  { git log --oneline -20; gh issue list --limit 20 2>/dev/null || true; \
14    gh run list --limit 10 2>/dev/null || true; } \
15    | llm -m "$CHEAP" -s "$(cat triage.md)" >> memory/STATE.md
16  ./scripts/log-cost.sh triage 0.01
17  grep -q "status: actionable" memory/STATE.md || { echo quiet; exit 0; }
18
19  # 2 CONDUCTOR: Fable, muy alto, contexto nuevo, solo lectura, JSON de salida
20  claude -p "$(cat conductor.md)
21STATE: $(cat memory/STATE.md)
22TRUST: $(./scripts/trust-log.sh --render)
23CONTRACT: $(cat contract.md)" \
24    --model claude-fable-5 --effort xhigh --allowedTools "Read" \
25    --output-format json > /tmp/c.json
26  ./scripts/log-cost.sh conductor 0.35
27
28  # 2a TOLERANCIA DE RUTA: nunca iteres en un modelo que no elegiste
29  SERVED=$(jq -r '.modelUsage | keys[0] // "claude-fable-5"' /tmp/c.json)
30  [[ "$SERVED" != *fable* ]] && { echo "rerouted" >> memory/STATE.md; exit 2; }
31
32  jq -r '.result' /tmp/c.json > work-order.json
33  SKILL=$(jq -r .skill work-order.json); ACTION=$(jq -r .action work-order.json)
34  [[ "$ACTION" == stop  ]] && exit 0
35  [[ "$ACTION" == queue ]] && { echo "queued: $SKILL" >> memory/STATE.md; continue; }
36
37  # 3 EJECUTAR: trabajador barato, árbol de trabajo aislado
38  WT="../wt-$i"; git worktree add "$WT" -b "loop/$SKILL-$i" >/dev/null
39  ( cd "$WT" && llm -m "$WORKER" -s "$(cat "$OLDPWD/workers/implement.md")" \
40      "$(cat "$OLDPWD/work-order.json")" > IMPLEMENTATION.md )
41  ./scripts/log-cost.sh worker 0.10
42
43  # 4 VERIFICAR: Fable nuevo, sin herramientas, ve solo especificación + diff
44  V=$(claude -p "$(cat workers/verify.md)
45SPEC: $(jq -r .spec work-order.json)
46DIFF: $(cd "$WT" && git diff)" \
47    --model claude-fable-5 --effort high --allowedTools "" \
48    --output-format json | jq -r .result)
49  ./scripts/log-cost.sh verifier 0.40
50
51  # 5 PUERTA: determinista; luego libro de confianza; enviar solo en nivel auto
52  if [[ "$V" == PASS* ]] && ( cd "$WT" && "$OLDPWD/guardrails/verify.sh" ); then
53    ./scripts/trust-log.sh "$SKILL" pass
54    if [[ "$(./scripts/trust-log.sh --tier "$SKILL")" == auto ]]; then
55      ( cd "$WT" && git add -A && git commit -qm "loop: $SKILL" && gh pr create --fill || true )
56      echo "- shipped: $SKILL" >> memory/STATE.md
57    else
58      echo "- review: $SKILL in $WT" >> memory/STATE.md
59    fi
60  else
61    ./scripts/trust-log.sh "$SKILL" fail
62    echo "- FAILED: $SKILL in $WT" >> memory/STATE.md
63  fi
64  ./scripts/cost-check.sh --budget "$DAILY_BUDGET_USD" || exit 3
65done
66exit 1   # límite de iteraciones sin detener: verifica STATE.md

Mapa de salida: 0 tranquilo/hecho, 1 límite, 2 redirigido, 3 presupuesto. Todos etiquetados, a propósito.

CHECK 3: chmod +x loop.sh guardrails/verify.sh luego ejecuta ./loop.sh una vez manualmente. Confirma: un repositorio tranquilo sale con 0 por aproximadamente un centavo; un repositorio procesable produce work-order.json con los cinco campos y una línea de veredicto en STATE.md.

BUILD 4: El Libro de Confianza

Por qué: "aumenta la autonomía a medida que crece la confianza" no es un mecanismo; un TSV con reglas de nivel sí lo es. La autonomía es por habilidad, no por bucle.

Crea loop/scripts/trust-log.sh:

1#!/usr/bin/env bash
2# uso: trust-log.sh <habilidad> <pass|fail> | --render | --tier <habilidad>
3set -euo pipefail
4F="$(dirname "$0")/../memory/trust.tsv"; touch "$F"
5tier_of() { awk -v r="$1" -v p="$2" 'BEGIN{
6  tasa=(r>0)?p/r:0
7  if (r>=20 && tasa>=0.95) print "auto"
8  else if (r<10 || tasa<0.90) print "watch"
9  else print "queue"}'; }
10case "${1:-}" in
11  --render)
12    printf "%-20s %5s %5s %6s %s\n" habilidad ejecuciones pases tasa nivel
13    while IFS=$'\t' read -r s r p; do [ -z "$s" ] && continue
14      printf "%-20s %5s %5s %5s%% %s\n" "$s" "$r" "$p" \
15        "$(awk -v r="$r" -v p="$p" 'BEGIN{printf "%.0f",(r>0)?p/r*100:0}')" \
16        "$(tier_of "$r" "$p")"; done < "$F";;
17  --tier)
18    line=$(grep -P "^${2}\t" "$F" || echo -e "${2}\t0\t0")
19    tier_of "$(cut -f2 <<<"$line")" "$(cut -f3 <<<"$line")";;
20  *)
21    awk -v s="$1" -v r="$2" -F'\t' 'BEGIN{OFS="\t"; f=0}
22      $1==s {f=1; print s,$2+1,$3+(r=="pass"); next} {print}
23      END{if(!f) print s,1,(r=="pass")?1:0}' "$F" > "$F.t" && mv "$F.t" "$F"
24    if [ "$2" = fail ]; then
25      runs=$(grep -P "^${1}\t" "$F" | cut -f2)
26      [ "$("$0" --tier "$1")" = watch ] && [ "$runs" -ge 10 ] \
27        && echo "ALERTA: $1 degradado a watch después de $runs ejecuciones" >&2 || true
28    fi;;
29esac

• Reglas de nivel: auto = 20+ ejecuciones Y 95%+ de aprobación, se envía sin supervisión. queue = los borradores verificados te esperan. watch = menos de 10 ejecuciones o menos del 90%, solo borrador. La degradación es automática y se imprime en stderr, que cron te envía por correo.
• Siembra la lista: crea loop/skills/<nombre>/SKILL.md para cada tarea recurrente (fix-lint-debt, fix-flaky-test, bump-deps, triage-issues son las cuatro estándar). Cada archivo: metadatos (nombre, descripción, cuándo), pasos, una lista de "nunca", un done-when verificable. Cada habilidad comienza en watch.

CHECK 4: Ejecuta ./scripts/trust-log.sh demo pass 21 veces, luego --tier demo imprime auto. Registra un fallo en una habilidad con 10+ ejecuciones y ve la ALERTA en stderr. Restablece: > memory/trust.tsv.

BUILD 5: Objetivos Permanentes + el Libro de Objetivos

Por qué, en una línea: un objetivo que solo verificas una vez es una suposición con una marca de tiempo, por lo que los objetivos terminados se gradúan a invariantes que se verifican diariamente y se registran.

Crea un archivo por cada cosa terminada, goals/<nombre>.md:

1predicate: cd $REPO && npm test -- tests/auth 2>&1 | tail -1 | grep -q passing
2born: 2026-07-06
3source: /goal session 2026-07-06 (fix auth flake)
4status: satisfied
5last-pass: 2026-07-06
6on-violation: wake me. Do not auto-fix.
7retire-when: auth module deleted. Retirement is a human decision, logged.

Crea loop/verify-goals.sh:

1#!/usr/bin/env bash
2set -uo pipefail
3LEDGER="memory/goal-ledger.tsv"; VIOLATIONS=0
4for g in goals/*.md; do
5  [ -e "$g" ] || continue
6  grep -q '^status: retired' "$g" && continue
7  pred=$(grep '^predicate:' "$g" | cut -d' ' -f2-); name=$(basename "$g" .md)
8  start=$(date +%s%3N)
9  if timeout 60 bash -c "$pred" >/dev/null 2>&1; then r=pass
10    sed -i "s/^status:.*/status: satisfied/; s/^last-pass:.*/last-pass: $(date +%F)/" "$g"
11  else r=FAIL; VIOLATIONS=$((VIOLATIONS+1)); sed -i "s/^status:.*/status: VIOLATED/" "$g"; fi
12  echo -e "$(date -Is)\t$name\t$r\t$(( $(date +%s%3N) - start ))" >> "$LEDGER"
13done
14[ "$VIOLATIONS" -gt 0 ] && { grep -l '^status: VIOLATED' goals/*.md; exit 1; }
15echo "todos los objetivos permanentes se mantienen"

Inicia el centinela (solo detección; las correcciones pasan por el canal normal):

1/loop 1d Ejecuta ./verify-goals.sh. Si es distinto de cero: para cada objetivo violado, lee su
2fecha de último pase y lista lo que se fusionó desde entonces (git log --oneline --since=<fecha>).
3Informa el objetivo, los sospechosos, la política de on-violation. No arregles nada.

La ley de graduación ya está en CLAUDE.md (BUILD 1): cada /goal aprobado escribe su propio objetivo permanente. Terminar ES la inscripción.

Consultas del libro de objetivos que realmente usarás:

1awk -F'\t' '$3=="FAIL"{n[$2]++} END{for(g in n) print n[g],g}' memory/goal-ledger.tsv | sort -rn | head -5   # más inestables
2grep <goal> memory/goal-ledger.tsv | awk -F'\t' '$3=="FAIL"' | head -1                                      # cuándo falló

Predicado inestable: quarantine (estado: retirado, nota "necesita un mejor predicado"), nunca eliminar.

CHECK 5: Agrega un objetivo con predicado: true y otro con predicado: false. ./verify-goals.sh devuelve 1, cambia el segundo a VIOLATED, y ambos aparecen en el ledger. Elimina los de prueba.

BUILD 6: El Presupuesto

Por qué: costo diario = ticks × triage + hits × (conductor + worker + verifier). A precios reales (triage $0.01, conductor $0.35, worker $0.10, verifier $0.40): un conserje diario cuesta ~$2.56/día; un niñero de 15 minutos con Fable en el asiento de triage cuesta $34/día por el mismo resultado. El modelo que lee los ticks silenciosos decide la factura.

Crear loop/scripts/log-cost.sh:

1#!/usr/bin/env bash
2echo -e "$(date -Is)\t$1\t$2" >> "$(dirname "$0")/../memory/usage.log"

Crear loop/scripts/cost-check.sh:

1#!/usr/bin/env bash
2set -euo pipefail
3F="$(dirname "$0")/../memory/usage.log"; touch "$F"; TODAY=$(date +%F)
4case "${1:-}" in
5  --budget)
6    spent=$(awk -F'\t' -v d="$TODAY" '$1 ~ d {s+=$3} END{printf "%.2f",s}' "$F")
7    awk -v s="$spent" -v b="$2" 'BEGIN{exit (s>=b)?1:0}' \
8      || { echo "gastaste \$$spent de \$$2" >&2; exit 1; };;
9  --report)
10    awk -F'\t' -v since="$(date -d '7 days ago' +%F)" \
11      '$1>=since{s[$2]+=$3;t+=$3} END{for(k in s) printf "  %-10s $%.2f\n",k,s[k]; printf "  TOTAL      $%.2f\n",t}' "$F";;
12esac

Reglas que lo mantienen plano: la cadencia es una decisión de costo (reducir el intervalo a la mitad duplica el piso); el tick silencioso debe costar centavos; el esfuerzo nunca supera "high" en los bucles (xhigh es para revisiones únicas; el esfuerzo es por paso, no por ejecución).

CHECK 6: Después de una semana de ticks, ./scripts/cost-check.sh --report coincide con la fórmula dentro del margen de ruido. Establece DAILY_BUDGET_USD en un número que no te importe desperdiciar.

BUILD 7: Los Bucles Opcionales (instalar cuando aparezca su condición)

• Quorum (instalar cuando el dispatch muestre activaciones de Fable que produjeron acción: stop). Tres modelos baratos votan; Fable se activa con 2 de 3. Los votantes nunca ven las respuestas de los demás.

1V=0
2for m in deepseek/deepseek-v4-flash qwen/qwen-3.6 moonshotai/kimi-k2.6; do
3  llm -m "openrouter/$m" -s "$(cat triage.md)" < /tmp/signals.txt \
4    | grep -q "status: actionable" && V=$((V+1))
5done
6[ "$V" -ge 2 ] && exec ./conduct.sh || echo "quorum: silencio ($V/3)"

• Ratchet (instalar cuando un solo número importe). Mejora monótona o auto-reversión; la métrica no puede ser manipulada; el piso terminado se convierte en un objetivo permanente.

1/goal Reducir `npm run lint 2>&1 | grep -c warning` a 0.
2Permisos: editar src/; commit por cada corrección; medir de nuevo tras cada cambio.
3Muros: el número NUNCA sube; revertir cualquier cambio que lo aumente o rompa una
4prueba; nunca editar la configuración de lint para reducirlo.
5Timebox: detenerse después de 3 intentos sin avance; reportar supervivientes.

• Sparring (instalar cuando subas código a diario). Constructor y destructor, opuestos; ninguno toca la salida del otro; las disputas van a ti.

1/loop 1d [destructor] Lee los diffs fusionados de ayer. Escribe UNA prueba fallida
2que exponga una debilidad real. Haz commit bajo tests/sparring/ etiquetado @sparring.
3No arregles nada. Código sólido = dilo, no escribas nada.
4/loop 1d [constructor] Si alguna prueba @sparring falla, arregla el CÓDIGO hasta que pase.
5Nunca edites, debilites o elimines una prueba de sparring; las disputas se encolan para mí.

• Compost (instalar siempre, semanal). Los fallos se convierten en leyes; máximo tres propuestas; se requiere firma humana.

1/loop 7d Lee el agotamiento de esta semana: FAILED en STATE.md, fallos en trust.tsv,
2FAILs en goal-ledger.tsv, PRs cerrados sin fusionar. Extrae MÁXIMO 3 propuestas:
3una nueva ley en CLAUDE.md (cita incidentes), una corrección de habilidad (mismo fallo repitiéndose),
4o un objetivo permanente que nos faltaba. Solo proponer. Semana limpia = dilo.

CHECK 7: Cada bucle opcional tiene su condición de instalación escrita junto a él en tus notas. Instalarlos de forma especulativa es cómo los sistemas se inflan.

BUILD 8: Operaciones

Crear Makefile:

1tick:            ; ./loop/loop.sh
2queue:           ; @grep -E "review:|queued:|FAILED:|rerouted" loop/memory/STATE.md || echo vacío
3trust:           ; @./loop/scripts/trust-log.sh --render
4audit:           ; @./loop/scripts/cost-check.sh --report
5goals:           ; @./loop/verify-goals.sh
6clean-worktrees: ; @git worktree list | awk '/wt-/{print $$1}' | xargs -rn1 git worktree remove --force

Cron, cuando comience la Semana 2:

10 7 * * 1-5  cd /ruta/al/repo/loop && ./loop.sh >> memory/cron.log 2>&1
230 7 * * *   cd /ruta/al/repo/loop && ./verify-goals.sh >> memory/cron.log 2>&1

El plan de confianza de 30 días

No te saltes las graduaciones; cada una desbloquea la siguiente.

Semana

Nivel

Tú haces

Graduarse cuando

1

L1 report

Builds 1-6;

make tick

a mano a diario; lee todo

3 ejecuciones consecutivas enrutan exactamente como tú lo habrías hecho

2

L2 draft

cron activado;

make queue

con café; las revisiones alimentan el ledger

2 habilidades cruzan 20 ejecuciones registradas

3

L3 ship

make audit

vs la fórmula; la mejor habilidad va sin supervisión

1 semana, cero intervenciones

4

L4 grow

compost firma; aprueba 1 habilidad propuesta; ejecuta el pase de eliminación

eliminaste algo y nada se rompió

El runbook. Qué significa cada alarma y qué hacer:

Señal

Significado

Acción

exit 2 (reroute)

el router de salvaguarda cambió de modelos a mitad de ejecución

lee el checkpoint; re-ejecuta el elemento mañana; nunca iteres sobre la salida cambiada

stop_reason: refusal

el clasificador de seguridad rechazó (HTTP 200, no es un error)

ruta oficial: recurrir a Opus 4.8 mediante

fallbacks

o middleware; si se repite en una habilidad, audita esa habilidad por eco de razonamiento o frases adyacentes a ciber/bio

exit 3 (budget)

el gasto diario alcanzó el límite

make audit

; encuentra qué etapa creció; arregla el mapa de esfuerzo, no el presupuesto

ALERT demoted

una habilidad establecida cayó por debajo del 90%

lee sus últimos 3 fallos; normalmente es el patrón de especificación, no el worker

goal VIOLATED

algo terminado dejó de ser cierto

el centinela da sospechosos; la corrección pasa por el pipeline normal

empate maker/checker x2

ninguno se presume correcto

tú decides, o ejecuta el rompe-empates (tercer revisor nuevo, juzga evidencia, no puede dividir la diferencia)

verify-goals timeout

predicado demasiado caro

eso es una violación; abarata el predicado

Las Reglas (imprime esto)

1. Leyes, no consejos: un número, un "nunca" o un comando que lo verifique.
2. El conductor planifica, los workers ejecutan, ninguno verifica. --allowedTools lo impone.
3. Los agentes hablan en órdenes de trabajo. done_when = especificación + condición de parada + invariante futuro.
4. Gasta esfuerzo donde el bucle se bifurca. Nunca por encima de "high" en un bucle.
5. El tick silencioso cuesta un centavo o el bucle cuesta un dineral.
6. Si un script de shell no pudiera verificarlo, no lo escribas como objetivo.
7. Los objetivos se gradúan; no se cierran. verify-goals.sh se ejecuta a diario, para siempre.
8. Autonomía por habilidad: 20 ejecuciones, 95%, automática. Degradación automática y ruidosa.
9. Dos ledgers: trust (workers) y goals (trabajo). Lee ambos con café.
10. Calcula el metabolismo antes de poner el cron.
11. Contrato en el repo: actúa-solo / encola / despiértame.
12. Nunca iteres sobre la salida de un modelo que no elegiste.
13. El centinela detecta; el pipeline corrige.
14. Quorum antes de despertar a Fable. Ratchet y luego suelda. Spar a diario. Compost semanal.
15. Un criterio de graduación a la vez. Cada mes, elimina algo.
16. De la documentación oficial: max_tokens limita el pensamiento más el texto, los rechazos son HTTP 200, nunca pidas razonamiento reflejado, las habilidades antiguas degradan a Fable, y los verificadores con contexto fresco superan la autocrítica. Anthropic lo dice; el sistema lo impone.

Cierre

Treinta días a partir de ahora, si hiciste los checks: un bucle envía trabajo aburrido sin supervisión, un directorio de objetivos reverifica todo lo que alguna vez terminaste, dos ledgers te dicen la verdad sobre tus workers y tu trabajo, y un compost semanal propone la próxima mejora del sistema para tu firma.

• El modelo nunca fue la parte difícil. La parte difícil fue construir algo a su alrededor que se mantenga honesto cuando dejas de mirar. Eso es lo que acabas de construir.
• Empieza esta noche con los veinte minutos que lo demuestran: el verify.sh del BUILD 2, el primer tick a mano del BUILD 3, y un objetivo permanente para lo último que terminaste.
• La primera vez que verify-goals.sh detecte una regresión silenciosa en algo que estabas seguro de que estaba terminado, no necesitarás más convencimiento sobre el resto.

Descargo de responsabilidad

Este artículo fue escrito utilizando las notas del usuario y editado por Claude Opus 4.8 max.