Guide · Agent skill
How to use the Continuous Agent Loop agent skill
Updated · written with AI from the project's own documentation and checked against our catalogue data
continuous-agent-loop is an agent skill from the ECC skill collection that teaches an AI agent how to run long, self-driving work sessions that repeat steps until a task is done. This guide explains what the skill changes in the agent's behaviour, how to install it, how to ask for it in plain language, and what to watch for. The source file is written in Japanese; this guide describes its contents in English. By the end you will know which loop style fits a task, what the skill's failure modes and recovery steps are, and what the skill needs before you rely on it.
Continuous Agent Loopaffaan-m/ECC · MIT Download the skill Quick start
- 1Download the ZIP. Get the skill ZIP from the directory page.
- 2Unzip into the skills folder. Unzip it into ~/.claude/skills/ for personal use, or into a project's .claude/skills/ folder for one project.
- 3Or upload in the Claude apps. If you use the Claude apps, go to Settings → Capabilities → Skills and upload the skill.
- 4Install the companion skills. Install ralphinho-rfc-pipeline, plankton-code-quality, eval-harness and nanoclaw-repl if you want the full stack, since they are not in this file.
- 5Describe the task as a loop. Ask for the work as a checked, repeating loop and state the stopping condition.
- 6Pick the loop style. Use continuous-pr for CI or PR control, rfc-dag for RFC decomposition, infinite for exploratory parallel generation, and sequential otherwise.
- 7Watch for failure modes. If progress stalls or retries repeat, freeze the loop, run /harness-audit, narrow scope and replay with acceptance criteria.
What the continuous-agent-loop skill makes the agent do
Normally an AI agent answers once and stops. This skill gives the agent a pattern for working in a loop: it repeats steps, checks its own output, and keeps going until the task is complete. The skill's description names three ideas: quality gates, evaluations, and recovery controls.
The skill is also the standard loop skill name in the collection and is meant to replace the older autonomous-loops name, which it stays compatible with for a transition period.
- Chooses a loop style for the task (sequential, PR-focused, RFC-decomposition, or exploratory parallel generation).
- Suggests a production stack that combines RFC decomposition, quality checks, evaluation loops and session persistence.
- Lists common failure modes, such as loop churn with no measurable progress and repeated retries on the same root cause.
- Gives a recovery procedure: freeze the loop, run a harness audit, narrow scope to the failing unit, and replay with explicit acceptance criteria.
Install the skill from the ZIP or the Claude apps
Download the ZIP for the skill from the directory page. Unzip it into one of two locations. Use ~/.claude/skills/ to make the skill available across your projects, or use a project's .claude/skills/ folder to make it available only in that project.
If you use the Claude apps instead of a local folder, open Settings, go to Capabilities, then Skills, and upload the skill there.
- Personal install: unzip into ~/.claude/skills/.
- Project install: unzip into the .claude/skills/ folder inside your project.
- App install: Settings → Capabilities → Skills, then upload.
~/.claude/skills/Choose the right loop style
The skill includes a decision flow. Start with the question on each branch and take the first 'yes'. If none applies, the default is the sequential loop.
Use the PR-focused loop (continuous-pr) when you need strict CI or pull request control. Use the RFC-decomposition loop (rfc-dag) when the work starts from an RFC that must be split up. Use the infinite loop when you want exploratory parallel generation. Otherwise, use sequential.
- Strict CI or PR control → continuous-pr
- RFC decomposition needed → rfc-dag
- Exploratory parallel generation → infinite
- Anything else → sequential
Set up the production stack and quality checks
For a full setup, the skill recommends four layers in order. Each layer names a companion skill, so those skills must be installed separately. This file does not contain them.
The quality gate layer uses the plankton-code-quality skill together with the /quality-gate command. Recovery uses the /harness-audit command.
- 1. RFC decomposition: ralphinho-rfc-pipeline
- 2. Quality gates: plankton-code-quality plus /quality-gate
- 3. Evaluation loop: eval-harness
- 4. Session persistence: nanoclaw-repl
/quality-gate
/harness-auditAsk for the loop in natural language
You do not need a special command to use the skill. Describe the work and say that you want it done as a checked, repeating loop. The agent can then select this skill when its description matches your request. Name the loop style if you already know it, and state what done means, so the loop has an acceptance condition to test against.
Good requests say what the task is, what the checkpoints are, and when to stop. Vague requests are more likely to produce a loop that repeats without progress.
- Example: Work through this multi-step refactor as a sequential loop with a quality gate after each step. Stop when all tests pass.
- Example: Use the PR-focused loop to fix the failing CI checks on this branch. Stop after three attempts and report what is still failing.
- Example: Split this RFC into units with a decomposition loop, then implement each unit with checks. Do not start a unit until the previous one passes its acceptance criteria.
Recognise failure modes and recover
The skill names four failure modes to watch for. Loop churn means the agent keeps looping without measurable progress. Repeated retries mean it tries the same fix for the same root cause. A stalled merge queue stops the pipeline. Cost drift means spending grows because the escalation has no limit.
When something goes wrong, follow the recovery order in the skill. Freeze the loop first so it stops spending. Run the harness audit. Narrow the scope to the failing unit. Replay with explicit acceptance criteria written down.
- Freeze the loop.
- Run /harness-audit.
- Narrow scope to the failing unit.
- Replay with explicit acceptance criteria.
What people use it for
- Working through a multi-step coding task with a checkpoint after each step.
- Fixing failing CI checks on a pull request with a capped number of attempts.
- Breaking an RFC into units and implementing each one against its own acceptance criteria.
- Generating several candidate solutions in parallel for exploration, then keeping the ones that pass checks.
Frequently asked questions
How do I install the continuous-agent-loop skill?
Download the ZIP from the directory page and unzip it into ~/.claude/skills/ for personal use, or into a project's .claude/skills/ folder. In the Claude apps, you can instead upload it under Settings → Capabilities → Skills.
Is continuous-agent-loop free to use?
The source file is licensed under MIT. Check the license file in the repository for the full terms before you use or redistribute it.
Does the skill run scripts or use the network?
The skill file itself does not run scripts and does not use the network. The companion skills and commands it refers to may have their own behaviour, so review them before installing.
Do I need other skills for it to work?
The pattern refers to ralphinho-rfc-pipeline, plankton-code-quality, eval-harness and nanoclaw-repl, and the /quality-gate and /harness-audit commands. These must be installed separately for the full stack. Without them, you still get the loop-style selection and failure-mode guidance.
What is the difference between continuous-agent-loop and autonomous-loops?
continuous-agent-loop is the standard name for this loop skill, and it replaces autonomous-loops while staying compatible with it for a transition period. New setups should use continuous-agent-loop.
Can the loop run up costs?
Yes. The skill lists cost drift from unlimited escalation as a failure mode. The file describes this risk but does not enforce any spending limit, so set your own limits before running unsupervised loops on production systems.
New agent skills, repos and AI tools — every week
The best new skills and open-source projects, the fastest-growing repos, and one free prompt. Five minutes to read. Unsubscribe anytime.
Our verdict
Use this skill if you want an agent to work through multi-step coding tasks with checkpoints, or to run PR or CI-driven workflows with guardrails, and you already use or will install the ECC companion skills. Skip it for simple questions or small edits, where a loop only adds overhead, and do not rely on it alone for unsupervised production work, because it does not enforce spending limits itself.
Download the skill