Autoloop Controller

v1.0.0

When continuous automated improvement of a Skill is needed. Wraps improvement-orchestrator in a persistent loop with convergence detection (plateau/oscillati...

0· 101·0 current·0 all-time
by_silhouette@lanyasheng

Install

OpenClaw Prompt Flow

Install with OpenClaw

Best for remote or guided setup. Copy the exact prompt, then paste it into OpenClaw for lanyasheng/auto-autoloop-controller.

Previewing Install & Setup.
Prompt PreviewInstall & Setup
Install the skill "Autoloop Controller" (lanyasheng/auto-autoloop-controller) from ClawHub.
Skill page: https://clawhub.ai/lanyasheng/auto-autoloop-controller
Keep the work scoped to this skill only.
After install, inspect the skill metadata and help me finish setup.
Use only the metadata you can verify from ClawHub; do not invent missing requirements.
Ask before making any broader environment changes.

Command Line

CLI Commands

Use the direct CLI path if you want to install manually and keep every step visible.

OpenClaw CLI

Bare skill slug

openclaw skills install auto-autoloop-controller

ClawHub CLI

Package manager switcher

npx clawhub@latest install auto-autoloop-controller
Security Scan
VirusTotalVirusTotal
Benign
View report →
OpenClawOpenClaw
Benign
high confidence
Purpose & Capability
Name/description match the implementation: autoloop.py runs repeated improvement-orchestrator subprocesses, persists state, detects plateau/oscillation, and enforces cost/iteration caps. No unrelated binaries or secrets are requested.
Instruction Scope
SKILL.md and autoloop.py limit actions to launching the orchestrator as a subprocess, reading/writing local state/log files, computing scores, and writing handoff artifacts. There are no instructions to read unrelated system paths or to transmit state to external endpoints. The code does modify sys.path to locate sibling modules and expects a repo layout that includes lib.common and the improvement-orchestrator skill.
Install Mechanism
No install spec provided (instruction-only). Files are included in the skill bundle; nothing is downloaded from external URLs and no archive extraction/install steps are present.
Credentials
The skill itself declares no required environment variables or credentials, which is appropriate. Note: it invokes improvement-orchestrator (a separate skill) as a subprocess — that orchestrator or the LLM/evaluator it runs may require API keys or other credentials outside this bundle. Users should review the orchestrator/learner skills for any credential needs and ensure autoloop is run with a non-sensitive state-root path.
Persistence & Privilege
No always:true privilege; the skill writes state and logs to the user-provided state-root (expected behavior). It does not modify other skills' configs or global agent settings beyond creating files under the specified state directory.
Assessment
This skill appears to do what it claims: repeatedly run the improvement-orchestrator, persist state, and stop on convergence/cost limits. Before installing or running: 1) Verify the improvement-orchestrator and improvement-learner skills (invoked by this loop) and any LLM/evaluator they call — those components may require API keys or network access. 2) Provide a dedicated state-root (not a sensitive system directory) because autoloop writes logs, JSONL iteration logs, handoffs, and a persistent autoloop_state.json. 3) Use --dry-run to test loop logic and verify outputs, and set conservative --max-cost before running continuous/overnight jobs. 4) If you will schedule this via cron, ensure the cron user's environment has necessary credentials and that you accept the cost implications of automated runs.

Like a lobster shell, security has layers — review code before you run it.

latestvk97f6avmnghpmww60a2san6rzn8491a1
101downloads
0stars
1versions
Updated 3w ago
v1.0.0
MIT-0

Autoloop Controller

Wraps improvement-orchestrator in a persistent loop with convergence detection and cost control.

When to Use

  • Continuously improve a skill over multiple iterations (overnight runs)
  • Schedule periodic improvement cycles via cron
  • Run a fixed number of improvement iterations with automatic plateau detection

When NOT to Use

  • Single-shot improvement → use improvement-orchestrator
  • Only want scores → use improvement-learner
  • Only want baseline data → use benchmark-store

CLI

python3 scripts/autoloop.py \
  --target /path/to/skill \        # REQUIRED: skill directory to improve
  --state-root /path/to/state \    # REQUIRED: persistent state directory
  --max-iterations 5 \             # default 5: total iterations before stop
  --max-cost 50.0 \                # default 50.0: cost cap in USD
  --plateau-window 3 \             # default 3: consecutive no-improvement rounds → stop
  --cooldown-minutes 30 \          # default 30: delay between iterations in continuous mode
  --mode single-run \              # single-run | continuous | scheduled
  --dry-run                        # simulate without calling orchestrator
ParamDefaultWhen to change
--max-iterations5Raise to 20 for overnight runs; lower to 2 for quick tests
--max-cost$50.0Lower to $5 for testing; raise for production overnight runs
--plateau-window3Raise to 5 if improvements are slow but steady
--cooldown-minutes30Lower to 5 for rapid iteration; raise to 60 for rate-limited APIs
--dry-runfalseUse to test loop logic without running real orchestrator

3 Modes

ModeBehaviorExit Condition
single-runLoop through iterations, exit when termination hitmax_iterations / cost_cap / plateau / oscillation
continuousLoop with cooldown_minutes sleep between iterationsSame + Ctrl+C saves state gracefully
scheduledRun exactly 1 iteration then exitCron triggers next run; state persists in autoloop_state.json

Termination (4 conditions, OR logic)

  1. max_iterations reached
  2. cost_cap exceeded (rough estimate: ~$0.10/min of LLM time)
  3. Score plateau: weighted_score no improvement for plateau_window consecutive rounds
  4. Oscillation: keep-reject alternating pattern detected over 4-round window

Cross-Session State

State persists in {state-root}/autoloop_state.json (dataclass → JSON):

{"schema_version": "1.0", "target": "/path/to/skill",
 "iterations_completed": 3, "max_iterations": 5,
 "total_cost_usd": 1.23, "max_cost_usd": 50.0,
 "score_history": [{"iteration": 1, "weighted_score": 0.72, "decision": "keep"}, ...],
 "plateau_counter": 1, "status": "running"}

Resume a stopped run: just re-run the same command — AutoloopState.load() picks up from where it left off.

Output Artifacts

  • handoffs/iteration-N.md — per-iteration handoff with Decided/Rejected/Scores/Remaining sections for cross-iteration context survival
  • iteration_log.jsonl — one JSON line per iteration: {"iteration": 1, "decision": "keep", "weighted_score": 0.72, "cost_usd": 0.15, "candidate_id": "cand-01-docs"}
  • autoloop_state.json — full serialized state for cross-session resume
<example> Run 5 iterations with cost cap: $ python3 scripts/autoloop.py --target /path/to/skill --state-root ./state --max-iterations 5 --max-cost 10.0 → --- Iteration 1/5 --- → Decision: keep Weighted score: 0.7200 Cumulative cost: $0.1500 → --- Iteration 2/5 --- → Decision: keep Weighted score: 0.7800 Cumulative cost: $0.3100 → --- Iteration 3/5 --- → Decision: keep Weighted score: 0.7800 Cumulative cost: $0.4600 → Stopped: plateau detected (no improvement in last 3 iterations) → State saved: ./state/autoloop_state.json </example> <anti-example> Running continuous mode without checking cost cap: $ python3 scripts/autoloop.py --target /path/to/skill --state-root ./state --mode continuous --max-cost 50.0 → Default $50 cap applies. For overnight runs, explicitly set --max-cost. → Always verify cost cap BEFORE launching continuous mode. </anti-example>

Error Handling

  • Orchestrator subprocess failure: state.status = "error", stderr saved to last_failure_trace, loop exits
  • KeyboardInterrupt (Ctrl+C): state saved as status=completed, graceful exit
  • Unhandled exceptions: traceback saved to last_failure_trace, status=error, exit code 1

Related Skills

  • improvement-orchestrator: Single pipeline run (called as subprocess each iteration)
  • improvement-learner: Provides dimension scores consumed by _load_latest_scores() for weighted_score computation
  • benchmark-store: Pareto front data for convergence tracking

Comments

Loading comments...