A stack de agentes de IA que todos devem usar com GPT-5.6 + Fable 5 (Guia do Desenvolvedor)

Edição 5 + GPT-5.6: A Construção Completa de uma Pilha de Agentes que Entrega Enquanto Você Dorme

Esta é a construção completa, em ordem, com um ponto de verificação após cada peça.

Marque estas 12 construções antes de esquecer.

Introdução

Você tem os dois modelos mais capazes já disponibilizados publicamente, e ainda assim está usando um de cada vez, manualmente.

Três coisas mudaram no último mês.

• Claude Fable 5 planeja em etapas, despacha seus próprios subagentes e verifica sua própria saída. US$ 10 por milhão de tokens de entrada, US$ 50 de saída.
• GPT-5.6 lançado em 9 de julho como três níveis permanentes. Sol a US$ 5 e US$ 30, Terra a metade do Sol, Luna a US$ 1 e US$ 6. A OpenAI agora vende a decisão de roteamento como o produto.
• Fable 5 passou 19 dias de junho suspenso sob uma ordem de exportação. Disponibilidade agora é algo que acontece com você.

Executados casualmente, esses modelos são uma maneira cara de gerar coisas erradas impressionantes.

Executados dentro de um sistema, eles são a coisa mais próxima de um funcionário que você pode alugar. Os números empresariais da Anthropic colocam o Claude Code em cerca de US$ 13 por desenvolvedor por dia ativo. A OpenAI coloca o Codex em US$ 100 a US$ 200 por mês.

Este guia constrói esse sistema em doze construções: os arquivos reais, em ordem, cada um testado antes da publicação, com um ponto de verificação após cada um para que você saiba que uma peça funciona antes de empilhar a próxima.

É para qualquer pessoa com um repositório, um terminal e acesso a qualquer um dos CLIs. Os exemplos são com sabor de código porque os loops cresceram em torno do código, mas o roteador, o conselheiro e o portão funcionam em faturas e relatórios da mesma forma.

Leia em ordem, fazendo as verificações. Cada construção leva de 10 a 20 minutos, cerca de duas horas no total. Os 30 dias no final são o cronograma durante o qual o sistema ganha o direito de rodar sem você.

Três princípios preveem cada decisão de design abaixo:

1. Roteie nos limites. Esforço antes do modelo. Uma troca de modelo no meio da sessão queima um desconto de cache de 90%. Aumentar o esforço de raciocínio no mesmo modelo não custa nada extra em encanamento.
2. Nada avalia sua própria lição de casa. Escritor, roteador, conselheiro e revisor são partes diferentes, de linhagens diferentes quando possível, e o voto final é um script bash.
3. Pronto é um fato sobre o ambiente. Um conjunto de testes aprovado, um arquivo de tarefas marcado, uma linha de veredito. Nunca a opinião do modelo sobre si mesmo.

O mapa, e por que o usual está errado

Engenharia de loops é um fluxo de trabalho de agente com uma condição de parada explícita e lógica de repetição. O arreio decide quando o trabalho está concluído, em vez de deixar "estou pronto" para o modelo.

A imagem padrão é a pilha Loopcraft da swyx: cinco loops aninhados uns dentro dos outros, execução dentro de tarefa dentro de produto dentro de sistema dentro de supervisão, cada um com sua própria saída. É a melhor que alguém já desenhou.

Usei por semanas. Então tentei construir contra ela, e quebrou em quatro lugares.

1) Problema um: os loops não se aninham.

Aninhar significa que uma volta do loop externo equivale a uma execução completa do loop interno. Não é o que acontece. O loop do sistema não espera o loop do produto terminar. Ele roda no domingo, quer algo tenha sido entregue ou não.

Você pode interromper um fluxo de tokens manualmente sem desenrolar quatro camadas. É uma imagem de contenção desenhada sobre um sistema que faz transferências.

2) Problema dois: um loop desenhado como infinito é uma conta.

O original desenha o loop do produto assim. Na prática, ele termina em um orçamento, em um ponto de verificação, ou em alguém perdendo a paciência.

Chamar isso de "nenhum por design" esconde o lugar exato onde o dinheiro vaza de um sistema de agente: um loop que ninguém instruiu a como sair.

3) Problema três: não há aborto.

Toda camada tem um final feliz e nenhum infeliz. Loops reais precisam de ambos: como ele fecha quando funciona, e como ele para quando não consegue.

Toda conta descontrolada que já vi era um loop com uma saída definida e um aborto indefinido.

4) Problema quatro: a verificação está faltando, e é o jogo todo.

A verificação é o contrato entre as camadas. Quando um loop inferior entrega a um loop superior um relatório em vez de um fato, o loop superior fecha em uma mentira.

Essa única lacuna é a razão pela qual um loop pode atingir sua condição de parada e ainda assim estar errado.

Esta é a versão contra a qual construo.

A Escada de Evidências

Seis degraus, duas saídas cada, e uma regra: o controle flui para baixo como metas, a evidência flui para cima como fatos, e nenhum degrau pode fechar com base em um relatório do degrau abaixo dele.

Cinco leis decorrem da forma.

Cada degrau tem um aborto, ou é uma conta. Se você não consegue nomear como um loop termina mal, você construiu uma assinatura. É por isso que o ralph.sh carrega dois limites e o enxame carrega um limite de ciclo.

A evidência flui para cima e o controle flui para baixo. Um degrau fecha com base em um fato produzido abaixo dele, nunca em um resumo escrito abaixo dele.

O portão da fábrica é esta lei em SQL. Dois revisores disseram verde. O portão ainda recusou, porque ninguém tinha produzido uma linha de teste aprovada.

Um veredito é uma opinião. Uma linha é evidência.

O custo por volta sobe cerca de dez vezes por degrau.

Um bug que escapa do degrau 2 custa dez vezes mais para ser pego no degrau 3, e cem vezes mais no degrau 4.

Esse é o argumento inteiro para colocar sua melhor verificação o mais baixo possível na escada, e é por isso que o portão é um script bash e não uma reunião.

A escala de tempo pertence ao modelo, não ao degrau.

O degrau 2 levava minutos em 2024, leva horas em 2026 e em breve levará dias. Projete contra a condição de saída, nunca contra o relógio. É aqui que a imagem antiga envelhece mais rápido.

Apenas o degrau 5 não tem condição de saída, e é isso que humano significa.

Você vive lá. A escada existe para merecer uma frase: um loop pode atingir sua condição de parada e ainda assim estar errado.

Testes passam, o portão fica verde, ambos os revisores assinam, e o último commit ainda é um erro. Cada degrau abaixo de você existe para tornar essa verificação menor. Nenhum deles pode tirá-la de você.

Pré-requisitos

1claude CLI (Claude Code) com acesso ao Fable 5
2codex CLI com acesso ao GPT-5.6        # ou o plugin oficial dentro do Claude Code
3python3, jq, git, gh, make, cron
4um repositório com um comando de teste que funciona hoje
5
6# opcional, para frotas mistas (CONSTRUÇÃO 7):
7openai/codex-plugin-cc               # oficial: rodar Codex dentro do Claude Code
8claude-model-switch                  # proxy local: qualquer provedor por trás do Claude Code
9CLIProxyAPI                          # wrap de assinaturas CLI como endpoints de API

O que você está construindo

1seu-repositorio/
2  CLAUDE.md                          # CONSTRUÇÃO 1: constituição do lado Claude
3  AGENTS.md                          # CONSTRUÇÃO 1: constituição do lado Codex
4  .claude/
5    skills/model-bench/SKILL.md      # CONSTRUÇÃO 0: preços, IDs de API, fallbacks. o único arquivo com números
6    skills/model-router/SKILL.md     # CONSTRUÇÃO 4
7    skills/stuck-protocol/SKILL.md   # CONSTRUÇÃO 5
8    skills/ship-gate/SKILL.md        # CONSTRUÇÃO 2
9    agents/fable-expert.md           # CONSTRUÇÃO 5
10    agents/fresh-eyes-reviewer.md    # CONSTRUÇÃO 6
11    agents/sol-reviewer.md           # CONSTRUÇÃO 6
12    agents/scout.md                  # CONSTRUÇÃO 7
13  loop/
14    ralph.sh                         # CONSTRUÇÃO 3: o batimento cardíaco
15    two_lane.sh                      # CONSTRUÇÃO 6: loop de revisão entre fornecedores
16    PROMPT.md  TASKS.md              # CONSTRUÇÃO 3: o protocolo de trabalho
17  gate/
18    verify.sh                        # CONSTRUÇÃO 2: voto final determinístico
19    eval_gate.py  eval/cases.jsonl   # CONSTRUÇÃO 2: portão de mudança de roteamento
20  router/
21    router.py                        # CONSTRUÇÃO 4
22    advisor_loop.py                  # CONSTRUÇÃO 5
23  ~/.codex/
24    config.toml                      # CONSTRUÇÃO 0: perfis luna/terra/sol
25    prompts/effort.md                # /effort      classifique a tarefa, nomeie o assento
26    prompts/plan-stop.md             # /plan-stop   planeje, precifique, depois pare
27    prompts/fable-advice.md          # /fable-advice consulta de especialista entre fornecedores
28    prompts/review-hostile.md        # /review-hostile veredito de contexto limpo
29    prompts/compost.md               # /compost     falhas se tornam leis, semanalmente
30  factory/
31    factory_gate.py                  # CONSTRUÇÃO 8: quadro negro + portão de conclusão
32    factory.sh                       # CONSTRUÇÃO 8: briefing -> implementar -> revisar -> portão
33    factory.db                       # CONSTRUÇÃO 8: as linhas que decidem
34  swarm/
35    swarm.sh                         # CONSTRUÇÃO 9: planejar -> despachar -> pontuar -> replanejar
36    goals.jsonl                      # CONSTRUÇÃO 9: uma meta por linha, cada uma com sua verificação
37  system/
38    verify_goals.py                  # CONSTRUÇÃO 10: reverificação diária, para sempre
39    goals/                           # CONSTRUÇÃO 10: um arquivo por coisa concluída
40  ROUTING.md                         # CONSTRUÇÃO 12: a política de roteamento completa, ambos os arreios
41  progress.log                       # cada construção anexa aqui
42  # opcional (CONSTRUÇÃO 7): proxy claude-model-switch em localhost:4000,
43  # CLIProxyAPI para wrap de assinaturas CLI como endpoints de API

CONSTRUÇÃO 0: Configure os Motores

Defina estes antes de escrever qualquer arquivo seu. Cada número abaixo foi verificado nas páginas oficiais de preços na semana da publicação.

O banco: cada assento, julho de 2026

O elenco que o sistema contrata.

Os preços vivem em um único arquivo de habilidade, .claude/skills/model-bench/SKILL.md, carregado sob demanda antes de qualquer questão de roteamento ou custo. Nenhum outro arquivo codifica um número.

Os preços mudaram três vezes nas seis semanas antes da redação deste texto. Um preço em um artigo está errado na publicação. Um preço em um arquivo de habilidade está a uma edição de distância.

A divisão que decide tudo a jusante:

• Fable 5 lidera trabalhos de software pesados. 80% no SWE-Bench Pro contra 64,6% do Sol, e ele supera o Sol em inteligência geral.
• Sol lidera trabalhos de terminal e agente. 88,8% no Terminal-Bench 2.1, e ele lidera o índice de agente de codificação a cerca de um terço do custo do Fable por tarefa.

Essa divisão é a razão pela qual este sistema é de dois fornecedores. O Fable julga e planeja, o Sol revisa e opera terminais, e nenhum deles faz a digitação em massa.

Dois assentos que as pessoas interpretam mal.

Opus 4.8 não é o antigo carro-chefe pegando poeira. É o fallback automático sob o Fable e o padrão recomendado para codificação agente complexa. Seu sistema o herda quer você planeje ou não.

Sonnet 5 com preço introdutório é o melhor custo-benefício do quadro. Próximo ao Opus 4.8 em capacidade, a uma fração do preço de entrada do Fable, e é por isso que é o executor padrão em todos os lugares nesta construção. Essa taxa expira em 31 de agosto, e o arquivo de habilidade já sabe disso.

Esse arquivo de habilidade é o único arquivo no sistema que contém um número:

1---
2name: model-bench
3description: A tabela de preços atual, IDs de modelo de API e cadeia de fallback para cada
4  modelo que este sistema pode contratar. Carregar antes de qualquer decisão de roteamento, estimativa de custo,
5  pergunta de orçamento, comparação de modelos, ou quando o usuário perguntar quanto algo custa.
6---
7
8# Banco de modelos
9
10Fonte única de verdade para preços e identificadores de API. Nada mais neste repositório
11codifica um preço, então quando os laboratórios alteram suas taxas, você edita este arquivo e
12nada mais. Verificado em 2026-07-13. Os preços mudam. Verifique novamente antes de orçar.
13
14## Anthropic (API Messages, /v1/messages)
15
16Esforço: output_config {"effort": "low|medium|high|xhigh|max"}. O pensamento adaptativo
17está sempre ativo para o Fable 5 e não pode ser desabilitado. max_tokens limita o pensamento MAIS
18o texto de resposta, então defina-o grande (comece perto de 64k) em alto e acima, ou o modelo
19fica sem espaço no meio do pensamento.
20
21| Modelo | Entrada/Saída por Mtok | Leitura de cache | Assento |
22|---|---|---|---|
23| claude-fable-5 | $10/$50 | $1,00 | condutor, planejador, conselheiro, juiz. Cai para opus-4-8 automaticamente |
24| claude-opus-4-8 | $5/$25 | $0,50 | condutor sob regras de retenção |
25| claude-sonnet-5 | $2/$10 (até 31 de agosto, depois $3/$15) | n/a | executor de codificação padrão |
26| claude-haiku-4-5 | $1/$5 | $0,10 | batedores, subagentes, trabalho mecânico |
27
281M de contexto no Fable, Opus 4.8, Sonnet 5, precificado PLANO em contexto longo, e é
29por isso que leituras longas são roteadas para cá. Saída máxima de 128K.
30
31## OpenAI (API Responses, /v1/responses)
32
33| Modelo | Entrada/Saída por Mtok | Em cache | Assento |
34|---|---|---|---|
35| gpt-5.6-sol | $5/$30 | $0,50 | revisor entre fornecedores, trabalho de terminal |
36| gpt-5.6-terra | $2,50/$15 | $0,25 | motorista diário do Codex (teste contra Luna primeiro) |
37| gpt-5.6-luna | $1/$6 | $0,10 | trabalho mecânico, tiques silenciosos |
38
39Contexto longo acima do limite aproximadamente DOBRA o preço de entrada, ao contrário do plano
40de 1M da Anthropic. Primeira família com pontos de interrupção de cache explícitos; escritas custam 1,25x.
41
42## Pesos abertos (trabalhadores em massa)
43
44| Modelo | Entrada/Saída por Mtok | Acerto de cache |
45|---|---|---|
46| deepseek-v4-flash | $0,14/$0,28 | $0,0028 (aproximadamente 98% de desconto) |
47| deepseek-v4-pro | $0,435/$0,87 | n/a |
48| kimi-k2.7-code | $0,95/$4,00 | $0,19 |
49
50## Descontos que acumulam
51  - leituras de cache custam um décimo da entrada nova em ambos os laboratórios (cerca de 90% de desconto)
52  - escritas de cache se pagam após uma leitura (5m) ou duas (1h)
53  - APIs em lote têm 50% de desconto em ambas as direções
54  - lote + leitura de cache em um prefixo repetido chega perto de 95% de desconto
55  - o tokenizador mais novo da Anthropic produz cerca de 30% mais tokens para o mesmo
56    texto, então o custo efetivo fica acima do indicado. Orçamento com base no efetivo.
57
58## Como responder a uma pergunta de custo
59  1. Estime entrada e saída separadamente. Agentes leem cerca de 100 tokens para cada
60     1 que escrevem, então a entrada domina e a taxa de acerto de cache decide a conta.
61  2. Aplique a taxa de leitura de cache ao prefixo repetido, não à taxa base.
62  3. Multiplique os valores da Anthropic por cerca de 1,3 para o tokenizador.
63  4. Dê uma faixa, nomeie as suposições, diga qual linha deste arquivo você usou.
64  5. Se o número exceder o limite diário do repositório, diga isso ANTES de executar qualquer coisa.
65
66Nunca apresente um preço que você não leu deste arquivo. Um modelo não listado aqui não está
67no banco, e adicionar um é uma mudança de roteamento que passa pelo portão.

Sete fatos que mudam como você constrói:

1. Entrada em cache tem 90% de desconto em ambos os laboratórios. Um timestamp no seu prompt de sistema queima isso em toda chamada. Prefixo estável, histórico somente anexado, sempre. Agentes leem cerca de 100 tokens para cada 1 que escrevem, então esse desconto é a maior parte da sua conta.
2. Escritas de cache custam extra, mas se pagam rápido. A escrita de 5 minutos da Anthropic custa 1,25x e se equilibra após uma única leitura. GPT-5.6 é a primeira família da OpenAI com pontos de interrupção de cache explícitos e escritas precificadas. Arquitetura em torno do cache da mesma forma que um programador de sistemas arquiteta em torno de uma hierarquia de memória.
3. O tokenizador mais novo da Anthropic cria cerca de 30% mais tokens para o mesmo texto. O preço efetivo fica acima do indicado. Faça orçamento com base no efetivo.
4. Uma recusa de segurança do Fable 5 não é um erro. A chamada é bem-sucedida e o trabalho cai no Opus 4.8, por design, em menos de 5% das sessões. Leia o que aconteceu, não apenas o código de saída, e configure a cadeia de fallback antes de precisar dela.
5. Não use o nível intermediário como padrão. Testes independentes descobriram que alguma configuração do Luna ou Sol sempre supera o Terra na fronteira custo-qualidade. Teste o Terra contra o Luna no seu próprio tráfego antes de pagar por ele.
6. APIs em lote reduzem pela metade qualquer coisa que pode esperar até o dia seguinte, e o desconto acumula com o cache: prefixos repetidos em trabalho em lote rodam perto de 95% de desconto. O queimador noturno na CONSTRUÇÃO 7 existe para explorar isso.
7. Disponibilidade é um risco operacional, não uma hipótese. O Fable 5 perdeu 19 dias em junho. Cada referência de modelo aqui tem um fallback: fable-5 cai para opus, sol cai para terra, e cada fallback é registrado.

O segundo medidor: um assento não é uma chave de API

Cada número acima é precificado em dólares por milhão de tokens. Essa é a moeda certa se você paga por chamada.

É a errada se você roda isso em uma assinatura Codex Pro de US$ 200 ou uma assinatura Claude Max.

Em uma assinatura, o medidor é uma janela de cinco horas e uma janela semanal, avaliadas juntas, e uma solicitação conta contra ambas.

Você pode estar cheio na semana e ainda assim bloqueado por quatro horas, porque uma única mensagem consumiu a janela curta.

Mesma doutrina. Moeda diferente. Três configurações decidem quanto de uma janela uma mensagem pode consumir:

O modo rápido é o caro, porque multiplica um número que acabou de ficar maior.

O GPT-5.6 roda muito mais tempo por mensagem do que o 5.5. Principalmente um presente. Também torna a queima imprevisível.

• Theo relata queimar mais de US$ 200.000 em tokens no Sol
• Ele viu uma única mensagem do 5.6 consumir 15% de uma janela de cinco horas
• Com o multiplicador, isso é 40% da janela em uma única mensagem

Velocidade não é de graça. O que ela cobra são os tokens que você queimaria de qualquer forma. Releia o multiplicador nos documentos de velocidade antes de confiar nele: é publicado por modelo, e muda.

O Ultra é a armadilha mais sutil, porque a interface o arquiva onde os níveis de esforço vivem, e ele não é um deles.

• Máximo é profundidade. Um modelo, um problema, mais tempo em uma única cadeia de raciocínio.
• Ultra é largura. O trabalho se ramifica para quatro agentes, depois é sintetizado.
• Eixos diferentes. Ultra não é "mais que máximo."

Apontado para uma tarefa que não se divide verdadeiramente, o ultra compra quatro agentes duplicando uma única investigação.

Vale cerca de 3,1 pontos no Terminal-Bench 2.1, de 88,8 para 91,9, para uma frota inteira de queima. Desligado até que os limites entre os subproblemas sejam reais.

Por que Sol e Terra são ambos padrões corretos

Um relatório de campo executa o Sol para quase tudo. O banco acima torna o Terra o motorista diário do Codex. Ambos estão certos, e o medidor é a razão.

• A tabela de preços diz que a saída do Sol custa o dobro da do Terra
• A assinatura diz que você já pagou
• Então a única questão viva é quantas voltas são necessárias para chegar ao verde
• Um modelo mais forte com menos esforço geralmente precisa de menos

Taxa não é custo. Custo é taxa vezes voltas-para-verde, e o segundo termo é o que se move.

Que é a lei da CONSTRUÇÃO 4 chegando da outra direção: atualize o assento antes de tocar no dial. Em uma assinatura que lê Sol no alto no nível de US$ 200, Sol no baixo abaixo disso. Meça antes de acreditar em qualquer um.

Defina os níveis do Codex agora:

1# ~/.codex/config.toml
2model = "gpt-5.6-terra"                 # motorista diário
3model_reasoning_effort = "medium"
4# service_tier = "fast"                 # DEIXE COMENTADO. modo rápido cobra 2,5x
5                                        # créditos. execute /fast status para confirmar
6                                        # que você não está nele.
7
8[profiles.fast]                         # trabalho mecânico. NÃO é "modo rápido": este
9model = "gpt-5.6-luna"                  # perfil é um modelo mais barato, não um medidor 2,5x
10model_reasoning_effort = "low"          # . Duas coisas diferentes, uma palavra.
11
12[profiles.deep]                          # planejamento, bugs difíceis, revisões
13model = "gpt-5.6-sol"
14model_reasoning_effort = "high"

VERIFICAÇÃO 0: ambos os CLIs autenticam, e seu comando de teste sai com 0 no repositório atual.

CONSTRUÇÃO 1: As Constituições

Esses modelos seguem leis e otimizam em torno de dicas, então cada linha precisa de um número, um nunca, ou um comando que a verifique.

Crie CLAUDE.md:

1# CLAUDE.md
2
3## NUNCA (exceções exigem permissão primeiro)
4- Nunca troque de modelo no meio da sessão. O roteamento acontece apenas nos limites de sessão
5  e subagente. Trocas no meio da tarefa queimam o cache.
6- Nunca revise seu próprio diff. A revisão vem de um contexto fresco ou de uma
7  linhagem diferente. O revisor do Devin pega 2 bugs por PR de agente
8  precisamente porque não compartilha nada com o escritor.
9- Nunca edite, enfraqueça ou exclua um teste para fazê-lo passar. FALHA AUTOMÁTICA.
10- Nunca relate conclusão com base em autoavaliação. Concluído = gate/verify.sh passou.
11- Nunca faça uma quarta consulta ao conselheiro. Três erros = BLOQUEADO, vez do humano.
12- Nunca mescle uma alteração de roteamento ou prompt que o eval_gate.py BLOQUEOU.
13- Nunca execute nenhum loop sem ambos os limites definidos: MAX_ITERS e BUDGET_USD.
14- Nunca presuma que um modelo de fronteira está ativo. Fallbacks: fable-5 -> opus,
15  sol -> terra. Registre cada fallback no progress.log.
16- Nunca crie um subagente que não foi solicitado. Filhos herdam o
17  modelo E esforço do pai, então uma frota ansiosa herda o assento caro.
18
19## DESPACHO (primeira correspondência vence)
20| # | Tarefa | Assento |
21|---|---|---|
22| 1 | planejar / arquitetar / migrar | fable-5 planeja, sonnet executa |
23| 2 | extrair / formatar / testes / docs | haiku ou luna |
24| 3 | contexto acima de 60k tokens | nível plano de 1M da Anthropic |
25| 4 | revisão de código escrito por agente | sol via codex, arreio nativo |
26| 5 | ambíguo | pontuação de dificuldade: 0-1 barato, 2 sonnet, 3+ fronteira |
27| 6 | ainda em dúvida | execute barato uma vez, verifique, escale uma vez em caso de falha |
28
29## CONCLUÍDO
30- Cada tarefa carrega um done_when verificável por máquina antes do início do trabalho.
31- Um revisor de contexto fresco julga especificação contra diff, nada mais.
32- gate/verify.sh detém o voto final. Duas discordâncias
33  fabricante/verificador em um item -> pare, enfileire para um humano.

Crie AGENTS.md na raiz do repositório, as mesmas leis no dialeto do Codex. Mantenha perto de 100 linhas, um índice, não uma enciclopédia:

1# AGENTS.md
2
3## Comandos
4| Propósito | Comando |
5|---|---|
6| Teste | make test   (este comando é a definição de concluído) |
7| Lint | make lint |
8
9## Protocolo de sessão
101. Leia progress.log e TASKS.md primeiro. 2. UMA tarefa não marcada.
113. Implemente, execute o SUITE completo, faça commit apenas verde, mensagem descritiva.
124. Marque a tarefa, acrescente uma linha ao progress.log, pare.
13Testes definem concluído. Nunca enfraqueça, pule ou exclua um. Teste errado =
14marque a tarefa como BLOQUEADA e diga por quê.
15
16## Política de modelo
17Padrão: terra, esforço médio. Mecânico: perfil fast (luna, baixo).
18Planejamento e bugs difíceis: perfil deep (sol, alto).
19Esforço antes do modelo. Perfil escolhido no início da sessão, nunca no meio da tarefa.
20Modo rápido DESLIGADO (2,5x créditos). Ultra DESLIGADO. Nenhum deles é um nível de esforço.
21Crie um subagente apenas quando eu pedir um. Filhos herdam o modelo E nível de raciocínio
22desta sessão, então uma criação ansiosa em alto esforço é uma frota inteira em alto esforço.
23
24## Travado
25Sinais: mesmo erro duas vezes; duas etapas sem progresso; um teste sobrevivendo a duas
26correções distintas. Então /fable-advice. Máximo de 3 consultas, depois BLOQUEADO.
27
28## Revisão
29/review-hostile em uma sessão NOVA antes de qualquer mesclagem, ou a pista
30entre fornecedores do lado do Claude. Nunca mescle seu próprio trabalho não revisado.

Uma doutrina deve viver em ambos os lados, ou o arreio com os hábitos mais frouxos vence toda vez que você troca de ferramenta.

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

CONSTRUÇÃO 2: O Portão

Um script bash deve deter o voto final antes que qualquer outra coisa exista, porque toda construção posterior assume que ele existe.

Crie gate/verify.sh para sua pilha:

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

Crie gate/eval_gate.py, o cinto de segurança para toda futura mudança de roteamento ou prompt. Ele executa 50 a 500 casos retidos através da configuração atual e da proposta, apenas com verificações determinísticas:

1for case in cases:   # {prompt, must_include, must_not_include, max_words}
2    hits += passes(case, run_config(case.prompt))
3verdict = "SHIP" if new_score >= old_score - 0.02 else "BLOCKED"

Em seguida, torne o portão impossível de pular como uma habilidade, .claude/skills/ship-gate/SKILL.md:

1---
2name: ship-gate
3description: Execute o eval gate antes de qualquer roteamento, troca de modelo ou alteração de prompt ser enviada.
4  Use quando o usuário pedir para alterar regras de roteamento, trocar um nível de modelo, editar um system
5  prompt, ajustar níveis de esforço ou fazer merge de qualquer coisa que envolva roteador, prompts ou
6  configuração de modelo.
7---
8
9# Ship gate
10
11Qualquer alteração em roteamento ou prompts é um risco à qualidade até que o gate
12diga o contrário. Esta skill existe para que o risco nunca seja enviado em silêncio.
13
14  1. Localize eval/cases.jsonl. Se não existir, PARE e avise o usuário para
15     construir primeiro de 50 a 500 casos representativos, a partir de tráfego real.
16     Não invente casos por conta própria.
17  2. Execute: python3 eval_gate.py eval/cases.jsonl, config atual vs. proposta.
18  3. BLOQUEADO: informe ambas as pontuações, liste quais casos regrediram, não aplique a
19     alteração, sugira o menor revert que desbloqueie o gate.
20  4. ENVIAR: aplique e acrescente uma linha ao progress.log com ambas as pontuações.
21
22Regras rígidas:
23  - Nunca substitua um veredito BLOQUEADO, mesmo que peçam educadamente. Escale para o humano
24    com os casos com falha anexados.
25  - Nunca edite o arquivo de casos na mesma sessão de uma alteração de roteamento. O gate
26    e a alteração não podem compartilhar o mesmo autor.
27  - Números de custo não são uma defesa contra queda de qualidade. O gate vence.

O gate usa apenas verificações determinísticas, porque nunca pode herdar o problema de quem-verifica-o-verificador. Uma alteração de roteamento sem um eval gate é um experimento de custo que você está fazendo com seus clientes.

CHECK 2: ./gate/verify.sh termina com 0 hoje, e eval_gate.py imprime SHIP na sua demonstração. Se o verify.sh falhar agora, corrija-o antes de qualquer outra coisa. O sistema se sustenta neste script.

BUILD 3: The Heartbeat

O modelo traz inteligência. O loop traz disciplina.

• Contexto fresco por iteração elimina o apodrecimento de contexto
• O repositório carrega toda a memória
• Dois limites transformam um agente descontrolado em uma lição de dez dólares

Esta é a forma exata por trás da execução de 16 loops da Anthropic que construiu um compilador C de 100.000 linhas por cerca de $20.000, sem nenhum modelo orquestrador em lugar algum.

Crie loop/PROMPT.md:

1Leia progress.log e TASKS.md. Escolha EXATAMENTE UMA tarefa não marcada.
2Implemente-a. Execute os testes. Se estiver verde: faça commit com uma mensagem
3descritiva, marque a tarefa, acrescente uma linha ao progress.log, pare.
4Se a mesma tarefa falhar duas vezes, marque-a como BLOQUEADA com o erro e pare.
5Crie um arquivo chamado DONE somente quando toda tarefa estiver marcada E a suíte
6completa passar. Nunca edite um teste para fazê-lo passar.

Crie loop/ralph.sh:

1#!/usr/bin/env bash
2set -u
3MAX_ITERS="${MAX_ITERS:-25}"      # cap one: iterations
4BUDGET_USD="${BUDGET_USD:-10}"    # cap two: dollars
5MAX_FAILS=3; fails=0; spent=0; i=0
6
7while [ ! -f DONE ] && [ "$i" -lt "$MAX_ITERS" ]; do
8  i=$((i + 1))
9  # fresh session every iteration: no memory except the repo itself
10  claude -p "$(cat PROMPT.md)" --max-turns 30 \
11    --output-format json > out.json 2> err.log \
12    && fails=0 || fails=$((fails + 1))
13  [ "$fails" -ge "$MAX_FAILS" ] && exit 2        # circuit breaker
14  cost=$(jq -r '.total_cost_usd // 0' out.json)
15  spent=$(awk -v a="$spent" -v b="$cost" 'BEGIN{printf "%.4f", a+b}')
16  awk -v s="$spent" -v c="$BUDGET_USD" 'BEGIN{exit !(s>c)}' && exit 3  # cap
17  sleep 2
18done
19[ -f DONE ] && echo "done in $i ticks, \$$spent" || echo "cap hit, \$$spent"

Troque a linha do claude por codex exec e o mesmo loop dirige o GPT-5.6.

O mapa de saída é intencional: 0 concluído ou silencioso, 2 disjuntor, 3 orçamento. Cada alarme no BUILD 12 se baseia nestes.

A linha de custo lê o próprio relatório de custo JSON da sessão, então o limite é aplicado pelo harness contra o gasto real, não uma estimativa.

Conte as paradas naquele prompt. Cada ramificação termina em uma, e isso é o design, não um tique.

Esta geração roda muito mais tempo por mensagem do que a anterior. Na maioria das vezes, um presente. Ocasionalmente, uma conta, porque um modelo que não precisa mais de incentivo para continuar vai levar uma tarefa quatro passos além do ponto onde você queria examiná-la.

O loop resolve isso estruturalmente: uma tarefa por tick, parada forçada no final.

Interativamente, você precisa dizer isso em voz alta. Dois prompts fazem o trabalho:

• "escreva o plano, então pare e me mostre antes de construir qualquer coisa"
• uma vez que o plano está bom: "construa, teste, abra o PR, lide com a primeira rodada de comentários da revisão, então pare"

Um modelo que roda por muito tempo só é perigoso quando ninguém disse a ele onde estava o limite.

Tarefas longas falham da mesma forma que o contexto falha, então as iterações permanecem curtas e o ambiente faz a memorização. A Fable 5 e os modelos Codex agora compactam seu próprio contexto durante a execução, então resista a adicionar plumbagem de memória engenhosa; a quantidade certa diminui a cada trimestre.

CHECK 3: duas tarefas reais minúsculas em TASKS.md, um tick executado manualmente com BUDGET_USD=2. Confirme um commit, uma tarefa marcada, uma linha de log, e que o loop sai em vez de iniciar uma segunda tarefa.

BUILD 4: The Router That Earns Its Job (modelo, depois esforço)

O benchmark de roteamento mais rigoroso de 2026, o LLMRouterBench, descobriu que muitos roteadores, incluindo os comerciais, falham em superar consistentemente a escolha do melhor modelo único. Portanto, o roteador é considerado culpado até que se prove inocente no seu próprio tráfego.

A regra de decisão, antes de qualquer código. Adicione um roteador somente quando ambos forem verdadeiros:

• Os níveis barato e frontier mostram aproximadamente uma lacuna de cinco vezes de capacidade-por-dólar no seu tráfego
• O conjunto de eval do BUILD 2 existe para policiá-lo

Se um modelo bem escolhido vencer seu roteador nesses evals, delete o roteador e mantenha a simplicidade.

Depois que ele superar a barreira, router/router.py executa três camadas, decisão mais barata primeiro. Observe que os níveis nomeiam assentos, nunca preços: as taxas vêm da skill bench em tempo de execução, então uma mudança de preço nunca toca seu roteador.

1TIERS = {                                   # assentos, não números
2  "cheap":    "gpt-5.6-luna",               # ou claude-haiku-4-5
3  "mid":      "claude-sonnet-5",
4  "frontier": "claude-fable-5",             # ou gpt-5.6-sol
5}
6PRICES = load_bench(".claude/skills/model-bench/SKILL.md")   # fonte única de verdade
7
8RULES = [
9  (kind in {"extract", "format", "summarize"},  "cheap"),
10  (kind in {"plan", "architect", "migrate"},    "frontier"),
11  (context_length > 60_000,                     "mid"),
12]
13tier = layer1_rules(task) or layer2_classifier(task)
14if tier: return call(TIERS[tier], task)
15return cascade(task)   # cheap first, verify, escalate ONCE on fail

A camada do meio pontua a dificuldade com base em marcadores que você pode ler: why, debug, race, deadlock, refactor, security, além de código no prompt, uma tentativa anterior falha, e mais de um subsistema tocado.

Zero ou um ponto vai para cheap. Dois vai para mid. Três ou mais vai para frontier. O verificador da cascata é determinístico e escala exatamente uma vez.

Conecte as mesmas decisões no harness para que disparem sem serem invocadas, .claude/skills/model-router/SKILL.md. Observe que a skill não reafirma as regras, ela as lê, o mesmo truque de fonte única de verdade que o bench usa para preços:

1---
2name: model-router
3description: Roteie cada tarefa para o assento e nível de esforço corretos antes de começar o trabalho.
4  Use no início da sessão, antes de gerar subagentes, quando o usuário perguntar qual modelo
5  usar, ou quando uma tarefa misturar planejamento e execução.
6---
7
8# Model router
9
10Leia ROUTING.md e aplique-o. Não improvise uma política, e não reafirme uma
11aqui: este arquivo apodreceria, e o arquivo de política é aquele que está sob o eval gate.
12
13Três coisas que esta skill aplica além desse arquivo:
14
15  1. Roteie apenas nas fronteiras. Início da sessão e geração de subagente. Uma troca
16     no meio da tarefa invalida o cache e recobra o contexto a dez vezes a taxa de cache.
17  2. Ao final da sessão, acrescente a participação do nível barato ao progress.log. As economias
18     só se acumulam quando a maior parte do tráfego vai para o barato, então esse número é o que deve ser observado.
19  3. Qualquer alteração em ROUTING.md é enviada através da skill ship-gate. Sem exceções.

A ordem de decisão espelha o custo: uma verificação gratuita primeiro, um palpite pontuado depois, um experimento pago por último.

O dinheiro está na divisão do tráfego, não na engenhosidade.

• Envie 70 por cento do trabalho para um nível a um décimo do preço e a conta cai cerca de dois terços
• Relatórios de produção se agrupam entre 40 e 85 por cento de economia, e a dispersão é quase inteiramente a divisão
• As economias só se acumulam depois que a maior parte do tráfego vai para o barato

É por isso que a participação do barato no progress.log é o único número que este sistema faz você observar.

O esforço é o segundo dial

O esforço é o roteamento um nível abaixo: a mesma skill, aplicada a quanto tempo o modelo pensa, em vez de qual modelo executa.

Cada ferramenta enterra o dial em um padrão diferente. Alto no Claude Code. Médio no Codex. Oculto na maioria dos aplicativos. Então as pessoas deixam uma configuração para tudo, e ou pagam demais ou pensam de menos.

Padrão para alto e trate o máximo como último recurso, não como exibicionismo.

• A própria documentação de esforço da Anthropic coloca o ponto ideal no alto, e alerta que o máximo tende a pensar demais
• Um benchmark público de 26 tarefas de codificação descobriu que o alto aproximadamente triplicou a qualidade do baixo
• O mesmo benchmark descobriu que o xhigh custou mais que o dobro por um ganho que raramente se pagava

O modelo importa pelo menos tanto quanto o dial. A Fable 5 com esforço menor muitas vezes supera modelos mais antigos rodando em xhigh, então busque o modelo melhor antes da configuração mais alta.

Duas configurações são confundidas com degraus mais altos desta escada. Nenhuma delas está nela.

• Máximo é profundidade. Um modelo, um problema, mais tempo.
• Ultra é largura. Uma tarefa desdobrada em quatro agentes paralelos, depois sintetizada.

Eixos diferentes. Ultra não é "mais que máximo", e apontá-lo para uma tarefa que não se divide verdadeiramente compra quatro agentes duplicando uma investigação.

A escada não é portável entre versões. A mesma palavra compra uma quantidade diferente de pensamento em um modelo novo do que comprava no antigo.

Ao mover uma tarefa familiar para um novo assento, comece um degrau abaixo da configuração em que você confia. Suba apenas se a saída pedir.

Uma armadilha pertence especificamente a swarms.

Subagentes herdam o modelo e o esforço do pai. Uma frota gerada a partir de um condutor de esforço máximo é uma frota de esforço máximo, e drena uma janela em uma única mensagem.

Prenda-os em seu próprio frontmatter, e saiba em qual harness você está quando fizer isso, porque a fixação só é tão boa quanto o gerador que a lê.

• Lado Claude. O frontmatter abaixo é o controle.
• Lado Codex. O 5.6 gera filhos no modelo e nível de raciocínio do pai, e ele gera ansiosamente. O dial do pai é o dial da frota.

No lado Codex, os únicos controles reais são a configuração com a qual você abriu a sessão, e uma linha em AGENTS.md que diz para não gerar a menos que seja solicitado. Verifique qual você tem antes de confiar em qualquer um:

1name: scout
2model: haiku
3effort: low     # subagentes herdam do pai. um swarm de esforço máximo
4                # esvazia uma janela em uma mensagem. prenda-os.

Defina por ferramenta: /effort no Claude Code e no TUI do Codex, uma flag como codex -e high, uma linha no config, ou o campo effort na API.

O roteamento de modelo decide quem pensa. O roteamento de esforço decide por quanto tempo, e o segundo dial é mais barato de girar porque nada mais na configuração muda e o cache permanece aquecido. Gaste esforço onde o loop ramifica. Em todos os outros lugares, é um imposto.

Acompanhe o único número semanalmente:

1grep '^route' progress.log | awk -F'\t' \
2  '{r++; if($3!="frontier")c++} END{printf "cheap share: %.0f%%\n", c/r*100}'

ROUTING.md, a política que ambos os harnesses leem

Tudo acima se condensa em um arquivo na raiz do repositório.

1# ROUTING.md
2
3Roteamento são quatro decisões, e a ordem é o ponto:
4  1. ONDE:    qual harness executa o trabalho
5  2. QUANDO:  em qual fronteira a decisão é tomada
6  3. QUEM:    qual modelo ocupa o assento
7  4. QUÃO INTENSO: em qual nível de esforço esse modelo roda
8A maioria dos times só discute o 3. O dinheiro está no 2 e no 4.
9
10## 1. ONDE: harness antes do modelo
11Um modelo pós-treinado dentro de um harness roda fora de distribuição em qualquer outro lugar.
12Variação medida: 20,2 por cento nativo vs 7,7 por cento estrangeiro, mesmos pesos.
13
14| Trabalho | Harness | Por quê |
15|---|---|---|
16| escrever código | harness nativo do modelo | escritores degradam fora de distribuição |
17| revisar código | harness nativo do revisor | uma revisão fraca é pior que nenhuma |
18| ler, explorar | qualquer lugar | leituras são baratas e verificáveis |
19| transformações mecânicas | qualquer lugar | se a verificação é determinística, o harness quase não importa |
20
21LEI: remapeie livremente as pistas de leitor e revisor. A pista do escritor permanece no harness nativo
22até que seu próprio conjunto de eval diga o contrário. Essa substituição deve ser uma medição, não
23uma preferência.
24
25## 2. QUANDO: roteie nas fronteiras, nunca dentro delas
26Uma troca no meio da sessão joga fora o cache de prompt. Entrada em cache custa um décimo da
27entrada fresca, então uma troca desnecessária recobra todo o contexto a dez vezes o preço
28e não compra nada.
29
30Fronteiras legais, os ÚNICOS lugares onde uma decisão de roteamento pode acontecer:
31  - início da sessão
32  - geração de subagente
33  - um novo objetivo no swarm
34  - uma entrega de revisão para a outra linhagem
35  - um fallback disparado por uma falha ou uma salvaguarda
36
37Ilegal em todos os outros lugares. Sem roteamento por turno. Sem troca adaptativa no meio da tarefa.
38A cascata tem EXATAMENTE UMA escalada, e ela abre uma nova fronteira.
39
40LEI: escolha o assento quando a fronteira se abrir, então fique até a próxima.
41
42## 3. QUEM: o procedimento de decisão (primeiro match vence, registre o resultado)
43
44Camada 1, regras. Grátis. Sempre verifique primeiro.
45
46| Sinal | Assento |
47|---|---|
48| extract / format / summarize / classify / tests | Haiku ou Luna, effort baixo |
49| plan / architect / migrate / root-cause | Fable planeja, Sonnet executa |
50| contexto acima de 60k tokens | Nível Anthropic 1M (preço fixo) |
51| revisar código escrito por agente | a outra linhagem, harness nativo |
52| objetivo se divide em partes independentes | swarm: Fable escreve e pontua |
53
54Camada 2, a pontuação. Um ponto cada:
55  - contém why / debug / race / deadlock / refactor / security / optimize
56  - toca mais de um subsistema
57  - uma tentativa anterior já falhou
58  - a mudança é irreversível ou voltada para o usuário
59  0-1 -> nível barato, effort baixo. 2 -> Sonnet, médio. 3+ -> frontier, alto.
60
61Camada 3, a cascata. Execute barato, verifique deterministicamente, escale EXATAMENTE UMA VEZ.
62Nunca duas. Uma segunda falha é um problema de especificação, e um modelo maior não vai consertar
63sua especificação.
64
65Assentos e fallbacks vivem em .claude/skills/model-bench/SKILL.md. Sem preços aqui.
66
67## 4. QUÃO INTENSO: roteamento de esforço
68Esforço é roteamento um nível abaixo. Dial mais barato neste arquivo: nada mais muda
69e o cache permanece aquecido.
70
71| Esforço | Use para |
72|---|---|
73| baixo | erros de digitação, renomeações, ordenação, extração, TODO subagente por padrão |
74| médio | código rotineiro a partir de uma especificação clara, resumos, escrita padrão |
75| alto | desmontagens, migrações, bugs difíceis, todo trabalho de condutor (PADRÃO) |
76| máximo | apenas o problema que o alto já falhou em resolver |
77| ultra | NÃO ESTÁ NESTA ESCADA. largura, não profundidade: 4 agentes em paralelo. desligado por padrão |
78
79  1. Padrão para alto. O ponto ideal está lá; o máximo tende a pensar demais.
80  2. Modelo melhor vence dial mais alto. Atualize o assento antes da configuração.
81  3. Subagentes HERDAM o modelo E o esforço do pai. Uma frota gerada a partir de um
82     condutor de esforço máximo roda no máximo e esvazia uma janela em uma mensagem. Prenda
83     cada subagente em seu próprio frontmatter: effort: baixo. Onde o gerador
84     ignora a fixação, o dial do pai É o dial da frota. Verifique qual você tem.
85  4. Máximo é profundidade. Ultra é largura. Ultra apenas quando os subproblemas são genuinamente
86     independentes, nunca como padrão, e não enquanto o harness gerar em excesso.
87  5. A escada não é portável entre versões. Em um modelo novo, comece um degrau
88     abaixo da configuração em que você confiava no antigo.
89  6. Modo rápido também não é um nível de esforço. Ele compra latência a 2,5x créditos em
90     tokens que você já estava queimando de qualquer forma. Desligado.
91
92O dial vive em quatro lugares: /effort no Claude Code e no TUI do Codex, codex -e high,
93model_reasoning_effort no config, o campo effort na API. Claude Code
94padrão alto, Codex padrão médio, a maioria dos aplicativos esconde completamente, e é por isso que
95times acidentalmente rodam um nível para tudo.
96
97## 5. Fallbacks: assuma que o frontier está fora
98A disponibilidade do frontier não é garantida, e uma salvaguarda pode redirecionar uma chamada para
99Opus 4.8 no meio da execução, em menos de 5 por cento das sessões, sem gerar erro.
100  - Todo assento tem um fallback nomeado. Sem exceções.
101  - Todo fallback é registrado. Um redirecionamento silencioso é um bug, porque você pode estar
102    lendo saída de um modelo que você não escolheu.
103  - NUNCA itere sobre a saída de um modelo que você não escolheu.
104
105## 6. O número que decide se algo disso funcionou
106O custo combinado é sua divisão de tráfego, nada mais. 70 por cento barato corta a conta
107em aproximadamente dois terços. 10 por cento economiza trocados. A precisão do roteador vale
108muito mais do que a engenhosidade do roteador.
109
110Acompanhe com o comando de uma linha no BUILD 4. Abaixo de 50 por cento, as economias não
111começaram a se acumular. Corrija a divisão antes de tocar em qualquer outra coisa aqui.
112
113## 7. O gate neste arquivo
114LEI: nenhuma alteração neste arquivo é enviada sem que eval_gate.py passe em 50 a 500
115casos retidos. Um veredito BLOQUEADO é final e não pode ser substituído na sessão.
116O gate e a alteração não podem compartilhar o mesmo autor.
117
118## 8. Quando deletar este arquivo
119Se um único modelo bem escolhido vencer toda esta pilha nos seus evals, delete o
120roteador e mantenha a simplicidade. O benchmark de roteamento mais rigoroso de 2026 descobriu
121que muitos roteadores, inclusive os comerciais, falham em superar consistentemente a escolha do melhor
122modelo único.
123Meça primeiro. Roteie depois. Delete com prazer.

CHECK 4: router.py roda offline e imprime uma decisão, um motivo e a divisão. Suas anotações contêm a medição da lacuna de 5x, ou uma nota datada dizendo que o roteador ainda não é justificado.

BUILD 5: The Advisor Inversion

O padrão clássico coloca o modelo inteligente no comando e queima tokens frontier em execução em massa. Inverta isso.

Resultados do advisor da Anthropic: Haiku com um advisor de classe Opus mais que dobrou sua pontuação em um benchmark difícil de navegação, 41,2 contra 19,7 sozinho, a 85 por cento menos custo por tarefa do que o nível médio.

Execução é volume. Conselho é gramas.

O harness decide quando o motorista está travado, nunca o motorista, .claude/skills/stuck-protocol/SKILL.md:

1---
2name: stuck-protocol
3description: Escale para o advisor fable-expert quando o progresso estagnar. Use quando
4  o mesmo erro aparecer duas vezes, quando dois passos consecutivos não alterarem nenhum arquivo enquanto
5  erros persistirem, quando um teste falhar após duas tentativas de correção distintas, ou quando o
6  usuário disser que o agente está andando em círculos.
7---
8
9# Stuck protocol (a inversão do advisor)
10
11Você é o motorista barato e isso é uma característica: execução é volume, conselho é
12gramas. Mas modelos pequenos são excessivamente confiantes, então você não pode decidir que está
13bem. Verifique os sinais determinísticos.
14
15Sinais de travamento (qualquer um dispara o protocolo):
16  1. A mesma string de erro em dois passos consecutivos.
17  2. Dois passos consecutivos com zero arquivos alterados enquanto erros persistem.
18  3. O mesmo teste falhando após duas tentativas de correção genuinamente diferentes.
19
20Procedimento:
21  1. Conte as consultas nesta sessão. Em 3, PARE: marque a tarefa como BLOQUEADA com o
22     erro anexado, resuma para o humano, siga em frente. Nunca uma quarta consulta.
23  2. Construa o resumo, nada mais entra nele:
24       OBJETIVO: uma linha
25       TENTATIVA x2: as duas últimas tentativas, 200 caracteres cada
26       ERRO: o erro exato, 300 caracteres
27  3. Gere fable-expert com o resumo. Ele retorna orientação, não código.
28  4. Aplique a orientação no passo seguinte, antes de qualquer coisa sua.
29  5. Acrescente uma linha ao progress.log: consulta #N, o que disse, se funcionou.
30
31Regras rígidas:
32  - Nunca peça ao expert para fazer o trabalho. Se a resposta contiver uma
33    implementação completa, pegue a ideia e descarte o código.
34  - Nunca preencha o resumo com seu histórico de raciocínio. O valor do expert é contexto
35    limpo; um resumo longo o envenena.
36  - Se a orientação falhar, isso conta como uma de suas duas tentativas para a próxima
37    consulta. Três consultas falhadas significam que a tarefa está acima do nível de pagamento
38    desta sessão, e dizer isso é a saída correta.

O assento do expert, .claude/agents/fable-expert.md:

1---
2name: fable-expert
3description: Advisor frontier para momentos de travamento. Recebe um resumo compacto de
4  stuck-protocol, retorna orientação abaixo de 600 tokens, nunca faz o trabalho em si.
5model: claude-fable-5      # troque para opus se as regras de retenção morderem
6effort: high
7tools: Read, Grep, Glob    # pode ler, nunca pode editar
8---
9
10Você é o consultor expert, não o contratado. Um modelo mais barato está dirigindo e
11bateu em uma parede. Seu valor é julgamento em gramas, e contexto limpo: você não sabe nada
12sobre como o motorista chegou aqui, que é exatamente por que sua leitura é mais precisa.
13
14Você recebe um resumo: OBJETIVO, as duas últimas TENTATIVAs e o ERRO. Se o resumo
15nomear arquivos específicos, você pode lê-los. Você não pode editar nada.
16
17  1. Se faltar algo que você precisa no resumo, responda com UMA linha nomeando o que
18     está faltando. Não adivinhe em torno de uma lacuna.
19  2. Diagnostique antes de prescrever: uma ou duas frases sobre o que está realmente errado.
20  3. Depois responda neste formato e nada depois dele:
21       ORIENTAÇÃO:
22       1. (correção mais provável: o que tentar, e por que deve funcionar)
23       2. (plano B se 1 falhar)
24       3. (apenas se houver um terceiro caminho genuinamente distinto)
25       CONFIANÇA: alta | média | baixa
26  4. Abaixo de 600 tokens. Sem blocos de código com mais de 10 linhas. Dê a ideia, não a
27     implementação. Se sua resposta contiver uma solução completa, você falhou no papel.
28  5. Se a tarefa em si for mal concebida, diga isso no item 1 e recomende o que
29     dizer ao humano.
30
31Nota do operador: se sua organização não puder aceitar a retenção de classe Mythos, mude a linha
32do modelo para opus. O papel funciona da mesma forma; o resultado do advisor foi comprovado primeiro com
33advisors de classe Opus.

E a mesma pista inversa para sessões Codex, ~/.codex/prompts/fable-advice.md:

1claude --model claude-fable-5 -p "Você é um advisor expert.
2  Um modelo mais barato está dirigindo e está travado. RESUMO: <objetivo, duas
3  tentativas, erro>. Responda ORIENTAÇÃO: até 3 itens numerados,
4  abaixo de 600 tokens. Não faça o trabalho."

Modelos pequenos são excessivamente confiantes, então o harness observa o comportamento em vez de perguntar.

O resumo permanece pequeno, porque o valor do expert é contexto limpo e um resumo longo o envenena.

Cada consulta consome algumas centenas de tokens de orientação. É por isso que a economia colapsa: milhões de execução viajam no nível de $1, e o julgamento chega por grama a $50 por milhão.

A Cognition publicou a falha primeiro. O teto é definido pelo motorista, não pelo advisor, e o padrão só se pagou depois que o motorista deles melhorou uma geração.

O problema em aberto é um motorista perceber que está travado. É por isso que os sinais acima são comportamentais, e por que vivem no harness.

CHECK 5: advisor_loop.py passa suas asserções: o motorista falha duas vezes da mesma forma, uma consulta dispara, a tarefa é concluída, as consultas permanecem abaixo do limite.

BUILD 6: The Two-Lane Bench

Nada avalia seu próprio dever de casa é uma lei, e este build a aplica entre fornecedores.

Os mesmos pesos em um harness estrangeiro caem forte. Uma medição de 2026 mostrou 20,2 por cento nativo contra 7,7 por cento de terceiros.

Então, cada revisor roda em sua própria casa. Claude revisa no Claude Code. Sol revisa através do Codex CLI.

O juiz interno, .claude/agents/fresh-eyes-reviewer.md:

1---
2name: fresh-eyes-reviewer
3description: Revisor de código com contexto limpo. Invocar após qualquer alteração feita por agente.
4  Não compartilha nenhum histórico com o autor, lê o diff por conta própria e não pode editar.
5model: haiku               # mude para opus quando o diff for crítico
6effort: medium
7tools: Read, Grep, Glob, Bash
8---
9
10Você não tem memória de como esta alteração foi escrita, e esse é o propósito. Não
11pergunte pelo raciocínio do autor. Não confie em nenhum resumo. Somente evidências.
12
13  1. git diff HEAD~1 (ou o intervalo informado) e leia cada hunk.
14  2. Leia o CONTEÚDO COMPLETO de cada arquivo modificado, não apenas os hunks. Bugs se
15     escondem nas linhas inalteradas ao redor de uma mudança.
16  3. Execute a suíte de testes mencionada no README ou CLAUDE.md.
17  4. Busque as três falhas clássicas de agentes:
18       preguiça: implementações parciais, TODOs, tratado para apenas um caso
19       autoavaliação: testes enfraquecidos, asserções deletadas, suítes puladas
20       desvio: alterações fora do escopo da tarefa declarada
21  5. Veredito, exatamente neste formato:
22       VEREDICTO: APROVADO ou REPROVADO
23       BUGS: numerados, cada um com arquivo:linha e um motivo em uma frase
24       RISCO: uma frase sobre o que há de mais arriscado nesta alteração
25
26Regras rígidas: você não pode editar arquivos, não pode reexecutar a tarefa do autor, e uma
27lista de BUGS vazia com VEREDICTO: REPROVADO é inválida. Se os testes não puderem ser executados,
28isso é uma REPROVAÇÃO automática com o motivo.

O juiz entre fornecedores, .claude/agents/sol-reviewer.md, é um encanamento que executa um comando e retransmite o veredito sem alterações. Sol é o revisor; este arquivo o coloca em sua própria estrutura:

1---
2name: sol-reviewer
3description: Revisor entre fornecedores. Envia o commit mais recente para o GPT-5.6 Sol através
4  do Codex CLI, na estrutura nativa do Sol, e retransmite o veredito sem alterações.
5model: haiku               # apenas encanamento. Sol é o revisor.
6effort: low
7tools: Bash, Read
8---
9
10Você é o encanamento, não o revisor. Modelos de uma mesma família compartilham pontos cegos; esta
11pista existe porque Sol não compartilha os de Claude.
12
13  1. Verifique o CLI: codex --version. Se estiver faltando, gere VEREDICTO: REPROVADO com o motivo
14     "codex CLI não instalado" mais o caminho de instalação (ou o plugin oficial:
15     /plugin marketplace add openai/codex-plugin-cc, /plugin install, /codex:review).
16  2. Execute a revisão com esforço alto, na estrutura nativa do Sol:
17
18     codex --profile deep exec "Review the latest commit (git show HEAD) as a
19     hostile senior engineer who has never met the author. Read every touched
20     file IN FULL, not just the hunks. Hunt: partial implementations, weakened
21     or deleted tests, changes outside the stated task scope. End with exactly
22     'VERDICT: PASS' or 'VERDICT: FAIL' followed by numbered findings, each with
23     file:line and a one-sentence reason."
24
25  3. Salve a saída completa em .review_sol_<hash-curto>.md.
26  4. Retransmita para cima: primeiro a linha do VEREDICTO, depois as conclusões LITERALMENTE. Não
27     resuma conclusões, não adicione tranquilização, não discuta com Sol.
28     Se o veredito for REPROVADO, o pai decide o que corrigir. Você não decide nada.
29
30Regras rígidas: nunca edite arquivos, nunca reexecute a tarefa do autor, nunca substitua
31sua própria revisão. Se o codex errar durante a execução, relate como REPROVADO com stderr anexado
32em vez de tentar novamente silenciosamente mais de uma vez.

Para CI, loop/two_lane.sh conduz toda a troca, no máximo três rodadas:

1claude -p "Implement: $TASK. Run the tests. Commit when green."
2review=$(codex exec "Review HEAD ... VERDICT: PASS or FAIL plus findings.")
3grep -q "VERDICT: PASS" <<< "$review" && exit 0
4claude -p "A reviewer from another model family found these issues.
5  Fix every one, rerun tests, commit: $review"

Dentro do Claude Code, você pode pular o script completamente.

A OpenAI lançou um plugin Codex oficial para o Claude Code, ativo desde março de 2026 e com aproximadamente vinte mil estrelas no GitHub em nove semanas. Isso é o mercado dizendo que a revisão entre fornecedores se tornou mainstream. Instale uma vez:

1/plugin marketplace add openai/codex-plugin-cc
2/plugin install codex@openai-codex
3/codex:setup

Três comandos dentro de qualquer sessão Claude:

• /codex:review para uma verificação padrão
• modo adversarial, que ataca suas decisões de design propositalmente
• transferência em segundo plano para o Codex

Use o modo adversarial em qualquer coisa crítica. Use a transferência quando o trabalho for pesado em terminal, onde Sol é mais forte.

Um número crescente de desenvolvedores agora executa o GPT-5.6 Sol dentro do Claude Code, através do proxy do BUILD 7, e o prefere ao Codex para o trabalho diário.

Isso demonstra a tese: alugue os pesos, possua a estrutura.

A desvantagem é a lei da estrutura nativa, já que o Sol no Claude Code é executado fora de seu ambiente original. Confirme isso em seu próprio conjunto de avaliação. Se suas avaliações disserem que a estrutura estrangeira vence, suas avaliações superam o benchmark.

Três propriedades fazem o revisor valer a pena:

• Contexto limpo. Ele chega sem nenhum histórico do autor.
• Linhagem diferente. Ele não compartilha os pontos cegos do autor.
• Estrutura nativa. Ele julga com força total.

Um veredito suavizado é um verificador quebrado, portanto a retransmissão é literal. Uma terceira REPROVAÇÃO notifica um humano em vez de tentar uma quarta vez.

CHECK 6: execute two_lane.sh, ou /codex:review no seu último commit. Um VEREDICTO cai em um arquivo .review, e uma REPROVAÇÃO retorna para a pista do autor.

BUILD 7: Fan-Outs Opcionais (instale quando a condição aparecer)

Enxame de batedores. Instale quando pesquisa ou arqueologia de código consumir mais de 30 minutos do seu dia. Crie três em paralelo em fatias separadas:

1---
2name: scout
3description: Leitor paralelo barato para fan-outs de pesquisa. Crie vários de uma vez
4  para levantamentos de código, auditorias de dependências, arqueologia de logs, pesquisa de documentação.
5  Apenas leitura por doutrina; leituras se espalham, escritas permanecem mono-thread.
6model: haiku
7effort: low                # guarda de herança (BUILD 4): um enxame que herda
8                           # esforço máximo esvazia uma janela em uma mensagem
9tools: Read, Grep, Glob, Bash
10---
11
12Você é um de possivelmente muitos leitores executando em paralelo. Levante sua fatia e
13relate de forma pequena e precisa. Apenas sua mensagem final retorna ao pai, então
14mantenha-a abaixo de 400 palavras e faça cada palavra valer seu lugar.
15
16  1. Delimite sua tarefa a uma fatia você mesmo (um diretório, um subsistema,
17     uma pergunta), e diga o que você delimitou.
18  2. Apenas leituras: Read, Grep, Glob, e shell somente leitura (ls, git log, git show, rg).
19     Nunca edite, instale ou delete. Se a tarefa precisar de uma escrita, relate, não a
20     faça.
21  3. Largura primeiro, depois profundidade nos dois ou três pontos mais quentes.
22
23Formato do relatório, nada mais:
24  DESCOBERTAS: até 10 tópicos, cada um um fato com sua evidência (arquivo:linha, hash de commit
25    ou URL)
26  LACUNAS: o que você não conseguiu determinar e por quê, para que o pai saiba o que ainda está escuro
27  PONTO QUENTE: o único arquivo ou função que mais merece uma análise aprofundada, uma linha
28    sobre o porquê
29
30Não editorialize, não proponha implementações, não encha. Um batedor que
31retorna 300 palavras úteis vence um que retorna 3.000 misturadas, porque
32tudo que você emite cai na janela de contexto do pai e o pai está pagando por isso.

As leituras se espalham porque leitores paralelos se multiplicam. O limite de palavras existe porque todo relatório cai em uma janela de contexto que o pai paga.

Escritas nunca se espalham. Um estudo de orçamento igual de 2026 descobriu que agentes individuais equivalem a configurações multi-agente em raciocínio quando os tokens são mantidos constantes. Esta pista é apenas para leitura.

Queimador noturno. Instale quando TASKS.md tiver dez ou mais itens pequenos verificáveis. A habilidade do queimador noturno configura os arquivos, confirma ambos os limites, verifica se o comando de teste é executado, então lança o ralph.sh. Interface matinal: git log, progress.log, marcas de verificação.

Divisão de plano. Instale quando tokens de planejamento dominarem a conta de uma sessão. Uma configuração no Claude Code executa um modelo classe Opus para o plano e Sonnet para a execução. Planeje na fronteira por grama, execute em massa.

Banco de trio. Instale quando uma alteração difícil merecer três perspectivas. Duas funções leem e uma escreve, e o quarto painel é uma armadilha. O encanamento fica abaixo.

O encanamento para frotas mistas

Duas peças de código aberto transformam uma configuração de dois fornecedores em uma de qualquer fornecedor. Instale-as apenas quando uma condição exigir um terceiro provedor.

claude-model-switch (código aberto, Rust, executa em localhost:4000). Um proxy local entre o Claude Code e qualquer endpoint compatível com Anthropic ou OpenAI.

• Remapeia os três níveis internos do Claude Code (haiku, sonnet, opus) para quaisquer modelos que seu provedor ofereça
• Troca de provedores sem reiniciar, via recarga de configuração
• Chega como um plugin do Claude Code com comandos de barra

1claude-model-switch init                 # aponta o Claude Code para o proxy
2claude-model-switch add openrouter sk-or-xxx
3claude-model-switch add glm \
4  --haiku glm-4.5-air --sonnet glm-4.7 --opus glm-5
5claude-model-switch use glm              # por sessão, nunca no meio da tarefa
6claude-model-switch orchestrate start --preset trio   # planejador/codificador/revisor

A predefinição de trio é o banco do BUILD 7 tornado físico: três painéis tmux, cada função em um provedor diferente, cada um endereçável (orchestrate send coder "implement milestone 1"), com reatribuição de função no meio da sessão se um provedor degradar.

CLIProxyAPI (código aberto). O mesmo truque, apontado na direção oposta.

Ele encapsula os logins OAuth do ChatGPT Codex, Claude Code, Gemini e Grok como endpoints de API compatíveis com OpenAI, Claude e Gemini.

Tradução: assinaturas que você já paga se tornam alvos de API roteáveis para scripts como ralph.sh e two_lane.sh, sem chaves de API separadas. Forks da comunidade estendem para Factory e Amp, e wrappers como ccs adicionam alternância de múltiplas contas.

A lei que rege ambos, dos dados do BUILD 6: um modelo remapeado executa em uma estrutura estrangeira.

Remapeie as pistas de leitor e revisor livremente. Elas são baratas e verificáveis.

Mantenha a pista que escreve código em um modelo nativo de sua estrutura, até que seu próprio conjunto de avaliação prove o contrário.

CHECK 7: cada fan-out instalado tem sua condição de gatilho escrita ao lado. Instalar qualquer coisa especulativamente é como as pilhas incham.

BUILD 8: A Fábrica (a conclusão se torna um fato de banco de dados)

Tudo até agora prova o trabalho no momento. O portão, o veredito e o conjunto de avaliação disparam durante a execução.

Assim que mais de um agente tocar um projeto em mais de uma sessão, você precisa de uma prova que sobreviva à execução: quem trabalhou no que, em que ordem, e se o último ciclo de revisão foi aprovado.

O padrão vem da demonstração pi-factory (github.com/xpriment626/pi-factory). A ideia central é uma frase:

Uma thread é um rastro. Uma linha é evidência. O portão lê linhas.

progress.log é um diário. O quadro-negro é um razão. SQLite é o razão porque é consultável depois que todos param de falar.

Crie factory/factory_gate.py. Ele contém quatro tabelas (tickets, briefs, evidence, verdicts), um comando de registro que cada agente chama enquanto trabalha, e o portão de conclusão. As condições de falha do portão mapeiam o trabalho em si:

1checks = [
2  (tickets == 0,                 "No tickets were recorded."),
3  (done != tickets,              "Not all tickets are done."),
4  (first_brief is None,          "No architecture brief was recorded."),
5  (first_brief > first_code,     "Implementation evidence predates the brief."),
6  (code_ev == 0,                 "No implementer code evidence was recorded."),
7  (build_ok == 0,                "No passing build command evidence."),
8  (test_ok == 0,                 "No passing test command evidence."),
9  (latest("architect") != "green",  "Latest architect verdict is not green."),
10  (latest("reviewer")  != "green",  "Latest reviewer verdict is not green."),
11]

Essa lista codifica toda a doutrina.

• A ordem é imposta. Um resumo que é posterior à primeira evidência de código é uma violação, o que torna planejar-antes-de-construir um fato verificável em vez de um hábito.
• Ambos os assentos de juiz devem estar verdes no mesmo ciclo mais recente. Uma aprovação desatualizada não pode carregar um diff mais novo.
• A conclusão com zero linhas de teste bem-sucedidas é impossível, não importa o quão confiante o histórico pareça.

Crie factory/factory.sh, que conecta os assentos que você já construiu na ordem de execução e registra linhas entre cada etapa:

1G ticket "kanban board" "columns render, drag persists"    # planner rows
2G brief  "$BRIEF"                                          # BEFORE any code
3../loop/ralph.sh && G evidence code pass "loop completed"  # BUILD 3 works
4npm test          && G evidence test pass "npm test green"
5G verdict 1 architect green "layout matches brief"         # Claude seat
6G verdict 1 reviewer  green "tests pass, scope clean"      # Sol seat, via codex
7python3 factory_gate.py gate factory.db                    # rows decide

Nada de novo é contratado.

Fable corta tickets e escreve o resumo, apenas leitura. O loop BUILD 3 implementa. Claude e Sol cada um retornam um veredito de sua própria estrutura. O ciclo se repete até três vezes até ambos ficarem verdes.

A fábrica é o organograma para funcionários que você já tem.

Uma execução real, não uma simulação. A segunda chamada do portão é o argumento inteiro para esta construção:

1$ factory_gate.py record demo.db ticket "kanban-board" "columns render, drag persists"
2
3$ factory_gate.py gate demo.db
4GATE: REFUSED
5  - Nem todos os tickets estão concluídos.
6  - Nenhum resumo de arquitetura foi registrado.
7  - Nenhuma evidência de código do implementador foi registrada.
8  - Nenhuma evidência de comando de build bem-sucedido foi registrada.
9  - Nenhuma evidência de comando de teste bem-sucedido foi registrada.
10  - Nenhum ciclo de revisão foi registrado.
11  exit: 1
12
13... os agentes trabalham. cada etapa escreve uma linha ...
14
15$ factory_gate.py record demo.db brief    "Stack: node+sqlite. /tasks CRUD."
16$ factory_gate.py record demo.db evidence code  pass "src/board.js written"
17$ factory_gate.py record demo.db evidence build pass "npm run build exit 0"
18$ factory_gate.py record demo.db done     "kanban-board"
19$ factory_gate.py record demo.db verdict 1 architect green "layout matches brief"
20$ factory_gate.py record demo.db verdict 1 reviewer  green "scope clean"
21
22$ factory_gate.py gate demo.db
23GATE: REFUSED
24  - Nenhuma evidência de comando de teste bem-sucedido foi registrada.
25  exit: 1
26
27$ factory_gate.py record demo.db evidence test pass "npm test 33/33"
28
29$ factory_gate.py gate demo.db
30GATE: COMPLETE (1/1 tickets, cycle 1 green x2)
31  exit: 0

Ambos os revisores disseram verde. O arquiteto confirmou que o layout correspondia ao resumo. O revisor confirmou que o escopo estava limpo.

E o portão ainda recusou, com uma linha: nenhuma evidência de comando de teste bem-sucedido. Ninguém tinha executado os testes.

Um veredito é uma opinião. Duas opiniões ainda não são um fato. Uma linha de evidência de teste bem-sucedido depois, o mesmo portão retorna COMPLETE e exit 0.

Modelos argumentam convincentemente por seu trabalho, e um histórico captura o argumento em vez da verdade. Linhas não podem ser contestadas.

Quando o portão recusa, ele nomeia o artefato exato que está faltando. Isso transforma "a execução falhou" em "produza uma linha de teste bem-sucedido." Uma tarefa, não um mistério.

Condição de instalação: mais de uma sessão de escrita por dia, ciclos de revisão que duram dias, ou uma necessidade de provar depois do fato o que aconteceu. Para um repositório solo com um loop noturno, o BUILD 3 é suficiente e isso é inchaço.

CHECK 8: reproduza a captura de tela. Registre tudo exceto uma linha de teste, e o portão deve recusar com exatamente um motivo. Adicione a linha e ele retorna COMPLETE. Um portão que passa sem ela é um leitor de histórico.

BUILD 9: O Enxame (Fable planeja, a frota executa, Fable pontua)

Um motorista com um conselheiro cobre uma tarefa. Um objetivo que se divide em quatro partes independentes quer quatro trabalhadores.

Mas uma frota só mantém sua direção se um modelo planeja cada objetivo e pontua cada resultado. Essa é a razão inteira pela qual esta construção existe, e a razão pela qual enxames geralmente falham sem ela.

O Degrau 3 tornado literal. Fable escreve os objetivos, a frota os executa, Fable pontua cada resultado contra sua própria verificação, e o próximo ciclo replaneja apenas as falhas.

Sua parada é o limite de ciclos. Quando o limite é atingido com falhas pendentes, isso é um problema de especificação indo para um humano, não uma razão para executar um quarto ciclo.

Crie swarm/swarm.sh. Três configurações carregam a doutrina:

1FLEET=4                              # writes never collide: one worktree each
2WORKER_MODEL=claude-sonnet-5         # or haiku / luna / kimi for pure execution
3WORKER_EFFORT=low                    # NEVER inherit the conductor's effort
4CONDUCTOR=claude-fable-5             # or opus-4-8 if retention rules bite

Essas três linhas são explícitas porque o padrão não é.

Uma frota que herda pega o modelo do condutor e o esforço do condutor. Um Fable-em-alto gerando quatro Fable-em-alto trabalhadores para fazer trabalho mecânico é a maneira mais cara possível de fazer a coisa mais barata possível.

Defina-as. Nunca deixe que usem o padrão.

Fan-out entre estruturas é permitido, e não é a exceção à primeira lei do ROUTING.md que parece ser.

• Um condutor Fable que chama codex exec executa Sol dentro do Codex, nativamente. Isso é a lei obedecida, não violada.
• O que viola a lei é um subagente do lado Claude usando uma string de modelo GPT, ou o inverso.

A estrutura viaja com o trabalhador, não com o condutor.

O condutor escreve objetivos, nunca código, e cada objetivo carrega seu próprio comando de verificação, para que "concluído" continue sendo um fato:

1{"id":"remover-auth-legado","spec":"remover o caminho de autenticação v1 de routes/","check":"npm test -- tests/auth"}
2{"id":"migrar-sessoes","spec":"mover o armazenamento de sessão para o novo adaptador","check":"npm test -- tests/session"}

Então despache, pontue e replaneje:

1# dispatch: um git worktree por objetivo, limitado a FLEET em paralelo
2claude --model "$WORKER_MODEL" --effort "$WORKER_EFFORT" -p "Execute esta especificação
3  exatamente. Não expanda o escopo. Execute os testes. Faça commit apenas quando estiver verde."
4
5# score: o condutor avalia cada objetivo contra SEU PRÓPRIO comando de verificação.
6# a confiança do trabalhador não é evidência. o código de saída é.
7bash -c "$chk" && echo "$id" >> passed.txt || misses=$((misses+1))
8
9# replan: o próximo ciclo vê passed.txt e replaneja apenas o que falhou

Assento por assento:

• Sonnet 5 para execução de codificação
• Haiku ou Luna para trabalho puramente mecânico
• Um trabalhador de pesos abertos como Kimi quando o trabalho é repetitivo e os pesos são gratuitos
• Sol quando o trabalho é pesado em terminal
• Opus 4.8 no assento de trabalhador, apenas quando um subagente precisar raciocinar

Reserve o Fable para os dois trabalhos que nenhum modelo barato pode fazer: escrever os objetivos e avaliá-los.

Uma frota é uma estratégia de custo, nunca uma estratégia de inteligência.

Execuções multi-agente queimam 3 a 10 vezes os tokens para trabalho equivalente, e um estudo de orçamento igual de 2026 descobriu que agentes individuais os igualam em raciocínio quando os tokens são mantidos constantes.

Um enxame se paga apenas quando os objetivos são independentes e principalmente mecânicos. As escritas permanecem mono-thread por worktree, as mesclagens acontecem serialmente, e um humano faz o último commit.

CHECK 9: execute o enxame em um objetivo que se divide em três direções. Um objetivo quebrado deve retornar REPROVADO em results.tsv e ser replanejado no ciclo 2, nunca declarado concluído.

BUILD 10: Degrau 4 (nada que passou uma vez fica sem vigilância)

Tudo até agora verifica o trabalho enquanto ele está sendo feito. Nada até agora percebe quando o trabalho concluído deixa de ser verdade seis semanas depois. Um objetivo que você verifica uma vez é uma suposição com um carimbo de data/hora.

O Degrau 4 tem duas metades, e sua parada é tão importante quanto sua saída: se nenhuma proposta passar pelo portão esta semana, o sistema não muda, e isso é um sucesso.

Metade um, objetivos permanentes. Cada coisa concluída se forma em um invariante com um predicado, re-verificado diariamente, para sempre. Crie um arquivo por coisa concluída em goals/:

1predicate: npm test -- tests/auth 2>&1 | tail -1 | grep -q passing
2born: 2026-07-13
3status: satisfied
4last-pass: 2026-07-13
5on-violation: acorde-me. não corrija automaticamente.

Então system/verify_goals.py executa tudo e sai com 1 se algum invariante quebrar, nomeando o objetivo, a data em que foi mantido pela última vez e a política que você definiu:

1held = subprocess.run(["bash","-c",predicate], timeout=60).returncode == 0
2g["status"] = "satisfied" if held else "VIOLATED"
3# a timeout é uma violação, não uma aprovação: um predicado caro é um predicado quebrado

As regras de predicado são estritas propositalmente: um comando de shell, exit 0 significa que o invariante se mantém, barato e somente leitura.

Adjetivos são proibidos. Se um shell não pode verificar, um modelo também não pode.

Objetivos não-código funcionam da mesma forma. test -s reports/$(date +%Y-%m)-review.md é um objetivo permanente perfeitamente aceitável para um relatório mensal.

Metade dois, compostagem. Uma vez por semana, leia o exaurido que o sistema já produziu: tarefas BLOQUEADAS, execuções de portão falhas, portões de fábrica recusados, PRs revertidos, objetivos violados.

Então proponha no máximo três mudanças. Uma nova lei para a constituição. Uma correção em uma habilidade que continua falhando da mesma maneira. Ou um objetivo permanente que estava faltando.

Apenas proponha. Você assina.

1claude --model claude-fable-5 --effort high --allowedTools "Read,Grep,Glob" \
2  -p "Leia o exaurido desta semana: linhas BLOQUEADAS no progress.log, entradas de
3  PORTÃO RECUSADO, objetivos VIOLADOS, PRs fechados sem mesclagem. Extraia NO MÁXIMO 3 propostas:
4  uma nova lei (cite os incidentes), uma correção de habilidade (mesma falha se repetindo), ou um
5  objetivo permanente que nos faltava. Apenas proponha, não edite nada. Semana limpa é uma
6  resposta válida, diga isso e pare."

Este degrau se fecha apenas quando as avaliações e os juízes dizem que o sistema melhorou. O que significa que o sistema precisa de uma memória de suas próprias falhas para melhorar contra elas.

A execução de compostagem é o que transforma um script em uma instituição.

Os objetivos permanentes são o que torna seguro finalizar. O sentinela detecta, o pipeline normal corrige, e nada apodrece em silêncio.

CHECK 10: verify_goals.py de demonstração nomeia o invariante quebrado com sua data de última aprovação e deixa o saudável em paz. Então escreva um objetivo permanente real para a última coisa que você concluiu.

BUILD 11: Degrau 5 (seu assento, e por que ele nunca fica vazio)

O Degrau 5 tem seu nome por um motivo mecânico, não sentimental.

Um loop pode atingir sua condição de parada e ainda estar errado. Testes passam, o portão fica verde, ambos os revisores assinam, e o último commit ainda é um erro.

Cada construção abaixo desta existe para reduzir esse risco. Nenhuma delas o elimina.

Suas funções permanentes, todas baratas:

• Leia a fila com café: tarefas BLOQUEADAS, linhas de PORTÃO RECUSADO, objetivos VIOLADOS, a parte do nível barato. Dez minutos.
• Verifique o último commit antes de mesclá-lo. Não todo diff, o último, aquele em que o sistema estava mais confiante.
• Assine ou rejeite as três propostas de compostagem. Essa é a única maneira de leis entrarem na constituição.

Três jogadas executam em uma cadência em vez de sob demanda, porque custam dinheiro real e pagam em direção em vez de diffs:

Jogada um, o ciclo de feedback do projeto, mensal.

Aponte o Fable para o que você já enviou, apenas leitura, e peça para ele escrever um plano de melhoria detalhado. Então entregue a execução desse plano para o Opus 4.8 ou Sol.

O modelo caro faz a parte que se multiplica, julgamento sobre o que mudar, e nunca a parte que não se multiplica, digitação.

1claude --model claude-fable-5 --effort high --allowedTools "Read,Grep,Glob" \
2  -p "Revise este projeto de ponta a ponta. Escreva um plano de melhoria classificado por
3  alavancagem: o que é frágil, o que é superconstruído, o que está faltando, o que deveria
4  ser deletado. Não escreva código. Gere tarefas com critérios de aceitação." \
5  > plans/$(date +%F)-improvement.md

Jogada dois, a análise comportamental, mensal.

Alimente-a com seu próprio histórico de sessões e projetos em ambos os arneses, e peça a ela para mapear como você constrói e onde você trava.

Este é o único relatório no sistema cujo assunto é você. Geralmente é o que mais muda.

Jogada três, a auditoria do segundo cérebro, trimestral. Aponte-a para suas anotações, documentos e backlog, e pergunte o que seu próprio pensamento diz que vale a pena construir a seguir e o que vale a pena deletar. Trate a saída como uma proposta, exatamente como o composto.

Os degraus abaixo otimizam a execução, e a execução é a parte barata agora. Direção é o insumo escasso, e direção é o que vale a pena pagar por um modelo de fronteira. Compre julgamento a gramas, execução a toneladas, e mantenha a última assinatura.

CHECK 11: execute a jogada um no seu próprio repositório. Se o plano não nomear nada que você já sabia que era frágil, seus arquivos de contexto são muito finos, o que é um problema de BUILD 1.

BUILD 12: Operações

Agentes queimam de 10 a 100 vezes mais tokens que uma chamada de chat, e a entrada domina em aproximadamente 100 para 1.

Empilhe as quatro alavancas do BUILD 0 (dividir, cache, lote, compactação) e as equipes relatam uma redução de 70 a 90 por cento em relação à sua linha de base não otimizada.

Para sanidade: $13 por desenvolvedor por dia ativo é a média empresarial do Claude Code, e 90 por cento dos usuários ficam abaixo de $30.

Uma linha de disciplina em vez de um novo subsistema: uma classe de tarefa pode fazer auto-merge somente após 20 execuções registradas com uma taxa de aprovação de 95 por cento, e uma única queda abaixo de 90 por cento a revoga com estardalhaço.

1awk -F'\t' '$2=="fix-lint"{r++; if($3=="pass")p++}
2  END{printf "%d runs, %.0f%%\n", r, (r?p/r*100:0)}' progress.log

Gasto semanal, a partir dos custos por tick que o ralph.sh já registra:

1grep '^cost' progress.log | awk -F'\t' \
2  -v d="$(date -d '7 days ago' +%F)" \
3  '$2>=d{s+=$3} END{printf "week: $%.2f\n", s}'

Calcule o metabolismo antes de cronar. O custo diário é ticks vezes o custo médio do tick.

O assento que lida com o tick de trabalho silencioso decide a conta. Centavos no nível barato, dólares em um modelo de fronteira com alto esforço, para a resposta idêntica de "nada a fazer".

Executando dentro dos seus limites

Esses modelos queimam tokens rapidamente, e como você os executa decide quanto do trabalho de um dia é concluído antes de você bater em uma parede.

Primeiro, saiba qual parede.

• Em uma chave de API, a parede é a conta. O progress.log já a monitora.
• Em um assento de assinatura, a parede é uma janela de cinco horas e uma janela semanal julgadas juntas. Nenhuma delas aparece em nenhum lugar no registro acima.

Observe o medidor em que você realmente está: o painel de uso nas configurações do Codex, /usage no lado do Claude, ou um monitor como ccusage ou codexbar estacionado no canto da tela.

Um limite que você nunca lê é um limite que você descobre ao atingi-lo, com quatro horas restantes no relógio e nada para executar.

Seis alavancas, da mais barata primeiro. A maioria atua nos degraus 0 a 2, onde os tokens queimam:

1. Apare CLAUDE.md e AGENTS.md para o essencial. Cada única instrução os lê, além de cada habilidade e ferramenta que você tem ativada. Desligue o que você não está usando; um servidor MCP não utilizado é um imposto em cada mensagem.
2. Reduza o esforço quando você não precisar do topo da escada. Padrão médio ou alto. Reserve o máximo para problemas que precisam dele. E confirme que o modo rápido está desligado enquanto você estiver lá, porque ele multiplica o que quer que você escolha.
3. Dê ao modelo pontos de parada claros. Esses modelos são projetados para executar por muito tempo. Peça para eles terminarem o plano e verificarem antes de executar, que é o trabalho real do modo de planejamento.
4. Mantenha os subagentes em esforço mais baixo. Eles herdam o modelo do pai e seu dial ambos, e um enxame no máximo esvazia uma janela em uma mensagem. A correção barata é uma lei em ambas as constituições: não spawnar a menos que seja solicitado.
5. Mantenha o modelo caro fora do volume. Quer o Fable se sente no topo como um condutor de baixo token ou como um consultor sob demanda, ele ganha seu preço nos pontos de decisão, nunca enquanto digita a milésima linha.
6. Leia o que uma mensagem custa, então ajuste as cinco acima com base nesse número. Esta é a única alavanca que lhe diz qual das outras cinco é o seu problema.

Juntas, essas alavancas definem por quanto tempo você pode executar os melhores modelos antes que o limite o pare.

Cron, quando a Semana 2 começar:

1# task loop: the daily tick, both caps set
20 7 * * 1-5   cd /path/to/repo/loop && BUDGET_USD=5 ./ralph.sh >> ../progress.log 2>&1
3
4# system loop: nothing that passed once goes unwatched
530 7 * * *    cd /path/to/repo && python3 system/verify_goals.py goals/ >> progress.log 2>&1
6
7# system loop: failures become laws, once a week, proposals only
80 9 * * 1     cd /path/to/repo && codex --profile deep exec \
9              "$(cat ~/.codex/prompts/compost.md)" >> proposals/$(date +\%F).md 2>&1

O runbook. Cada alarme, e o que fazer sobre ele:

O cronograma de 30 dias. Não pule as graduações; cada uma desbloqueia a próxima.

O Painel de Comando

Cada loop aqui é acessível por um atalho de teclado. Comandos de barra vivem em ~/.codex/prompts/ no lado do Codex, onde o nome do arquivo se torna o comando, e em .claude/skills/ no lado do Claude. Os clips CLI são as versões headless que o cron e o CI executam.

Comandos de barra do Codex

/plan-stop e /effort se pagam mais rápido. Ambos gastam algumas centenas de tokens para impedir que você gaste algumas centenas de milhares.

Esses modelos executam por muito tempo, então o checkpoint que você quer vem antes do gasto. /plan-stop retorna o plano, os comandos de "pronto-quando", o raio da explosão, o custo e a única pergunta que faria a um humano. Então ele para.

Coloque ambos os arquivos em ~/.codex/prompts/, onde o nome do arquivo se torna o comando.

effort.md se torna /effort, o dial de roteamento tornado explícito:

1# /effort - pick the effort level before you spend it
2
3Do not answer the task yet. Route it first.
4
5Score it. One point each:
6  - contains a why, a debug, a race, a deadlock, a refactor, a security concern,
7    or an optimize
8  - touches more than one subsystem
9  - a previous attempt already failed
10  - the change is irreversible or lands in front of users
11
12Then map:
13
14| Score | Effort | Seat |
15|---|---|---|
16| 0-1 | low | codex -e low, or profile fast (Luna). Never put a frontier seat on it. |
17| 2 | medium | Terra at medium is the seat. |
18| 3+ | high | the default for real work, and where the sweet spot sits. |
19
20Only if high has ALREADY been tried and failed: recommend max, and say plainly
21what the extra thinking is expected to buy. The base rate you are arguing
22against is roughly double the cost for a gain that usually does not repay.
23
24Two reminders before recommending an upgrade:
25  1. A better model at lower effort usually beats a weaker model at max. Change
26     the seat before the dial.
27  2. If this task spawns subagents, state their effort explicitly (low unless
28     proven otherwise). Subagents inherit the parent, and a fleet at max empties a
29     context window in one message.
30
31Output exactly:
32  EFFORT: low | medium | high | max
33  SEAT: <model>
34  WHY: <one line, naming the points that scored>
35  SUBAGENTS: <effort to pin, or none>
36Then stop. The human runs the task at the level you named.

Uma resposta ao vivo se parece com isso, e custa algumas centenas de tokens para evitar algumas centenas de milhares:

1EFFORT: high
2SEAT: gpt-5.6-sol
3WHY: contains "why", touches auth and sessions, prior attempt failed
4SUBAGENTS: low

plan-stop.md se torna /plan-stop, o checkpoint antes do gasto:

1# /plan-stop - plan the work, then stop
2
3These models run long. That is a feature when the plan is right and an expensive
4way to be wrong when it is not. This command buys the checkpoint before the spend.
5
6Plan the task. Do not edit a single file. Do not run a build. Do not start.
7
8Produce:
9  GOAL: <one line>
10  ASSUMPTIONS: <what you take for granted; if these are wrong, so is the plan>
11  STEPS: <numbered, each one commit's worth of work>
12  DONE_WHEN: <the exact shell command that proves each step landed>
13  BLAST RADIUS: <files and systems touched; name auth, payments, migrations, prod
14    config explicitly>
15  COST: <rough tokens or dollars, and which seat runs each step>
16  UNKNOWNS: <what you would ask a human if you could ask exactly one question>
17
18Then stop and wait.
19
20Rules while planning:
21  - Ambiguity goes in UNKNOWNS. Do not resolve it by guessing and proceeding. A
22    guess that survives into execution costs a hundred times more than a question.
23  - If the plan needs a credential, endpoint, or convention that is not written
24    down in this repo, stop and say so. Never invent one.
25  - If any DONE_WHEN is not a shell command, rewrite that step until it is. If a
26    shell cannot check it, neither can a reviewer.
27  - If the blast radius touches the never-list in AGENTS.md, say so at the top and
28    recommend queueing for a human.
29
30You are paid for the plan here, not the diff. A short honest plan with real
31unknowns beats a confident plan that quietly assumed the wrong thing.

fable-advice.md e review-hostile.md se tornam /fable-advice e /review-hostile. Ambos são os espelhos do lado do Codex dos arquivos que você já escreveu: o briefing do consultor do BUILD 5 e o contrato do revisor hostil do BUILD 6. Mesmas regras, mesmos limites, apontados na direção oposta através da linha do fornecedor.

compost.md se torna /compost, o construtor institucional semanal do degrau 4:

1# /compost - turn this week's failures into next week's laws
2
3Read this week's exhaust, all of it, and nothing else:
4  - BLOCKED lines in progress.log (tasks that beat three advisor consults)
5  - GATE: REFUSED entries (a run that could not prove it was done)
6  - VIOLATED standing goals (something finished stopped being true)
7  - circuit-breaker and budget exits (codes 2 and 3)
8  - PRs opened by the loop and closed unmerged (the human silently disagreed)
9  - any task class whose pass rate dropped below 90 percent
10
11Extract AT MOST three proposals. Three is a hard cap, not a target. A clean week is
12a valid finding, and saying so is more useful than manufacturing work.
13
14Each proposal is exactly one of:
15  1. A NEW LAW for CLAUDE.md or AGENTS.md. Quote the incidents it would have
16     prevented. A law with one incident behind it is a coincidence; wait for the
17     second.
18  2. A SKILL FIX, when the same failure repeats in the same place. Name the skill,
19     the pattern, and the smallest edit that breaks it.
20  3. A STANDING GOAL you were missing, when something rotted silently. Write the
21     predicate as a shell command, or do not propose it.
22
23Output:
24  WEEK: <dates>
25  EXHAUST: <counts: blocked, refused, violated, reverted>
26  PROPOSAL n: <law | skill fix | standing goal>
27    EVIDENCE: <the incidents, quoted>
28    CHANGE: <the exact text or predicate to add>
29    COST OF NOT DOING IT: <one line>
30  VERDICT: <what you would do first if you could only do one>
31
32Hard rules:
33  - Propose ONLY. Do not edit CLAUDE.md, AGENTS.md, any skill, or any goal file.
34    The human signs, or it does not happen.
35  - Do not propose a law that softens a gate, raises a budget, or relaxes a never.
36    Those are the system asking to be allowed to fail more comfortably.
37  - Empty exhaust: say "clean week" and stop. Do not go looking for work to justify
38    the run.

CLI clips

Mantenha estes em um arquivo de rascunho. Eles são o sistema inteiro acessível a partir de um terminal:

1# the daily tick, capped in both dimensions
2BUDGET_USD=5 MAX_ITERS=20 ./loop/ralph.sh
3
4# plan first, spend later (the single highest-leverage habit here)
5codex -e high exec "$(cat ~/.codex/prompts/plan-stop.md)
6
7TASK: migrate the session store off the legacy adapter"
8
9# cross-vendor review of the last commit, in Sol's native harness
10codex --profile deep exec "$(cat ~/.codex/prompts/review-hostile.md)"
11
12# the mirrored lane: Codex stuck, Claude advises
13claude --model claude-fable-5 --effort high -p "$(cat ~/.codex/prompts/fable-advice.md)"
14
15# the goal loop: Fable plans, the fleet runs, Fable scores
16CYCLES=3 FLEET=4 WORKER_EFFORT=low ./swarm/swarm.sh "split the auth migration"
17
18# the system loop: nothing that passed once goes unwatched
19python3 system/verify_goals.py goals/          # exit 1 names what rotted
20python3 gate/eval_gate.py eval/cases.jsonl     # exit 1 blocks the routing change
21
22# rung 3, the factory: rows decide, not transcripts
23./factory/factory.sh "build the kanban and notes app per PRD.md"
24python3 factory/factory_gate.py gate factory.db
25
26# the weekly institution-building run
27codex --profile deep exec "$(cat ~/.codex/prompts/compost.md)"
28
29# the one number that says whether any of this worked
30grep '^route' progress.log | awk -F'\t' \
31  '{n++; if($3!="frontier") c++} END{printf "cheap share: %.0f%%\n", c/n*100}'

A política completa está em ROUTING.md do BUILD 4, que ambos os arneses leem.

As Regras (imprima isto)

1. Leis, não dicas: um número, um "nunca", ou um comando que as verifica.
2. O modelo é alugado. O loop é seu. Você vive no degrau 5.
3. Um loop sem aborto é uma conta. Dois limites em cada um: iterações e dólares.
4. Evidência flui para cima, controle flui para baixo. Nenhum degrau fecha com base em um relatório de baixo dele.
5. Um loop pode parar e ainda assim estar errado. Verifique o último commit antes de ele fazer merge.
6. Roteie nas fronteiras. Esforço antes do modelo. O cache vota contra a troca.
7. Padrão é alto. Máximo é profundidade, ultra é largura, modo rápido é um imposto de 2,5x, e subagentes herdam o assento e o dial do pai.
8. O roteador é culpado até que ele vença o melhor modelo único em suas avaliações.
9. Economias são a divisão de tráfego. Observe a fatia barata, não a tabela de preços.
10. Execução é volume, conselho é gramas. Limite as consultas a três.
11. Nada avalia seu próprio dever de casa. Contexto novo, outra linhagem, arnês nativo.
12. Um thread é um rastro. Uma linha é evidência. O portão lê linhas.
13. Nunca edite um teste para fazê-lo passar. Nunca faça merge passando por um portão BLOQUEADO.
14. Uma meta que você verifica uma vez é uma suposição com um carimbo de data/hora.
15. Uma graduação de cada vez. Todo mês, delete algo.

Conclusão

Trinta dias a partir de agora, se você fez as verificações:

• Um loop envia trabalho entediante sem supervisão, atrás de um portão determinístico
• Um driver barato consulta um especialista de fronteira apenas quando ele trava
• Cada diff significativo é julgado por um modelo que não o escreveu
• Um número no progress.log lhe diz se a economia está se compondo

Os modelos nunca foram a parte difícil. Um sistema que permanece honesto quando você para de olhar é a parte difícil, e é por isso que o degrau 5 ainda tem seu nome nele.

Comece esta noite com os vinte minutos que provam isso. O verify.sh do BUILD 2. Um tick executado manualmente do BUILD 3. Uma revisão da outra linhagem no seu último commit.

Na primeira vez que um revisor que não compartilha contexto com o escritor encontrar um bug real em um trabalho que você tinha certeza de que estava pronto, você não precisará de convencimento sobre o resto.

Construa o portão esta noite. Responda com o que ele pegou na primeira execução.

Aviso Legal

Escrito a partir das notas de pesquisa do autor e fontes verificadas, com assistência de rascunho e verificação de fatos do Claude. Todos os preços e comportamentos de modelo foram verificados contra as páginas oficiais de preços e documentação na semana da publicação; eles mudam, então verifique antes de orçar.

Este artigo foi escrito a partir das notas do autor, conforme mencionado no parágrafo anterior, e editado com Claude Opus 4.7.

Se você quiser adicionar outras correções, por favor, adicione-as nos comentários.