Awesome Loop Engineering

Loop Engineering is the operating layer for recurring AI-agent work. It defines how work enters, what an agent may do, which external evidence proves completion, what state survives, and whether the system retries, reports, escalates, or exits.

This field guide connects 874 papers, docs, tools, benchmarks, and guides to 22 operational patterns, 22 schema-checked contracts, and 8 runtime starters, so a recurring job can move from evidence to a reviewable implementation.

The reliability gap: prompts, context, and harnesses can improve one run; recurring work also needs explicit triggers, verification, durable state, bounded budgets, and human handoff. Software event loops, control theory, growth loops, generic automation, and one-off prompting are outside this map.

Start In 60 Seconds

Contents

• Implementation Kit
• Mental Model
• Reading Paths
• Choose Your Loop
• Working Definition
• Concept Guides
• How To Judge Each Source
• Resource Type Legend
• Start Here
• What Counts As Loop Engineering
• The Loop Contract
• Loop Design Checklist
• Loop Maturity Model
• Pattern Library
• Core Loop Primitives
• Official Runtime Guides
• Research Foundations
• Model-Level Recurrence
• Agent Workflow Patterns
• Coding-Agent Loop Systems
• Verification And Feedback Gates
• Securing Unattended Loops
• State, Memory, And Context Persistence
• Orchestration And Multi-Agent Delegation
• Benchmarks And Evaluation
• Operations Playbooks
• Templates And Patterns
• Examples And Schema
• Community Gallery
• Critiques, Risks, And Limitations
• Future Directions
• Adjacent Awesome Lists
• Explore And Reuse
• Shape What Comes Next
• Build From This
• Citation
• Star History

Implementation Kit

Move from evidence to implementation through four connected layers:

Fastest build path: name the recurring symptom, inspect its pattern, adapt the linked contract, then choose a runtime for the required persistence, isolation, and permissions.

Browse the interactive Resource Atlas, query the structured dataset, or use one of 8 language entry points.

See it end to end: the four worked paths cover CI repair, knowledge-base refresh, bounded queue processing, and read-only threshold monitoring, including commands and verifiable completion signals.

Two-minute dry run: clone the repository and inspect a bounded queue item without an agent account or extra dependency.

git clone https://github.com/ChaoYue0307/awesome-loop-engineering.git
cd awesome-loop-engineering
printf '%s\n' '{"id":"demo","objective":"Validate one queue item"}' > /tmp/loop-queue.jsonl
python3 examples/runnable/queue-worker-loop.py --queue /tmp/loop-queue.jsonl --dry-run

Mental Model

Prompt engineering asks: what should I say to the model?

Context engineering asks: what state and knowledge should the model see?

Harness engineering asks: what tools, permissions, tests, sandboxes, and feedback should surround the agent?

Loop engineering asks: what recurring system should discover work, delegate to agents, verify results, persist state, decide next actions, and re-run when the human is no longer in the inner loop?

Prompt, context, and harness engineering make one agent run better. Loop Engineering makes agent work repeatable, observable, and governable over time.

Loop shape:

Objective
  -> Trigger / cadence
  -> Discover / intake work
  -> Delegate to agents
  -> Act in an isolated workspace
  -> Verify with tests, evals, traces, or reviewers
       -> if failed: feed back the evidence and retry
       -> if passed: persist state and decide what happens next
  -> Repeat, report, open a PR, or escalate to a human

Reading Paths

Choose a goal before opening the full catalog. Learn the field through the definition and research foundations; build through a pattern, contract, and runtime; or review reliability through verification, state, security, benchmarks, and critiques.

For analysis, the Hugging Face dataset exposes collection, lifecycle, audience, evidence, source-status, publication, and repository-stat facets for every resource.

Fastest conceptual path: read the Working Definition, inspect the Loop Contract, choose a symptom in the Pattern Library, and follow a worked implementation.

Choose Your Loop

Choosing a loop means choosing the operating policy around an agent, not the model itself. A pull-request loop, deploy loop, and adversarial-testing loop may use the same model, but they need different triggers, permissions, evidence gates, durable state, retry budgets, and human owners. Those controls decide what the agent may do, what counts as success, what the next run can remember, and when automation must stop.

A generic "keep trying" loop collapses those differences. It can retry a judgment call, let the acting model approve its own work, lose evidence between runs, or change a high-risk system when it should only observe and escalate. A named pattern supplies a reviewable starting policy for a recurring job; its contract makes that policy exact for your environment.

First Decide Whether The Work Should Loop

Choose In Four Decisions

Select the pattern for the class of work, adapt its contract to your exact controls, then choose the runtime based on persistence, isolation, and permissions. Start from the problem and its verified finish below, or compare every field in the pattern matrix.

After choosing the pattern, compare runtime persistence, isolation, permissions, and escalation.

Working 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.

Concept Guides

These vendor-neutral guides define the concept, boundaries, vocabulary, and reviewable artifacts.

How To Judge Each Source

Open the original work before relying on a summary. Use the contribution, novelty, impact, and evidence fields to compare approaches and understand what supports each entry.

Resource Type Legend

Every row shows the work and type, its original publishing platform or venue, the contribution that matters for Loop Engineering, and a plain-language evidence label. Author lists are shortened for scanning; the queryable dataset exports and Resource Atlas retain full authorship, dates, venues, identifiers, contribution, novelty, impact, evidence signal, link status, and repository statistics.

Evidence labels describe the kind of source behind an entry, not its scientific quality. Each label means the same thing on every row, so it is defined once here rather than repeated in the tables; a row carries an extra note only when its link was access-restricted or unavailable at the latest check.

Start Here

Direct resources about the new AI/coding-agent meaning of Loop Engineering.

What Counts As Loop Engineering

Model-level recurrence belongs in the map when it explains the model inside an agent: a learned block or latent state is iterated to allocate compute, refine reasoning, or simulate a world. It is an adjacent foundation, not a complete operational loop. The outer system still needs work intake, tools, external verification, durable state, budgets, escalation, and exit.

The Loop Contract

A Loop Contract is a reviewable operating specification for one recurring agent job. It is not a legal agreement, a long prompt, or a particular runtime. It records the decisions a person normally supplies during a one-off session - what work is authorized, what the agent may touch, what evidence counts, what survives, and when control returns to a human - so those decisions remain stable across runs.

The contract becomes necessary when an agent runs from a schedule, event, queue, or goal instead of waiting for live supervision. Unanswered questions become hidden defaults: the agent may select the wrong work, widen its own scope, approve its own output, forget a previous failure, or retry without a stopping rule. Making the policy explicit lets builders, reviewers, security teams, and operators inspect the same boundaries before the loop acts.

Prompt, context, and harness choices improve one run. A pattern describes how a class of recurring work should operate. The contract fixes the exact policy for one implementation, and the runtime executes it.

Read It As Three Decisions

| Phase | Contract parts | What the phase decides