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

Este é um guia completo A–Z sobre o 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 rodar por horas sem supervisão, despachar seus próprios subagentes e fazer uma semana de trabalho em uma noite. Ele também é medido (US$ 10/M entrada, US$ 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 forma 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 sobre ele: 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.

O que você terá ao 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á finalizou continua sendo verificado diariamente, para sempre, para que nada apodreça silenciosamente (CONSTRUÇÃO 5)
• Um orçamento que se impõe sozinho 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 autoexpansivo.

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 com 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 rodar sem você. Tempo total prático: 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. Nada 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 re-verificado. 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 Mecanismo (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

documentos introdutórios

Preço

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

documentos introdutórios

Pensamento

adaptativo, sempre ativo;

thinking: {type:"disabled"}

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

documentos de introdução + esforço

Esforço

baixo

médio

alto

muito alto

máx

;

alto

= padrão = omitir o parâmetro

documentos de esforço

Forma da API

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

na API Messages

documentos de esforço

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

1. max_tokens é um limite rígido para o pensamento MAIS o texto de resposta. Em alto e muito alto, 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. muito alto é 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 supera o desempenho muito alto em modelos anteriores", então resista a atualizar os trabalhadores.
3. Recusas são HTTP 200. O Fable 5 executa classificadores de segurança (cibernética ofensiva, 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. Solução 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.
5. Turnos são longos por design. Tarefas difíceis levam muitos minutos por requisição em esforço mais alto; 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 diretamente para seus prompts textualmente; não os parafraseie para torná-los mais enxutos:

1. Antiexcesso de planejamento (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 seguir. Se estiver ponderando uma escolha,
4dê uma recomendação, não um levantamento exaustivo.

1. Antiexcesso de engenharia (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 acontecer.
5Valide 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 isso 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 foram
3importantes. Não salve o que o repositório já registra; atualize notas existentes
4em vez de duplicar; exclua notas que se revelam erradas.

1. Instrução oficial do verificador (os documentos afirmam diretamente: "subagentes verificadores separados, 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 scaffolding 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 definir o escopo), 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 alto dentro de qualquer loop. muito alto é 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 de 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 alto, somente leitura.
242. Leituras >50k tokens (logs/PDFs/capturas de tela) -> codex. Nunca fable.
253. Enviado para usuários (UI/API/cópia) -> bom gosto >= 8 recebe passagem final.
264. Especificação completa -> sonnet-5, esforço médio.
275. Senão sonnet-5; suba 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 de fluxo de trabalho (procedimento de PR, checklist de release) 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 150

CONSTRUÇÃO 2: Muros e Portão

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

Crie loop/contract.md:

1## age sozinho
2PRs de rascunho em branches; corrija dívida de lint/teste; atualize STATE.md; rotule 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 US$ 50/M saída); Fable como condutor emite 10-20% dos tokens enquanto toma 100% das decisões. Um modelo de US$ 0,01 lê as batidas silenciosas. Os 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/execução>
4  status: acionavel | informacional
5Sem correções, sem opiniões. Nada a relatar = produza exatamente "status: quieto".
6Qualquer coisa tocando em 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": ["<verificável>", ...] }
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.
2Dê o PRÓXIMO passo em direção a done_when. Diffs pequenos vencem.
3Credencial faltante 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}"
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 TRIAGEM: portão de batida silenciosa, ~$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 triagem 0.01
17  grep -q "status: acionavel" memory/STATE.md || { echo quieto; exit 0; }
18
19  # 2 CONDUTOR: Fable, muito alto, 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 ROTEAMENTO: 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 .habilidade work-order.json); ACAO=$(jq -r .acao work-order.json)
34  [[ "$ACAO" == parar  ]] && exit 0
35  [[ "$ACAO" == fila ]] && { echo "fila: $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 "$WORKER" -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 .especificacao 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; 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 "- revisao: $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 parada: 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 "vigia"
9  else print "fila"}'; }
10case "${1:-}" in
11  --render)
12    printf "%-20s %5s %5s %6s %s\n" habilidade execs passos 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      execs=$(grep -P "^${1}\t" "$F" | cut -f2)
26      [ "$("$0" --tier "$1")" = vigia ] && [ "$execs" -ge 10 ] \
27        && echo "ALERTA: $1 rebaixado para vigia após $execs execuções" >&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ê. vigia = 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.
• Popule o quadro: crie loop/skills/<nome>/SKILL.md para cada tarefa recorrente (corrigir-divida-de-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 vigia.

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 re-verificados 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
2nascida: 2026-07-06
3fonte: /goal sessão 2026-07-06 (corrigir instabilidade auth)
4status: satisfeita
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: aposentada' "$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: satisfeita/; s/^ultima-aprovacao:.*/ultima-aprovacao: $(date +%F)/" "$g"
11  else r=FALHA; VIOLACOES=$((VIOLACOES+1)); sed -i "s/^status:.*/status: VIOLADA/" "$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: VIOLADA' 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. Finalizar É 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.

CHECK 5: Adicione um objetivo com predicado: true e outro com predicado: false. ./verify-goals.sh retorna 1, altera o segundo para VIOLATED, e ambos aparecem no ledger. Delete os fictícios.

BUILD 6: O Orçamento

Por que: custo diário = ticks × triagem + hits × (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 triagem custa $34/dia para o mesmo resultado. 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).

CHECK 6: Após uma semana de ticks, ./scripts/cost-check.sh --report corresponde à fórmula dentro da margem de ruído. Defina DAILY_BUDGET_USD para um valor que você não se importaria de gastar.

BUILD 7: Os Loops Opcionais (instale quando a condição aparecer)

• Quorum (instale quando o despacho mostrar despertares do Fable que produziram ação: pare). Três modelos baratos votam; Fable desperta 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: silêncio ($V/3)"

• Ratchet (instale quando um único número importa). Melhoria monotônica ou auto-reversão; a métrica não pode ser manipulada; o piso concluído se torna um objetivo 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 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 corrija nada. Código sólido = diga isso, não escreva nada.
4/loop 1d [construtor] Se algum teste @sparring falhar, corrija o CÓDIGO até passar.
5Nunca edite, enfraqueça ou delete um teste de sparring; disputas entram na fila para mim.

• Compost (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 um objetivo permanente que nos faltava. Apenas proponha. Semana limpa = diga isso.

CHECK 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.

BUILD 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

Builds 1-6;

make tick

manualmente diariamente; leia tudo

3 execuções consecutivas roteiam exatamente como você faria

2

L2 rascunho

cron ativado;

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

compost assina; 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 frases adjacentes a cyber/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 o 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 objetivo.
7. Objetivos se graduam; eles não 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: trust (trabalhadores) e goals (trabalho). Leia ambos com café.
10. Calcule o metabolismo antes de configurar o cron.
11. Contrato no repositório: age-sozinho / enfileira / me-acorda.
12. Nunca itere na saída de um modelo que você não escolheu.
13. O sentinel detecta; o pipeline corrige.
14. Quorum antes de acordar Fable. Ratchet e depois solde. Spar diariamente. Compost semanalmente.
15. Um critério de graduação por vez. Todo mês, delete algo.
16. Das 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 os checks: um loop entrega trabalho chato sem supervisão, um diretório de objetivos reverifica tudo que você já concluiu, dois ledgers contam a verdade sobre seus trabalhadores e seu trabalho, e uma compostagem semanal 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 é o que você acabou de construir.
• Comece hoje à noite com os vinte minutos que provam isso: BUILD 2's verify.sh, BUILD 3's primeiro tick manual, e um objetivo 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 por Claude Opus 4.8 max.