What Is Loop Engineering? A Practical Guide to Agent Loops

Loop engineering is the practice of designing systems that prompt coding agents automatically. Instead of asking an agent to do one task, checking the result, and then writing another prompt, you design a repeatable loop that discovers work, hands it to an agent, verifies the output, records state, and runs again safely.

In plain English: prompt engineering writes one instruction; loop engineering designs the machine that keeps producing the right instructions, checks the work, and knows when to stop.

Why loop engineering matters

AI coding agents are useful when a human gives them a clear task. They become much more useful when recurring work can be discovered, packaged, verified, and reviewed without a person babysitting every step.

That is the core job of loop engineering: turning repeated engineering chores into narrow, observable, reversible agent loops. The goal is not to remove engineers. The goal is to remove repetitive prompting while keeping human judgment where it matters.

A good loop engineering system can answer four questions:

1. What work should be done next?
2. Which agent or playbook should handle it?
3. How do we know the result is correct?
4. Where must a human approve the next action?

Loop engineering vs prompt, context, and harness engineering

| Layer | What it optimizes | Output | | ------------------- | ------------------- | ------------------------------------------------------- | | Prompt engineering | One model response | A better instruction | | Context engineering | One model window | The right files, facts, and constraints | | Harness engineering | One agent run | Tools, permissions, recovery, and a done condition | | Loop engineering | Repeated agent work | Triggers, state, agents, verification, and review gates |

The harness runs once. The loop makes the harness run again with memory, evidence, and boundaries.

The five moves of an agent loop

Every reliable agent loop has five moves. If one is missing, the loop usually stalls, repeats uselessly, or creates risk.

1. Discovery

The loop finds work without waiting for a person to paste a task. Discovery sources can include CI failures, GitHub issues, stale pull requests, support tickets, analytics, logs, documentation gaps, dependency updates, or a queue.

2. Handoff

The loop packages one bounded task for the agent. A good handoff includes the goal, relevant files, constraints, acceptance criteria, a branch or worktree, and the rule for when to stop.

3. Verification

The loop checks the result independently. Verification can be a test suite, static analysis, a deterministic rule, a second evaluator agent, or a human reviewer. The agent that created the change should not be the only judge of its own output.

4. Persistence

The loop writes down what happened. Useful state can live in STATE.md, a pull request, an issue comment, a database row, a run log, or a board. The next run should not start from zero.

5. Scheduling

The loop runs again through a cron job, webhook, CI event, queue trigger, or manual dispatch. Scheduling is what turns a useful agent run into an engineered operating loop.

Six components of a production loop engineering system

A production loop is not just a script that calls an agent. It needs a few boring parts that make the system safe to operate.

Scheduled automation

The trigger decides when the loop wakes up: daily triage, hourly CI sweeps, webhook events, or queue changes.

Isolated worktrees

Each agent run should have an isolated worktree, branch, sandbox, or permission boundary. This keeps parallel work from colliding and makes review simpler.

Reusable skills

A skill stores the durable judgment: how to triage, what commands to run, what files matter, and what counts as done. Updating a skill is better than pasting the same giant prompt into every schedule.

Connectors and MCP integrations

Connectors give the loop reach. GitHub, CI, docs, issue trackers, Slack, databases, calendars, and MCP tools can all become part of the loop contract.

Generator and evaluator agents

One agent should generate the change. Another agent or deterministic gate should evaluate it. Separating generator and evaluator reduces self-approval and makes failures easier to catch.

State and memory

The loop needs durable state outside the model context. Logs, summaries, STATE.md, pull requests, issue comments, and metrics let maintainers audit what happened.

Safe loop engineering requires human gates

The biggest mistake in loop engineering is giving an autonomous loop too much authority too early. A safe loop can draft changes, run checks, summarize risk, and prepare a pull request — but it should stop before irreversible actions.

Use a human gate before merge, deploy, delete, publish, close, bill, or any other action that is hard to undo.

Common loop engineering patterns

Useful first loops are narrow and boring:

• PR babysitter loop — finds stale pull requests, summarizes blockers, and nudges the right owner.
• Daily triage loop — scans new issues, labels urgency, detects duplicates, and prepares a review queue.
• CI sweeper loop — classifies repeated failures, separates flaky tests from real regressions, and drafts a minimal diagnostic PR.
• Dependency sweeper loop — groups safe upgrades, runs compatibility checks, and escalates risky packages.
• Changelog drafter loop — turns merged work into release notes with links, scope, and risk notes.

First loop engineering checklist

Before you automate a recurring agent workflow, answer these questions:

1. What exact source does the loop read?
2. What task boundary prevents scope creep?
3. Where does the loop write state?
4. How is each run isolated?
5. What verifies the output independently?
6. What cost, retry, and timeout limits exist?
7. Which exact step requires human approval?
8. How can a bad run be rolled back or discarded?

If you cannot answer those questions, the loop is not production-ready yet.

Final definition

Loop engineering is the engineering discipline for building repeatable, safe, observable agent loops. It sits above prompts, context, and harnesses. The best loop engineering systems make agents more useful without making humans less responsible.