loop-engineer

---

What it does

You describe a goal in one or two sentences — any goal. The skill researches the problem space, discovers every available resource (MCPs, skills, APIs, datasets, local tools), plans atomic tasks, assembles a team of specialists tailored to the domain, then executes fully autonomously until every task passes verification or the budget runs out. No further user input needed after the two setup questions.

Works for any objective: software development, research papers, data analysis, content creation, automation pipelines, system configuration, or anything else.

What makes it different from a single-agent prompt:

• Domain-agnostic by design — no hardcoded task types or procedures. Agents derive their behavior from the goal. The same framework that builds a web service can write a research report or configure a data pipeline.
• Self-assembling agent team — after planning, an agent-factory creates 1–3 specialized agents tuned to the specific goal domain and writes an AGENTS.md manifest. Executors check this and use specialists when available. If generic agents are sufficient, factory creates nothing.
• Resource scout runs before everything — discovers MCPs, skills, local tools, APIs, and datasets relevant to the goal. Writes a usage guide with exact callable names and invocation syntax so executors never have to guess.
• Researcher runs before every executor pass — the executor never acts blind. The researcher consults a 33-category knowledge-sources directory to find the right research channels for the goal domain, then prioritizes finding existing tools, MCPs, libraries, and APIs before planning how to build. Writes structured findings for two audiences: executor (how to do it) and verifier/auditor (verification criteria and quality standards).
• Memory accumulates across tasks and loops — each completed task distills learnings into MEMORY.md. The .global/MEMORY.md persists across all loops in the project so the agent gets smarter over time.
• Fully autonomous failure handling — 3 verifier failures → auto-skip; auditor BLOCK → auto-fix once then skip. Never pauses for user input.

---

Supported platforms

All entries below confirmed against each vendor's own current documentation (fetched directly, not secondhand).

Platform	Skill	Agent dispatch	Parallelism
Claude Code	/loop-engineer	Agent tool	✅ true parallel — call it N times in one response
Cursor	/loop-engineer	Task tool	✅ true parallel — confirmed via cursor.com/docs/subagents: multiple Task calls in one message run simultaneously
Antigravity CLI (agy)	/loop-engineer	invoke_subagent	✅ true parallel — confirmed via antigravity.google/docs/subagents: each call returns immediately (async background execution), so calling it N times back-to-back dispatches N concurrent subagents. No "Subagents array" parameter exists. Nesting capped at 10 levels.
Antigravity IDE (VS Code / JetBrains)	/loop-engineer	invoke_subagent	✅ true parallel (see above)
Antigravity 2.0 (desktop)	/loop-engineer	invoke_subagent	✅ true parallel (see above)
Hermes Agent	/loop-engineer	delegate_task(tasks=[...])	✅ true parallel — one call, array of task definitions, synchronous (blocks until all return). Default cap of 3 concurrent (delegation.max_concurrent_children, floor 1, no ceiling)
Gemini CLI	/loop-engineer	named agent tools (@agent-name)	✅ true parallel (v0.36+, confirmed via developers.googleblog.com) — official caveat: avoid parallel subagents for heavy concurrent code edits (file conflict risk)
OpenCode	/loop-engineer	task tool	⚡ sequential — still unresolved as of writing. Original bug (#14195) was closed, but sequential dispatch was reported again in a newer issue (#29638) with fix PRs open as of late May 2026; check that issue for current status
OpenAI Codex CLI	/loop-engineer	spawn_agent	✅ true parallel — enabled by default on current releases (no feature flag needed; older versions may need features.multi_agent = true). Default cap of 6 concurrent (agents.max_threads), nesting capped at depth 1 (agents.max_depth)
VS Code GitHub Copilot	attach loop-engineer.prompt.md	agent/runSubagent tool	✅ true parallel — confirmed via code.visualstudio.com/docs/agents/subagents: phrase a batch as "Run these N subagents in parallel" and they run concurrently. Nesting disabled by default (enable via chat.subagents.allowInvocationsFromSubagents, max depth 5)

---

Install

Plugin system — Claude Code (recommended, auto-updates)

claude plugin add https://github.com/vibhasdutta/loop-engineer

One-liner — macOS / Linux (Claude Code)

curl -s https://raw.githubusercontent.com/vibhasdutta/loop-engineer/main/install.sh | bash

Manual — macOS / Linux

git clone https://github.com/vibhasdutta/loop-engineer.git
cd loop-engineer
bash install.sh              # Claude Code (default)
bash install.sh --cursor     # Cursor
bash install.sh --gemini     # Gemini CLI
bash install.sh --antigravity # Antigravity (CLI + IDE + 2.0)
bash install.sh --opencode   # OpenCode
bash install.sh --hermes     # Hermes Agent
bash install.sh --codex      # OpenAI Codex CLI
bash install.sh --copilot    # VS Code GitHub Copilot
bash install.sh --all        # all platforms

Manual — Windows (PowerShell)

git clone https://github.com/vibhasdutta/loop-engineer.git
cd loop-engineer
.\install.ps1              # Claude Code (default)
.\install.ps1 -Cursor      # Cursor
.\install.ps1 -Gemini      # Gemini CLI
.\install.ps1 -Antigravity # Antigravity (CLI + IDE + 2.0)
.\install.ps1 -OpenCode    # OpenCode
.\install.ps1 -Hermes      # Hermes Agent
.\install.ps1 -Codex       # OpenAI Codex CLI
.\install.ps1 -Copilot     # VS Code GitHub Copilot
.\install.ps1 -All         # all platforms

→ Full installation guide with per-platform verify steps

---

Quick start

Claude Code / Cursor — open any project and type:

/loop-engineer

Gemini CLI — describe a multi-step goal (auto-activates) or use the shortcut:

/loop-engineer

Antigravity — in agy, IDE, or 2.0, describe a goal or type:

/loop-engineer

OpenCode — open any project and type:

/loop-engineer

Hermes Agent — type the slash command or describe a multi-step goal:

/loop-engineer

Codex CLI — open Codex and type:

/loop-engineer

This scaffolds the state files and prints a /goal command to paste for the actual loop run.

VS Code GitHub Copilot — after installing:

1. From your project root, run the init command printed by install (or run init-loop.sh --platform copilot directly).
2. Open Copilot Chat, switch to Agent mode.
3. Attach .github/prompts/loop-engineer.prompt.md via #loop-engineer.prompt and describe your goal.

The wizard asks 3 questions only (mode is skipped if passed as an argument, e.g. /loop-engineer patch):

Q1. Mode? build / research / patch / audit
Q2. What do you want the loop to accomplish? (1–2 sentences)
Q3. Auto-commit after each verified task? (yes / no)

Everything else is automatic — LOOP_ID, stop condition, budget, context gathering, task decomposition, resource discovery, agent assembly, and the full execution loop.

Modes:

Mode	What it does
build (default)	New work from scratch — the full pipeline below, unchanged.
patch	Fixes or extends the existing codebase instead of building greenfield — same pipeline, but every researcher/executor is told the existing code is ground truth: read it first, then fix or extend it.
research	Investigate and report only — no code changes. Skips the build and audit steps; the researcher writes each task's final deliverable directly, and the verifier checks that against the stop condition.
audit	Review only — no code changes. Skips the build step; the auditor's review of existing code/output is the task, with findings written to RESEARCH.md instead of triggering an auto-fix.

---

How it works