Your agent thinks.
loop0 gives the structure.
A loop is one mission for your coding agent: built, checked, documented and reported, then accepted by you. Loop 0 is the first conversation: it turns an idea into Loop 001. loop0 is an MCP server that serves the method, renders every mission and checks every report.
Foundation, then one verified loop at a time
Vision, promise, standards: VISION.md, PRODUCT.md, ARCHITECTURE.md, LOOP.md
What this loop must do, criteria a person can check, saved before code
The smallest complete increment; documents updated where it changed
Tests, then the real app, used as its user would
A checked report: you accept, ask for rework or mark it blocked
Starts by re-running the checks; unfinished work carried over
Who does what
Search links, similar products (labelled when unverified), the angle, the riskiest assumption, a verdict. Never blocks you.
Objective, users, scope, out of scope, decisions with a status, at most three questions.
Stack, cloud, CI and standards from a preset, devlog included. They become fixed requirements.
loop0 renders Loop 001 from the brief; the agent saves loops/001-mission.md and waits for your go.
The repository is the memory
- You type
/mcp__loop0__nextwith what you want. - The agent reads LOOP.md, the last mission and report in loops/, STATUS and BACKLOG.
- validate_report lists what was not finished: it is carried over, not forgotten.
- render_mission writes loops/002-mission.md, short, because LOOP.md holds the rules.
- You say go. The agent builds, writes the report and the devlog page. You accept.
What loop0 enforces
- A test is passed only if it was run and seen to pass; otherwise not_run, and it carries over.
- Only you confirm decisions and accept a loop. Status fields from the agent are ignored and flagged.
- Rejected choices stay rejected: a mission line that needs one is flagged before you see it.
- Loop 001 never deploys, applies infrastructure or changes remote settings.
- The mission is saved before building and never edited after; changes go in the report.
The structure that makes the next loop better.
Your agent writes the code either way. loop0 adds what an agent forgets between sessions: intent, proof and memory.
- The promise, and what it makes mandatory
- Experience criteria for the key journeys
- Decisions with a status: confirmed, proposed, assumed
- The mission saved in loops/ before any code
The agent builds what the user meant, not the least that passes. Nothing important is cut by accident, and the next loop knows what was decided and by whom.
- The smallest complete increment
- The app tried for real, as its user will: a browser for the web, the window for a desktop app or a game
- Documents updated only where the change touches them
Bugs only real use shows are caught now, not by users. Documents stay true without being rewritten.
- A report checked by loop0: tests with evidence, not_run declared
- Unfinished work listed, never hidden
- A devlog page with what changed and the screenshots
You decide from facts. What was not done is written down, so it cannot be forgotten.
- Re-running the previous loop’s checks
- Reading LOOP.md, PRODUCT.md, ARCHITECTURE.md — not a chat history
- The unfinished items carried into the new mission
Each loop starts from a verified state and a written memory. That is what makes the tenth loop as solid as the first.
A barber shop booking, built twice by the same coding agent over three requests, once on its own and once with loop0: what the structure changed in intent, checking, memory and the human’s place.
FAQ
Why no AI on loop0’s side?
Your coding agent is already a strong model, and it sees your real repository. A second model in a browser only added cost, waiting and copy-paste. loop0 gives the agent what it lacks: a method and a structure that do not drift from one session to the next.
What does loop0 check, then?
Shape and consistency, never the code. render_mission refuses a brief without scope or acceptance criteria and flags lines that need a rejected choice. validate_report flags tests marked passed without evidence, “all tests pass” with failures, and any attempt by the agent to accept its own loop.
Where is my project stored?
In your repository: LOOP.md, loops/ (missions and reports) and devlog/. loop0 keeps nothing of it: a request is answered and its content forgotten. It only counts that a call happened.
Does it work with my agent?
Any agent that supports remote MCP servers over Streamable HTTP: Claude Code, Codex, Cursor, VS Code and others. Prompts show up as slash commands where the agent supports them; otherwise ask the agent to call loop0_guide with step "start".
Do I have to use loop0 for every loop?
No. LOOP.md works on its own: an agent without loop0 can still follow it. loop0 adds the guides, the mission renderer and the report checks.
What is the devlog?
One self-contained HTML page per loop in devlog/: your words, what changed, screenshots, checks, what is left. It is a standard, on in every preset, and it must say the same thing as the report.
Is it free?
Yes. There is no model to pay for. A per-network rate limit keeps the server responsive for everyone.
Ready for Loop 0?
Add loop0 to your agent and start with your idea.