Como criar um SO Agêntico usando o Fable 5 (Guia do Desenvolvedor)

Esta é uma análise completa de A a Z do Claude Fable 5: o que é e como usá-lo como um engenheiro 100x

Isso mudará tudo sobre como você trabalha com o Claude

Marque estas 8 construções antes de esquecer

Introdução

Você tem o modelo mais capaz já disponibilizado ao público em geral e ainda está digitando prompts um de cada vez. Este guia resolve isso.

Aqui está a situação em julho de 2026. O Fable 5 pode funcionar por horas sem supervisão, despachar seus próprios subagentes e fazer uma semana de trabalho em uma noite. Ele também é medido ($10/M entrada, $50/M saída através de créditos de uso), entrega além do esperado quando o escopo não é delimitado e argumenta a favor de seus erros de forma mais convincente do que a maioria das pessoas argumenta a favor de suas respostas corretas.

Usado casualmente, é uma maneira cara de gerar coisas erradas impressionantes. Usado dentro de um sistema, é a coisa mais próxima de um funcionário que você pode alugar por três dólares por dia.

Este guia constrói esse sistema. Não uma filosofia dele: os arquivos reais, em ordem, com um checkpoint após cada um para que você saiba que funciona antes de empilhar a próxima peça em cima.

O que você terá no final:

• Um CLAUDE.md com o qual o modelo não pode negociar (CONSTRUÇÃO 1)
• Um loop diário onde o Fable 5 toma todas as decisões, mas escreve quase nenhum token, modelos baratos fazem o trabalho, um verificador independente avalia e um script bash dá o voto final (CONSTRUÇÕES 2-3)
• Um livro de confiança que concede e revoga autonomia por habilidade, automaticamente, com base em taxas de aprovação medidas (CONSTRUÇÃO 4)
• Um diretório de metas onde tudo que você já terminou continua sendo verificado novamente diariamente, para sempre, para que nada apodreça silenciosamente (CONSTRUÇÃO 5)
• Um orçamento que se impõe em vez de te surpreender (CONSTRUÇÃO 6)
• Quatro loops opcionais (quórum, catraca, sparring, compostagem) cada um com a condição que te diz quando instalá-lo (CONSTRUÇÃO 7)
• Uma agenda cron, um manual para cada alarme que o sistema pode levantar e um cronograma de confiança de 30 dias que o leva de supervisionado a autoextensível.

Para quem é isso. Qualquer pessoa com um repositório, um terminal e uma assinatura do Claude Code ou chave de API. Os exemplos são com sabor de código porque os loops cresceram em torno de bases de código, mas o sistema de metas e metade dos loops funcionam igualmente bem em faturas, relatórios e listas de leitura; os predicados são apenas comandos shell.

Como ler. Em ordem, fazendo as verificações. A CONSTRUÇÃO 0 são as configurações oficiais da Anthropic e a linguagem de prompt; tudo depois disso é o sistema construído sobre elas. Cada construção leva de 10 a 20 minutos. Os 30 dias no final não são tempo de leitura; são o cronograma de confiança gradual durante o qual o sistema ganha o direito de funcionar sem você. Tempo prático total: cerca de 2 horas.

Os três princípios por trás de tudo, para que você possa prever qualquer decisão de design antes de lê-la:

1. Leis, não dicas. Toda regra tem um número, um "nunca" ou um comando que a verifica. Qualquer coisa mais branda é otimizada para desaparecer.
2. Ninguém avalia seu próprio dever de casa. O planejador, o trabalhador, o verificador e o portão são quatro partes diferentes, e a última é determinística.
3. Nada que passou uma vez fica sem vigilância. O trabalho concluído se forma em um invariante verificado novamente. Uma meta que você verifica apenas uma vez é uma suposição com um carimbo de data/hora.

Sem ensaios daqui em diante. Oito construções, cada uma com arquivos, comandos e um checkpoint.

Pré-requisitos

1CLI claude (Claude Code) com acesso ao Fable 5     # créditos de uso ativados, limite /usage-credits definido
2CLI llm + chave OpenRouter                          # llm install llm-openrouter
3jq, gh, git, make, cron
4um repositório com um comando de teste

O que você está construindo

1seu-repositorio/
2  CLAUDE.md                    # CONSTRUÇÃO 1: a constituição
3  loop/
4    loop.sh                    # CONSTRUÇÃO 3: o batimento cardíaco
5    conductor.md               # CONSTRUÇÃO 3: prompt de roteamento
6    triage.md                  # CONSTRUÇÃO 3: prompt de leitura barato
7    contract.md                # CONSTRUÇÃO 2: as três listas
8    workers/implement.md       # CONSTRUÇÃO 3
9    workers/verify.md          # CONSTRUÇÃO 3
10    guardrails/verify.sh       # CONSTRUÇÃO 2: portão determinístico
11    scripts/trust-log.sh       # CONSTRUÇÃO 4
12    scripts/log-cost.sh        # CONSTRUÇÃO 6
13    scripts/cost-check.sh      # CONSTRUÇÃO 6
14    quorum.sh                  # CONSTRUÇÃO 7 (opcional)
15    verify-goals.sh            # CONSTRUÇÃO 5
16    goals/                     # CONSTRUÇÃO 5: metas permanentes
17    skills/                    # CONSTRUÇÃO 4: um arquivo por funcionário
18    memory/
19      STATE.md  trust.tsv  goal-ledger.tsv  dispatch.tsv  usage.log
20  Makefile                     # CONSTRUÇÃO 8: tick / queue / trust / audit / dream

CONSTRUÇÃO 0: Configure o Motor (da documentação oficial do Fable 5)

Tudo nesta construção vem da própria documentação da Anthropic. Defina estas configurações antes de escrever qualquer arquivo seu.

A ficha técnica:

Configuração

Valor

Fonte

String do modelo

claude-fable-5

visão geral dos modelos

Contexto / saída

1M tokens / até 128k de saída por requisição

docs de introdução

Preço

$10/M entrada, $50/M saída

docs de introdução

Pensamento

adaptativo, sempre ativo;

thinking: {type:"disabled"}

é REJEITADO; a saída do pensamento é apenas resumida

docs de introdução + esforço

Esforço

low

medium

high

xhigh

max

;

high

= padrão = omitir o parâmetro

docs de esforço

Forma da API

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

na API Messages

docs de esforço

Cinco fatos oficiais que mudam como você constrói:

1. max_tokens é um limite rígido para PENSAMENTO MAIS texto de resposta. Em high e xhigh, defina-o grande (comece com 64k) ou o Fable fica sem espaço no meio do pensamento. Aplica-se a toda chamada claude -p neste guia.
2. xhigh é oficialmente para "tarefas agentivas de longa duração (mais de 30 minutos) com orçamentos de tokens na casa dos milhões." Esse é o assento do condutor e nada mais neste sistema. Os documentos também dizem que esforço menor no Fable 5 "frequentemente excede o desempenho xhigh em modelos anteriores", então resista a atualizar os trabalhadores.
3. Recusas são HTTP 200. O Fable 5 executa classificadores de segurança (cyber ofensivo, biologia/ciências da vida, extração de raciocínio). Uma requisição recusada retorna stop_reason: "refusal" como uma resposta de SUCESSO. Seus scripts devem verificar o motivo da parada, não o código de saída. Remédio oficial: configure fallbacks no lado do servidor ou middleware SDK para redirecionar para o Opus 4.8.
4. Nunca peça ao Fable para ecoar seu raciocínio. Prompts ou habilidades que dizem "mostre seu pensamento" ou "explique seu raciocínio na resposta" acionam a categoria de recusa reasoning_extraction e elevam fallbacks. Audite toda habilidade antiga quanto a isso ao migrar. Leia os blocos de pensamento estruturados em vez disso.
5. Turnos são longos por design. Tarefas difíceis levam muitos minutos por requisição em esforço maior; execuções autônomas se estendem por horas. Ajuste os timeouts do cliente e verifique as execuções de forma assíncrona (tarefas agendadas, não esperas bloqueantes). É por isso que o batimento cardíaco é cron, não um loop bloqueante.

O pacote de prompt oficial. A Anthropic fornece linguagem de prompt testada para os comportamentos conhecidos do Fable 5. Eles vão para seus prompts textualmente; não os parafraseie de forma mais enxuta:

1. Anti-planejamento excessivo (para o condutor e qualquer sessão interativa):

1Quando você tiver informações suficientes para agir, aja. Não rederive fatos já
2estabelecidos na conversa, não reabra uma decisão que o usuário já tomou,
3nem narre opções que você não vai perseguir. Se você está ponderando uma
4escolha, dê uma recomendação, não um levantamento exaustivo.

1. Anti-enfeite (para cada prompt de trabalhador; esta é a cerca oficial contra entrega excessiva):

1Não adicione recursos, refatore ou introduza abstrações além do que a tarefa
2exige. Uma correção de bug não precisa de limpeza ao redor. Não projete para
3requisitos futuros hipotéticos: faça a coisa mais simples que funciona bem.
4Não adicione tratamento de erros ou validação para cenários que não podem
5acontecer. Valide apenas nos limites do sistema.

1. Alegações de progresso fundamentadas (para qualquer execução longa; nos testes da Anthropic, isso quase eliminou relatórios de status fabricados):

1Antes de relatar progresso, audite cada alegação contra um resultado de ferramenta
2desta sessão. Relate apenas trabalho para o qual você possa apontar evidências;
3se algo ainda não foi verificado, diga isso explicitamente. Se os testes falharem,
4diga com a saída; se uma etapa foi pulada, diga isso.

1. Lembrete de pipeline autônomo (para cada prompt acionado por cron; elimina a parada precoce "Vou executar X agora"):

1Você está operando de forma autônoma. O usuário não está assistindo e não pode
2responder perguntas no meio da tarefa. Para ações reversíveis que decorrem da
3solicitação original, prossiga sem perguntar. Antes de encerrar seu turno,
4verifique seu último parágrafo: se for um plano, uma pergunta ou uma promessa
5sobre trabalho que você não fez, faça esse trabalho agora com chamadas de
6ferramenta. Termine apenas quando a tarefa estiver completa ou você estiver
7bloqueado por uma entrada que apenas o usuário pode fornecer.

1. Formato de memória oficial (para o sonhador e memory/learnings/):

1Armazene uma lição por arquivo com um resumo de uma linha no topo. Registre
2correções e abordagens confirmadas igualmente, incluindo por que elas
3importaram. Não salve o que o repositório já registra; atualize notas
4existentes em vez de duplicar; exclua notas que se revelarem erradas.

1. Instrução oficial do verificador (os documentos afirmam diretamente: "subagentes verificadores separados e com contexto novo tendem a superar a autocrítica"):

1Estabeleça um método para verificar seu próprio trabalho em um intervalo de [X]
2enquanto você constrói. Execute isso a cada [intervalo X], verificando seu
3trabalho com subagentes contra a especificação.

Duas ordens de andaime dos documentos que vale a pena obedecer: comece no topo da sua faixa de dificuldade (testar o Fable apenas em cargas de trabalho simples o subestima; dê a ele o problema mais difícil não resolvido e deixe-o escopar), e refatore habilidades antigas (instruções escritas para modelos anteriores são muitas vezes muito prescritivas para o Fable 5 e DEGRADAM a saída; se o desempenho padrão for melhor sem uma instrução, exclua a instrução).

VERIFICAÇÃO 0: Toda chamada claude -p em seus scripts tem um max_tokens grande explícito onde suportado; seus scripts verificam stop_reason: "refusal"; nenhum prompt ou habilidade em qualquer lugar diz "mostre seu pensamento".

CONSTRUÇÃO 1: A Constituição (CLAUDE.md)

Por que, em uma linha: O Fable segue leis e otimiza em torno de dicas, então cada linha precisa de um número, um "nunca" ou um comando que a verifique.

Regras para o arquivo: quatro blocos, abaixo de 150 linhas, sem "pense passo a passo" (o raciocínio está sempre ativo; esses são tokens pagos), sem personas de agente predefinidas (o Fable projeta equipes melhores do que você pode predefinir), principalmente sinais de parada.

Crie CLAUDE.md:

1# CLAUDE.md
2
3## NUNCA (leis; exceções exigem perguntar primeiro)
4- Nunca exceda 200 linhas alteradas em um commit sem perguntar.
5- Nunca toque em src/auth/, src/billing/, migrations/ ou config de produção sem supervisão.
6- Nunca relate trabalho como concluído com base em sua própria avaliação. Concluído = a verificação passou.
7- Nunca invente um segredo, um endpoint ou uma convenção. Pare e pergunte.
8- Nunca adicione uma dependência. Proponha-a em STATE.md e pare.
9- Nunca exceda o esforço high dentro de qualquer loop. xhigh é apenas para revisões únicas.
10- Nunca edite ou exclua um teste para fazê-lo passar. Isso é uma falha, sempre.
11- Nunca ecoe, transcreva ou explique seu raciocínio interno no texto da resposta.
12  (Oficial: aciona recusas de reasoning_extraction no Fable 5.)
13- Quando uma condição de /goal passar, escreva goals/<nome>.md com a condição como
14  seu predicado antes de relatar sucesso.
15
16## DESPACHO (roteie toda tarefa; primeira correspondência vence; registre em memory/dispatch.tsv)
17| modelo           | marginal | apetite | inteligência | bom gosto |
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 (2º sub)  | 9        | 10      | 9            | 5         |
231. Decisão (planejar/revisar/rotear/impasse) -> fable-5, esforço high, somente leitura.
242. Leituras >50k tokens (logs/PDFs/capturas de tela) -> codex. Nunca fable.
253. Envio para usuários (UI/API/cópia) -> bom gosto >= 8 recebe aprovação final.
264. Especificação completa -> sonnet-5, esforço medium.
275. Senão sonnet-5; escale um degrau em caso de erro sem perguntar.
28
29## PALAVRAS
30- "inteligência" = problema mais difícil tratado sem supervisão
31- "bom gosto" = UI/UX, qualidade de código, design de API, cópia
32- "concluído" = o predicado passa; nada mais
33- "pequeno" = abaixo de 50 linhas alteradas; "rápido" = abaixo de 10 minutos do seu tempo
34- "limpeza" = comportamento idêntico, verify.sh verde antes e depois
35
36## CONCLUÍDO
37- Toda tarefa tem um done_when verificável por máquina antes do trabalho começar.
38- Um agente de contexto novo que não viu nem o plano nem o rascunho verifica contra ele.
39- guardrails/verify.sh tem o voto final.
40- Desvios: opção conservadora, registre em IMPLEMENTATION.md, continue.
41- Criador e verificador discordam duas vezes -> pare, coloque na fila para um humano.

Edite os números e caminhos para os seus. Material específico do fluxo de trabalho (procedimento de PR, lista de verificação de lançamento) vai em skills/, não aqui.

VERIFICAÇÃO 1: Para cada linha, pergunte: o modelo poderia cumprir 80% e alegar sucesso? Se sim, reescreva com um número ou um "nunca". wc -l CLAUDE.md abaixo de 15

CONSTRUÇÃO 2: Muros e Portão

Por que: o raio da explosão deve ser declarado antes do primeiro tick, e um script bash deve ter o voto final.

Crie loop/contract.md:

1## age sozinho
2rascunha PRs em branches; corrige dívida de lint/teste; atualiza STATE.md; rotula issues
3
4## coloca na fila para mim
5auth, pagamentos, migrações; qualquer habilidade abaixo do nível "auto"; qualquer diff > 400 linhas
6
7## me acorda
8verificação falha duas vezes no mesmo item
9roteador de salvaguarda trocou modelos durante a execução
10orçamento diário estourado
11qualquer coisa solicita um segredo
12uma meta permanente é VIOLADA

Crie loop/guardrails/verify.sh (edite para sua stack):

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

VERIFICAÇÃO 2: ./loop/guardrails/verify.sh executa e sai com 0 no seu repositório atual. Se falhar agora, corrija isso primeiro; todo o sistema se baseia neste script.

CONSTRUÇÃO 3: O Batimento Cardíaco

Por que, em três linhas: Fable como trabalhador é uma conta de quatro dígitos (sessões de 500k-1M tokens a $50/M saída); Fable como condutor emite 10-20% dos tokens enquanto toma 100% das decisões. Um modelo de $0,01 lê os ticks silenciosos. Agentes passam o bastão através de um esquema JSON para que qualquer modelo se encaixe em qualquer assento.

Crie loop/triage.md:

1Você recebe commits recentes, issues abertas e execuções de CI. Produza APENAS constatações:
2- constatacao: <uma linha>
3  evidencia: <id do commit/issue/execucao>
4  status: acionavel | informativo
5Sem correções, sem opiniões. Nada a relatar = produza exatamente "status: quieto".
6Qualquer coisa tocando auth, pagamentos, migrações, segredos = sempre acionavel,
7anotado "sensivel-ao-contrato".

Crie loop/conductor.md:

1Você é o condutor. Você não escreve código. Você não edita arquivos.
21. Leia STATE, LIVRO DE CONFIANÇA, CONTRATO abaixo. Não confie na memória deles.
32. Escolha o ÚNICO item acionável de maior valor.
4   sensivel-ao-contrato, ambíguo ou provável diff >400 linhas -> acao: fila
5   nada que valha a pena fazer -> acao: parar
63. Senão acao: executar, com uma especificação que um modelo medíocre possa seguir.
7Produza APENAS este JSON:
8{ "acao": "executar|fila|parar", "item": "...", "habilidade": "<kebab-case,
9estável entre execuções>", "especificacao": "...", "done_when": ["<verificavel>", ...] }
10Você é caro. Seja breve. Sua saída é uma decisão, não um ensaio.

Crie loop/workers/implement.md:

1Você recebe uma ordem de serviço (JSON). Execute a especificação exatamente.
2Faça o PRÓXIMO passo em direção a done_when. Diffs pequenos vencem.
3Credencial faltando ou decisão não documentada -> PARE, escreva a pergunta em
4IMPLEMENTATION.md. Nunca invente segredos ou convenções.
5Registre o que fez e por que em IMPLEMENTATION.md (máx. 3 linhas).

Crie loop/workers/verify.md:

1Você recebe uma ESPECIFICAÇÃO e um DIFF, nada mais. Julgue apenas o que está à sua frente.
21. O diff satisfaz cada done_when? Cite linhas.
32. Algo fora do escopo da especificação? Falha instantânea. Testes deletados/pulados? Falha instantânea.
4Produza exatamente uma linha: "PASSOU: <motivo>" ou "FALHOU: <motivo>".
5O criador estava confiante. Isso não é evidência.

Crie 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}"
6BARATO="${BARATO:-openrouter/deepseek/deepseek-v4-flash}"
7TRABALHADOR="${TRABALHADOR:-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 TRIAGEM: portão 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 "$BARATO" -s "$(cat triage.md)" >> memory/STATE.md
16  ./scripts/log-cost.sh triagem 0.01
17  grep -q "status: acionavel" memory/STATE.md || { echo quieto; exit 0; }
18
19  # 2 CONDUTOR: Fable, xhigh, contexto novo, somente leitura, JSON na saída
20  claude -p "$(cat conductor.md)
21STATE: $(cat memory/STATE.md)
22CONFIANCA: $(./scripts/trust-log.sh --render)
23CONTRATO: $(cat contract.md)" \
24    --model claude-fable-5 --effort xhigh --allowedTools "Read" \
25    --output-format json > /tmp/c.json
26  ./scripts/log-cost.sh condutor 0.35
27
28  # 2a TOLERÂNCIA DE ROTA: nunca itere em um modelo que você não escolheu
29  SERVIDO=$(jq -r '.modelUsage | keys[0] // "claude-fable-5"' /tmp/c.json)
30  [[ "$SERVIDO" != *fable* ]] && { echo "reroteado" >> memory/STATE.md; exit 2; }
31
32  jq -r '.result' /tmp/c.json > work-order.json
33  HABILIDADE=$(jq -r .skill work-order.json); ACAO=$(jq -r .action work-order.json)
34  [[ "$ACAO" == parar ]] && exit 0
35  [[ "$ACAO" == fila ]] && { echo "enfileirado: $HABILIDADE" >> memory/STATE.md; continue; }
36
37  # 3 EXECUTAR: trabalhador barato, árvore de trabalho isolada
38  WT="../wt-$i"; git worktree add "$WT" -b "loop/$HABILIDADE-$i" >/dev/null
39  ( cd "$WT" && llm -m "$TRABALHADOR" -s "$(cat "$OLDPWD/workers/implement.md")" \
40      "$(cat "$OLDPWD/work-order.json")" > IMPLEMENTATION.md )
41  ./scripts/log-cost.sh trabalhador 0.10
42
43  # 4 VERIFICAR: Fable novo, sem ferramentas, vê apenas especificação + diff
44  V=$(claude -p "$(cat workers/verify.md)
45ESPECIFICACAO: $(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 verificador 0.40
50
51  # 5 PORTÃO: determinístico; depois livro de confiança; envie apenas no nível auto
52  if [[ "$V" == PASSOU* ]] && ( cd "$WT" && "$OLDPWD/guardrails/verify.sh" ); then
53    ./scripts/trust-log.sh "$HABILIDADE" pass
54    if [[ "$(./scripts/trust-log.sh --tier "$HABILIDADE")" == auto ]]; then
55      ( cd "$WT" && git add -A && git commit -qm "loop: $HABILIDADE" && gh pr create --fill || true )
56      echo "- enviado: $HABILIDADE" >> memory/STATE.md
57    else
58      echo "- revisar: $HABILIDADE em $WT" >> memory/STATE.md
59    fi
60  else
61    ./scripts/trust-log.sh "$HABILIDADE" fail
62    echo "- FALHOU: $HABILIDADE em $WT" >> memory/STATE.md
63  fi
64  ./scripts/cost-check.sh --budget "$DAILY_BUDGET_USD" || exit 3
65done
66exit 1   # limite de iteração sem parar: verifique STATE.md

Mapa de saída: 0 quieto/concluído, 1 limite, 2 reroteamento, 3 orçamento. Todos rotulados, de propósito.

VERIFICAÇÃO 3: chmod +x loop.sh guardrails/verify.sh então execute ./loop.sh uma vez manualmente. Confirme: um repositório quieto sai com 0 por cerca de um centavo; um repositório acionável produz work-order.json com todos os cinco campos e uma linha de veredito em STATE.md.

CONSTRUÇÃO 4: O Livro de Confiança

Por que: "aumente a autonomia à medida que a confiança cresce" não é um mecanismo; um TSV com regras de nível é. A autonomia é por habilidade, não por loop.

Crie loop/scripts/trust-log.sh:

1#!/usr/bin/env bash
2# uso: trust-log.sh <habilidade> <pass|fail> | --render | --tier <habilidade>
3set -euo pipefail
4F="$(dirname "$0")/../memory/trust.tsv"; touch "$F"
5nivel_de() { awk -v r="$1" -v p="$2" 'BEGIN{
6  taxa=(r>0)?p/r:0
7  if (r>=20 && taxa>=0.95) print "auto"
8  else if (r<10 || taxa<0.90) print "vigiar"
9  else print "fila"}'; }
10case "${1:-}" in
11  --render)
12    printf "%-20s %5s %5s %6s %s\n" habilidade execucoes aprovacoes taxa 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        "$(nivel_de "$r" "$p")"; done < "$F";;
17  --tier)
18    line=$(grep -P "^${2}\t" "$F" || echo -e "${2}\t0\t0")
19    nivel_de "$(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      execucoes=$(grep -P "^${1}\t" "$F" | cut -f2)
26      [ "$("$0" --tier "$1")" = vigiar ] && [ "$execucoes" -ge 10 ] \
27        && echo "ALERTA: $1 rebaixado para vigiar após $execucoes execucoes" >&2 || true
28    fi;;
29esac

• Regras de nível: auto = 20+ execuções E 95%+ de aprovação, envia sem supervisão. fila = rascunhos verificados esperam por você. vigiar = abaixo de 10 execuções ou abaixo de 90%, apenas rascunho. O rebaixamento é automático e imprime em stderr, que o cron envia para você por e-mail.
• Semeie o elenco: crie loop/skills/<nome>/SKILL.md para cada tarefa recorrente (corrigir-divida-lint, corrigir-teste-instavel, atualizar-deps, triar-issues são os quatro padrão). Cada arquivo: frontmatter (nome, descrição, quando), passos, uma lista de "nunca", um done-when verificável. Toda habilidade começa em vigiar.

VERIFICAÇÃO 4: Execute ./scripts/trust-log.sh demo pass 21 vezes, então --tier demo imprime auto. Registre uma falha em uma habilidade com 10+ execuções e veja o ALERTA em stderr. Redefina: > memory/trust.tsv.

CONSTRUÇÃO 5: Metas Permanentes + o Livro de Metas

Por que, em uma linha: uma meta que você verifica apenas uma vez é uma suposição com um carimbo de data/hora, então metas concluídas se formam em invariantes que são verificados novamente diariamente e registrados.

Crie um arquivo por coisa concluída, goals/<nome>.md:

1predicado: cd $REPO && npm test -- tests/auth 2>&1 | tail -1 | grep -q passing
2nascido: 2026-07-06
3origem: /goal sessão 2026-07-06 (corrigir instabilidade auth)
4status: satisfeito
5ultima-aprovacao: 2026-07-06
6ao-violar: me acorde. Não corrija automaticamente.
7aposentar-quando: módulo auth deletado. Aposentadoria é uma decisão humana, registrada.

Crie loop/verify-goals.sh:

1#!/usr/bin/env bash
2set -uo pipefail
3LIVRO="memory/goal-ledger.tsv"; VIOLACOES=0
4for g in goals/*.md; do
5  [ -e "$g" ] || continue
6  grep -q '^status: aposentado' "$g" && continue
7  pred=$(grep '^predicado:' "$g" | cut -d' ' -f2-); nome=$(basename "$g" .md)
8  inicio=$(date +%s%3N)
9  if timeout 60 bash -c "$pred" >/dev/null 2>&1; then r=pass
10    sed -i "s/^status:.*/status: satisfeito/; s/^ultima-aprovacao:.*/ultima-aprovacao: $(date +%F)/" "$g"
11  else r=FALHA; VIOLACOES=$((VIOLACOES+1)); sed -i "s/^status:.*/status: VIOLADO/" "$g"; fi
12  echo -e "$(date -Is)\t$nome\t$r\t$(( $(date +%s%3N) - inicio ))" >> "$LIVRO"
13done
14[ "$VIOLACOES" -gt 0 ] && { grep -l '^status: VIOLADO' goals/*.md; exit 1; }
15echo "todas as metas permanentes se mantêm"

Inicie o sentinela (apenas detecção; correções passam pelo pipeline normal):

1/loop 1d Execute ./verify-goals.sh. Se não-zero: para cada meta violada, leia sua
2data de ultima-aprovacao e liste o que foi mesclado desde então (git log --oneline --since=<data>).
3Relate meta, suspeitos, política ao-violar. Não corrija nada.

A lei de graduação já está em CLAUDE.md (CONSTRUÇÃO 1): toda /goal aprovada escreve sua própria meta permanente. Terminar É a matrícula.

Consultas ao livro que você realmente usará:

1awk -F'\t' '$3=="FAIL"{n[$2]++} END{for(g in n) print n[g],g}' memory/goal-ledger.tsv | sort -rn | head -5   # mais instáveis
2grep <goal> memory/goal-ledger.tsv | awk -F'\t' '$3=="FAIL"' | head -1                                      # quando quebrou

Predicado instável: quarentena (status: aposentado, nota "precisa de um predicado melhor"), nunca deletar.

VERIFICAÇÃO 5: Adicione uma meta com predicado: true e outra com predicado: false. ./verify-goals.sh sai com 1, vira a segunda para VIOLATED, e ambas aparecem no ledger. Delete os placeholders.

CONSTRUÇÃO 6: O Orçamento

Por quê: custo diário = ticks × triagem + acertos × (condutor + trabalhador + verificador). A preços reais (triagem $0,01, condutor $0,35, trabalhador $0,10, verificador $0,40): um zelador diário custa ~$2,56/dia; uma babá de 15 minutos com Fable na cadeira de triagem custa $34/dia para o resultado idêntico. O modelo que lê os ticks silenciosos decide a conta.

Crie loop/scripts/log-cost.sh:

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

Crie 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 "gastou \$$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

Regras que mantêm tudo enxuto: cadência é uma decisão de custo (reduzir o intervalo pela metade dobra o piso); o tick silencioso deve custar centavos; esforço nunca acima de alto em loops (xhigh é para revisões únicas; esforço é por etapa, não por execução).

VERIFICAÇÃO 6: Após uma semana de ticks, ./scripts/cost-check.sh --report corresponde à fórmula dentro da margem de erro. Defina DAILY_BUDGET_USD para um número que você não se importaria de desperdiçar.

CONSTRUÇÃO 7: Os Loops Opcionais (instale quando a condição aparecer)

• Quórum (instale quando o despacho mostrar despertares do Fable que produziram ação: pare). Três modelos baratos votam; Fable acorda com 2 de 3. Os votantes nunca veem as respostas uns dos outros.

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: quieto ($V/3)"

• Catraca (instale quando um único número importar). Melhoria monotônica ou auto-reversão; a métrica não pode ser manipulada; o piso concluído se torna uma meta permanente.

1/goal Reduzir `npm run lint 2>&1 | grep -c warning` para 0.
2Permissões: editar src/; commit por correção; medir novamente após cada alteração.
3Muros: o número NUNCA sobe; reverta qualquer alteração que o aumente ou quebre um
4teste; nunca edite a config do lint para reduzi-lo.
5Timebox: pare após 3 tentativas sem progresso; relate os sobreviventes.

• Sparring (instale quando você enviar código diariamente). Construtor e destruidor, opostos; nenhum toca na saída do outro; disputas vão para você.

1/loop 1d [destruidor] Leia os diffs mesclados de ontem. Escreva UM teste falho
2expondo uma fraqueza real. Commit em tests/sparring/ marcado @sparring.
3Não conserte nada. Código sólido = diga isso, não escreva nada.
4/loop 1d [construtor] Se algum teste @sparring falhar, conserte o CÓDIGO até passar.
5Nunca edite, enfraqueça ou delete um teste de sparring; disputas entram na fila para mim.

• Composto (instale sempre, semanalmente). Falhas viram leis; máximo de três propostas; assinatura humana necessária.

1/loop 7d Leia o exaurido desta semana: FAILED em STATE.md, falhas em trust.tsv,
2FAILs em goal-ledger.tsv, PRs fechados sem merge. Extraia NO MÁXIMO 3 propostas:
3uma nova lei em CLAUDE.md (cite incidentes), uma correção de skill (mesma falha repetindo),
4ou uma meta permanente que nos faltava. Apenas proponha. Semana limpa = diga isso.

VERIFICAÇÃO 7: Cada loop opcional tem sua condição de instalação escrita ao lado em suas anotações. Instalá-los especulativamente é como os sistemas incham.

CONSTRUÇÃO 8: Operações

Crie Makefile:

1tick:            ; ./loop/loop.sh
2queue:           ; @grep -E "review:|queued:|FAILED:|rerouted" loop/memory/STATE.md || echo vazio
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, quando a Semana 2 começar:

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

O cronograma de confiança de 30 dias

Não pule graduações; cada uma desbloqueia a próxima.

Semana

Nível

Você faz

Gradua quando

1

L1 relatório

Construções 1-6;

make tick

manualmente diariamente; leia tudo

3 execuções consecutivas roteiam exatamente como você teria feito

2

L2 rascunho

cron ligado;

make queue

com café; revisões alimentam o ledger

2 skills cruzam 20 execuções registradas

3

L3 envio

make audit

vs a fórmula; melhor skill fica sem supervisão

1 semana, zero intervenções

4

L4 crescimento

composto aprova; aprove 1 skill proposta; execute o passe de exclusão

você removeu algo e nada quebrou

O runbook. O que cada alarme significa e o que fazer:

Sinal

Significado

Ação

exit 2 (reroute)

roteador de salvaguarda trocou modelos no meio da execução

leia o checkpoint; reexecute o item amanhã; nunca itere na saída trocada

stop_reason: refusal

classificador de segurança recusou (HTTP 200, não um erro)

caminho oficial: fallback para Opus 4.8 via

fallbacks

ou middleware; se recorrer em uma skill, audite essa skill por eco de raciocínio ou fraseado adjacente a ciber/bio

exit 3 (budget)

gasto diário atingiu o limite

make audit

; descubra qual estágio cresceu; corrija o mapa de esforço, não o orçamento

ALERT rebaixado

uma skill estabelecida caiu abaixo de 90%

leia suas últimas 3 falhas; geralmente o padrão da spec, não do trabalhador

goal VIOLATED

algo concluído deixou de ser verdade

sentinel dá suspeitos; correção passa pelo pipeline normal

impasse maker/checker x2

nenhum é presumido correto

você decide, ou execute o quebra-impasse (terceiro revisor novo, julga evidências, não pode dividir a diferença)

verify-goals timeout

predicado muito caro

isso é uma violação; barateie o predicado

As Regras (imprima isto)

1. Leis, não dicas: um número, um nunca, ou um comando que verifique.
2. O condutor planeja, trabalhadores executam, nenhum verifica. --allowedTools impõe isso.
3. Agentes falam em ordens de serviço. done_when = spec + condição de parada + invariante futura.
4. Gaste esforço onde o loop ramifica. Nunca acima de alto em um loop.
5. O tick silencioso custa um centavo ou o loop custa mil.
6. Se um script shell não pudesse verificar, não escreva como meta.
7. Metas se graduam; não se fecham. verify-goals.sh roda diariamente, para sempre.
8. Autonomia por skill: 20 execuções, 95%, automático. Rebaixamento automático e barulhento.
9. Dois ledgers: confiança (trabalhadores) e metas (trabalho). Leia ambos com café.
10. Calcule o metabolismo antes de configurar o cron.
11. Contrato no repositório: age-sozinho / enfileira / acorda-me.
12. Nunca itere na saída de um modelo que você não escolheu.
13. O sentinel detecta; o pipeline corrige.
14. Quórum antes de acordar Fable. Catraca e depois solde. Spar diariamente. Composto semanalmente.
15. Um critério de graduação por vez. Todo mês, delete algo.
16. Dos docs oficiais: max_tokens limita pensamento mais texto, recusas são HTTP 200, nunca peça raciocínio ecoado, skills antigas degradam Fable, e verificadores com contexto fresco superam autocrítica. Anthropic diz isso; o sistema impõe.

Encerramento

Trinta dias a partir de agora, se você fez as verificações: um loop entrega trabalho chato sem supervisão, um diretório de metas reverifica tudo que você já concluiu, dois ledgers contam a verdade sobre seus trabalhadores e seu trabalho, e uma execução semanal de composto propõe a própria próxima melhoria do sistema para sua assinatura.

• O modelo nunca foi a parte difícil. A parte difícil foi construir algo em torno dele que permaneça honesto quando você para de vigiar. É isso que você acabou de construir.
• Comece hoje à noite com os vinte minutos que provam isso: VERIFICAÇÃO 2's verify.sh, VERIFICAÇÃO 3's primeiro tick manual, e uma meta permanente para a última coisa que você concluiu.
• Na primeira vez que verify-goals.sh pegar uma regressão silenciosa em algo que você tinha certeza que estava pronto, você não vai precisar de convencimento sobre o resto.

Aviso Legal

Este artigo foi escrito usando as anotações do usuário e editado pelo Claude Opus 4.8 max.