Communitygithub.com

Renn-Labs/Looptimal

Looptimal — transforme um objetivo em um resultado ENTREGUE e VERIFICADO: uma suíte de aceitação lacrada, o loop correto, aprovação em war-game, execução com especialistas de domínio (criador != verificador) e um verificador separado. Contém o assistente de design de loops (anteriormente LoopPrint).

O que é Looptimal?

Looptimal é um orchestrator de resultados para agentes de IA, projetado para transformar um objetivo em um resultado entregue e verificado. Ele vai além de simples execuções, garantindo que cada objetivo seja validado contra o estado real do sistema por meio de uma suíte de aceitação lacrada (hash-pinned) e um verificador separado, eliminando a dependência de autoavaliações tendenciosas (GREEN) do agente executor. A skill é inspirada em princípios de engenharia de software e segurança, como separação de responsabilidades (maker != checker) e verificação externa. Ela suporta múltiplos modos de operação: pipeline completa (8 estágios), fast-path de design (apenas blueprint de loop) e modo single-pass (para entregas únicas e verificadas). A ferramenta é construída para ser modulada por checkpoint, garantindo que cada etapa (Frame, Analyze, Design-loop/Route, Plan, Simulate) pare para validação e aprovação humana antes de prosseguir para Execução. A decisão de qual modo usar é tomada por um fork inicial, onde o usuário escolhe entre obter um resultado único e verificado, executar uma missão (iteração limitada), construir um loop recorrente, ou gerar apenas um blueprint. Looptimal é ideal para objetivos não triviais, com múltiplos domínios, onde 'pronto' precisa ser provado contra o estado real. Ele pode ser invocado por comandos como "looptimal", "/looptimal", "run an outcome loop", ou "orchestrate this objective to done".

Funciona com~Claude Code~Codex CLI~Cursor
npx skills add Renn-Labs/Looptimal

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

Looptimal — orquestrador de resultados

Transforme um objetivo em um resultado entregue e verificado: sele os critérios de aceitação, escolha ou rejeite o loop correto, faça war-game do plano, execute com especialistas de domínio e bloqueie a conclusão em um verificador separado que reexecuta a suíte lacrada contra o estado real — nunca dependa de um GREEN auto-relatado.

O assistente de design de loops (anteriormente o LoopPrint autônomo) está incorporado como Estágio 2: Design-loop. Ele também é executado como um fast-path design quando você só quer um blueprint de loop sem orquestração de resultados.

Quando usar

  • "looptimal", "/looptimal", "run an outcome loop", "orchestrate this objective to done", "plan and ship this goal".
  • Um objetivo não trivial onde "pronto" deve ser provado contra o estado real, não apenas afirmado pelo agente que fez o trabalho.
  • Trabalho multi-domínio que precisa de um Manifesto de Capacidade, plano de consenso e criador != verificador na altitude do resultado.
  • Padrões recorrentes, supervisionados, de catraca ou de orquestração — depois que o Design-loop confirmar que isso é realmente um loop.
  • Você quer que o Simulate faça war-game do plano antes de qualquer execução autônoma.
  • Um objetivo único e não trivial que você quer entregar uma vez e provar contra o estado real. Se precisar de iteração limitada, direcione-o como uma missão / goal-run; se uma passada cuidadosa for suficiente, use o modo single-pass (veja o fork de modo abaixo).

Quando usar o fast-path de design

  • "design a loop", "build a loop", "new loop", "loop wizard", ou uma tarefa recorrente vaga para automatizar.
  • Você só quer um blueprint de loop (especificação + artefatos) — sem orquestração de resultados.
  • Pula diretamente para o Estágio 2 (Portão de Decisão → assistente → geração de artefatos) e para.

Quando NÃO usar

  • Uma resposta única trivial, edição rápida ou pergunta conversacional → apenas faça bem feito uma vez, sem ferramenta necessária. (Um objetivo único substancial que você ainda quer provar — não trivial, apenas não recorrente — é direcionado para missão / goal-run ou single-pass abaixo, não é uma razão para pular o Looptimal completamente.)
  • Análise sem obrigação de entrega → responda diretamente ou use esat.
  • Ações irreversíveis, de alto julgamento, sem humano disposto a segurar o portão GO → recomende um processo com portão humano.
  • Meta-loops ("execute Looptimal para verificar Looptimal", "auto-mesclar quando Looptimal disser GREEN") → o Design-loop deve REJEITAR.
  • Métricas de sucesso baseadas apenas em sintomas, sem um oráculo de resultado comportamental → re-Frame ou REJEITE.

Regras operacionais (leia primeiro)

  • Esta é uma skill, não uma persona ou modo. Abra com uma linha de ativação, depois faça o trabalho.
  • Gateada por checkpoint: Frame → Analyze → Design-loop / Route → Plan → Simulate — cada um para para um breve status. Execute nunca começa sem um GO humano explícito após o Simulate — ou, no modo single-pass, após o leve pre-mortem que substitui os checkpoints Analyze/Design-loop/Plan/Simulate (veja o fork de modo abaixo).
  • Nunca execute ações irreversíveis automaticamente: deploys em produção, envios, pagamentos, rotação de credenciais, exclusão de dados — apenas com portões humanos pré-ação.
  • Desacoplado do harness: resolva as ligações de ./.looptimal/profile.yaml → ~/.looptimal/profile.yaml → scripts/looptimal-detect.py → padrões genéricos. Contrato: references/agent-foundry.md.

Exemplos de linha de ativação:

  • Pipeline completa: "Looptimal — enquadrando este objetivo em um loop de resultado lacrado."
  • Fast-path de design: "Looptimal — blueprintando este loop."
  • Single-pass: "Looptimal — uma passada verificada neste, sem loop."
  • Invocado sem objetivo: faça exatamente uma pergunta — "Qual resultado deve ser verdadeiro quando terminarmos?" — então o fork de modo abaixo.
  • Objetivo já dado: reconheça em uma linha, então o fork de modo abaixo.

O fork de modo (antes do Frame — pergunte uma vez, de forma leve)

O julgamento de validade de loop do Looptimal é o Portão de Decisão (Passo 1 do assistente, abaixo) — mas hoje isso só é acionado no fundo do Estágio 2, depois que Frame e Analyze já foram executados. Decida a forma antes de qualquer trabalho começar:

  • Frase já inequívoca — pule a pergunta:
    • Palavras-gatilho do fast-path de design ("design a loop", "build a loop", "blueprint", "loop wizard") → Estágio 2 diretamente.
    • Linguagem explícita de one-shot que também descarta tentativas úteis ("single pass", "one careful pass", "no retry loop needed") → single-pass diretamente.
    • Linguagem explícita de entrega única com possível trabalho de verificador/tentativa ("one-shot", "just do X once", "build/fix/ship this once") → pipeline completa para que o Portão de Decisão possa escolher missão / goal-run vs single-pass.
    • Linguagem explícita de recorrência/cadência ("nightly", "every PR", "keep this fresh", "ongoing") → pipeline completa diretamente.
  • Caso contrário — faça uma pergunta estruturada de três opções antes de tocar no Estágio 0:
    1. Faça isso uma vez, comprovado — um único resultado verificado sem loop de tentativas útil → single-pass.
    2. Execute uma missão ou construa um loop — seja limitado (uma missão / goal-run que itera até um portão, depois para — correções de bugs, conformidade com especificações, construções únicas) ou recorrente (executa em um cronograma/gatilho indefinidamente) → pipeline completa (Estágio 0 → 1 → 2; o Portão de Decisão escolhe a rota/arquétipo — Tarefa / Recorrente / Supervisionado / Catraca-persistente / Orquestração, missão / goal-run, ou rejeição completa).
    3. Apenas gere um blueprint de loop → fast-path de design (apenas Estágio 2).

Isso apresenta a mesma chamada de validade de loop que o Portão de Decisão já faz como julgamento do próprio usuário, upfront e barato, em vez de ser alcançável apenas depois que Analyze, Design-loop e Plan já foram gastos na forma errada (Frame é executado independentemente do modo escolhido, então nunca é desperdiçado). Se a evidência do Estágio 0/1 contradizer o modo escolhido posteriormente — um objetivo "single-pass" que claramente se repete ou precisa de iteração até um portão, ou um "sistema recorrente" que não sobrevive ao Portão de Decisão — diga isso claramente e deixe o usuário redirecionar. Nunca substitua silenciosamente a escolha deles; nunca obedeça silenciosamente a um modo que a evidência não suporta.

Resolva a ligação (preâmbulo do Estágio 0)

python3 scripts/looptimal-detect.py          # sondar marcadores; sugerir perfil
# ou leia ./.looptimal/profile.yaml → ~/.looptimal/profile.yaml

Fornece state_dir, dispatch.maker, dispatch.checker, verifier.default, banner opcional. Padrões genéricos: loops/<slug>/, verificador de shell.


O pipeline de 8 estágios

EstágioNomeTrabalhoReferência
0FrameTransforme o objetivo em uma suíte de aceitação com hash fixo e LACRADA. Cada critério afirma um resultado (não um sintoma) e vincula um oráculo de resultado de domínio. As entradas não podem ser gravadas pelo criador. Emita acceptance-suite.yaml + acceptance-suite.sha256.references/pipeline.md
1AnalyzeProduza um Manifesto de Capacidade e um inventário de prontidão de capacidade local: domínios, mapa de integrações, riscos, dependências, skills/plugins/connectors/MCPs/agentes/dados disponíveis. Delegue trabalho de definição profunda ao esat quando os riscos justificarem um teste de estresse tri-modelo.references/pipeline.md
2Design-loop / RouteExecute o assistente de design de loops ou direcione o objetivo. Escolha o arquétipo — Tarefa (entrega limitada), Recorrente (atualização agendada), Supervisionado (autônomo dentro de limites), Catraca-persistente (cada passada melhora estritamente uma métrica de resultado), Orquestração (multi-ator / multi-repo), missão / goal-run, single-pass — ou REJEITE apenas para casos sem verificador/meta-loop/somente sintomas.references/pipeline.md
3PlanConstrua um grafo de tarefas de consenso: nós, dependências, hooks de aceitação por tarefa vinculados à suíte lacrada, tags de raio de explosão, notas de reversão.references/pipeline.md
4SimulateRole o loop N passos para frente; modos de falha pré-mortem (reward-hacking, falha silenciosa, conclusão parcial, desvio de ambiente); endureça o plano. Apresente as descobertas e quaisquer deltas para a suíte lacrada (re-hash + confirmação do usuário).references/pipeline.md
—GO HumanoAprovação explícita para executar. Superfície os principais riscos, irreversíveis, dependências abertas. Sem GO → sem Execute.references/pipeline.md
5ExecuteCrie subagentes especialistas de domínio dinâmicos de acordo com o perfil de ligação. Criador ≠ verificador nos portões de iteração. Passos retomáveis e idempotentes; caminhos de reversão para falha parcial. Portões pré-ação em irreversíveis.references/pipeline.md
6Verify-outcomeUm verificador separado reexecuta a suíte LACRADA contra o estado real. Ignore o GREEN auto-relatado pelo loop. Bloqueie em um pacote de evidências.references/pipeline.md
7PersistEscreva estado durável: hash do objetivo, hash da suíte, o que funcionou/falhou, resultados do oráculo, classe de remediação, ponteiros de retomada, lições para a próxima execução.references/pipeline.md

Transições de estágio (padrão)

  • 0 → 1: suíte lacrada existe, cada critério tem um oráculo, hash registrado.
  • 1 → 2: Manifesto de Capacidade cobre todos os domínios materiais, arestas de integração e prontidão de capacidade local.
  • 2 → 3: arquétipo ou rota de missão escolhida (ou REJEIÇÃO completa emitida com alternativa honesta).
  • 3 → 4: grafo de tarefas é acíclico, cada nó se conecta a um critério da suíte, limites de segurança definidos.
  • 4 → GO: relatório de simulação entregue; plano endurecido; irreversíveis marcados.
  • GO → 5: aprovação humana explícita capturada no estado.
  • 5 → 6: criador declara iteração completa — apenas informativo; verificador possui a verdade.
  • 6 → 7: pacote de evidências VERDE; senão FALHA com classe de remediação e ponteiro de retomada.

Retomada

Se uma execução anterior existir em state_dir e o hash do objetivo corresponder, retome do último estágio incompleto. Se o objetivo mudou materialmente, re-Frame (novo hash da suíte). Nunca retome após uma REJEIÇÃO completa sem um novo Design-loop / Route.


Estágio 2 — Assistente Design-loop / Route

O assistente impõe os quatro átomos, executa o portão de decisão de rota e então ramifica. Rotas de loop reutilizável geram o pacote completo de artefatos LoopPrint. Rotas de missão / goal-run emitem route.md + um pacote de missão (mission.yaml após o Estágio 3) e continuam para o Estágio 3 Plan sem a estrutura de loop reutilizável. Rotas single-pass emitem route.md mais o leve pre-mortem e seguem o caminho Degrade single-pass. Ele reside no Estágio 2 do pipeline completo e também é executado de forma autônoma como o fast-path design.

Entrada do assistente

  • Pipeline completa (chamado do Estágio 2): objetivo é o resultado do Estágio 0. Pule para o Passo 0.5.
  • Fast-path de design (invocação direta): abra com uma linha de ativação; se nenhum objetivo for dado, faça uma pergunta primeiro.

Passo 0.5 — Resolva a ligação

Execute scripts/loopprint-detect.py (ou leia ./.loopprint/profile.yaml → ~/.loopprint/profile.yaml) para obter state_dir, verifier.default, dispatch, marker_path, runner, banner. Padrões genéricos: loops/<slug>/, verify.sh. Contrato: references/profiles.md. Nunca codifique convenções de harness.

Passo 1 — Portão de Decisão (+ rota)

Execute o teste Tier-0 em references/decision-gate.md: 4 condições + checklist de 30 segundos. Reporte a rota com uma linha de raciocínio por condição. Recorrência permanece como o teste de amortização de loop reutilizável, não todo o portão de orquestração: trabalho não recorrente, mas com respaldo de verificador, pode ser direcionado para missão / goal-run ou single-pass. A REJEIÇÃO completa permanece obrigatória quando não há verificador externo/checkpoint humano, quando o objetivo é autorreferencial/meta-loop, ou quando o sucesso é baseado apenas em sintomas, sem âncora comportamental.

Imediatamente ramifique na rota selecionada:

  • Rota de loop reutilizável: continue pelos Passos 2-6, fixe o arquétipo/perfil do loop, gere loops/<slug>/, e execute loopprint-lint.
  • Rota de Missão / Goal Run: não continue para o perfil do loop ou geração de artefatos. Emita route.md com driver, artefato de estado, verificador, parada/orçamento, nível de autonomia, lacunas de prontidão e por que nenhum blueprint de loop reutilizável está sendo produzido; então continue para o Estágio 3 Plan, que emite mission.yaml, task-graph.yaml, execute-scope.yaml e looptimal-lint.txt.
  • Rota de Passagem Única Verificada: não continue para o perfil do loop ou geração de artefatos. Emita route.md com verificador, artefato de estado, parada, lacunas de prontidão e um leve pré-mortem de 3 cenários; então siga o caminho Degrade single-pass em vez do Estágio 3/4.
  • Rota de fluxo de trabalho com portão humano: emita route.md com os checkpoints humanos e verificador externo, então continue apenas pelo caminho supervisionado que corresponda a esses portões.
  • REJEIÇÃO completa: emita reject.md com o motivo não verificável/inseguro e alternativa honesta; pare a menos que o usuário reenquadre o objetivo.

Passo 2 — Refinamento de objetivo de loop reutilizável

Faça 3-5 perguntas direcionadas (não mais):

  1. Objetivo aprimorado — uma frase, testável.
  2. Recorrência / frequência — confirma que o loop reutilizável se amortiza.
  3. Método de verificação — qual sinal externo diz que uma iteração foi bem-sucedida?
  4. Riscos irreversíveis — o que não pode ser desfeito? (→ checkpoint humano)
  5. Nível de autonomia — totalmente autônomo, gateado por checkpoint ou dry-run?

Passo 3 — Imposição de primitivas de loop reutilizável

Force um valor concreto para cada átomo. Não prossiga com nenhum vago:

  • Objetivo — o objetivo de uma frase do Passo 2.
  • Estado — caminho do artefato durável do state_dir da ligação; o que registra: registro de tentativas, o que falhou, hipótese atual, contexto.
  • Verificador — o comando externo exato ou revisor nomeado. Se a única verificação proposta for o mesmo agente se autoavaliando, rejeite-o e encontre um portão real. Criador ≠ verificador.
  • Parada — critérios de sucesso e um limite de segurança (máximo de iterações, orçamento de token/tempo, parada explícita). Nenhum loop é enviado sem um limite de segurança.

Passo 4 — Seleção de perfil de loop reutilizável

Fixe o perfil completo do arquétipo — padrão de trabalho (de references/patterns.md) e forma do verificador/parada:

  • MORTY — bug específico; verificador = teste de reprodução; fin…

[truncado para tradução]

Habilidades Relacionadas