O agente que escreve o código não pode ser o que o certifica

Toda demo de agente termina igual

O modelo escreve o arquivo, roda a coisa, imprime "pronto". Ninguém confere.

A entrega que parecia terminada às 2 da manhã vira um arquivo que não existe, um
teste que nunca rodou e um resumo confiante.

Batemos nisso vezes suficientes para parar de acreditar na palavra do agente que
fez o trabalho. Não porque o modelo é preguiçoso — porque um LLM não consegue
certificar o próprio artefato. Ele declara sucesso de dentro, onde não vê a falha.

Três falhas, uma causa

Construir um laço de validação para os nossos agentes expôs três modos de quebra:

1. Autoavaliação forjada. O modelo que gerou o artefato é o modelo que o avalia. Mesmo contexto, mesmos pontos cegos. Ele diz "parece correto" sobre um diff que nunca executou.
2. FoFo — Found on False. A IA não pode corrigir a própria prova. Quem escreve o código não escreve o teste que o valida, e quem julga não compartilha contexto com quem construiu.
3. Verificação fraudável. Se o verificador mora onde o agente alcança, o agente falsifica o verificador. Um pytest.py falso que devolve 0 não é hipótese — é o movimento óbvio.

As duas primeiras são sobre autoridade: só evidência externa pode declarar
PRONTO. A terceira é sobre alcance: a evidência tem de ser produzida num lugar
que o construtor não toca.

O gate cego

Então a arquitetura parte o laço e põe a prova do lado de fora:

Tarefa ──▶ [SOUL / Builder] ──▶ [Gate cego] ──▶ [Juiz / Revisor] ──▶ Envelope
              ▲                    │ FAIL              │ REJECT
              └──── required_fix ──┘                   │ (max_attempts → ESCALADO)
                     (re-gate, estrito)                ▼ APROVADO → SUCESSO

• Builder / SOUL. Rascunha a partir de persona + memória procedural + tarefa. Pode referenciar um segredo pelo nome ($VAULT_X), nunca pelo valor.
• Gate cego. O ambiente inalcançável. Roda a ferramenta de verdade — HTTP via curl, nc, ffprobe, EXPLAIN em seco, HMAC-SHA256, um regex declarado — e devolve (passou: bool, log: str). A evidência é refeita a cada tentativa. Gate verde da rodada 1 nunca é reaproveitado na rodada 2.
• Juiz / Revisor. Uma sessão sem o histórico do Builder, confrontando rascunho
  • log do gate contra as regras injetadas. Ele emite um veredito de roteamento, não o texto final. A rejeição injeta required_fix no próximo prompt do Builder, invisível ao canal humano.

O contrato é tipado (Pydantic v2 — sem LangChain, sem LangGraph, decisão
documentada): o envelope carrega soul_id, um status restrito a
SUCCESS | ESCALATED_TO_DM | TOOL_FAILURE, e uma trilha de auditoria com
self_correction_count, rules_applied, latency_ms, hedge_warning e o
gate_log cru.

A regra de ouro do laço

O LLM pode sugerir que terminou. Só evidência externa pode declarar PRONTO.

SUCCESS só existe quando gate_pass == true e judge_pass == true. Todo o
resto termina em ESCALATED_TO_DM (teto de tentativas) ou TOOL_FAILURE. O agente
para onde a autorização termina — o que provamos num piloto ao vivo que bateu num
404 real e devolveu nenhum payload inventado em vez de alucinar um.

O que é preciso para confiar no testador

Gates vêm em dois tipos, ambos declarados num registro só:

• subprocess: argv renderizado com o artefato, executado como processo do host.
• static: validador determinístico em processo (um regex de prompt MEDIA:), ainda fora do intérprete do LLM e ainda declarado no registro.

Parâmetros entram por string.Template, então literal de shell/HTTP/JSON
(%{http_code}, {"exact":false}) nunca colide com interpolação.

O harness mede a si mesmo com função pura, sem LLM no meio, em seis dimensões —
contratos determinísticos, autoteste do orquestrador, orquestração ponta a ponta,
política de custo, operação viva, documentação. Cada dimensão devolve um de quatro
estados (PASS | FAIL | NOT_VERIFIABLE | ERROR), e o veredito é derivado, não julgado:

APTO          todas as dimensões PASS e total >= 90% do teto (fixo)
COM RESSALVAS nenhum FAIL/ERROR, mas algo é NOT_VERIFIABLE (>= 70%)
REPROVADO     qualquer FAIL/ERROR, ou total < 70%

Dimensão não executada fica no denominador, e os códigos de saída são 0 / 1 / 2 —
para o CI poder chamar. Inconclusivo nunca passa o gate: essa regra veio de uma
máquina quebrada que, sem ela, teria entregue verde.

Onde está hoje

Números honestos, todos medidos localmente:

• 44 testes pytest verdes
• 2 pilotos ponta a ponta (dois projetos sem relação, mesmo motor)
• 1 entrega real num canal humano (message_id=43843)
• política de custo imposta: o gate nunca chama modelo pago

Não é framework. Sem montanha de dependência, sem marketing de agente-de-agentes.
A alegação é estreita de propósito: não deixa seu agente mais inteligente, deixa o
"pronto" valer alguma coisa.

A versão de código aberto do motor do laço, incluindo o registro de gates e o
harness de qualidade, está aqui:

→ Baixe a skill AI Test Loop grátis