LoopEngineer is the control plane for autonomous coding. Point it at a GitHub repo, design a Workflow, and Workers pull ready issues, open PRs, and review each other’s work — on a harness with the best practices already built in.
No card required · Bring Codex or Claude · Your repo stays untouched
Works with the repos you already have.
There’s always more ready work than hands to do it. The backlog grows; the agents you could point at it don’t exist yet.
Spinning up a reliable autonomous agent — worktree isolation, atomic claims, maker/checker review, retries, backoff, never auto-merge safety — is its own engineering project.
LoopEngineer is that project, finished. You design the Loop; the harness handles the rest.
LoopEngineer isn’t another chat window. It’s the control plane — recurring dispatches, isolated Workers, gated review, and one Board to drive it all.
A Loop runs one Workflow — a graph of Nodes you design. Start from a built-in (Implement, Review PR, Implement → Review) or wire your own in the Workflow builder, then save Project and runtime settings as a reusable configured Loop. Trigger it from an event or run it manually against selected work.
Configured Loops are ready when work arrives. Start one manually against a selected issue, or let a Trigger create a Run from a validated event payload. Wake up to visible Runs, not hidden automation.
Every change is implemented by one Worker and reviewed by another — on a different model. LoopEngineer never auto-merges. Review is operator-gated; you stay the final word.
Isolated worktrees, atomic claims, retries, backoff, cooldowns, and a bundled agent kit of generic workflow skills — injected only into Worker worktrees. The reliability engineering is already done, so you spend your time on the work, not the harness. Out of the box.
A live lifecycle Board — Blocked → Ready → In progress → In review → Reviewed — pulled straight from GitHub. Every card shows its Worker and Run history. Drive it from your laptop or your phone.
Runtime state lives off to the side, never in your main checkout. Workers run in throwaway worktrees with a kit injected only there. Bring Codex or Claude; keep your repo exactly as you left it.
Work through a freeform brief in a live planning session, publish an operator-confirmed PRD plus ready child issues, then hand those issues to Launch as explicit work scope.
Every Loop runs one Workflow — a graph of Nodes you draw on a canvas. A Node is just an agent plus instructions; an edge is a dependency. Chain them in sequence, fan out to run in parallel, join them back, and gate the merge. Roles are presets — the graph is yours.
An edge is a dependency: a Node runs only once every inbound Node has finished, and its Worker receives their output as input. Worker Nodes run an agent in an isolated worktree; action Nodes — merge, close — run a Control action instead.
One Worker turns a ready Issue into a PR.
One Worker reviews an open PR and posts findings.
The default: make it, then a second model checks it.
Add gated action Nodes to merge and close on green.
Fan out to parallel reviewers, then a Fix Node joins them.
Drag Nodes, pick agents, write instructions, connect.
Codex, Claude, Cursor, opencode, Kimi or Gemini — chosen per Node, with its own Model and Effort.
implement, review and fix seed a Node’s icon, agent, and prompt — then you edit freely.
Drop a Node with your own instructions and Skill bundle. No preset required.
merge and close run a Control action instead of a Worker, gated on your rules.
Three steps to a backlog that clears itself. Nothing is written to your checkout; you stay the final word on every merge.
Pick a GitHub Project. LoopEngineer reads your issues, base branch, and ready label — nothing is written to your checkout.
Build a Workflow from Nodes — each Node an agent with its own instructions — then create a Loop that binds that Workflow to a Project and runtime configuration.
Start a Loop Run manually against selected work, or let a Trigger create one from an incoming event. Watch the Board; merge when you’re ready.
A Loop Run starts from selected work or a validated Trigger payload, then records a clear state as it moves through Workers. The control plane runs on an always-on Server, so you can drive it from a laptop or your phone.
Point LoopEngineer at your repo, design a dispatch, and let coding Workers clear your ready column around the clock — safely, on a harness that already has the best practices built in.