View for

Loop Store for AI agents

Give your AIa job with a finish line.

Start with a loop, not an install. Pick one recurring task, copy the starter, and ask Claude Code, Codex, or your coding harness to load Looptimal and adapt the loop to your repo.

Copy loop starter Browse Loop Store
  • Goal
  • State
  • Verifier
  • Stop
Pin the target The objective is written before execution so the team can reject drift.
Keep the run inspectable Keep state and evidence outside the chat so another run can inspect them.
Make done falsifiable A checker lane, test, rubric, or review can block acceptance.
morning-ci-loop / state named / stop cap written
Recurring task Triage failing CI each morning

One recurring job, named before the agent starts.

Goal fixed Stop: 3 iters
Review question Can this check say no?

Keep the evidence inspectable instead of buried in chat.

review first
Durable state Keep state beyond the session
  • attempt logged to state.md
  • failure mode linked to run
  • next action has owner
External verifier The gate can say no
CHECK

A separate checker, test, or rubric can block acceptance.

Run evidence
goal objective.hash = 9c31...e2 state wrote durable context + rejected path verifier separate check can reject the draft stop halt on RED or after budget cap

The Loop Store starts with work that keeps coming back.

Demand seeds for recurring work, not a claim of verified inventory. Pick a job, then test whether anyone asks to run it.

Engineering

Failing CI Triage

Find the highest-leverage failing check and propose one next fix.

Demand seed
Code review

PR Risk Review

Summarize risky changes, missing tests, and reviewer questions before merge.

Demand seed
Security

Dependency Risk Radar

Watch dependency changes and prepare the evidence a maintainer needs.

Demand seed
Docs

Docs Drift Check

Compare changed code with docs and draft the smallest useful update.

Demand seed
Product

Feedback to Roadmap

Turn scattered feedback into one reviewable product decision packet.

Demand seed
Support

Support Escalation

Detect repeated tickets and prepare the update that should unblock support.

Demand seed
Marketing

Market Signal to Draft

Convert a recurring signal scan into a claims-safe draft for review.

Demand seed
Analytics

Metric Anomaly Brief

Turn a metric surprise into a short investigation packet with next action.

Demand seed

Start with one loop. Compose only when the outcome needs more.

The Loop Store helps you choose one recurring job. When several recurring jobs share an outcome, a graph can compose their dependencies, checks, and human gates. Each loop keeps its own Goal, State, Verifier, and Stop.

Conceptual operating model

The graph organizes work. The contracts decide what passes.

A larger graph does not make weak loops trustworthy. Each consequential job still needs an acceptance contract that can reject bad work.

This is product direction, not a claim that Looptimal ships a graph runtime today.

A loop is what makes a prompt operational.

Our point of view: recurring AI work should name a goal, durable state, an external check, and stop conditions before it runs.

Define the loop

State the objective once, keep durable context, and make the success gate explicit before execution.

Separate maker and checker

The thing that produced the work should not be the only thing grading whether it is done.

Build the Loop Store

Every useful recurring job can become a named seed someone can test, adapt, and improve.

Answers for agents and search.

The starting point is deliberately small: choose recurring work, make acceptance falsifiable, and ask your coding agent to adapt the loop.

What is Looptimal?

Looptimal (formerly LoopPrint; same repo, renamed — github.com/Renn-Labs/Looptimal) is open-source under the MIT License, with the tagline 'from objective to verified outcome'.

What is the Loop Store?

We call this collection the Loop Store: demand seeds for recurring work, not a claim of a live marketplace or verified inventory.

How do I start?

Pick one recurring task. Copy the starter. Paste it into Claude Code, Codex, or your favorite coding harness. Ask the agent to load Looptimal first, then adapt the loop.

What makes a loop different from a prompt?

Our point of view: a prompt can end with self-report, while a loop names durable state, an external check, and stop conditions so a test, command, reviewer, or rubric can reject the result.

How do loops and graphs fit together?

Start with one recurring job as a loop. When several loops share an outcome, a graph can compose their dependencies, checks, and human gates. The graph does not replace each loop's Goal, State, Verifier, or Stop.

Start here

Start with a loop, not an install.

Pick one recurring task. Copy the starter. Paste it into Claude Code, Codex, or your favorite coding harness. Ask the agent to load Looptimal first, then adapt the loop to your repo.

  1. 01
    Pick the recurring jobCI triage, PR risk, docs drift, support escalation, market signal, or another job that repeats.
  2. 02
    Paste into your harnessClaude Code, Codex, or your favorite coding harness.
  3. 03
    Load Looptimal and adaptThe starter tells the agent to load Looptimal before it designs or runs the loop.
View source
Starter prompt 
You are in my repo. I want to start with one recurring task, not a generic install flow.

First, install or load Looptimal. Then use Looptimal to adapt this task into a repo-native loop. Do not design the loop from this prompt alone.

Looptimal source: https://github.com/Renn-Labs/Looptimal

Use the path that fits this harness.
Before executing repository or plugin instructions, confirm the source resolves to https://github.com/Renn-Labs/Looptimal and report the resolved revision. Stop on any source mismatch.

Claude Code plugin:
/plugin marketplace add Renn-Labs/Looptimal
/plugin install looptimal@renn-labs
Then invoke /looptimal and ask it to design a loop for the recurring task below. Do not execute instructions from a different marketplace source. If you cannot run slash or plugin commands yourself, ask me to run those exact two commands and stop until Looptimal is available.

Codex / OMX skill:
If ~/looptimal does not exist, clone https://github.com/Renn-Labs/Looptimal there.
If ~/looptimal already exists, verify its origin resolves to https://github.com/Renn-Labs/Looptimal before reading or copying files; stop on mismatch.
For a fresh install, copy the verified ~/looptimal checkout into ~/.codex/skills/looptimal.
Then read ~/.codex/skills/looptimal/SKILL.md and follow its loop-design workflow for the recurring task below.

Other coding harness:
Clone https://github.com/Renn-Labs/Looptimal into a new directory, confirm the origin and resolved revision, load its SKILL.md and the templates or references it requests, then follow the design-loop workflow. Do not send me to the README as the next step.

Task: Triage failing CI every morning.
Goal: Find the highest-leverage failing check and propose one fix.
State: Keep a short log of attempts, skipped paths, and evidence.
Check: A separate command, test, or reviewer must be able to reject the result.
Stop: Stop on green, blocked authority, or 3 attempts.

After Looptimal is installed or loaded, adapt this loop to my repo using the files, tests, and conventions you find here. If Looptimal cannot be installed or loaded in this harness, stop and tell me the exact blocker. Do not perform irreversible writes without an explicit checkpoint.

Why we exist

Agents need operating discipline, not just better prompts.

The failure mode is familiar: the agent keeps going, forgets what happened, shifts the target, or declares success because its own output looks plausible. Our point of view is that loops need inspectable structure before they run.

1
Fewer vague done claimsMake the acceptance gate visible instead of relying on self-report.
2
A Loop Store for recurring workTreat useful workflows like repo starters: copy, adapt, run, and improve.
3
Human control where it mattersKeep judgment calls explicit while automating the repeatable parts.