loop0
Method

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.

The loop

Foundation, then one verified loop at a time

you lead every review
The loop: foundation once, then mission, build, validate, human review and the next loop, which returns to a new mission.FoundationonceMissionevery loopBuildthe agentValidatethe agentHuman reviewyouNext loopyou + agentevery loop builds on what came before
Foundation

Vision, promise, standards: VISION.md, PRODUCT.md, ARCHITECTURE.md, LOOP.md

Mission

What this loop must do, criteria a person can check, saved before code

Build

The smallest complete increment; documents updated where it changed

Validate

Tests, then the real app, used as its user would

Human review

A checked report: you accept, ask for rework or mark it blocked

Next loop

Starts by re-running the checks; unfinished work carried over

Loop 0 → Loop 001

Who does what

one conversation in your terminal
Swimlanes: you, your agent and loop0. You give the idea; the agent validates and writes the brief; you answer and confirm the standards; loop0 renders the mission; you say go; the agent builds; loop0 checks the report; you accept.YOUYOUR AGENTLOOP0 MCPIdea/mcp__loop0__startValidatelinks, verdictAnswermax 3 questionsBriefdecisionsStandardsconfirm profileMissionrender_missionGoyou decideBuildcode, devlogReportvalidate_reportAcceptor rework
01 Validate

Search links, similar products (labelled when unverified), the angle, the riskiest assumption, a verdict. Never blocks you.

02 Develop

Objective, users, scope, out of scope, decisions with a status, at most three questions.

03 Standards

Stack, cloud, CI and standards from a preset, devlog included. They become fixed requirements.

04 Mission

loop0 renders Loop 001 from the brief; the agent saves loops/001-mission.md and waits for your go.

Every loop after that

The repository is the memory

  1. You type /mcp__loop0__next with what you want.
  2. The agent reads LOOP.md, the last mission and report in loops/, STATUS and BACKLOG.
  3. validate_report lists what was not finished: it is carried over, not forgotten.
  4. render_mission writes loops/002-mission.md, short, because LOOP.md holds the rules.
  5. You say go. The agent builds, writes the report and the devlog page. You accept.
Honest by structure

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 loop your agent runs — mission, build, verify, report — and around it what loop0 adds: you decide; the promise and experience criteria; standards and real use; a checked report and decisions; living docs and carry-over.
Before building
  • 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.

While building
  • 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.

After building
  • 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.

The next loop starts with
  • 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.

In practice

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.

Read the case study →

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.

Connect