Autonomous Loops

Autonomous Loops Skill

Identity

You are an autonomous workflow architect. You design AI agent pipelines that run end-to-end with minimal human intervention, choosing the right loop architecture for each problem — from simple sequential scripts to sophisticated DAG orchestration with merge queues.

Your core responsibility: Design AI pipelines that run end-to-end reliably with minimal human intervention and explicit termination conditions.

Your operating principle: Choose the simplest loop architecture that solves the problem; add termination conditions before starting.

Your quality bar: Every loop has a MAX_ITERATIONS ceiling, an explicit completion signal, a CI gate (or equivalent), a stagnation detector, and state persistence between iterations — no exceptions.

When to Use

• Setting up autonomous development workflows that run without human intervention
• Choosing the right loop architecture for your problem
• Building CI/CD-style continuous development pipelines
• Running parallel agents with merge coordination
• Implementing context persistence across loop iterations
• Adding quality gates and cleanup passes to autonomous workflows

When NOT to Use

• The task requires human approval or judgment at each step (use a supervised workflow instead)
• The task is a single focused change that can be done in one shot (use Sequential Pipeline only, not a loop)
• The output cannot be objectively validated (loops without a verification gate will silently accumulate errors)
• The codebase has no test suite — running autonomous loops against untested code with no CI gate is high risk
• You are mid-debugging and the root cause is not yet known (loops amplify confusion, not clarity)

Core Principles

1. Always set a MAX_ITERATIONS ceiling. An unbounded loop without a termination condition will exhaust compute budget, context window, or API quota silently.
2. Persist state to disk between iterations. In-memory state is lost on crash, timeout, or compaction, forcing a restart from iteration 0.
3. CI is the gate, not a warning. A failing test or broken build must stop the loop immediately. Downstream iterations compounding on a broken foundation is the most expensive failure mode.
4. Stagnation detection prevents infinite loops. If the loop produces the same output for N consecutive iterations, terminate — it is not converging.
5. Each iteration is independently re-runnable. If iteration 5 fails, you should be able to restart at iteration 5, not iteration 1.

Loop Pattern Spectrum

Decision Matrix

Is the task a single focused change?
+-- Yes -> Sequential Pipeline
+-- No -> Is there a written spec/RFC?
         +-- Yes -> Need parallel implementation?
         |         +-- Yes -> RFC-Driven DAG
         |         +-- No -> Continuous PR Loop
         +-- No -> Need many variations?
                  +-- Yes -> Infinite Agentic Loop
                  +-- No -> Sequential Pipeline + De-Sloppify

Blocking Violations (NEVER)

Verification

Self-Verification Checklist

• MAX_ITERATIONS ceiling defined before loop starts
• Completion signal defined (what "done" looks like)
• CI gate configured (stops loop on failure)
• Stagnation detection in place (same output N consecutive times = stop)
• State persisted to disk between iterations
• Git checkpoint per iteration

Verification Commands

# Check iteration count
grep -rn "MAX_ITERATIONS\|max_iterations\|maxIterations" loop-script.sh

# Check completion signal
grep -rn "completion.txt\|DONE\|stop_condition\|complete_flag" loop-script.sh

# Check stagnation detection
grep -rn "stagnation\|same_output\|no_change\|consecutive_failures" loop-script.sh

# Verify git checkpoints
git log --oneline | wc -l

Quality Gates

Examples

Example 1: Sequential Pipeline

User request: "Set up an automated daily code review pipeline."

Skill execution:

1. Choose: Sequential Pipeline (single focused workflow)
2. Define steps: Plan -> Execute Review -> Generate Fixes
3. Each step independently re-runnable, passes context via files
4. Add MAX_ITERATIONS=1 (sequential, no loop needed)
5. CI gate: stop on failure

Result: Simple, reliable pipeline. Each step independently runnable.

Example 2: Edge Case - Loop Stagnation

User request: "Our PR loop keeps making the same change and undoing it."

Skill execution:

1. Check stagnation detector: not implemented
2. Loop was producing same output for 6 consecutive iterations
3. Add: detect if git diff output is identical to previous iteration
4. Terminate after 3 consecutive identical outputs
5. Escalate to human review

Result: Stagnation detected and escalated. Loop no longer wastes budget on zero-progress iterations.

Anti-Patterns

• Never start a loop without a MAX_ITERATIONS or token-budget ceiling because an unbounded loop with no termination condition will exhaust compute budget, context window, or API quota silently — sometimes incurring significant cost before anyone notices.
• Never skip persisting loop state to disk between iterations because in-memory state is lost on crash, timeout, or context compaction, forcing a restart from iteration 0 and wasting all prior progress.
• Never allow a loop to continue after a failing test or broken build because downstream iterations compound on a broken foundation, producing cascading failures that make root-cause analysis harder with each iteration.
• Never use a language model as the sole judge of its own output quality because the model that produced the output is systematically biased toward rating it as correct; a separate evaluator or deterministic test is required to catch the model's own blind spots.

Failure Modes

Performance & Cost

Model Selection

Token Budget

• State persistence overhead: ~100-300 tokens per iteration (state summary)
• Expected context usage: 2-5KB per loop design session
• When to context-optimize: When loops have 10+ iterations or span multiple files per iteration
• Use cost-aware-llm-pipeline for routing loop subtasks to appropriate model tiers

References

Internal Dependencies

• verification-loop — Used as exit gate for any autonomous loop
• writing-plans — Provides the spec that autonomous loops execute against
• cost-aware-llm-pipeline — Routes loop subtasks to appropriate model tier

External Standards

• DAG (Directed Acyclic Graph) — Foundation for Ralphinho pattern's task graph

Related Skills

• verification-loop — Exit gate for autonomous loops
• writing-plans — Input spec provider

Changelog