Loop Engineering HF Dataset GitHub
Awesome Loop Engineering

Design loops,
not just prompts.

Loop Engineering is the AI and coding-agent practice of designing recurring systems that discover work, delegate it to agents, verify results, persist state, decide next actions, and run again.

Explore the list Choose your loop Pattern matrix
Diagram of the engineering stack: Prompt, Context, and Harness Engineering improve one run; Loop Engineering governs recurring agent work over time.
15operational patterns
15loop contracts
6runnable templates
270curated entries
8languages
Canonical definition. Loop Engineering is the AI and coding-agent practice of designing recurring systems that discover work, delegate it to agents, verify results, persist state, decide next actions, and run again on a cadence, event, or until a verifiable goal is reached.
The stack

Four layers, one recurring system

Prompt, context, and harness engineering make a single agent run better. Loop Engineering sits on top and governs agent work over time.

Prompt Engineering — what should I say to the model?
Context Engineering — what state, memory, and knowledge should the model see?
Harness Engineering — what tools, permissions, sandboxes, and checks surround one run?
Loop Engineering — what recurring system governs agent work over time?
The lifecycle

One pass of a recurring loop

Verification is a deterministic gate, not the agent's opinion. State persists outside the model. Every loop has a budget and a human exit.

Loop Engineering lifecycle: Intake, Delegate, Act, Verify, Persist, Decide; Decide retries by feeding evidence back, escalates to a human, or exits when the goal is met.
Choose your loop

Start from the problem you have

Each card opens a ready-to-adapt pattern with a trigger, verification gate, durable state, budget, and escalation path. Compare them all in the pattern matrix.

“My PR is stuck”PR babysitter “CI keeps failing”CI repair loop “The docs may be stale”Docs drift collector “A deploy needs monitoring”Deploy verifier “Feedback is noisy”Feedback clusterer “Updates pile up”Dependency triage loop “Agent evals regressed”Evaluation regression loop “Sensitive changes need review”Security review loop “Agent spend is rising”Cost-control loop “Recurring bug discovery”Bug hunting loop “A change needs sign-off”Enterprise approval loop “An incident just paged”Incident response loop “A dataset keeps drifting”Data-quality loop “Release notes are a chore”Release-note loop “Model choice is ad hoc”Model-routing loop
The loop contract

Every loop names the same parts

A useful loop has a contract. If a part is missing, it becomes either a manual prompt habit or an unsafe background automation.

Loop Contract cards: objective, trigger, intake, workspace, context, delegation, verification, state, budget, escalation, and exit.

Verifiable by design

Tests, typechecks, evals, traces, or reviewers decide done — never the acting agent alone.

State outside the model

Progress files, issues, checkpoints, and traces survive the next run and every context reset.

Budgeted and bounded

Retries, runtime, and concurrency are capped, with a clear human exit before anything risky ships.

Where loops run

Pick a runtime deliberately

The same contract can run as a session command, a scheduled cloud job, a CI workflow, or a cron wrapper. The runtime selection guide compares persistence, file access, isolation, and permissions.

Claude Code /loop

Session-scoped recurring task while you are nearby.

Desktop scheduled task

Local recurring runs with file access and missed-run guardrails.

Codex automation

Unattended background task in an isolated worktree.

GitHub agentic workflow

Scheduled or event-triggered loop in GitHub Actions.

Shell / cron

Minimal wrapper that delegates to an agent CLI and records receipts.

Runnable reference

A dependency-light test-repair loop you can run today.
Loop maturity model

Climb the model slowly

A reliable Level 3 loop with clear state and deterministic checks is usually more valuable than a flashy Level 5 loop with vague goals.

0
Manual prompting
A human reads state and writes the next prompt.
1
Scripted retry
A shell or script loop feeds errors back to an agent.
2
Scheduled loop
The agent runs on a cadence and reports findings.
3
Stateful loop
Progress survives across sessions through files, issues, or checkpoints.
4
Self-verifying loop
Deterministic checks or evaluator agents gate completion.
5
Multi-agent loop
Specialized agents split discovery, implementation, review, and judgment.
6
Production-supervised loop
Observability, budgets, approvals, rollback, and escalation are first-class.
The curated list

Browse by category

Primary sources, official docs, papers, benchmarks, and implementation-heavy write-ups — selective, not a dump. Jump into any section of the README.

Start Here Core Loop Primitives Runtime Guides Research Foundations Verification & Feedback Securing Unattended Loops State & Memory Orchestration Benchmarks Critiques & Risks Adjacent Lists
Contribute

Bring a source or a real loop

Add a resource

Primary sources and implementation-heavy write-ups, with one specific annotation.

Share a loop

Use the case-study and anonymization checklists to publish a real or anonymized loop.

Join the discussion

Show your Loop Engineering patterns and compare notes with other builders.
FAQ

Loop Engineering, answered

Short answers to the questions people ask first.

What is loop engineering?

Loop Engineering is the practice of designing recurring AI agent and coding-agent systems. Instead of prompting an agent turn by turn, you build a loop that discovers work, delegates it to agents, verifies the result against tests or other gates, persists state outside the model, decides what happens next, and runs again on a cadence or until a verifiable goal is reached.

How is loop engineering different from prompt, context, and harness engineering?

Prompt engineering improves what you ask, context engineering improves what the model can see, and harness engineering improves the tools, permissions, and checks around a single run. Loop engineering sits above all three: it governs how agent work repeats, verifies, persists state, and escalates over time.

When should you use an agent loop?

Use a loop when work recurs and a deterministic check can decide success, such as keeping a pull request moving, repairing failing CI, monitoring a deploy, or triaging dependency updates. If a task is one-off, or "done" depends only on a human's judgment, a single agent run is usually enough.

What is in a loop contract?

A loop contract names the parts every reliable loop shares: objective, trigger, intake, workspace, context, delegation, a verification gate, durable state, budget, escalation, and an exit condition. The repository ships a JSON schema and validated example contracts for each pattern.

Which runtimes can run agent loops?

The same loop can run as a Claude Code /loop or scheduled task, a Codex automation, a GitHub agentic workflow, a shell or cron wrapper, or a durable-execution runtime. The runtime selection guide compares persistence, file access, isolation, and permissions so you can choose deliberately.