loopy
8 loops shipped · PR-first · provider-agnostic

Reusable automation loops for your repo.

loopy is a library of guardrailed loops software teams import into their repositories. One contract, a fail-safe runner, and a reviewable pull request out the other end — import one in a single command.

Star on GitHub See it work ↗
$ npx loopy add auto-docs
8
Production loops
1
Portable contract
PR
Reviewable output, always
0
Partial / on-error writes
The loop contract

One contract, every loop.

However smart its internals, every loop follows the same five-stage shape and runs through a single loop-agnostic runner. That uniformity is what makes loops importable, reviewable, and safe.

01 trigger A cron schedule, a repo event, or a manual run kicks the loop off.
02 detect Cheap, deterministic check for whether there is actually work to do.
03 act Do the work — an AI step, deterministic code, or a hybrid of both.
04 output A reviewable pull request — safe and reversible — or an advisory comment.
05 guardrails Path allowlist, max-files cap, idempotency, and human approval gates.
Fail-safe by design. On any error — including a guardrail violation — the runner produces no output and never partially applies changes.
The catalog

Loops that keep your repo healthy.

Each loop does one job and ships its own reviewable output. Add any of them with npx loopy add <loop>.

auto-docsAI

Updates documentation when the code surface drifts away from what the docs describe.

dep-updatesDeterministic

One grouped pull request bumping your non-major dependency updates together.

changelogDeterministic

Drafts a changelog entry from unreleased commits using conventional-commit history.

pr-reviewAI

Posts an advisory automated review comment on a pull request — never blocking.

test-coverageAI

Backfills tests for uncovered changed lines, self-validating before it opens a PR.

security-remediationHybrid

Human-gated fixes for security findings above a configured severity threshold.

kb-gapAI

Self-heals docs by drafting KB articles for recurring support-ticket topics.

metric-anomalyDeterministic

Z-score anomaly detection that ships a concise brief when a metric goes sideways.

incident-followupLong-horizon

Tracks overdue action items and flags recurrence across past incidents.

1-click install

Import a loop in a single command.

loopy vendors the loop into your repo — workflow, config, and playbook — so it lives in your version control and runs on your CI. No platform to adopt, no lock-in.

bash — your-repo
$ npx loopy add dep-updates
✓ added dep-updates → .github/workflows/loopy-dep-updates.yml
✓ wrote loopy/dep-updates/loop.yaml
✓ guardrails: allowlist · max-files · skip-if-open-PR
 
$ npx loopy list
auto-docs dep-updates changelog pr-review
test-coverage security-remediation kb-gap …
 
$ npx loopy run dep-updates
detect → 6 updates · act → grouped bump
output → PR #142 opened for review ✓
  • +
    Add a loop
    npx loopy add dep-updates — vendors the loop and its guardrails into your repo.
  • ≡
    List the catalog
    npx loopy list — see every loop available to import.
  • ▷
    Run it
    npx loopy run <loop> — trigger a loop locally or wire it to CI / cron.
Compared to best-in-class

One framework, many loops.

Specialist tools are excellent in their niche. loopy's angle is different: a single guardrailed, importable framework that spans many loops with one contract and one CLI.

Dependabot / Renovate CodeRabbit Vanta / Drata Statsig / Eppo loopy
Scope Dependency updates PR review Compliance Experiments Many loops in one framework
Install Per-tool setup Per-tool setup Per-tool setup Per-tool setup One CLI — npx loopy add
Output PRs PR comments Dashboards / reports Dashboards / readouts Reviewable PR or comment, uniformly
Guardrails Update rules Review config Policy controls Experiment gates First-class: allowlist · caps · idempotency · human gates
Extensibility Closed product Closed product Closed product Closed product ✓ Importable, open loops
AI provider n/a Vendor-managed Vendor-managed n/a Provider-agnostic (defaults to OpenRouter, configurable)

Honest take: the specialists go deeper in their niche — Renovate's update graph, CodeRabbit's review depth, Vanta's audit coverage, and Statsig's stats engine each outclass a single loopy loop on their home turf. loopy isn't trying to beat them at X; it gives you one guardrailed, importable framework spanning many loops, so you adopt the contract once instead of stitching together point tools.

Long-horizon primitives

Loops that remember, wait, and resume.

Beyond single-shot loops, loopy ships the substrate for stateful, multi-step work that unfolds over days — the same contract, extended across time.

Durable state

A persistent store gives loops memory across runs — they pick up where they left off.

Human-approval gates

First-class checkpoints that block a plan until a person signs off — built into the contract.

Resumable plans

Multi-step plans with wait-states and gate-blocking that survive restarts and resume cleanly.

Powered by the primitives

Experiment Lifecycle Orchestrator

1Design
2Approvehuman gate
3Launch
4Bakewait-state
5Readout
6Decidehuman gate

Adopt the contract once.

Import your first loop, review the PR it opens, and let it run on your CI. That's the whole onboarding.

Get started on GitHub
$ npx loopy add auto-docs