Cómo construir un SO agéntico usando Fable 5 (Guía para desarrolladores)

Aquí tienes la traducción al español (Latinoamérica) del texto proporcionado, siguiendo todas las pautas y reglas especificadas.

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

Esto cambiará todo sobre cómo trabajas con Claude

Guarda estas 8 builds antes de que se te olviden

Introducción

Tienes el modelo más capaz jamás creado y disponible para el público, y sigues escribiendo prompts de uno en 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 el trabajo de una semana en una noche. También se mide ($10/M de entrada, $50/M de 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 de lo que la mayoría de la gente defiende sus respuestas correctas.

Usado de forma casual, es una forma costosa de generar cosas impresionantes pero 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 de bash tiene el voto final (BUILDs 2-3)
• Un libro de confianza que otorga y revoca la autonomía por habilidad, automáticamente, basado en las tasas de aprobación medidas (BUILD 4)
• Un directorio de objetivos donde todo lo que terminas se sigue reverificando a diario, 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, compost) cada uno con la condición que te dice cuándo instalarlo (BUILD 7)
• Un cronograma de cron, un manual de operaciones para cada alarma que el sistema pueda generar, y un cronograma de confianza de 30 días que lo lleva de supervisado a autoextensible.

Para quién es esto. Cualquiera que tenga un repositorio, una terminal y una suscripción a Claude Code o una clave de API. Los ejemplos tienen sabor a código porque los bucles crecieron alrededor de las 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 es de 10 a 20 minutos. Los 30 días al final no son tiempo de lectura; son el cronograma de confianza gradual durante el cual el sistema se gana el derecho a ejecutarse sin ti. Tiempo práctico total: aproximadamente 2 horas.

Los tres principios subyacentes 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 y desaparece.
2. Nadie califica su propio trabajo. 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 una invariante reverificada. 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 una 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 lector barato
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 esta build proviene de la documentación oficial de Anthropic. Establece esto antes de escribir cualquier archivo propio.

La ficha técnica:

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

Razonamiento

adaptativo, siempre activo;

thinking: {type:"disabled"}

es RECHAZADO; la salida del razonamiento es solo un resumen

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 Mensajes

Documentos de esfuerzo

Cinco hechos oficiales que cambian la forma en que construyes:

1. max_tokens es un límite estricto para el razonamiento MÁS el texto de respuesta. En niveles 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 agentivas de larga duración (más de 30 minutos) con presupuestos de tokens en los 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 resístete a actualizar 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. Solución oficial: configurar fallbacks 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 fallbacks. Audita cada habilidad antigua al migrar. Lee los bloques de razonamiento estructurados en su lugar.
5. Los turnos son largos por diseño. Las tareas difíciles ejecutan muchos minutos por solicitud con un esfuerzo mayor; las ejecuciones autónomas se extienden por horas. Ajusta los tiempos de espera del cliente y verifica las ejecuciones de forma asíncrona (trabajos programados, 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 prompt 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 reabras una decisión que el usuario ya ha
3tomado, ni narres opciones que no vas a seguir. Si estás sopesando una elección,
4da una recomendación, no un estudio exhaustivo.

1. 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 una 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 el 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
4se omitió un paso, dilo.

1. Recordatorio de pipeline autónomo (para cada prompt impulsado por cron; elimina la parada temprana de "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, verifica tu último
4párrafo: si es un plan, una pregunta o una promesa sobre el trabajo que no has
5hecho, haz ese trabajo ahora con llamadas a herramientas. Termina solo cuando la tarea esté completa
6o 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
4duplicarlas; 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 a 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 sin resolver más difícil y deja que lo delimite), y refactoriza las habilidades antiguas (las instrucciones escritas para modelos anteriores a menudo son 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 y 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 las leyes y optimiza en torno a los 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 las 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 reportes el trabajo como hecho basándote en tu propia evaluación. Hecho = la verificació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 o elimines una prueba para que pase. Eso es un fallo, siempre.
11- Nunca repitas, transcribas o expliques tu razonamiento interno en el texto de
12  respuesta. (Oficial: activa los rechazos de reasoning_extraction en Fable 5.)
13- Cuando una condición de /goal se cumpla, escribe goals/<nombre>.md con la condición como
14  su predicado antes de reportar el é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 (2do sub) | 9        | 10      | 9            | 5     |
231. Decisión (planificar/revisar/enrutar/estancamiento) -> fable-5, esfuerzo alto, solo lectura.
242. Lecturas >50k tokens (logs/PDFs/capturas de pantalla) -> codex. Nunca fable.
253. Se envía a usuarios (UI/API/copia) -> gusto >= 8 obtiene la revisión final.
264. Especificación completa -> sonnet-5, esfuerzo medio.
275. Sino sonnet-5; sube 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 se cumple; 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 verificable por máquina antes de que comience el trabajo.
38- Un agente con contexto nuevo que no vio ni el plan ni el borrador lo 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 las rutas para que sean 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 reclamar éxito? Si es así, reescríbela con un número o un "nunca". wc -l CLAUDE.md menor de 15

BUILD 2: Muros y Puerta

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

Crea loop/contract.md:

1## actúa solo
2PRs borradores en ramas; corrige deuda de lint/pruebas; actualiza STATE.md; etiqueta issues
3
4## pone en cola para mí
5auth, 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 modelo a mitad de la 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 se adapte a 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 reportar = genera exactamente "status: quiet".
6Cualquier cosa que toque auth, pagos, migraciones, secretos = siempre procesable,
7anotado "contract-sensitive".

Crea loop/conductor.md:

1Eres el conductor. No escribes código. No editas archivos.
21. Lee STATE, TRUST LEDGER, CONTRACT a continuación. No confíes en tu memoria de ellos.
32. Elige el ÚNICO elemento procesable de mayor valor.
4   contract-sensitive, ambiguo o probablemente diff >400 líneas -> acción: queue
5   nada que valga la pena hacer -> acción: stop
63. Sino acción: execute, 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.
2Haz 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 SPEC 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 spec? 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, salida JSON
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 spec + 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 contabilidad; 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 parada: verifica STATE.md

Mapa de salidas: 0 silencio/hecho, 1 límite, 2 reruta, 3 presupuesto. Todas etiquetadas, a propósito.

CHECK 3: chmod +x loop.sh guardrails/verify.sh luego ejecuta ./loop.sh una vez manualmente. Confirma: un repositorio silencioso 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 ejecs pasa 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      ejecs=$(grep -P "^${1}\t" "$F" | cut -f2)
26      [ "$("$0" --tier "$1")" = watch ] && [ "$ejecs" -ge 10 ] \
27        && echo "ALERTA: $1 degradado a watch después de $ejecs 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 esperan por ti. 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 el roster: crea loop/skills/<nombre>/SKILL.md para cada tarea recurrente (fix-lint-debt, fix-flaky-test, bump-deps, triage-issues son los cuatro estándar). Cada archivo: frontmatter (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 reverifican a diario 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 cumplen"

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

1/loop 1d Ejecuta ./verify-goals.sh. Si es distinto de cero: para cada objetivo violado, lee su
2fecha de last-pass y lista lo que se fusionó desde entonces (git log --oneline --since=<fecha>).
3Reporta el objetivo, los sospechosos y 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 contabilidad 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: cuarentena (estado: retirado, nota "necesita un mejor predicado"), nunca eliminar.

VERIFICACIÓN 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 registro. Elimina los de prueba.

CONSTRUCCIÓN 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).

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

CONSTRUCCIÓN 7: Los Bucles Opcionales (instalar cuando aparezca su condición)

• Quorum (instalar cuando el despacho 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 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 corrección; medir de nuevo después de 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 los sobrevivientes.

• Sparring (instalar cuando envíes 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, semanalmente). Los fallos se convierten en leyes; máximo tres propuestas; firma humana requerida.

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 (citar incidentes), una corrección de habilidad (mismo fallo
4repitiéndose), o un objetivo permanente que nos faltaba. Solo proponer. Semana limpia = dilo.

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

CONSTRUCCIÓN 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 /path/to/repo/loop && ./loop.sh >> memory/cron.log 2>&1
230 7 * * *   cd /path/to/repo/loop && ./verify-goals.sh >> memory/cron.log 2>&1

El cronograma de confianza de 30 días

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

Semana

Nivel

Tú haces

Graduarse cuando

1

L1 reporte

Construcciones 1-6;

make tick

a mano a diario; lee todo

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

2

L2 borrador

cron activado;

make queue

con el café; las revisiones alimentan el registro

2 habilidades cruzan 20 ejecuciones registradas

3

L3 envío

make audit

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

1 semana, cero intervenciones

4

L4 crecimiento

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

eliminaste algo y nada se rompió

El manual de operaciones. Qué significa cada alarma y qué hacer:

Señal

Significado

Acción

exit 2 (reenrutamiento)

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

lee el punto de control; 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: retroceder a Opus 4.8 mediante

fallbacks

o middleware; si se repite en una habilidad, audita esa habilidad por eco de razonamiento o redacción relacionada con ciber/bio

exit 3 (presupuesto)

el gasto diario alcanzó el límite

haz audit

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

ALERT degradado

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 fresco, juzga la 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ático. Degradación automática y ruidosa.
9. Dos registros: trust (workers) y goals (trabajo). Lee ambos con el café.
10. Calcula el metabolismo antes de configurar el cron.
11. Contrato en el repositorio: 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. Sparring 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 pensamiento más texto, los rechazos son HTTP 200, nunca pidas razonamiento repetido, las habilidades viejas degradan a Fable, y los verificadores con contexto fresco superan a la autocrítica. Anthropic lo dice; el sistema lo impone.

Cierre

Treinta días a partir de ahora, si hiciste las verificaciones: un bucle envía trabajo aburrido sin supervisión, un directorio de objetivos re-verifica todo lo que alguna vez terminaste, dos registros te dicen la verdad sobre tus workers y tu trabajo, y una ejecución semanal de compost 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: CONSTRUCCIÓN 2's verify.sh, CONSTRUCCIÓN 3's primer tick a mano, 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 que te convenzan del resto.

Descargo de responsabilidad

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