What is loop engineering?

Loop engineering is the practice of designing the system that prompts an AI agent — its trigger, instructions, guardrails, verification, state, and logging — rather than prompting it by hand.

What is an agent loop?

An agent loop is a system that repeatedly runs an AI agent toward a specified outcome without a human driving each run. Every production loop declares six parts: a heartbeat, a body, a spine, a stopping condition, a checker, and a human gate.

What is a heartbeat in an agent loop?

A heartbeat is the trigger that starts one iteration of a loop. It can be in-session, conditional (run-until-done), scheduled, or event-driven.

What is the spine of a loop?

The spine is a loop's durable state between runs, usually a state file. An interrupted loop with a spine resumes where it stopped; a loop without one restarts from the beginning.

Why should a loop never check its own work?

Because maker and checker must be separate. A checker is the independent reviewer of a loop's output; if the loop grades itself, a confidently wrong result passes unchallenged.

When does an agent loop stop?

A loop stops on one of three machine-checkable conditions: success when the stopping condition is met, limit when the run cap is hit, or no-progress when nothing has changed for N beats. Feeling done is not a stopping condition.

Is the Loop Engineering Crash Course free?

Yes. The full curriculum, all 20 starter kits, the graded labs, and the Loop Ready certification are MIT licensed and free to use.

Agents that run on a heartbeat

Loop Engineering: Build Agents That Run Themselves

Stop prompting. Start looping.

A hands-on crash course in loop engineering — building agents that run on a heartbeat, checked by a second pair of eyes, and gated by a human who stays the engineer.

Start the course Browse the repo

MIT · 6 parts · 20 starter kits · 11 projects

loop-kit — daily-triage

npx @loop-engineering/loop-kit daily-triage

fetching @loop-engineering/loop-kit — no clone · no global install

scaffolding daily-triage into ./ — Node 18+, nothing else

loops/daily-triage/

LOOP.md — the definition — six parts, prompt, stops

daily-triage-state.md — the spine — commit before beat 1

loop-budget.md — caps + the 80% tripwire

loop-constraints.md — the constitution

loop-run-log.md — append-only, one line per beat

.claude/

skills/daily-triage/SKILL.md — the procedure

agents/loop-verifier.md — the read-only checker

Loop Ready ████████████ L1 · report-only

First loop command:

/loop 1d Run loop-triage. Update STATE.md. No auto-fix in week one.

done · 7 files · Node 18+ · no clone required

Anatomy of a loop

What one loop looks like

A loop is not a prompt you re-send. It's a cycle that schedules itself, does the work in isolation, gets graded by a second pair of eyes, and stops at a human. Then it beats again.

01 Schedule
The heartbeat fires — a timer, a condition, or an event.
02 Load state
Read STATE.md and the run log — what survived the last beat.
03 Triage
Pick the next unit of work, or stop if there's none.
04 Worktree
Isolate the run in its own checkout so nothing collides.
05 Implement
The maker agent does the work inside the worktree.
06 Verify
A separate checker grades it — never the maker itself.
07 Human gate
A person approves, escalates, or rejects the change.
08 Commit
Apply over MCP, append one line to the log — then beat again.

The six parts

Drop any one and the loop earns a familiar failure name — no heartbeat and it's a script you run by hand; no checker and it grades itself; no human gate and it ships with no owner.

Heartbeatpulse: When does a beat start?
Bodyhands: What may it do and touch?
Spinememory: What survives between beats?
Stopping conditionfinish line: How does it provably end?
Checkersecond pair of eyes: Who grades the work?
Human gatesignature: Where does a person decide?

Building blocks

The primitives you compose

Six moving parts. Learn each on its own, then wire them into a loop that runs without you.

Architecture

How a loop is built up

The same five layers under every loop. A human designs the top; work descends to real tools at the bottom; results climb back up to the gate.

L0
Human
Design the loop, hold the gate, review the diffs.
The engineer
L1
Control plane
Scheduling, pattern selection, and budget caps.
Heartbeat
L2
Durable memory
STATE.md, LOOP.md, and the run log — carried between beats.
Spine
L3
Execution
Worktrees and the maker / checker agents doing the work.
Body
L4
Tooling
CLIs and MCP connectors — the hands that touch real systems.
Hands

Three rungs of autonomy

Every loop starts on the bottom rung and earns its way up. You decide how far.

L1Report-only
The loop looks and tells you. It writes findings; a human makes every change.
Where triage-loop runs.
L2Assisted
The loop proposes and drafts — one small change at a time — and waits at the gate.
Small auto-wins after week one.
L3Unattended
The loop runs to completion on its own, stopping only when done or stuck.
Where build-loop runs — still human-gated on deploy.

Patterns

Production patterns, ready to fork

Six loops that already earn their keep. Each ships as a write-up plus a starter kit you can fork today.

Pattern	Cadence	Risk	What it does	Links
PR Babysitter	On PR events	medium	Shepherds a PR through review, CI, and rebase. The human stays in the merge seat.	Pattern →Starter kit →
Daily Triage	Daily	low	A morning scan of CI, issues, and commits. Report-only in week one, small auto-wins after.	Pattern →Starter kit →
CI Sweeper	On CI failure	medium	Reacts to a failing check with the smallest fix that passes it. Escalates after three tries.	Pattern →Starter kit →
Dependency Sweeper	Weekly	medium	Opens one PR per upgrade, reads the changelog, and flags anything that needs a human look.	Pattern →Starter kit →
Issue Triage	On new issue	low	Labels, dedupes, and routes a new issue before anyone on the team has seen it.	Pattern →Starter kit →
Changelog Drafter	On release	low	Reads the merged commits since last tag and drafts release notes for a human to edit.	Pattern →Starter kit →

Get started

Clone it and go

bash — LoopEngineering-CrashCourse

$ git clone https://github.com/ayeshakhalid192007-dev/LoopEngineering-CrashCourse.git

public repo · MIT · git 2.x

1
Clone & skim the map
Start here — the course overview and how to navigate it.
2
Learn the foundations
The primitives and mental models every loop is built from.
3
Build your first loop
A guided watch loop — your first hands-on project.

Build a loop that ships while you sleep.

Get the course on GitHub

Loop Engineering: Build Agents That Run Themselves

What one loop looks like

The six parts

The primitives you compose

Scheduling

Worktrees

Skills

Connectors

Sub-agents

State

How a loop is built up

Human

Control plane

Durable memory

Execution

Tooling

Three rungs of autonomy

Six parts, start to finish

The Shift

Heartbeat

The Body

The Spine

Complete Loop

Human Control

Production patterns, ready to fork

Clone it and go

Clone & skim the map

Learn the foundations

Build your first loop

Build a loop that ships while you sleep.