autonomous-loops — independently scanned and version-tracked by SaferSkills.
SaferSkills independently audited autonomous-loops (Agent Skill) and scored it 100/100 (green). The audit ran 55 deterministic rules across Security, Supply Chain, Maintenance, Transparency, and Community; it found 0 high-severity and 0 lower-severity findings. The full rule-by-rule trace and per-finding evidence are below. Free, methodology-open.
Findings & checks · 0 flagged
Every scanned point with the score it earned and what moved between them.
First recorded scan — no prior version to compare against.
The primary manifest — the file an agent reads to learn what this artifact does.
A loop is an agent that prompts itself — selecting the next task, doing it, checking it, logging progress, repeating — until a stop condition is met. Done well it multiplies throughput; done badly it manufactures comprehension debt (code nobody reviewed) and invites cognitive surrender (accepting output without thinking). The job of this skill is to build loops that stay accountable: a verifiable stop, a checker separate from the maker, a place for decisions that need a human, and hard caps on spend — with you still the engineer who confirms it works, not the person who pressed go.
This is the autonomy conductor. It composes [[parallel-subagents]] (fan-out), [[long-running-agents]] (multi-hour coherence), and [[agent-verification]] (trustworthy "done"); it does not replace them. It sits under [[agent-guardrails]] — autonomy never widens what an agent may do without approval.
/goal until a stop condition; /loop on a cadence)Skip / don't loop when:
Not a substitute for your judgment: a loop is a tool built with critical thinking, not a way to avoid it.
Before any loop runs, define done as something a machine can check — tests green, a metric met, an empty queue, a checklist all-passed ([[agent-verification]] owns the check). "Until it looks done" is not a stop condition; it's an open tab burning tokens. No verifiable stop → don't loop.
The agent that does the work must not be the only one that judges it — models grade themselves too generously. Route each iteration's output through a separate evaluator (a sub-agent, ideally a different model) per [[agent-verification]]. The checker can refuse and send work back.
pushes to a protected branch ([[git-flow]]).
loop or not.
Set explicit caps before starting: max iterations, wall-clock limit, and a token/cost ceiling ([[finops-budget]] for spend). On breach, stop and surface — a runaway loop is a budget incident.
Anything the loop shouldn't decide — ambiguous trade-offs, risky changes, judgment calls — goes to a single triage inbox (an issue list, a Linear board, a TRIAGE.md) for a human, instead of the agent guessing. Confident guessing on missing intent is intent debt; make the loop ask, not assume.
Each iteration commits a meaningful unit and updates an external progress/plan file so a reset or crash can resume without redoing work ([[long-running-agents]] owns the mechanics).
Sample the loop's output continuously; don't wait for the end. Your job is to ship code you confirmed works. If you find yourself rubber-stamping, that's cognitive surrender — slow the loop, shrink the batch, or stop it.
Stop when the stop condition is met, a circuit breaker trips, the triage inbox is backing up, or the checker's reject rate climbs (the loop is thrashing). Then review the batch as a human before merge.
~30 seconds. Free. No account. Every finding cites a rule and a line of evidence.