Coding agents work the loop. You hold the gate.

Loopgate runs the workflows you draw — plan, build, check, review, fix, pull request — on the Claude Code, Codex and pi you already use. Every step is a conversation you can steer, every loop stops at its limit, and every gate waits for you.

One email when your invite is ready. No newsletter.

Runs on Claude Code Codex pi

The desktop app, running in your browser on example data. Click a station, answer the gate, add a step.

How a run goes

From task to pull request, one station at a time.

This is plan-build-review, one of eight workflows Loopgate ships. Agents work the blue stations; the brass ones wait for you.

  1. task
    your task

    Say what you want done.

    Write the task once. Every step's message opens with it, word for word, and files you attach travel with it to every step. Hand it to one agent, pick a workflow, or let the copilot suggest one. Nothing starts until you say so.

    Add rate limiting to the public API and cover it with tests.

    ledger-api main plan-build-review · 4 agents Attach Run
    The Tasks composer. The first step reads this verbatim.
  2. plan
    Planner · Claude Code
    lock
    you lock the plan

    Lock the plan before a line is written.

    The planner reads the repository first, then asks you only what it can't look up, each question with a recommended answer. The plan is a document: edit it, compare versions, lock it. The builder works from what you locked.

    Needs you · Lock

    Lock PLAN.md v2?

    # Rate limiting for the public API

## Decisions
1. Per API key, not per IP (you chose this)
2. Counters in Redis, which the queue already uses
3. 100 requests a minute, bursts of 20

## Change map
- src/middleware/rate-limit.ts — the limiter
- src/app.ts — mount it before the public routers
    Lock v2 Request changes
    Version 2 carries your edit to the burst size.
  3. build
    Builder · Codex

    Every step on the engine that suits it.

    Plan on Claude Code with Opus thinking hard, build on Codex, review with another model again. Each step picks its engine, its model and how long it thinks, and carries its own permissions: read only, workspace access, or full access you turned on for that step.

    Each step's engine, model, thinking level and permissions
    Step Engine Thinking Access
    plan Claude Code · opus high Read only
    build Codex · gpt-5.5 medium Workspace
    review Claude Code · opus xhigh Read only
    fix Codex · gpt-5.5 medium Workspace
    Levels come from each harness, per model. Nothing is guessed or downgraded.
    1. test
      runs verify

      Pass or fail is a command, not an opinion.

      A check runs the command your repository declares — pnpm verify, make test, whatever you use — and its exit code routes the run. No agent gets to decide its own work passed. 

      $ pnpm verify
✓ lint        0 problems
✓ typecheck   0 errors
✗ test        1 failed · 211 passed

  rate-limit.test.ts › a burst gets 429
    expected header retry-after, got none

fail → fix  round 1 of 2
      Declared once in .loopgate/repo.yaml.
    2. review
      Reviewer · Claude Code
      fix
      Fixer · Codex

      Loops that know when to stop.

      The reviewer ends with a verdict and the edges do the routing: approve moves on, changes requested goes to the fixer. Every loop has a limit, drawn on the track as round 2 of 2. When it runs out, the run asks you instead of trying forever.

      review · round 1 handed off to fix changes requested

      Two findings before this can ship.

      1. High — src/middleware/rate-limit.ts:41: the count and its expiry are two calls, so a crash between them locks a key out for good.
      2. Medium — no test covers two instances sharing one Redis.

      Verdict: changes_requested

      saved as REVIEW.md$0.41
      The whole handoff is the step's last message. Nothing is summarised.
  5. decide
    you decide

    Your decisions, with the evidence beside them.

    Choices, approvals, locks and questions wait in Needs you, each with what it is about: the review, the diff, the checks. Answer in a click, or take the branch over in your own terminal.

    Review finished or the round budget was used. Choose what happens next.

    decide

    Open PR One more round Take over in terminal
    Every gate asks the smallest decision, and records who made it.
  6. ship
    opens a draft PR

    A draft pull request that shows its work.

    The branch opens as a draft pull request with the locked plan and the last review in its body. Every step's conversation stays on your machine, readable end to end.

    Draft Add rate limiting to the public API #214

    +212 −9 · 6 files · add-rate-limiting-to-the-public-api → main

    Plan · locked v2

    Per API key, counters in Redis, 100 requests a minute with bursts of 20.

    Review · round 2

    Both findings are fixed. Nothing blocking remains. Verdict: approve.

    The body comes from the plan and the review, as they were written.

Workflows

Start from one that works. Draw your own.

Eight workflows ship built in. Open one in the builder, swap an engine, add a check, bend a loop back, and the readback says in plain words what it will do. Or describe what you want and the copilot drafts it on the canvas.

Also built in: one-agent, a single conversation on your workspace, and readiness-scan, which proposes the files that make a repository easy for agents to work in — and writes nothing until you have read each one.

For teams

Shared workflows and a ledger. Never the code.

Publish a workflow to your org and it lands on every teammate's shelf within the hour. Set policy once — which engines, which commands are banned, whether full access is allowed — and every installation enforces it when a run starts and at each decision.

Runs report back as metadata: who ran which workflow, how it ended, what it cost, how long decisions waited. Your code, diffs, prompts and transcripts stay on the laptops that made them.

  • Engines Claude Code, Codex
  • Banned git push --force terraform apply
  • Full access Not allowed
  • Step summaries Off

Reported window

The last seven days

succeeded failed cancelled or taken over

38runs finished

$84.20estimated spend

51decisions made

Where the money went

plan-build-review$52.10

build-fix$22.75

security-audit$9.35

Who is running them

priya16

tomas13

mei9

Reported by each installation when a run ends. The control plane never receives code, diffs, prompts, transcripts or the task.

Promises

What Loopgate never does.

Questions

Before you join.

Which coding agents does it run?

Claude Code, Codex and pi: the versions installed on your machine, signed in with your own accounts. Each step can use a different one, with its own model and thinking level.

Where does the work happen?

On your machine. A run works in a worktree of your repository, and your agents talk to their providers exactly as they do today; Loopgate puts no server in between. The team portal, if you use it, receives run metadata and nothing else.

Is there a command line?

Yes. loopgate run plan-build-review "Add rate limiting" runs headless, and loopgate decide answers a gate. The desktop app and the CLI share one daemon, so a run started in one shows up in the other.

Can it run without me watching?

As far as you let it. A step on Auto hands off and moves on; a step on Interactive waits for you after each turn. A gate you place always waits, and every run has a spending ceiling: $50 unless you set another.