Awesome Loop Engineering

A practical field guide and implementation kit for recurring, stateful, verified AI-agent systems.

📦 Build from this | 🧩 Pattern library | ▶️ Examples | 🧾 Schema | 🌐 Website | 🤗 Dataset

🌍 Languages: English | 中文 | Español | Français | Deutsch | 日本語 | 한국어 | Português | Help translate

_{⭐ Star to find it again · 🔀 Fork the contracts and dataset schema · 🔔 Watch Releases and Discussions}

Build recurring AI-agent and coding-agent systems that can find work, act within clear boundaries, verify outcomes, preserve state, and decide what happens next.

Prompt engineering shapes the instruction. Context engineering shapes what the model can see. Harness engineering shapes one run's tools, permissions, isolation, and checks. Loop Engineering governs what happens across runs: how work enters, agents act, evidence decides, state survives, and the system continues.

A loop discovers work, delegates it, verifies the result, records state and receipts, then retries, reports, escalates, or exits within a defined budget.

Loop Engineering covers recurring AI-agent systems with explicit triggers, external verification, durable state, bounded budgets, and human handoff. It does not include software event loops, control theory, growth loops, generic automation, or one-off prompting.

Start In 60 Seconds

🧭 Explore the field	Open the Resource Atlas	Filter 601 sources by goal, loop layer, lifecycle stage, artifact type, and evidence.
▶️ Build one loop	Follow a worked path	Move from a recurring job to its pattern, contract, runtime, and completion signal.
📊 Analyze the map	Load the dataset	Query 50 publication, evidence, lifecycle, source, and repository fields in CSV, JSONL, or Parquet.
🔔 Follow useful updates	Read the current release · Follow the digest	Use Watch → Custom → Releases and Discussions for a low-noise update feed.

Contents

• Implementation Kit
• The Reliability Gap
• Mental Model
• Find Your Path
• Reading Paths
• Choose Your Loop
• Working Definition
• Concept Guides
• Recommended Path
• What You Can Use
• 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
• Citation
• Star History

Implementation Kit

Move from evidence to implementation through four connected layers:

Start with	What it gives you	Use it to	Example
📚 601 resources	Papers, official docs, tools, benchmarks, and critiques with publication and evidence fields	Understand the design space and open the original work behind a claim	Compare verification methods in the Resource Atlas
🧩 20 operational patterns	Symptom-first playbooks with roles, gates, state, budgets, escalation, and worked scenarios	Choose how a recurring job should operate	"CI keeps failing" becomes a CI repair loop
🧾 20 schema-checked contracts	One schema-valid JSON specification for every pattern	Make permissions, evidence, limits, and human handoff reviewable	Adapt the CI repair contract to your repository
▶️ 8 runtime starters	Three dependency-light executables plus five copy/paste runtime templates	Wire a contract to a session, schedule, CI event, or durable worker	Start with test repair, threshold monitoring, or queue processing

Fastest build path: name the symptom, inspect the pattern's worked example, adapt its linked contract, then select the runtime starter that matches the required persistence, file access, isolation, and permissions.

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

The Reliability Gap

Reliable recurring agent work needs more than a strong prompt or harness. It needs a reviewable operating contract for triggers, intake, permissions, verification, state, budgets, escalation, and exit. The resources map the evidence; the patterns, contracts, and starters turn that evidence into systems you can inspect and adapt.

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.

_{Figure 1. Prompt, context, and harness engineering improve one run; Loop Engineering governs recurring work 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

_{Figure 2. Evidence moves through a recurring, stateful, verified loop toward retry, escalation, or exit.}

Find Your Path

Learning the field? Read the Working Definition, Start Here, and the Loop Contract. Building a loop? Choose a pattern, runtime guide, adaptable contract, and runnable starter. Reviewing reliability? Focus on verification, unattended-loop security, durable state, benchmarks, and critiques.

Reading Paths

Choose a goal before opening the full catalog. These paths lead from a decision to the most relevant evidence and implementation artifacts.

Goal	Start here	Continue with	Best for
🧭 Learn	Working definition	Start Here → Research Foundations	Newcomers and researchers
🧠 Study model recurrence	Model-Level Recurrence	Research Foundations → Benchmarks And Evaluation	Model, reasoning, and agent researchers
✏️ Design	Loop Contract	Pattern Library → Core Loop Primitives → Agent Workflow Patterns	Architects and loop designers
🛠️ Build	Runtime selection	Official Runtime Guides → Coding-Agent Loop Systems → Orchestration	Agent and platform builders
💾 Persist	State and context	Core Loop Primitives → Operations Playbooks	Long-running and resumable loops
✅ Verify	Verification Gates	Benchmarks And Evaluation → Critiques And Limitations	Eval and reliability engineers
🛡️ Govern	Securing Unattended Loops	Operations Playbooks → Critiques And Limitations	Operators, approvers, and security
📦 Apply	Templates And Patterns	Examples And Schema → Community Gallery → Contributing	Teams adopting or sharing loops

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

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

Use a loop when...	Prefer one supervised run when...
Work returns through a schedule, event, queue, or recurring condition.	The task is genuinely one-off.
An external check can prove progress or completion.	"Done" depends mainly on open-ended human judgment.
Saved evidence, checkpoints, or receipts improve the next run.	No useful state should survive the session.
Permissions, retries, time, and cost can be bounded in advance.	A safe permission or budget boundary cannot be stated.
A named human owns ambiguity, exceptions, and high-impact decisions.	Every meaningful step already needs live human direction.

Choose In Four Decisions

Decision	Ask	What it fixes
1. Name the recurring job	What signal keeps returning, and what outcome should improve?	Objective, trigger, and intake
2. Define proof	What evidence can a reviewer or machine inspect to decide "pass"?	Verification gate and exit condition
3. Bound action	What may the agent read or change, and what must it never do?	Workspace, permissions, non-goals, and budget
4. Plan the next pass	What should persist, retry, escalate, or stop after each result?	Durable state, handoff, and next action

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.

When you say...	Start with	The loop can finish when...
"My PR is stuck"	PR babysitter	Required checks pass, review threads are resolved, and merge state is current.
"CI keeps failing"	CI repair loop	The original failing command passes with a scoped patch.
"The docs may be stale"	Docs drift collector	Verified code/docs mismatches are patched and examples still run.
"A deploy needs monitoring"	Deploy verifier	Synthetic checks and rollout thresholds remain within policy.
"Feedback is noisy"	Feedback clusterer	Themes cite source items and separate frequency from severity.
"Dependency updates pile up"	Dependency triage loop	Safe updates pass tests and risky upgrades have an owner-backed escalation.
"Agent evals regressed"	Evaluation regression loop	Targeted evals return to the accepted baseline without scorer changes.
"Sensitive changes need review"	Security review loop	Findings cite concrete evidence and approval boundaries stay intact.
"Agent spend is rising"	Cost-control loop	Spend falls on a comparable workload without quality regression.
"I need recurring bug discovery"	Bug hunting loop	Every accepted finding has reproducible steps or a failing test.
"A change needs sign-off"	Enterprise approval loop	Every required gate has a recorded decision and audit trail.
"An incident just paged"	Incident response loop	Impact, evidence, timeline, and accountable owner are recorded.
"A dataset keeps drifting"	Data-quality loop	Hard quality rules pass before a new version is promoted.
"Release notes are a chore"	Release-note loop	Every shipped change maps to a merged source and audience-facing note.
"Model choice is ad hoc"	Model-routing loop	Routing meets quality, latency, privacy, and cost tolerances.
"A stable system should improve"	Benchmark optimization loop	Repeated measurements confirm improvement with protected metrics intact.
"The agent's knowledge is stale"	Knowledge freshness loop	A versioned corpus passes provenance, freshness, retrieval, and leakage gates.
"Performance regressed"	Performance regression loop	A controlled benchmark confirms recovery with correctness intact.
"A UI accessibility check failed"	Accessibility regression loop	The exact regression is fixed and required human criteria are approved.
"The agent needs adversarial testing"	Adversarial red-team loop	Findings are reproduced, minimized, privately reported, and regression-tested.

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.

Resource	Published at	Contribution	Evidence
🧾 Working Definition Template	2026 · GitHub Project documentation	Short definition, positioning, minimal loop test, and citation note.	Project artifact Schema, example, guide, or repository documentation
🧾 Loop Engineering Manifesto Template	2026 · GitHub Project documentation	Concise statement of the concept, commitments, non-goals, and success standard.	Project artifact Schema, example, guide, or repository documentation
🧾 Loop Engineering Taxonomy Template	2026 · GitHub Project documentation	Classification by trigger, intake, verification, state model, topology, and operating domain.	Project artifact Schema, example, guide, or repository documentation
⚠️ Loop Engineering Anti-Patterns Critique	2026 · GitHub Project documentation	Common failure modes such as prompt loops with no contract, infinite retries, model self-approval, hidden state, and unsafe autonomy.	Project artifact Schema, example, guide, or repository documentation
🧾 Comparison Guide Template	2026 · GitHub Project documentation	Distinguishes Loop Engineering from prompt engineering, context engineering, harness engineering, workflow automation, agent workflows, and evaluation loops.	Project artifact Schema, example, guide, or repository documentation
🧾 Sourced Signals And Quotes Template	2026 · GitHub Project documentation	Short sourced signals from linked public materials that anchor the emerging concept.	Project artifact Schema, example, guide, or repository documentation
🧾 Outreach Kit Template	2026 · GitHub Project operations guide	Conservative messages for inviting corrections, sources, and real-world loop patterns.	Project artifact Schema, example, guide, or repository documentation

Recommended Path

A five-stop path through the concept, evidence, operating patterns, reliability gates, and reusable artifacts.

• 🧭 Concept: Addy Osmani's Loop Engineering essay frames the practice (Start Here), while the Working Definition and Manifesto explain the scope and principles (Concept Guides).
• 🧱 Foundations: the harness-layer taxonomy decomposes control, agency, and runtime beneath the loop and proposes a HarnessCard so reported agent gains can be separated from harness effects (Agent Workflow Patterns).
• 🛠️ Practice: the Codex long-horizon runbook (Official Runtime Guides) and Claude's scheduled-task docs (Core Loop Primitives) cover the core mechanics, then the PR babysitter and CI repair patterns turn the contract into operating models (Pattern Library).
• ✅ Reliability: "Give It Backpressure" (Verification And Feedback Gates) and "Building Effective Agents" (Agent Workflow Patterns) make verification the learning signal, with the Anti-Patterns guide listing failure modes to avoid (Concept Guides).
• 📦 Reusable artifacts: the loop contract schema and schema-checked examples make the contract concrete (Examples And Schema), and the Loop Gallery is the format for sharing real or anonymized loops (Community Gallery).

What You Can Use

Explore the field, choose an operating pattern, and build from reusable artifacts:

• 📚 601 resources with publication, contribution, novelty, impact, evidence, and signal fields
• 🧩 20 operational patterns with a symptom-first comparison matrix and worked use cases
• 🧾 20 adaptable contracts checked against the Loop Contract JSON schema
• ▶️ 8 runtime starters: 3 dependency-light executables plus 5 copy/paste runtime templates
• 🖼️ Community gallery format for real or anonymized operating evidence
• 🌍 8 language entry points to the core concepts
• 🤗 Structured Hugging Face dataset plus a searchable Resource Atlas
• 💬 Correction and discussion paths for source accuracy, patterns, and operating lessons

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.

Dimension	Evidence standard
Scope	Every entry must directly inform recurring AI-agent systems, offer concrete value to builders or researchers, and link to evidence that readers can inspect.
Link availability	At the latest source check on 2026-07-20 UTC, 548 public links opened successfully, 5 required access, 48 pointed to files in this repository, and none were broken or unreachable.
Evidence label	Labels distinguish published research, official documentation, inspectable implementations, practitioner analysis, risk analysis, and discovery indexes. They describe the kind of source behind an entry, not its scientific quality.
How summaries are written	Summaries explain each work's contribution in original language rather than copying abstracts. They do not imply author endorsement; follow the link to inspect methods, results, limitations, and current documentation.
Corrections	Report an error through the annotation-correction form or a pull request. Corrections to contribution, novelty, impact, publication metadata, and source links take priority.
Licensing	Original summaries, metadata, templates, and project documentation are CC0-1.0. Linked works retain their own licenses and terms.

Resource Type Legend

Type	Rows	Includes
📄 Paper	220	Academic paper, preprint, or technical report
📝 Blog	78	Essay, field note, article, or practitioner write-up
📚 Docs	72	Official product, API, SDK, or platform documentation
🧰 Tool	105	Repository, framework, SDK, runtime, or implementation
🧪 Benchmark	40	Benchmark, eval suite, leaderboard, or evaluation dataset
🔁 Pattern	35	Operational playbook or reusable workflow
🧾 Template	25	Template, checklist, schema, guide, or contribution artifact
🧭 List	15	Adjacent directory, ecosystem map, or reading list
⚠️ Critique	11	Risk analysis, limitation, caveat, or skeptical take

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.

Start Here

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

Resource	Published at	Contribution	Evidence
📝 Loop Engineering by Addy Osmani Blog	addyosmani.com Addy Osmani	Addy Osmani's framing of loop engineering as the layer above manually prompting coding agents, with concrete primitives across Codex and Claude Code; also on Substack with the original discussion trail and Steinberger and Cherny quotations.	Practitioner analysis Experience-backed implementation context
📝 Peter Steinberger on designing loops Blog	2026 · X (formerly Twitter)	The June 2026 post - "you shouldn't be prompting coding agents anymore, you should be designing loops that prompt your agents" - that catalyzed the current discussion.	Practitioner analysis Experience-backed implementation context
📝 Boris Cherny: five tips for running Opus autonomously for hours or days Blog	2026 · X (formerly Twitter)	The Claude Code creator's compact loop recipe: auto-mode permissions, dynamic workflows, /goal or /loop, the cloud runner, and end-to-end self-verification.	Practitioner analysis Experience-backed implementation context
📝 Loop Engineering by Cobus Greyling Blog	Substack Cobus Greyling	Concise explanation of the shift from prompting agents to designing loops that discover work, delegate, verify, persist, and continue.	Practitioner analysis Experience-backed implementation context
📝 Stop Prompting. Design the Loop. Blog	2026 · pulumi Engin Diri	Practical breakdown of loop building blocks - automations, worktrees, skills, connectors, subagents - plus external memory and verification through oracles such as tests and builds.	Practitioner analysis Experience-backed implementation context
📝 Writing Loops, Not Prompts, Explained Blog	rico.codes	Rico Kahler's break-even model for when a recurring task justifies building a loop instead of prompting, with stop conditions, evidence collection, and an execution-horizon framing for moving from execution-bound to judgment-bound work.	Practitioner analysis Experience-backed implementation context
📝 Loop Engineering: A Guide for Engineers and Practitioners Blog	Medium	Adnan Masood's practitioner guide that organizes loop design into triggers, topologies, verifiers, and termination rules, with coverage of failure modes, cost control, and observability for production agent loops.	Practitioner analysis The linked source required access at the latest check
📝 Loop Engineering: When Generation Gets Cheap, Judgment Gets Expensive Blog	Substack Stephane Derosiaux	Stephane Derosiaux's essay on the economics of the loop layer (generation becomes abundant while judgment becomes the bottleneck), proposing evaluator agents that must act rather than merely review, and cataloging failure modes such as unverified merges and quota depletion.	Practitioner analysis Experience-backed implementation context
📝 Andrew Ng on Loop Engineering and the Three Loops of AI-Native Product Development Blog	2026 · X (formerly Twitter)	Andrew Ng's letter laying out three product-development loops (agentic coding in minutes, developer feedback in hours, external feedback in days) and arguing that human-in-the-loop persists wherever the human knows something the AI does not.	Practitioner analysis Experience-backed implementation context
📝 From Prompting Agents to Loop Engineering Blog	2026 · X (formerly Twitter)	DAIR.AI founder Elvis Saravia's X article examining the claim that you should stop prompting coding agents and start designing loops that prompt them for you.	Practitioner analysis Experience-backed implementation context
📝 My Lord! AI Programming Undergoes Another Major Shift Blog	eu.36kr.com	Broad coverage of the Boris Cherny and Peter Steinberger discussion, including the distinction between cold-start scripts and persistent agent loops.	Practitioner analysis Experience-backed implementation context
📝 The Anthropic leader who built Claude Code ditched prompting - now he writes loops Blog	2026 · The New Stack Janakiram MSV	The New Stack's report on Boris Cherny's shift from prompting to loop writing and what it changes about developer workflow.	Practitioner analysis Experience-backed implementation context
📝 Engineering for Agents That Never Sleep Blog	Substack Nader Dabit	Cognition's Nader Dabit predicts the human-initiated share of Devin sessions will invert from 70/30 to 10/90 within a year as signals like alerts and failing tests trigger agents directly, recasting the engineer's job as designing triggers, constraints, and quality gates.	Practitioner analysis Experience-backed implementation context
📝 Loop Engineering Orange Book Blog	2026 · GitHub alchaincyf/loop-engineering-orange-book	Plain-language bilingual (Chinese and English) field guide to loop engineering by HuaShu, framing the discipline as one floor above harness engineering: the outer system that decides when and why agents run.	Practitioner analysis Experience-backed implementation context
📝 How I AI: How to Write AI Agent Loops in Claude Code and Codex Blog	lennysnewsletter.com Lenny Rachitsky	Mozilla distinguished engineer Brian Grinstead demonstrates goal-based and scheduled loops, including a daily PR-review loop with per-PR subagents, on Lenny's Newsletter.	Practitioner analysis Experience-backed implementation context
📄 Proof-or-Stop: Don't Trust the Agent, Trust the Evidence -- Loop Engineering for Verifiable Evidence-Gated Lifecycle Control Paper	2026 · arXiv Jek Huang et al.	Defines evidence-gated lifecycle control for agent loops and reports zero false-DONE outcomes across 10 scenarios and zero accepts across 18 tampering classes; its 9,240-cell ablation identifies which gates prevent error amplification, while noting the evaluation covers one model family and 24 tasks.	Research preprint Preprint; inspect methods and evaluation

What Counts As Loop Engineering

Qualifies	Does not qualify
AI/coding-agent loops that coordinate prompts, context, harnesses, verification, and state over repeated agent runs	Software event loops, UI/game loops, or control theory loops
Scheduled, goal-driven, or event-triggered agent work	Generic cron jobs with no agentic reasoning or verification
Agent loops with durable state, worktrees, checkpoints, traces, or progress files	One-off prompt examples with no loop, state, or feedback signal
Verification loops using tests, CI, evals, reviewers, or deterministic gates	Pure AI news, generic product pages, or marketing copy
Multi-agent maker/checker/delegation patterns	Broad agent lists without specific loop-design relevance

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.

_{Figure 3. The Loop Contract makes recurring agent work explicit, reviewable, and bounded.}

Read It As Three Decisions

Phase	Contract parts	What the phase decides
1. Set up	Objective, trigger, intake, workspace	Why a run is authorized, which work qualifies, and where action is allowed.
2. Run	Context, delegation, verification, state	What the agents know, who acts and checks, what proves progress, and what is remembered.
3. Govern and close	Budget, escalation, exit, next action	How autonomy is capped and whether the loop retries, reports, hands off, or stops.

Part	Decision the contract must make	Common artifact
Objective	Which measurable outcome is worth repeating toward?	Goal, issue, PRD, runbook
Trigger	Which event, schedule, or goal authorizes a run?	Schedule, webhook, /loop, /goal, automation
Discover / Intake	Which items qualify, and how are duplicates or stale work rejected?	GitHub queries, Linear filters, CI failures, feedback stream
Workspace	What may the agent read or change, and where is execution isolated?	Worktree, sandbox, branch, container
Context	Which instructions and current evidence must be loaded fresh?	AGENTS.md, CLAUDE.md, SKILL.md, docs, logs
Delegation	Who explores, acts, and checks, and can the acting agent approve itself?	Explorer, implementer, reviewer, judge
Verification	Which external evidence must pass before progress or completion is valid?	Tests, typecheck, lint, evals, trace graders
State	Which checkpoints and receipts survive, and when are they updated?	Progress file, database checkpoint, trace, issue comment
Budget	How much time, retry, token, cost, or concurrency may one run consume?	Max turns, max retries, token budget, time box
Escalation	Which conditions require a named human owner or review channel?	PR, issue, Slack alert, triage inbox
Exit	What proves success, and what stops the loop without success?	Acceptance criteria, passing checks, explicit blocked state

Why The Boundaries Matter

If the contract omits...	The recurring failure is predictable
Trigger and intake	The loop invents work, reprocesses the same item, or runs at the wrong time.
Workspace and permissions	A narrow repair expands into unrelated files, credentials, or production changes.
Independent verification	The acting model can declare its own output complete without external evidence.
Durable state and receipts	The next run repeats failed attempts and cannot explain what already happened.
Budget, escalation, and exit	The loop retries indefinitely, spends past its value, or stalls without an owner.

Worked Example: PR Babysitter

Suppose a team wants an agent to keep one pull request moving without asking a person to poll CI and review threads all day. "Keep this PR moving" is only a goal; the contract turns it into bounded operation.

Contract decision	PR babysitter implementation
Authorize the run	Run every two hours during working hours and after requested changes or failed required checks. Select only explicit blockers on one pull request.
Bound the action	Use a dedicated branch or worktree. Allow narrow fixes, checks, and progress comments; prohibit force pushes, dependency upgrades, secrets access, and production changes.
Load and delegate	Load AGENTS.md, CONTRIBUTING.md, the latest PR SHA, review threads, and CI logs. An explorer identifies the blocker, an implementer patches it, and a reviewer checks scope.
Prove and remember	Require GitHub checks to pass, review threads to resolve, and the diff to stay scoped. Persist commands, check URLs, changed files, blockers, and the next action.
Cap and hand off	Stop after three retries or 60 minutes. Escalate architectural decisions, repeated failures, reviewer disagreement, or any force-push requirement to the human owner.
Exit	Succeed when the PR is merge-ready or waiting only on human review; stop without success when blocked, out of budget, or facing a judgment call.

Open the full pr-babysitter-loop.json, render it with python3 scripts/preview_loop_contract.py, or browse the 20 schema-checked contracts below.

Loop Design Checklist

Check	Question
Name one objective	Does the loop optimize for a specific outcome instead of a vague goal such as "improve the repo"?
Define the intake	Where does work enter: PR comments, CI failures, issues, logs, eval failures, feedback, or schedule?
Isolate execution	Does the agent act in a worktree, sandbox, branch, container, or read-only mode?
Write the feedback signal first	Do tests, typechecks, lint, evals, policy checks, or trace graders exist before retries begin?
Persist state outside the model	Does progress survive in files, issue comments, checkpoints, traces, or a database?
Separate maker and checker	Does something other than the acting agent decide whether the work is done?
Put a budget on autonomy	Are runtime, turns, retries, token spend, and concurrent workers capped?
Design escalation	Is it clear when the loop should open a PR, file an issue, ask a human, or stop?
Keep receipts	Are commands, evidence, changed files, and stop reasons recorded?

Loop Maturity Model

The Loop Maturity Model is a capability ladder for one recurring agent workflow. It helps you choose the smallest operating model that can perform a job reliably. The level describes how the workflow is triggered, remembered, verified, divided, and supervised; it does not score model intelligence, team sophistication, or product quality.

How To Use The Model

Start with the job, not the target level. Identify the recurring outcome, evidence, risk, and human owner before choosing an architecture.

Treat levels as cumulative capabilities. A Level 4 loop still needs a bounded trigger and durable state; adding a verifier does not repair missing foundations.

Move up only for a recurring failure or operating need. Every level adds code, observability, permissions, and maintenance. Stop at the lowest level that meets the job's continuity, evidence, and blast-radius requirements.

Earn autonomy in order. Persist state before increasing unattended runtime, establish external verification before adding more agents, and add production controls before actions can affect users or infrastructure.

Level	Operating model	Why it exists	Concrete example	Progress signal
0 · Manual prompting	A person holds the state, supplies each next instruction, and judges the result.	Keeps ambiguous, one-off, or high-judgment work under direct supervision.	A developer asks an agent to fix one failing test, reviews the diff, and decides whether to continue.	The same task and feedback sequence recur often enough to encode.
1 · Scripted retry	A bounded wrapper reruns one agent and feeds back an external failure.	Removes repetitive reprompting while keeping one objective and one feedback signal.	Run pytest; return the failing output to the agent for at most three repair attempts.	The job should start from a schedule or event without a person launching it.
2 · Scheduled loop	A schedule or event triggers fresh intake, one bounded run, and a report or artifact.	Removes manual launch and makes cadence, idempotence, and no-work exits explicit.	A nightly docs-drift scan opens a report only when code and documentation disagree.	Work spans runs, repeats items, or loses context between invocations.
3 · Stateful loop	Durable checkpoints and receipts record completed work, blockers, evidence, and the next action outside the model.	Survives restarts, avoids duplicate work, and makes each run resumable and inspectable.	A feedback clusterer stores processed IDs, prior themes, and the last successful checkpoint.	Stable external evidence can decide whether a transition or completion is valid.
4 · Self-verifying loop	Tests, evals, policy checks, traces, or an independent evaluator gate progress and exit.	Replaces the agent's claim of success with reviewable evidence.	A CI repair loop exits only when the original failing command passes and the diff remains in scope.	One role becomes a bottleneck, duties must be separated, or independent review is required.
5 · Multi-agent loop	Specialists divide discovery, action, review, and judgment through explicit handoffs and shared state.	Adds separation of duties and parallel expertise without letting the acting agent approve itself.	A security loop uses an explorer to find a candidate, a reproducer to confirm it, and a reviewer to judge severity and scope.	The loop can affect production, customers, money, credentials, or other high-impact systems.
6 · Production-supervised loop	Telemetry, least privilege, budgets, approvals, rollback, incident ownership, and human escalation govern every run.	Controls blast radius and makes unattended production work observable, interruptible, and accountable.	A deploy verifier watches rollout metrics, pauses on a breached threshold, preserves evidence, and hands rollback approval to the release owner.	Harden service objectives, replay, permission reviews, failure drills, and cost controls as the workflow evolves.

Levels describe capability, not ambition. Many useful workflows should stop at Level 2 or 3. A dependable Level 3 loop with durable state is more valuable than a Level 5 design with vague goals, weak checks, or ceremonial agent roles.

Pattern Library

Practical loop patterns translate the abstract contract into runnable operating models. Each pattern documents the trigger, discover/intake step, agents, workspace, state, verification gates, retry budget, escalation path, and loop instruction.

Resource	Published at	Contribution	Evidence
🔁 PR babysitter Pattern	2026 · GitHub Pattern library	Repeatedly checks review comments, CI, merge conflicts, stale threads, and readiness to merge.	Project artifact Schema, example, guide, or repository documentation
🔁 CI repair loop Pattern	2026 · GitHub Pattern library	Reproduces failing checks, patches narrowly, reruns evidence, and escalates when failures are outside scope.	Project artifact Schema, example, guide, or repository documentation
🔁 Docs drift collector Pattern	2026 · GitHub Pattern library	Finds mismatches between docs and code, proposes small patches, and verifies examples.	Project artifact Schema, example, guide, or repository documentation
🔁 Deploy verifier Pattern	2026 · GitHub Pattern library	Watches rollout signals, compares them with release expectations, and stops on anomalies.	Project artifact Schema, example, guide, or repository documentation
🔁 Feedback clusterer Pattern	2026 · GitHub Pattern library	Periodically groups GitHub, Linear, Slack, support, or social feedback into actionable themes.	Project artifact Schema, example, guide, or repository documentation
🔁 Dependency triage loop Pattern	2026 · GitHub Pattern library	Classifies dependency updates, applies safe groups, verifies them, and escalates risky upgrades.	Project artifact Schema, example, guide, or repository documentation
🔁 Evaluation regression loop Pattern	2026 · GitHub Pattern library	Investigates degraded agent evals with baseline traces, targeted reruns, and repair proposals.	Project artifact Schema, example, guide, or repository documentation
🔁 Benchmark optimization loop Pattern	2026 · GitHub Pattern library	Runs bounded experiments against a frozen benchmark and accepts only reproducible gains with correctness intact.	Project artifact Schema, example, guide, or repository documentation
🔁 Security review loop Pattern	2026 · GitHub Pattern library	Reviews sensitive diffs with evidence-backed findings, safe permissions, and human approval boundaries.	Project artifact Schema, example, guide, or repository documentation
🔁 Adversarial red-team loop Pattern	2026 · GitHub Pattern library	Discovers agent failures inside an authorized sandbox, then independently reproduces, minimizes, and reports them.	Project artifact Schema, example, guide, or repository documentation
🔁 Accessibility regression loop Pattern	2026 · GitHub Pattern library	Repairs reproducible accessibility regressions while preserving required human review for non-automatable criteria.	Project artifact Schema, example, guide, or repository documentation
🔁 Cost-control loop Pattern	2026 · GitHub Pattern library	Monitors agent workflow spend, identifies waste, proposes scoped savings, and preserves quality gates.	Project artifact Schema, example, guide, or repository documentation
🔁 Performance regression loop Pattern	2026 · GitHub Pattern library	Profiles a measured regression and verifies a narrow fix against the same controlled workload and correctness gates.	Project artifact Schema, example, guide, or repository documentation
🔁 Bug hunting loop Pattern	2026 · GitHub Pattern library	Discovers, reproduces, minimizes, and reports bugs with concrete evidence.	Project artifact Schema, example, guide, or repository documentation
🔁 Enterprise approval loop Pattern	2026 · GitHub Pattern library	Drives a permissioned change through required gates and approvers with a full audit trail.	Project artifact Schema, example, guide, or repository documentation
🔁 Incident response loop Pattern	2026 · GitHub Pattern library	Triages an alert into an owned, evidence-backed incident with a postmortem seed.	Project artifact Schema, example, guide, or repository documentation
🔁 Data-quality loop Pattern	2026 · GitHub Pattern library	Validates each dataset refresh against quality rules and quarantines bad versions.	Project artifact Schema, example, guide, or repository documentation
🔁 Knowledge freshness loop Pattern	2026 · GitHub Pattern library	Rebuilds a versioned retrieval corpus and promotes it only after provenance, freshness, quality, and leakage gates pass.	Project artifact Schema, example, guide, or repository documentation
🔁 Release-note loop Pattern	2026 · GitHub Pattern library	Drafts release notes from merged commits, issues, and PRs with linked evidence.	Project artifact Schema, example, guide, or repository documentation
🔁 Model-routing loop Pattern	2026 · GitHub Pattern library	Routes tasks across models on measured quality, latency, privacy, and cost.	Project artifact Schema, example, guide, or repository documentation

Core Loop Primitives

Feature-level building blocks you assemble a loop from: schedulers, goals, worktrees, hooks, skills, plugins, and protocols.

Resource	Published at	Contribution	Evidence
📚 Scheduled tasks - ChatGPT Learn Docs	ChatGPT Learn	Official guidance for recurring background tasks, triage inboxes, skills, and isolated workspaces.	Official documentation Primary product or standard behavior
📚 Follow a goal - ChatGPT Learn Docs	ChatGPT Learn	Official guidance for durable objectives with stopping conditions, validation commands, checkpoints, and progress logs.	Official documentation Primary product or standard behavior
📚 Git worktrees - ChatGPT Learn Docs	ChatGPT Learn	Official worktree model for isolated parallel tasks and handoffs between local and background workspaces.	Official documentation Primary product or standard behavior
📚 Prompting - ChatGPT Learn Docs	ChatGPT Learn	Explains the Codex loop, threads, context, and goal-oriented prompting.	Official documentation Primary product or standard behavior
📚 Customization overview - ChatGPT Learn Docs	ChatGPT Learn	Maps AGENTS.md, memories, skills, MCP, and subagents into a coherent customization stack.	Official documentation Primary product or standard behavior
📚 Build skills - ChatGPT Learn Docs	ChatGPT Learn	Official skill format for reusable workflows, scripts, MCP dependencies, invocation policy, and plugin packaging.	Official documentation Primary product or standard behavior
📚 Plugins - ChatGPT Learn Docs	ChatGPT Learn	Bundles skills, app integrations, and MCP servers into reusable loop capabilities.	Official documentation Primary product or standard behavior
🧰 dotskills Tool	2026 · GitHub vincentkoc/dotskills · License: MIT	A .skills registry of curated Codex and OpenClaw skills, framed as an "ADE Loop" (Agent Development Environment to registry to Skills Gym) where reusable skills are developed, shared, and evaluated across runs.	Source implementation Inspectable source and runtime behavior
📚 Developer commands - ChatGPT Learn Docs	ChatGPT Learn	CLI commands for switching agent threads, browsing skills, inspecting MCP tools, and using subagent workflows.	Official documentation Primary product or standard behavior
🔁 Autonomous Loops Pattern	claudecodeguide.dev	Claude Code pattern using task files, stop hooks, restart behavior, hard limits, and a kill switch.	Operational pattern Transferable operating practice
📚 Claude Code Glossary Docs	Anthropic	Defines the agentic loop, hooks, subagents, skills, MCP, and related primitives in Claude Code terminology.	Official documentation Primary product or standard behavior
📚 Keep Claude working toward a goal Docs	Claude Code Docs	/goal runs turn after turn until a completion condition is met by a verifier.	Official documentation Primary product or standard behavior
📚 Run prompts on a schedule Docs	Claude Code Docs	/loop, scheduled tasks, reminders, monitor tools, and session-scoped recurring prompts.	Official documentation Primary product or standard behavior
📚 Automate work with routines Docs	Claude Code Docs	Claude Code routines: persistent cloud automations triggered by schedules, API calls, or GitHub events, with connectors, scoped environments, and branch-push limits.	Official documentation Primary product or standard behavior
📚 Desktop scheduled tasks Docs	Claude Code Docs	Local recurring runs on your own machine, with the persistence, file-access, permission, worktree, and missed-run trade-offs that distinguish them from /loop and cloud routines.	Official documentation Primary product or standard behavior
📚 Run parallel sessions with worktrees Docs	Claude Code Docs	Worktree isolation for parallel sessions and subagents so concurrent edits do not collide.	Official documentation Primary product or standard behavior
📚 Automate actions with hooks Docs	Claude Code Docs	Claude Code hooks guide for deterministic lifecycle control around model actions.	Official documentation Primary product or standard behavior
📚 Hooks reference Docs	Anthropic	Event-level reference for session, turn, tool-call, and subagent hooks.	Official documentation Primary product or standard behavior
📚 Common workflows - Claude Code Docs	Claude Code Docs	Practical workflows for worktrees, subagents, CI, batch processing, planning, and resuming prior work.	Official documentation Primary product or standard behavior
📚 Manage multiple agents with agent view Docs	Anthropic	Dashboard for dispatching, monitoring, and attaching to background agent sessions.	Official documentation Primary product or standard behavior
📚 Run agents in parallel Docs	Anthropic	Compares agent view, subagents, agent teams, worktrees, tasks, and workflows for parallel work.	Official documentation Primary product or standard behavior
📚 Orchestrate subagents at scale with dynamic workflows Docs	Claude Code Docs	Moves loop state and branching into workflow scripts so large tasks do not overload the conversation context.	Official documentation Primary product or standard behavior
📚 Create plugins Docs	Claude Code Docs	Packaging model-invoked skills, agents, hooks, MCP servers, monitors, and settings as shareable loop components.	Official documentation Primary product or standard behavior
📚 Model Context Protocol Docs	Model Context Protocol	Standard protocol for exposing tools and data sources to agent loops.	Official documentation Primary product or standard behavior
📚 Allowing GitHub Copilot CLI to work autonomously Docs	GitHub Docs	Copilot CLI autopilot mode plus /every and /after scheduling, turning the CLI into an unattended loop that runs steps until a task is complete.	Official documentation Primary product or standard behavior
🧰 opencode-scheduler Tool	2026 · GitHub different-ai/opencode-scheduler · License: MIT	OpenCode plugin that runs recurring agent jobs through OS-native schedulers (launchd on macOS, systemd on Linux), with workdir-scoped jobs, timeouts, and skipped ticks when the previous run is still active.	Source implementation Inspectable source and runtime behavior
🧰 Agent-Loop-Skills Tool	2026 · GitHub gaasher/Agent-Loop-Skills · License: MIT	Reusable verification-gated loops (autoresearch, scientific writing, data analysis, code and prompt optimization, red-teaming) packaged as open-standard Agent Skills, each with a feedback signal, run ledger, and termination conditions.	Source implementation Inspectable source and runtime behavior
🧰 launch-your-agent Tool	2026 · GitHub anthropics/launch-your-agent · License: Apache-2.0	Anthropic's official Claude Code skill set that operationalizes an interview, launch, grade-against-definition-of-done, iterate, and schedule loop for Claude Managed Agents, leaving a live recurring scheduled agent plus an eval scaffold and roadmap.	Source implementation Inspectable source and runtime behavior

Official Runtime Guides

End-to-end operating guides and release notes from the runtime vendors themselves: how each platform expects you to run recurring agent work.

Resource	Published at	Contribution	Evidence
📚 Run long horizon tasks with Codex Docs	OpenAI Developers	OpenAI's runbook for plan-edit-test-observe-repair-document-repeat work, including specs, plans, status logs, and validation gates.	Official documentation Primary product or standard behavior
📚 Best practices - ChatGPT Learn Docs	ChatGPT Learn	Official best practices for context, AGENTS.md, MCP, skills, subagents, and automations.	Official documentation Primary product or standard behavior
📚 Agents SDK Docs	OpenAI Developers	OpenAI guide for agent orchestration, tool execution, approvals, state, guardrails, and observability.	Official documentation Primary product or standard behavior
📚 Agents - OpenAI Agents SDK Docs	openai.github.io	SDK primitives for agents, tools, handoffs, guardrails, and runner-managed loops.	Official documentation Primary product or standard behavior
📚 Running agents Docs	OpenAI Developers	OpenAI guide to turns, state, approvals, sessions, and continuation in the SDK runtime loop.	Official documentation Primary product or standard behavior
📚 Integrations and observability Docs	OpenAI Developers	OpenAI guide to MCP wiring and traces as the basis for debugging and evaluation loops.	Official documentation Primary product or standard behavior
📚 Sandbox Agents Docs	OpenAI Developers	Splits the harness control plane from the sandbox execution plane for long-running file and command work.	Official documentation Primary product or standard behavior
📚 Guardrails and human review Docs	OpenAI Developers	Approval and validation boundaries for sensitive agent actions.	Official documentation Primary product or standard behavior
📝 ChatGPT Work and the Codex Desktop App Blog	OpenAI	OpenAI's July 9, 2026 launch of ChatGPT Work, a GPT-5.6-powered agent that stays with a project for hours by breaking a goal into smaller steps and completing them independently across apps and files, alongside Codex merging into the ChatGPT desktop app with in-sidebar PR review and cross-repository projects, extending the long-horizon coding-agent loop pattern to general knowledge work.	Practitioner analysis The linked source required access at the latest check

Resource	Published at	Contribution	Evidence
📚 Building agents with the Claude Agent SDK Docs	Anthropic	Claude SDK overview for tool-using agents, subagents, state, permissions, and streaming.	Official documentation Primary product or standard behavior
📚 How the agent loop works Docs	Claude Code Docs	Official walkthrough of the inner agent loop that outer recurring loops build on.	Official documentation Primary product or standard behavior
📚 Extend Claude with skills Docs	Claude Code Docs	Claude Code skill system for reusable loop instructions and assets.	Official documentation Primary product or standard behavior
📚 Create custom subagents Docs	Claude Code Docs	Claude Code custom subagents with isolated context, model choice, and tool permissions.	Official documentation Primary product or standard behavior
📚 Writing effective tools for AI agents Docs	Anthropic	Anthropic's guidance on evaluating and improving tool specs using agentic loops and realistic tasks.	Official documentation Primary product or standard behavior
📚 Introducing advanced tool use on the Claude Developer Platform Docs	Anthropic	Tool search, programmatic tool calling, and tool-use examples for scaling large tool libraries without flooding context.	Official documentation Primary product or standard behavior
📚 Effective harnesses for long-running agents Docs	Anthropic	Anthropic's guidance for agents that work across many context windows: durable progress artifacts, environment setup, and self-verification.	Official documentation Primary product or standard behavior
📚 Claude Code best practices Docs	Claude Code Docs	Widely cited workflow guidance that underlies many recurring Claude Code loops.	Official documentation Primary product or standard behavior
📚 Claude Managed Agents: Scheduled Deployments and Vaults Docs	Claude	Scheduled deployments for Claude Managed Agents, where each cron firing starts a fresh session to complete the task, plus environment-variable vaults that let sandboxed agents authenticate tools while the real secret attaches only at the network boundary.	Official documentation Primary product or standard behavior
📝 Getting Started with Loops Blog	Claude	Official Claude Code team guide by Delba de Oliveira and Michael Segner (June 30, 2026) that defines loops as agents repeating cycles of work until a stop condition is met, categorizes turn-based, goal-based (/goal), time-based (/loop, /schedule), and proactive loops by trigger and stop criteria, and recommends encoding verification as skills with quantitative success criteria alongside token-spend management.	Practitioner analysis Experience-backed implementation context
📚 Claude Code What's New, Week 28 Docs	2026 · Claude Code Docs	Weekly digest whose loop-integrity features include auto mode blocking tampering with session transcript files and confirmation prompts before destructive operations in unattended runs.	Official documentation Primary product or standard behavior

Resource	Published at	Contribution	Evidence
📚 GitHub Agentic Workflows Docs	GitHub Agentic Workflows	Repository automation that runs coding agents in GitHub Actions on events or schedules with guardrails.	Official documentation Primary product or standard behavior
📚 Continuous AI Docs	githubnext.com	GitHub Next's umbrella framing for CI/CD-style AI automation across the software lifecycle, the category that agentic workflows demonstrate.	Official documentation Primary product or standard behavior
📝 Automate repository tasks with GitHub Agentic Workflows Blog	2026 · The GitHub Blog Don Syme, Peli de Halleux	Official walkthrough of writing Markdown-defined agentic workflows with guardrails for triage, QA, and docs chores, announced in the technical preview changelog.	Practitioner analysis Experience-backed implementation context
📝 Continuous AI in practice: What developers can automate today with agentic CI Blog	2026 · The GitHub Blog GitHub Staff	Concrete agentic-CI automations available today, with recurring patterns for triage, review, and documentation upkeep.	Practitioner analysis Experience-backed implementation context
📚 About GitHub Copilot coding agent Docs	GitHub Docs	GitHub's autonomous coding agent: assign an issue, the agent works in an isolated Actions-powered workspace, and a reviewable pull request comes back.	Official documentation Primary product or standard behavior
📝 GitHub Copilot: Meet the new coding agent Blog	2025 · The GitHub Blog Thomas Dohmke	Launch overview of the issue-to-PR delegation loop, including iteration on review feedback.	Practitioner analysis Experience-backed implementation context
📚 GitHub Copilot for Jira Is Now Generally Available Docs	2026 · The GitHub Blog	General availability of Copilot for Jira: delegate a Jira issue to the Copilot coding agent, monitor session progress inside the issue, and send follow-up instructions that continue the same draft pull request instead of starting a new one.	Official documentation Primary product or standard behavior
📚 Copilot Agent Session Streaming (Public Preview) Docs	2026 · The GitHub Blog	Public preview that streams Copilot agent session activity, including prompts, responses, and tool calls, from cloud agents, the CLI, and IDEs to SIEM-compatible endpoints and a REST API, giving enterprises an audit trail for delegated agent work.	Official documentation Primary product or standard behavior
📚 Security Reviews in the GitHub Copilot App Docs	2026 · The GitHub Blog	Changelog adding on-demand security reviews inside the Copilot app, so an agent's proposed changes can be scanned for vulnerabilities before they are merged.	Official documentation Primary product or standard behavior

Resource	Published at	Contribution	Evidence
📚 Cursor cloud agents Docs	Cursor Documentation	Remote agents that work asynchronously in isolated environments and hand results back for review.	Official documentation Primary product or standard behavior
📚 Cursor 3.8: Improvements to Cursor Automations Docs	Cursor	Cursor 3.8 changelog introducing an /automate skill that configures an automation's triggers, instructions, and tools from a plain-language description, plus Slack emoji-reaction and five new GitHub event triggers for dispatching cloud agents.	Official documentation Primary product or standard behavior
📝 Expanding Our Long-Running Agents Research Preview Blog	Cursor Cursor Team	Cursor's research preview of days-long autonomous agents gated by an upfront human-approved plan and cross-checked by multiple agents, reporting merge rates comparable to standard agents on runs as large as 52 hours and 151k lines.	Practitioner analysis Experience-backed implementation context
📚 Cursor 3.11: Side Chats, Transcript Search, and Cloud Agent Hooks Docs	Cursor	Cursor changelog adding cloud-agent hooks (before-submit, after-response, after-thought, stop, and subagent-start) that the platform pitches for gating and observing background agent runs.	Official documentation Primary product or standard behavior

Resource	Published at	Contribution	Evidence
📚 Jules Docs	Jules	Google's asynchronous coding agent that plans, executes tasks in isolated cloud VMs, and returns reviewable diffs.	Official documentation Primary product or standard behavior
📚 Devin Docs Docs	Devin Docs	Documentation for a long-running autonomous software engineer with sessions, playbooks, knowledge, and review boundaries.	Official documentation Primary product or standard behavior
📝 Amp: Agents, Anywhere Blog	ampcode.com	Amp launches remote agent creation on any machine with shell access plus a headless runner mode that lets multiple agents run concurrently without a terminal UI.	Practitioner analysis Experience-backed implementation context

Research Foundations

Loop Engineering is new as a practice name, but it builds on years of agent-loop, feedback, planning, and self-correction research.

Resource	Published at	Contribution	Evidence
📄 ReAct: Synergizing Reasoning and Acting in Language Models Paper	2023 · International Conference on Learning Representations (ICLR) Shunyu Yao et al.	Foundational reason-act-observe loop for tool-using language agents.	Research paper Published or accepted research record
📄 Reflexion: Language Agents with Verbal Reinforcement Learning Paper	2023 · Advances in Neural Information Processing Systems 36 (NeurIPS) Noah Shinn et al.	Converts environment feedback into written reflections stored in memory for future attempts.	Research paper Published or accepted research record
📄 Self-Refine: Iterative Refinement with Self-Feedback Paper	2023 · Advances in Neural Information Processing Systems 36 (NeurIPS) Aman Madaan et al.	Generate-feedback-refine loop where a model improves outputs over repeated passes.	Research paper Published or accepted research record
📄 CRITIC: Large Language Models Can Self-Correct with Tool-Interactive Critiquing Paper	2024 · International Conference on Learning Representations (ICLR) Zhibin Gou et al.	Uses tools to ground critique and correction rather than relying only on introspection.	Research paper Published or accepted research record
📄 Tree of Thoughts Paper	2023 · Advances in Neural Information Processing Systems 36 (NeurIPS) Shunyu Yao et al.	Search over multiple reasoning branches; relevant when loop design needs exploration before committing.	Research paper Published or accepted research record
📄 Graph of Thoughts Paper	2024 · Proceedings of the AAAI Conference on Artificial Intelligence 38 (AAAI) Maciej Besta et al.	Generalizes thought structures beyond chains and trees, useful for complex loop planning and aggregation.	Research paper Published or accepted research record
📄 Language Agent Tree Search Unifies Reasoning Acting and Planning in Language Models Paper	2024 · Proceedings of the 41st International Conference on Machine Learning (ICML) Andy Zhou et al.	Combines search, action, and environment feedback for language agents.	Research paper Published or accepted research record
📄 Voyager: An Open-Ended Embodied Agent with Large Language Models Paper	2024 · Transactions on Machine Learning Research (TMLR) Guanzhi Wang et al.	Demonstrates lifelong skill acquisition through iterative exploration, feedback, and a skill library.	Research paper Published or accepted research record
📄 Generative Agents: Interactive Simulacra of Human Behavior Paper	2023 · Proceedings of the 36th ACM Symposium on User Interface Software and Technology (UIST) Joon Sung Park et al.	Introduces reflection and memory mechanisms for long-running agent behavior.	Research paper Published or accepted research record
📄 Measuring AI Ability to Complete Long Software Tasks Paper	2025 · Advances in Neural Information Processing Systems 38 (NeurIPS) Thomas Kwa et al.	METR's task-length time horizon metric; grounds why loop budgets, checkpoints, and escalation matter as autonomous work gets longer.	Research paper Published or accepted research record
📝 Measuring AI Ability to Complete Long Tasks Blog	2025 · METR Blog	Accessible summary of the 50% task-completion time horizon and its doubling trend.	Practitioner analysis Experience-backed implementation context
📄 Reflection-Driven Control for Trustworthy Code Agents Paper	2026 · AAAI Workshop on Trust and Control in Agentic AI (TrustAgent) Bin Wang et al.	Elevates reflection from an external pass to an internal control loop that monitors the agent's decision path during generation and constrains risky steps with low overhead.	Research paper Published or accepted research record
📄 Hyperagents Paper	2026 · arXiv Jenny Zhang et al.	Self-referential agents that fold task-solving and self-modification into editable programs, extending the Darwin Godel Machine toward open-ended self-improvement, the loop where an agent rewrites its own improvement mechanism across runs.	Research preprint Preprint; inspect methods and evaluation
📄 PARC: An Autonomous Self-Reflective Coding Agent for Robust Execution of Long-Horizon Tasks Paper	2025 · arXiv Yuki Orimo et al.	Hierarchical plan-execute-assess loops that detect and correct strategic errors during multi-hour autonomous runs.	Research preprint Preprint; inspect methods and evaluation
📄 When the Specification Emerges: Benchmarking Faithfulness Loss in Long-Horizon Coding Agents Paper	2026 · arXiv Lu Yan et al.	Measures how agents drift from intent when specifications arrive incrementally across a long loop, and proposes a mitigation that recovers most of the loss.	Research preprint Preprint; inspect methods and evaluation
🧰 Reflexion code Tool	2023 · GitHub noahshinn/reflexion · License: MIT	Reference implementation and experiments for verbal reinforcement loops.	Source implementation Inspectable source and runtime behavior
📄 Stop Hand-Holding Your Coding Agent: Engineering the Loops that Replace Step-by-Step Prompting Paper	2026 · arXiv Sandeco Macedo	Position paper that formalizes the loop specification (trigger, goal, verification step, stopping rule, memory) as a reusable artifact handed to an agent harness, with a taxonomy, a five-level verification ladder, and a hand-coded analysis of fifty real-world loops.	Research preprint Preprint; inspect methods and evaluation
📄 From Question Answering to Task Completion: A Survey on Agent System and Harness Design Paper	2026 · arXiv Jianyuan Guo et al.	Survey that decomposes the agent execution harness into six runtime responsibilities (observation, context, control, action, state, verification) and argues task performance emerges from the interaction of model, runtime, task structure, and evaluation rather than the model alone.	Research preprint Preprint; inspect methods and evaluation
📄 MOSS: Self-Evolution through Source-Level Rewriting in Autonomous Agent Systems Paper	2026 · arXiv Qianshu Cai et al.	Self-evolution loop where the agent rewrites its own source code, with each change anchored to a production failure and accepted only after deterministic replay verification with rollback, lifting a four-task mean grader score from 0.25 to 0.61 without human intervention.	Research preprint Preprint; inspect methods and evaluation
📝 METR Time Horizon 1.1 Blog	2026 · METR Blog	Update to METR's time-horizon methodology, expanding the task suite to 228 tasks (31 at 8+ hours), migrating to the open-source Inspect framework, and revising the post-2023 capability doubling time to roughly 131 days.	Practitioner analysis Experience-backed implementation context
📄 MetaSkill-Evolve: Recursive Self-Improvement via Two-Timescale Meta-Skill Evolution Paper	2026 · arXiv Zefeng Wang et al.	Two-timescale recursive self-improvement where a fast loop rewrites task skills from execution traces while a slow loop evolves the meta-skill governing improvement itself, gaining up to 23.5 points on OfficeQA, SealQA, and ALFWorld.	Research preprint Preprint; inspect methods and evaluation
📄 SkillOpt-Lite: Better and Faster Agent Self-Evolution via One Line of Vibe Paper	2026 · arXiv Yifei Shen et al.	Formalizes agent skill self-evolution as zeroth-order optimization and distills it into a minimal pipeline of file-system trajectory exploration, consensus attribute mining, and independent validation gating, letting a smaller model surpass larger ones on LiveMath and SpreadsheetBench.	Research preprint Preprint; inspect methods and evaluation
📄 Recursive Self-Improvement in AI: From Bounded Self-Refinement to Autonomous Research Loops Paper	2026 · arXiv Mingguang Chen et al.	Survey of 1,250 arXiv papers from 2024-2026 organized along two axes, what a self-improvement loop improves and its degree of loop closure, separating bounded evaluable self-refinement from open-ended recursive self-improvement.	Research preprint Preprint; inspect methods and evaluation
📄 From Atomic Actions to Standard Operating Procedures: Iterative Tool Optimization for Self-Evolving LLM Agents Paper	2026 · arXiv Haipeng Ding et al.	EvoSOP has agents distill recurring execution trajectories into reusable standard operating procedures and iteratively optimize the toolset through a construction, merging, evaluation, and pruning lifecycle.	Research preprint Preprint; inspect methods and evaluation
📄 TTHE: Test-Time Harness Evolution Paper	2026 · arXiv Jun Nie et al.	Adapts LLM agents at test time by evolving a population of candidate harnesses (the executable control program around the model) from execution traces, using a label-free agentic proposer and judge to sustain improvements on text-to-SQL and competitive programming while flagging execution-derived proxy reliability as the key open challenge.	Research preprint Preprint; inspect methods and evaluation
📄 DeepSearch-World: Self-Distillation for Deep Search Agents in a Verifiable Environment Paper	2026 · arXiv Xinyu Geng et al.	Introduces DeepSearch-Evolve, where a deep search agent improves by self-distilling its own trajectories inside a deterministic 420K-task verifiable environment, progress verification, grounded reflection, and failure recovery replace teacher trajectories and sparse RL reward, lifting a 9B model to 31.2% BrowseComp and 61.5% GAIA.	Research preprint Preprint; inspect methods and evaluation
📄 What Makes a Good Bug Report for an AI Agent? Paper	2026 · arXiv Lara Khatib et al.	Statistical analysis of 433 issues plus controlled multi-model experiments showing LLM repair agents succeed more when bug reports carry reproduction scripts, fix suggestions, and fault-localization cues, while longer natural-language reports correlate with lower success, directly informing how a loop's work-discovery step should specify tasks before dispatching agents.	Research preprint Preprint; inspect methods and evaluation
📄 AutoPersonas: A Multi-Timescale Loop Engine for Open-Ended Persona Evolution Paper	2026 · arXiv Mengchen Li	Names self-locking as a runtime failure mode of continuing agent loops, where accumulated state and history pull generation toward stale repetition (over 95% rolling action-repetition across an eight-model 40-day stress test), and proposes a multi-timescale loop that admits divergent material only through evidence-governed absorption, cutting macro-theme repetition from 61.8% to 36.3%.	Research preprint Preprint; inspect methods and evaluation
📄 Agentic Data Environments Paper	2026 · IEEE Data Engineering Bulletin 50(1) Elaine Ang et al.	Vision paper from the IEEE Data Engineering Bulletin reframing data systems as the active execution environment agents operate in, spanning files, APIs, applications, and system state, arguing the substrate under recurring agent loops should both amplify agent capability and enforce safety guarantees that bound the cost of failure.	Research paper Published or accepted research record
📄 Better Harnesses, Smaller Models: Building 90% Cheaper Agents via Automated Harness Adaptation Paper	2026 · arXiv Chenyang Yang et al.	Meta agent maps observed failure modes to harness adaptation strategies, letting small-model agents recover ~90% of frontier-LLM performance at ~4% of the cost, the harness itself becomes the optimization target.	Research preprint Preprint; inspect methods and evaluation
📄 Inside the Skill Market: From Software Engineering Activities to Reusable Agent Skills Paper	2026 · arXiv Jialun Cao et al.	First large-scale empirical study of public agent-skill repositories and marketplaces, characterizing which software-engineering activities get packaged as reusable skills, their coverage across the development lifecycle, how they evolve, and how they are evaluated - an activity-centric map of the skills layer that agent loops compose (Cao, Cheung, et al., HKUST).	Research preprint Preprint; inspect methods and evaluation
📝 Harness Engineering for Self-Improvement Blog	2026 · lilianweng.github.io Lilian Weng	Lilian Weng's deep-dive arguing the harness, the system surrounding a base model that orchestrates execution, matters as much as raw intelligence for recursive self-improvement, with a taxonomy of harness components and failure modes.	Practitioner analysis Experience-backed implementation context
📄 Compile, Then Page: Executable SOP Programs and a Capability-Gated Runtime Paper	2026 · arXiv Chenglin Yu et al.	Compiles safety-critical standard operating procedures into executable pseudo-code run by a program-guided stack machine that pages the active frame while the LLM does semantic execution, finding runtime guidance is capability-gated (it helps strong models and harms weak ones) across a six-model, seven-domain SOPBench study.	Research preprint Preprint; inspect methods and evaluation
📄 Mako: A Self-Evolving Agentic Operating System for Autonomous Web Exploitation Paper	2026 · arXiv Praneeth Narisetty & Shiva Nagendra Babu Kore	Industrial self-evolving agentic OS that treats exploit capability as a mutable, versioned kernel: the agent observes its own failures, synthesizes new capabilities, proves them against a live target, and hot-loads them back, a self-improvement loop with in-loop verification.	Research preprint Preprint; inspect methods and evaluation
📄 How Do Practitioners Build SE Agents? Insights from a Mixed-Methods Study Paper	2026 · arXiv Yunbo Lyu et al.	Mixed-methods study of how practitioners actually design software-engineering agents, surfacing the recurring loop, harness, and verification decisions teams make and where their mental models diverge from benchmark assumptions.	Research preprint Preprint; inspect methods and evaluation
📄 Dynamic Agent Skills: A Lifecycle Survey and Taxonomy of Evolving Skill Libraries Paper	2026 · Transactions on Machine Learning Research (TMLR) Yubo Li	Survey and taxonomy of how agent skill libraries are created, evaluated, retired, and reused over time, organizing the fast-growing self-evolving-skills literature into a lifecycle framework.	Research paper Published or accepted research record

Resource	Published at	Contribution	Evidence
📄 SIA: Self Improving AI with Harness & Weight Updates Paper	2026 · arXiv Prannay Hebbar et al.	Co-evolves a task agent's harness and model weights through a meta-agent, target agent, and feedback agent that evaluate outcomes and carry improvements across generations.	Research preprint Preprint; inspect methods and evaluation

Model-Level Recurrence

Use these works to understand the inner computation of the model that an agent may call. Looped, recurrent-depth, and recursive models reuse learned computation within one inference to refine hidden states, vary effective depth, or simulate dynamics. Operational Loop Engineering sits outside that inference and decides when work runs, what tools and context are allowed, what evidence proves progress, what state survives, and when to retry, escalate, or stop.

Question	Model-level recurrence	Agent or operating loop
What repeats?	A shared layer, block, module, or latent-state update	A model/tool/action cycle or a complete agent run
Where is state?	Hidden activations or learned latent state	Context, files, checkpoints, traces, queues, and systems of record
What controls depth?	Fixed recurrences, learned halting, routing, or compute budget	Trigger policy, verification result, retry budget, escalation, and exit
What proves success?	Task accuracy, loss, calibration, efficiency, or rollout fidelity	External tests, evals, receipts, approvals, service thresholds, or human review
How do they connect?	Supplies a model with stronger or more adaptive internal computation	Governs how that model acts repeatedly in a real environment

Every entry below is tagged Model layer · Adjacent foundation in the README and exported as loop_layer=model, scope_fit=adjacent in the dataset.

Foundations And Theory

Resource	Published at	Contribution	Evidence
📄 Universal Transformers Paper · Model layer · Adjacent foundation	2019 · International Conference on Learning Representations (ICLR) Mostafa Dehghani et al.	Introduces recurrent depth for Transformers by repeatedly applying shared self-attention and transition blocks, with optional per-position adaptive halting; establishes the architectural foundation for later looped models.	Research paper Published or accepted research record
📄 Looped Transformers as Programmable Computers Paper · Model layer · Adjacent foundation	2023 · International Conference on Machine Learning Angeliki Giannou et al.	Constructs a constant-depth looped Transformer that advances an in-state program counter and executes reusable instructions, showing how iterative algorithms and in-context gradient descent can be represented through repeated shared computation.	Research paper Published or accepted research record
📄 Looped Transformers are Better at Learning Learning Algorithms Paper · Model layer · Adjacent foundation	2024 · International Conference on Learning Representations (ICLR) Liu Yang et al.	Trains input-injected looped Transformers for in-context data fitting and shows that iterative shared computation can match standard Transformers on tested function classes with substantially fewer parameters.	Research paper Published or accepted research record
📄 On Expressive Power of Looped Transformers: Theoretical Analysis and Enhancement via Timestep Encoding Paper · Model layer · Adjacent foundation	2025 · International Conference on Machine Learning Kevin Xu & Issei Sato	Derives approximation rates for looped Transformers, identifies a loop-specific expressivity limit, and uses timestep-conditioned scaling to improve function approximation as recurrence increases.	Research paper Published or accepted research record
📄 Reasoning with Latent Thoughts: On the Power of Looped Transformers Paper · Model layer · Adjacent foundation	2025 · International Conference on Learning Representations (ICLR) Nikunj Saunshi et al.	Connects effective recurrent depth to reasoning, proves that looped models can simulate multi-step chain-of-thought in latent space under the paper's construction, and studies the trade-off between reasoning and memorization.	Research paper Published or accepted research record

Latent Reasoning And Adaptive Compute

Resource	Published at	Contribution	Evidence
📄 Scaling up Test-Time Compute with Latent Reasoning: A Recurrent Depth Approach Paper · Model layer · Adjacent foundation	2025 · Advances in Neural Information Processing Systems 38 (NeurIPS 2025) Jonas Geiping et al.	Presents Huginn, a 3.5B recurrent-depth language model trained on 800B tokens whose shared core can be unrolled further at inference, with gains concentrated on reasoning tasks and support for adaptive compute and KV-cache sharing.	Research paper Published or accepted research record
📄 Mixture-of-Recursions: Learning Dynamic Recursive Depths for Adaptive Token-Level Computation Paper · Model layer · Adjacent foundation	2025 · Advances in Neural Information Processing Systems 38 (NeurIPS 2025) Sangmin Bae et al.	Combines shared recursive layers with token-level routers so difficult tokens receive more depth while attention and KV caching are restricted to active tokens.	Research paper Published or accepted research record
📄 Scaling Latent Reasoning via Looped Language Models Paper · Model layer · Adjacent foundation	2025 · arXiv Rui-Jie Zhu et al.	Introduces the Ouro family of pretrained LoopLMs, combining latent iteration, learned depth allocation, and large-scale pretraining to study recurrent depth as a scaling axis distinct from parameter count and generated reasoning tokens.	Research preprint Preprint; inspect methods and evaluation
📄 LoopFormer: Elastic-Depth Looped Transformers for Latent Reasoning via Shortcut Modulation Paper · Model layer · Adjacent foundation	2026 · International Conference on Learning Representations (ICLR) Ahmadreza Jeddi et al.	Trains variable-length latent trajectories with time and step-size conditioning plus shortcut consistency, allowing one model to trade compute for quality across inference budgets without retraining.	Research paper Published or accepted research record
📄 MoDr: Mixture-of-Depth-Recurrent Transformers for Test-Time Reasoning Paper · Model layer · Adjacent foundation	2026 · International Conference on Learning Representations (ICLR) Xiaojing Zhang et al.	Replaces a single recurrent reasoning path with dynamically routed LoRA branches, adding solution-space exploration and load-balanced routing to the Huginn-style depth-recurrent backbone.	Research paper Published or accepted research record
📄 ChainGPT: Dual-Reasoning Model with Recurrent Depth and Multi-Rank State Updates Paper · Model layer · Adjacent foundation	2026 · International Conference on Learning Representations (ICLR) Yunao Zheng et al.	Combines within-layer multi-substep state updates, state-guided sparse attention, across-layer recurrence, and adaptive stopping to increase latent reasoning depth without extending visible chain-of-thought.	Research paper Published or accepted research record
📄 Think-at-Hard: Selective Latent Iterations to Improve Reasoning Language Models Paper · Model layer · Adjacent foundation	2026 · International Conference on Machine Learning (ICML) Tianyu Fu et al.	Learns when a token needs extra latent refinement, using a neural decider, depth-aware LoRA, and cross-iteration attention to avoid always paying for or being degraded by additional loops.	Research paper Published or accepted research record
📄 Fixed-Point Reasoners: Stable and Adaptive Deep Looped Transformers Paper · Model layer · Adjacent foundation	2026 · Proceedings of the 43rd International Conference on Machine Learning (ICML), PMLR 306 Sajad Movahedi et al.	Stabilizes very deep recurrence with pre-normalization and residual scaling, then uses latent-state convergence as the halting signal so the model allocates more iterations to harder Sudoku, maze, state-tracking, and ARC-AGI instances without a separate stopping head.	Research paper Published or accepted research record

Scaling, Stability, And Mechanistic Evidence

Resource	Published at	Contribution	Evidence
📄 Loop the Loopies! Paper · Model layer · Adjacent foundation	2026 · arXiv Zitian Gao et al.	Introduces the Loopie family of sparse looped Transformers (20B parameters with 2B active and 6B with 0.6B active); the authors' matched-compute experiments over 3.5T pretraining tokens overtake a reproduced vanilla 30B-A3B baseline after roughly 600B tokens, while post-training plus test-time scaling reaches 35/42 on IMO 2025 and 20.3 on IPhO 2025. The paper announces preview weights and code, but those artifacts are not yet public.	Research preprint Preprint; inspect methods and evaluation
📄 LoopMoE: Unifying Iterative Computation with Mixture-of-Experts for Language Modeling Paper · Model layer · Adjacent foundation	2026 · arXiv Wenkai Chen et al.	Combines sparse expert routing with weight-shared recurrence through iteration-conditioned adaptive normalization and capacity balancing; under matched parameters, per-token FLOPs, and active-sublayer ratios, the reported 3B model beats its vanilla MoE control on 8 of 9 benchmarks by more than one point on average, with the advantage persisting at 9B.	Research preprint Preprint; inspect methods and evaluation
📄 Sparse Layers are Critical to Scaling Looped Language Models Paper · Model layer · Adjacent foundation	2026 · arXiv Ryan Lee et al.	Finds that dense looped models lose their scaling advantage while looped MoE models recover expressivity because routing diverges across repeated passes; also shows that loop boundaries form stronger early-exit points than arbitrary layers in standard Transformers.	Research preprint Preprint; inspect methods and evaluation
📄 A Mechanistic Analysis of Looped Reasoning Language Models Paper · Model layer · Adjacent foundation	2026 · arXiv Hugh Blayney et al.	Traces cyclic recurrence inside looped language models and finds that many studied layers converge to distinct fixed points, with attention behavior stabilizing as recurrent blocks repeat feedforward-like inference stages; tests how block size, input injection, and normalization shape those dynamics.	Research preprint Preprint; inspect methods and evaluation
📄 Parcae: Scaling Laws For Stable Looped Language Models Paper · Model layer · Adjacent foundation	2026 · Learning to Iterate Workshop at ICLR 2026 Hayden Prairie et al.	Treats the recurrent block as a dynamical system, constrains its stability, and studies how training and test-time recurrence trade parameters for additional computation.	Research paper Published or accepted research record
📄 SpiralFormer: Looped Transformers Can Learn Hierarchical Dependencies via Multi-Resolution Recursion Paper · Model layer · Adjacent foundation	2026 · arXiv Chengting Yu et al.	Recurs over progressively compressed representations so repeated layers specialize across resolutions instead of recomputing every token at full resolution.	Research preprint Preprint; inspect methods and evaluation
📄 Training-Free Looped Transformers Paper · Model layer · Adjacent foundation	2026 · arXiv Lizhang Chen et al.	Retrofits recurrence onto frozen pretrained models by applying a damped mid-stack block as smaller refinement steps, testing when inference-time looping helps without fine-tuning.	Research preprint Preprint; inspect methods and evaluation
📄 Loop, Think, & Generalize: Implicit Reasoning in Recurrent-Depth Transformers Paper · Model layer · Adjacent foundation	2026 · arXiv Harsh Kohli et al.	Shows systematic generalization and depth extrapolation in controlled recurrent-depth reasoning tasks while documenting overthinking when recurrence exceeds the useful computation horizon.	Research preprint Preprint; inspect methods and evaluation
📄 DeepLoop: Depth Scaling for Looped Transformers Paper · Model layer · Adjacent foundation	2026 · arXiv Shuzhen Li et al.	Derives residual-scaling rules that account for repeated parameter visits and tests them on GPT-style looped language models, addressing instability that nominal layer depth alone misses.	Research preprint Preprint; inspect methods and evaluation
📄 How Much Is One Recurrence Worth? Iso-Depth Scaling Laws for Looped Language Models Paper · Model layer · Adjacent foundation	2026 · arXiv Kristian Schwethelm et al.	Separates recurrent passes from unique parameter depth and training compute to estimate when an additional loop is worth more than adding distinct layers.	Research preprint Preprint; inspect methods and evaluation

Code, World Models, And Architecture Bridges

Resource	Published at	Contribution	Evidence
📄 LoopCoder: Scaling Code Intelligence via Looped Language Models Paper · Model layer · Adjacent foundation	2026 · Findings of the Association for Computational Linguistics: ACL 2026 Jian Yang et al.	Scales looped code models through dense-to-loop initialization, recurrent pretraining, and post-training; the Findings of ACL 2026 paper reports a 40B-active/80B-total model trained on more than 12T code and general tokens.	Research paper Published or accepted research record
📄 Looped World Models Paper · Model layer · Adjacent foundation	2026 · arXiv Hongyuan Adam Lu et al.	Introduces LoopWM, which repeatedly refines action-conditioned latent environment states with a parameter-shared Transformer core, stability constraints, and adaptive early exit for long-horizon simulation.	Research preprint Preprint; inspect methods and evaluation
📄 Bridging the Gap Between Latent and Explicit Reasoning with Looped Transformers Paper · Model layer · Adjacent foundation	2026 · arXiv Ying Fan et al.	Introduces LOTUS, which loops over parallel latent thought blocks with intermediate supervision and reports explicit-chain-of-thought-level quality at 3B scale with lower thought-phase latency.	Research preprint Preprint; inspect methods and evaluation
📄 Looped SSMs: Depth-Recurrence and Input Reshaping for Time Series Classification Paper · Model layer · Adjacent foundation	2026 · arXiv Mónika Farsang et al.	Extends tied-depth recurrence beyond Transformers by repeatedly applying a shared state-space block and reshaping inputs across iterations, testing which loop principles transfer across model families.	Research preprint Preprint; inspect methods and evaluation
📄 Looped Diffusion Language Models Paper · Model layer · Adjacent foundation	2026 · arXiv Sanghyun Lee et al.	Applies selective shared-layer recurrence to masked diffusion language models so effective depth can scale during training and inference without adding parameters.	Research preprint Preprint; inspect methods and evaluation

For a deeper architecture-only index, use Awesome Loop Models in the adjacent-list catalog below. Its stricter model definition complements this section; the resources above are the bridge most relevant to agents, coding systems, adaptive compute, and world simulation.

Agent Workflow Patterns

Use these resources to design the higher-level loop around agents: recurring control flow, delegation, verification, state, and next-action decisions.

Resource	Published at	Contribution	Evidence
📚 Building Effective Agents Docs	Anthropic	Anthropic's canonical guide to workflows and agents, including evaluator-optimizer and orchestrator-workers patterns.	Technical documentation Technical reference from the source
📄 Harness Engineering for Language Agents: The Harness Layer as Control, Agency, and Runtime Paper	2026 · Preprints.org Chaoyue He et al.	Decomposes the harness layer that loops build on into control, agency, and runtime, audits 63 harness works, and proposes a HarnessCard so reported agent gains can be separated from harness effects.	Research paper The linked source required access at the latest check
📝 How we built our multi-agent research system Blog	Anthropic	Detailed orchestrator-worker system with planning, memory, subagents, citation passes, and iterative research loops.	Practitioner analysis Experience-backed implementation context
📄 Building Effective AI Agents: Architecture Patterns and Implementation Frameworks Paper	2025 · Anthropic eBook Anthropic	PDF overview of agent architecture patterns, including generator-evaluator loops.	Research paper Published or accepted research record
📝 AI Agent Architectures Blog	The HLD Handbook	System-design overview of ReAct, reflection, planning, tool use, memory, and control strategies.	Practitioner analysis Experience-backed implementation context
📝 What Are Agentic Workflows? Blog	2025 · weaviate.io	Accessible taxonomy of planning, tool use, reflection, and memory patterns.	Practitioner analysis Experience-backed implementation context
📝 Agent Planning & Reflection Patterns Blog	Learn AI Visually	Visual explanation of plan-execute, observe, reflect, retry, and stop patterns.	Practitioner analysis Experience-backed implementation context
📝 Agentic Design Patterns Blog	addyosmani.com Addy Osmani	Practical overview of ReAct, reflection, tool use, planning, and how to combine them in real-world agents.	Practitioner analysis Experience-backed implementation context
🔁 12 Factor Agents Pattern	2025 · GitHub humanlayer/12-factor-agents	Operating principles for production agents, including explicit prompts, state ownership, and pause-resume behavior.	Operational pattern Transferable operating practice
🔁 Durable Execution for Agentic Workflows Pattern	2026 · Arizen	Explains checkpointing, event-sourced journals, replay, and recovery for long-running agent workflows.	Operational pattern Transferable operating practice
📄 Code as Agent Harness Paper	2026 · arXiv Xuying Ning et al.	Organizes agent infrastructure into harness interface, feedback-driven control, and multi-agent scaling for executable, verifiable, stateful systems; maps the harness layer that loops build on.	Research preprint Preprint; inspect methods and evaluation
📄 Agentic Agile-V: From Vibe Coding to Verified Engineering Paper	2026 · arXiv Christopher Koch	Proposes a task-level SCOPE-V loop (Specify, Constrain, Orchestrate, Prove, Evolve, Verify) with human approval gates, arguing agentic coding needs process control and independent verification, not better prompts.	Research preprint Preprint; inspect methods and evaluation
📄 Agentic Software Engineering: Foundational Pillars and a Research Roadmap Paper	2025 · arXiv Ahmed E. Hassan et al.	Splits agentic SE into an Agent Command Environment for human orchestration and an Agent Execution Environment for agent task execution, a research roadmap for the layers recurring loops run inside.	Research preprint Preprint; inspect methods and evaluation
📝 The Art of Loop Engineering Blog	LangChain	LangChain's account of four stacked loops around agents (core execution, rubric-based verification, event-driven triggers, and trace-driven self-improvement) using a documentation-writing agent as the running example.	Practitioner analysis Experience-backed implementation context
🧰 Loopy Tool	2026 · GitHub Forward-Future/loopy · License: MIT	Library of reusable AI-agent loops with verification checks and stopping conditions, plus an installable skill for finding, adapting, and designing repeatable agent workflows.	Source implementation Inspectable source and runtime behavior
📝 The Factory Model: How Coding Agents Changed Software Engineering Blog	addyosmani.com Addy Osmani	Addy Osmani's February 2026 essay recasting engineers as operators of parallel agent workstreams, with agents running "thirty minutes, an hour, several hours and increasingly days" and verification, not generation, as the new bottleneck; the fleet-level framing that precedes his June Loop Engineering essay.	Practitioner analysis Experience-backed implementation context
📚 2026 Agentic Coding Trends Report Docs	2026 · Anthropic	Anthropic's official 2026 trends report on the shift from single coding assistants to coordinated agent teams running autonomously for hours or days, with case studies from Rakuten, TELUS, and Zapier (landing page is registration-gated; the direct PDF is public).	Technical documentation Technical reference from the source
🧰 HomeRail Tool	2026 · GitHub xiaotianfotos/homerail · License: MIT	TypeScript runtime that turns one-off agent chats into auditable, reusable DAG workflows on self-hosted hardware, with a DAG engine, CLI, and voice front end.	Source implementation Inspectable source and runtime behavior
📝 Old and New Apps, via Modern Coding Agents Blog	2026 · What's new	Terence Tao's July 11, 2026 account of porting roughly two dozen Java 1.0 applets to JavaScript and resurrecting long-abandoned projects through iterative agent sessions, concluding that domain expertise remains the human verification layer: high-level design decisions stay with the author while implementation is automated away, and the exchange was "a net wash" on code quality, he caught one minor bug in the agent's output while the agent found two bugs in his original code. Named-practitioner post; loop content is iterative-refinement rather than unattended loops, so it fits the practitioner-workflow section rather than core loop patterns.	Practitioner analysis Experience-backed implementation context
📄 Harness Handbook: Making Evolving Agent Harnesses Readable,Navigable, and Editable Paper	2026 · arXiv Ruhan Wang et al.	Introduces a behavior-centered source map and behavior-guided program decomposition for evolving harnesses, improving behavior localization and edit planning on two agent harnesses while reducing planner token use.	Research preprint Preprint; inspect methods and evaluation
📄 MemoHarness: Agent Harnesses That Learn from Experience Paper	2026 · arXiv Yue Huang et al.	Lets an agent adapt six harness dimensions per case using a dual-layer experience memory; results improve over fixed harnesses, while broad robustness and the contribution of each adaptive component remain open questions.	Research preprint Preprint; inspect methods and evaluation
📄 Recursive Harness Self-Improvement Paper	2026 · arXiv Hyunin Lee et al.	Represents an agent loop as a prompt-level harness specification and iteratively revises it from pairwise feedback over its own history; across 30 synthetic machine-learning research tasks, a few revisions lift low-reasoning agents above the corresponding maximum-reasoning setting while cutting inference cost by up to 60%, primarily through better context flow between agents.	Research preprint Preprint; inspect methods and evaluation
📄 SkillCorpus: Consolidating and Evaluating the Open Skill Ecosystem for Real-World LLM Agents Paper	2026 · arXiv Yanze Wang et al.	Filters roughly 821,000 crawled agent skills into a 96,401-item corpus with a 16-class taxonomy and utility, robustness, and safety facets; evaluations across three benchmarks, two harnesses, and two open models report gains up to 7.5 percentage points while exposing both coverage and harness boundaries. The announced dataset, models, and code are pending release.	Research preprint Preprint; inspect methods and evaluation
📄 Behavioral Controllability of Agentic Models for Information Extraction: From Fixed Workflows to Reflective Agents Paper	2026 · arXiv Lujia Zhang et al.	Compares a fixed extraction workflow with reflective variants under one evaluation harness, measuring tool execution, retries, reflection, memory use, runtime, and recovery so agentic mechanisms can be judged by observable process changes rather than output scores alone.	Research preprint Preprint; inspect methods and evaluation
📄 Understanding Agent-Reactive Bugs at the Model-Harness Boundary: An Empirical Study of LLM Agent Issue Reports Paper	2026 · arXiv Jingyi Chen et al.	Manually analyzes 255 issue reports from Codex, Gemini CLI, LangChain, and CrewAI to classify bugs triggered by an interaction between model output and harness behavior; silent failures, weak test oracles, and stochastic reproduction motivate dedicated replay and fault-localization support.	Research preprint Preprint; inspect methods and evaluation
📄 SciForge: An AI-Native, Multimodal Workbench for Scientific Discovery Paper	2026 · arXiv SciForge Team et al.	Organizes long-running scientific work around goal-scoped review gates, domain translators, an agent runtime and workflow engine, and an evidence DAG that links claims to provenance; eight end-to-end cases include multi-day research sprints, while deeper team collaboration remains planned work.	Research preprint Preprint; inspect methods and evaluation

Coding-Agent Loop Systems

End-to-end systems and field reports of coding agents running in loops, from single-repo Ralph runners to production agent fleets.

Resource	Published at	Contribution	Evidence
🧰 SWE-agent Tool	2024 · GitHub SWE-agent/SWE-agent · License: MIT	Agent-computer interface and autonomous software engineering agent for repository tasks.	Source implementation Inspectable source and runtime behavior
📄 SWE-agent: Agent-Computer Interfaces Enable Automated Software Engineering Paper	2024 · Advances in Neural Information Processing Systems 37 (NeurIPS) John Yang et al.	Paper behind SWE-agent and its interface design.	Research paper Published or accepted research record
🧰 mini-SWE-agent Tool	mini-swe-agent.com	Minimal coding agent that is useful for understanding the core loop without a large framework.	Implementation Working implementation or runtime
🧰 OpenHands Tool	2024 · GitHub All-Hands-AI/OpenHands	Open platform for AI software developers as generalist agents.	Source implementation Inspectable source and runtime behavior
📄 OpenHands: An Open Platform for AI Software Developers as Generalist Agents Paper	2025 · International Conference on Learning Representations (ICLR) Xingyao Wang et al.	Paper describing OpenHands, CodeActAgent, benchmarks, and generalist agent evaluation.	Research paper Published or accepted research record
🧰 Agentless Tool	2024 · GitHub OpenAutoCoder/Agentless · License: MIT	Workflow-based approach for software issue resolution using localization, repair, and patch validation.	Source implementation Inspectable source and runtime behavior
📄 Agentless: Demystifying LLM-based Software Engineering Agents Paper	2024 · arXiv Chunqiu Steven Xia et al.	Useful contrast case: strong results through structured workflow rather than a fully open-ended agent.	Research preprint Preprint; inspect methods and evaluation
🧰 AutoCodeRover Tool	2024 · GitHub AutoCodeRoverSG/auto-code-rover	Autonomous program improvement system for issue localization, patch generation, and validation.	Source implementation Inspectable source and runtime behavior
📄 AutoCodeRover: Autonomous Program Improvement Paper	2024 · Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA) Yuntong Zhang et al.	Paper on autonomous code repair loops over real repositories.	Research paper Published or accepted research record
🧭 SWE-bench reading list List	2025 · GitHub SWE-bench/reading-list	Maintained map of software engineering agent systems and related papers.	Discovery index Broader ecosystem coverage for finding related work
📄 TraceCoder: A Trace-Driven Multi-Agent Framework for Automated Debugging of LLM-Generated Code Paper	2026 · Proceedings of the 48th IEEE/ACM International Conference on Software Engineering (ICSE) Jiangping Huang et al.	ICSE'26 observe-analyze-repair loop with instrumentation, analysis, and repair agents, a history-learning mechanism, and a rollback to the last good state; iteration alone drives most of the gain.	Research paper Published or accepted research record
📄 The Kitchen Loop: User-Spec-Driven Development for a Self-Evolving Codebase Paper	2026 · arXiv Yannick Roy	Production loop where an agent exercises a spec surface as a synthetic power user behind ground-truth tests and quality gates, reporting 285+ self-correcting iterations and 1,000+ merged PRs with zero detected regressions.	Research preprint Preprint; inspect methods and evaluation
📄 Inside the Scaffold: A Source-Code Taxonomy of Coding Agent Architectures Paper	2026 · arXiv Benjamin Rombaut	Dissects 13 open-source coding-agent scaffolds and identifies five composable loop primitives (ReAct, generate-test-repair, plan-execute, retry, tree search) that real agents layer, mapping how control loop, tools, and state combine.	Research preprint Preprint; inspect methods and evaluation
📄 A Self-Improving Coding Agent Paper	2025 · arXiv Maxime Robeyns et al.	An agent that edits its own code and tools and re-runs against a benchmark, lifting itself from 17% to 53% on a SWE-bench Verified subset, a concrete self-modifying improvement loop.	Research preprint Preprint; inspect methods and evaluation
📄 Don't Blame the Large Language Model: How Scaffolding Evolution Shapes Coding Agent Quality Paper	2026 · arXiv Oussama Ben Sghaier et al.	Longitudinal study of 35 Qwen Code CLI releases with the model held constant, tracing coding-agent shifts to specific scaffolding changes in system prompts, tools, context management, and reasoning loops, and separating scaffolding regressions from model regressions.	Research preprint Preprint; inspect methods and evaluation
📄 ToFu: A White-Box, Token-Efficient Agent Harness for Researchers Paper	2026 · arXiv Junhao Ruan et al.	MIT-licensed white-box agent harness built on the thesis that agent behavior is set by the orchestration code around the model as much as the model itself, letting researchers inspect, modify, and evaluate its orchestration logic with reported token-efficiency gains over existing harnesses.	Research preprint Preprint; inspect methods and evaluation
📄 When Does Restricting a Coding Agent to execute_code Help? Paper	2026 · KDD Workshop on Agentic Software Engineering (SE 3.0) Hong Yang et al.	Regime-by-design ablation measuring when constraining a coding agent to a single execute_code action helps or hurts, separating task regime from agent design so harness choices can be made from evidence rather than intuition.	Research paper Published or accepted research record
📄 Agentic Synthesis against Counterexample-Supplemented Sketches Paper	2026 · arXiv Muness Castle & Eric Rubeck	Turns human-approved failures into durable policy: a coding agent revises a code-shaped sketch, regenerates code and prompt surfaces, preserves provenance, and must pass a regression gate before seeing the next case. In one captured run, the evolved-sketch rebuild passes 19 of 21 withheld cases versus 15 of 21 for replaying accepted examples; the single-model, single-order study does not establish general superiority.	Research preprint Preprint; inspect methods and evaluation
📄 Making Agent-Mediated Contributions Governable: A Project-Level Governance Manifest for Open-Source AI Collaboration Paper	2026 · arXiv Jinjin Gao et al.	Defines a repository-hosted governance contract connecting contributor evidence with maintainer verification and decision authority; after an audit of 50 repositories, a 15-reviewer study improves exact risk-label recovery from 15/37 to 37/38 with the manifest-supported materials.	Research preprint Preprint; inspect methods and evaluation

Resource	Published at	Contribution	Evidence
🔁 Ralph Pattern	2025 · Geoffrey Huntley	Geoffrey Huntley's original Ralph technique: run one agent in a bare loop with fresh context per iteration and the filesystem plus specs as memory.	Operational pattern Transferable operating practice
🔁 everything is a ralph loop Pattern	2026 · Geoffrey Huntley	Follow-up essay arguing the loop, not the agent, is the durable engineering unit: one task per iteration, deterministic context, and verification inside the loop.	Operational pattern Transferable operating practice
🧰 how-to-ralph-wiggum Tool	2026 · GitHub ghuntley/how-to-ralph-wiggum	Reference repository documenting the Ralph Wiggum technique end to end, from the bare loop script to guardrails and conventions.	Source implementation Inspectable source and runtime behavior
📝 A Brief History of Ralph Blog	2026 · humanlayer.dev	Traces how the bare-loop technique spread from a provocation to a production practice among early adopters.	Practitioner analysis Experience-backed implementation context
🔁 Ralph Copilot Pattern	2026 · GitHub giocaizzi/ralph-copilot	Language-agnostic Ralph loop implementation using fresh context, filesystem memory, PRD.md, and PROGRESS.md.	Operational pattern Transferable operating practice
🧰 Ralph (snarktank) Tool	2026 · GitHub snarktank/ralph · License: MIT	Ryan Carson's PRD-driven Ralph implementation that re-runs Amp or Claude Code with a fresh instance per iteration, gates each story on typecheck and tests, and persists state in prd.json, progress.txt, and Git history until every story passes.	Source implementation Inspectable source and runtime behavior
🧰 ralph-claude-code Tool	2025 · GitHub frankbria/ralph-claude-code · License: MIT	Loop runner that repeatedly re-executes Claude Code against project requirements, using dual-condition exit detection, rate limiting, and a circuit breaker to decide when the loop should stop.	Source implementation Inspectable source and runtime behavior
🧰 ralph-orchestrator Tool	2025 · GitHub mikeyobrien/ralph-orchestrator · License: MIT	Multi-backend implementation of the Ralph Wiggum technique that keeps a coding agent looping until task completion, using role-scoped hat personas that coordinate through events, with human-in-the-loop controls and a monitoring dashboard.	Source implementation Inspectable source and runtime behavior
🧰 ralphex Tool	2026 · GitHub umputun/ralphex · License: MIT	Extended Ralph loop runner that creates a Git branch per plan, executes tasks in fresh sessions with a commit after each, runs a multi-phase review pipeline with parallel review agents, and archives the completed plan.	Source implementation Inspectable source and runtime behavior
🧰 ralph (iannuttall) Tool	2026 · GitHub iannuttall/ralph	File-based Ralph-style agent loop that executes one JSON PRD story per iteration with fresh model context, using Git and on-disk state as memory across Claude, Codex, Droid, and OpenCode backends.	Source implementation Inspectable source and runtime behavior
🧰 ralph-loop-agent Tool	2026 · GitHub vercel-labs/ralph-loop-agent · License: Apache-2.0	Vercel Labs implementation of the Ralph loop for the AI SDK: an outer loop re-runs the agent with verifier feedback until a verifyCompletion check passes or iteration, token, or cost stop conditions trigger.	Source implementation Inspectable source and runtime behavior
🧰 Open Ralph Wiggum Tool	2026 · GitHub Th0rgal/open-ralph-wiggum · License: MIT	Agent-agnostic CLI that runs the Ralph Wiggum loop by feeding the same prompt to a fresh agent instance each iteration, with task tracking, live status monitoring, and mid-loop context injection across six coding-agent backends.	Source implementation Inspectable source and runtime behavior

Resource	Published at	Contribution	Evidence
🔁 Compound Engineering Pattern	every.to	Every's named plan-work-review-compound loop, where each run feeds lessons back into AGENTS.md-style memory so the next loop is easier; the self-improving counterpart to Ralph.	Operational pattern Transferable operating practice
🧰 Gas Town Tool	2025 · GitHub steveyegge/gastown · License: MIT	Steve Yegge's multi-agent orchestrator that runs 20-30 parallel coding agents with coordinator, worker, and merge-queue roles; the structured-orchestration end of the spectrum that Ralph anchors with bare iteration.	Source implementation Inspectable source and runtime behavior
🧰 Amp Tool	ampcode.com	Agentic coding tool built around threads, subagents, and an opinionated harness, with an owner's manual that documents loop-style operating practices.	Implementation Working implementation or runtime
🧰 karl Tool	2026 · GitHub kayoslab/karl · License: MIT	Autonomous multi-agent development loop with planner, reviewer, architect, tester, developer, deployment, and retry phases.	Source implementation Inspectable source and runtime behavior
🔁 joelclaw agent-loop skill Pattern	2026 · GitHub joelhooks/joelclaw	Durable Planner-Implementor-Reviewer-Judge coding loops via Inngest events and progress files.	Operational pattern Transferable operating practice
🧰 ARIS (Auto-Research-In-Sleep) Tool	2026 · GitHub wanshuiyin/Auto-claude-code-research-in-sleep · License: MIT	Markdown-only skills that run autonomous overnight ML research loops on Claude Code, Codex, or other LLM agents, iterating idea discovery and experiments with cross-model review as the verification gate.	Source implementation Inspectable source and runtime behavior
🧰 AutoAgent Tool	2026 · GitHub kevinrgu/autoagent	Meta-agent that autonomously edits its own harness (system prompt, tools, orchestration), re-runs the benchmark, and keeps or discards each change by score, with an author-reported top SpreadsheetBench result from a 24-hour unattended run.	Source implementation Inspectable source and runtime behavior
🧰 zeroshot Tool	2025 · GitHub the-open-engine/zeroshot · License: MIT	CLI that runs a planner, an implementer, and independent validators in isolated environments, looping until a change is verified or rejected with reproducible failures.	Source implementation Inspectable source and runtime behavior
🧰 Loki Mode Tool	2025 · GitHub asklokesh/loki-mode	Autonomous spec-to-app loop that runs Reason-Act-Reflect-Verify cycles behind quality gates, with completion gated by a blind three-reviewer council and a deterministic evidence receipt that rejects empty diffs and failing tests.	Source implementation Inspectable source and runtime behavior
🧰 Looper Tool	2026 · GitHub ksimback/looper · License: MIT	Claude Code skill for designing review-gated agent loops before running them, coaching the user into a portable loop.yaml spec with explicit goals, typed verification, iteration caps, and budget limits, then emitting artifacts runnable in-session or via an external Python runner.	Source implementation Inspectable source and runtime behavior
🧰 Agent Apprenticeship Tool	2026 · GitHub Forsy-AI/agent-apprenticeship · License: MIT	Multi-backend ecosystem where apprentice agents complete tasks through workflow loops, mentors or humans verify results, and execution traces are compiled into a published dataset that feeds future agent improvement.	Source implementation Inspectable source and runtime behavior
🧰 Scholar Loop Tool	2026 · GitHub renee-jia/scholar-loop · License: MIT	Autonomous multi-agent research loop from literature to hypothesis to real ML experiments to write-up, scoring every checkable agent claim against frozen ground-truth metrics and shipping an adversarial cheater engine that probes the loop for reward-hacking gaps.	Source implementation Inspectable source and runtime behavior
🧰 loop-engineering (Cobus Greyling) Tool	2026 · GitHub cobusgreyling/loop-engineering · License: MIT	Patterns-and-tooling repo shipping seven npm CLIs (loop-init, loop-audit, loop-cost, loop-sync, loop-context, loop-mcp-server, loop-worktree), starter kits, and production loop patterns; scaffolds skills/state/budget files, scores a repo's "Loop Ready" readiness, detects state drift, and estimates token spend per cadence for Claude Code, Codex, OpenCode, and Grok loops.	Source implementation Inspectable source and runtime behavior
🧰 AutoCVE Tool	2026 · GitHub larlarua/AutoCVE · License: AGPL-3.0	Open-source agent-driven CVE discovery platform whose orchestrator coordinates Recon, Scan, Triage, Finding, and Verification agents through ReAct loops with correction nudges and structured FinalizeFinding termination, running the full discover, source-audit, dynamic-verify, dedup, and report loop on a self-hosted FastAPI/React/PostgreSQL stack with agent-tree observability.	Source implementation Inspectable source and runtime behavior
🧰 LoongFlow (Baidu) Tool	2025 · GitHub baidu-baige/LoongFlow · License: Apache-2.0	Baidu's open-source agent framework built explicitly for Loop Engineering: a Plan-Execute-Summary loop with structured experiential memory lets agents plan, execute, reflect, and evolve across software-engineering, math, and ML tasks (Apache-2.0, on PyPI, paper: arXiv 2512.24077).	Source implementation Inspectable source and runtime behavior
🧰 cc10x Tool	2025 · GitHub romiluz13/cc10x · License: MIT	Claude Code plugin that routes work through one router, nine specialist agents, sixteen skills, and four workflows, enforcing fail-closed verification and test-honesty gates and writing each workflow's intent, evidence, and verdicts to durable .cc10x/ disk artifacts so resume and review survive context compaction.	Source implementation Inspectable source and runtime behavior
🧰 RigorLoop Tool	2026 · GitHub ronikobrosly/RigorLoop · License: MIT	Statistically-grounded loop-engineering framework in which a strategy agent directs concurrent executor agents that iteratively build and refine a solution against gold-standard examples.	Source implementation Inspectable source and runtime behavior
🧰 Open-Inspect Tool	2026 · GitHub ColeMurray/background-agents · License: MIT	Open-source background coding-agent system inspired by Ramp's Inspect: hosted agents in full dev-environment sandboxes, reachable from a web UI, Slack, GitHub PRs, Linear, or webhooks.	Source implementation Inspectable source and runtime behavior
🧰 T3MP3ST Tool	2026 · GitHub elder-plinius/T3MP3ST · License: AGPL-3.0	Multi-agent offensive-security meta-harness that turns an existing coding agent into an autonomous vulnerability-research loop, with a verify-claims receipt step that separates confirmed findings from speculation.	Source implementation Inspectable source and runtime behavior
🧰 Loom Tool	2026 · GitHub valkor-ai/loom · License: Apache-2.0	Open-source delivery harness for existing coding agents that treats delivery as a durable loop: route, execute, verify, record evidence, repair, and continue from saved state.	Source implementation Inspectable source and runtime behavior
🧰 Inferoa Tool	2026 · GitHub agentic-in/inferoa · License: Apache-2.0	Inference-native agent harness for loop engineering that treats every loop as an inference workload, shaping each turn to preserve cacheable prefixes and bound stale evidence.	Source implementation Inspectable source and runtime behavior
🧰 PlanWeave Tool	2026 · GitHub GaosCode/PlanWeave · License: MIT	File-backed loop-engineering system for long-running coding agents that turns fuzzy plans into a claimable task graph of nodes and block documents routed through implementation and review.	Source implementation Inspectable source and runtime behavior
🧰 loop.js Tool	2026 · GitHub loop-js/loop.js · License: Apache-2.0	TypeScript loop-engineering framework that runs an agent in rounds against a stated goal until a skeptical, read-only verifier agent accepts the result or a budget is exhausted.	Source implementation Inspectable source and runtime behavior
🧰 ai-trains-ai Tool	2026 · GitHub Danau5tin/ai-trains-ai · License: MIT	Recursive training loop where a trainer agent autonomously writes complete reinforcement-learning jobs (environments, rewards, configs), runs them, and iterates on the results.	Source implementation Inspectable source and runtime behavior

Resource	Published at	Contribution	Evidence
📝 Factory 2.0: From Coding Agents to Software Factories Blog	2026 · Factory Factory	Factory's software-factory pattern, where Automations coordinate recurring workflows with shared objectives and memory, Missions run multi-agent execution over hours or days, and Droid Computers give agents persistent remote execution across the SDLC.	Practitioner analysis Experience-backed implementation context
📝 Superpowers 6 Blog	2026 · Massively Parallel Procrastination	Release notes doubling as a case study of an unattended overnight autoresearch loop that ran 25 harness experiments against the project's own eval suite, roughly halving orchestration runtime and cutting token spend about 60%.	Practitioner analysis Experience-backed implementation context
📝 Introducing Devin Security Swarm Blog	2026 · cognition.com	Cognition's agent swarm runs a continuous discover-verify-fix security loop: parallel agents hunt vulnerabilities, reproduce each in an isolated sandbox to confirm exploitability before reporting, and open remediation PRs, re-running on a schedule after the backlog clears.	Practitioner analysis Experience-backed implementation context
📝 Towards Self-Driving Codebases Blog	Cursor Wilson Lin	Cursor research on running thousands of coding agents as a recursive planner-subplanner-worker hierarchy sustaining roughly 1,000 commits per hour, finding that tolerating small error rates that peer agents later fix beats enforcing per-step correctness.	Practitioner analysis Experience-backed implementation context
📝 Factory: Incident Response Automation Blog	2026 · Factory Factory	Factory's July 10, 2026 launch where a Droid triggered by Slack alerts (Sentry, Datadog, Rootly, Axiom) autonomously investigates each incident on a dedicated computer, triages, prepares fixes, and reports back in the thread, recording what it learns in a persistent runbook that Factory says improves its incident response over time.	Practitioner analysis Experience-backed implementation context
📝 A Week-Long Autonomous Voxel Manhattan Build Blog	2026 · X (formerly Twitter)	Matt Shumer's demonstration of a single-prompt run in which a frontier model worked autonomously for almost a week with subagent fan-out to build a navigable voxel Manhattan.	Practitioner analysis Experience-backed implementation context
📄 Self-Improving AI Coding Agents Through Accumulated Behavioral Rules: A Closed-Loop Framework Paper	2026 · 32nd IEEE International Conference on Engineering Technology and Innovation (ICE/ITMC) Aditya Aggarwal & Nahid Farhady Ghalaty	Converts accepted review feedback into versioned behavioral rules that future coding sessions can apply; across 11 reported production sessions, error classes covered by a rule did not recur, a promising but deliberately small-scope result.	Research paper Published or accepted research record

Resource	Published at	Contribution	Evidence
🧰 Webwright Tool	2026 · GitHub microsoft/Webwright · License: MIT	Treats workspace code, screenshots, and run artifacts as durable state while browsers remain disposable, producing a readable write-run-inspect-repair loop for long-horizon web tasks.	Source implementation Inspectable source and runtime behavior

Verification And Feedback Gates

Turn harness and observability mechanisms into exit gates, durable receipts, and retry signals with the resources below.

Resource	Published at	Contribution	Evidence
📝 Why Agentic Systems Must Produce Deterministic Outputs to Scale Blog	streamzero.com	Argues for deterministic boundaries, contracts, and execution gates around probabilistic agent reasoning.	Practitioner analysis Experience-backed implementation context
🔁 Stop Babysitting Your Coding Agent. Give It Backpressure. Pattern	generativeprogrammer.com	Explains how to turn tests, linters, builds, traces, and other signals into feedback loops for coding agents.	Operational pattern Transferable operating practice
🔁 How to Build a Self-Verification Loop in Claude Code Pattern	DEV Community	Uses hooks to enforce syntax, intent, and regression checks before an agent can finish.	Operational pattern Transferable operating practice
📝 Agentic Code Review Blog	addyosmani.com Addy Osmani	Addy Osmani argues that review, not code generation, is the bottleneck in agentic workflows, proposing risk-tiered verification depth, heterogeneous AI reviewers, and hard CI gates while warning against closed loops of models with correlated blind spots.	Practitioner analysis Experience-backed implementation context
📝 Using DSPy to Evaluate and Improve Datasette Agent's SQL System Prompts Blog	2026 · Simon Willison’s Weblog Simon Willison	Simon Willison wires a DSPy evaluation harness to a live Datasette instance with real tool calls and gold-standard metrics, then uses the eval traces to find and fix weaknesses in the agent's SQL system prompt.	Practitioner analysis Experience-backed implementation context
📝 Agentic coding notes Blog	danluu.com	Dan Luu's first-hand benchmarks and workflows arguing that systematic test infrastructure such as fuzzing and randomized testing, not human review, is what lets agent-generated code ship, and documenting why a self-contained agentic quality loop has so far eluded him.	Practitioner analysis Experience-backed implementation context
📝 Understanding Is the New Bottleneck Blog	2026 · geoffreylitt.com	Geoffrey Litt argues that human understanding, not verification, is the real bottleneck in agent loops, warning that cognitive debt accrues when iterations outpace comprehension and proposing literate diffs, quizzes, and interactive micro-worlds as speed regulators.	Practitioner analysis Experience-backed implementation context
📝 Verifying Agentic Development at Scale Blog	2026 · cognition.com	Cognition details the verification stack behind Devin sessions going majority-async: source-grounded test plans, deterministic reusable testing skills, and annotated video artifacts with pass/fail assertions so unattended runs return merge-ready results.	Practitioner analysis Experience-backed implementation context
📝 Loop Engineering Without Verification Is Just Automation Blog	sonarsource.com	Sonar formalizes a two-tier verification gate for agent loops, pairing a probabilistic LLM verifier sub-agent for intent with a deterministic analysis gate as the hard halt, arguing that LLM-only verification amounts to two optimists agreeing.	Practitioner analysis Experience-backed implementation context
📝 Closing the Verification Loop: Observability-Driven Harnesses Blog	2026 · Datadog Alp Keles, Jai Menon, Sesh Nalla, Vyom Shah	Datadog engineers' case for harness-first engineering once agents write code faster than humans can review, using deterministic simulation testing across millions of seeds as the verification gate.	Practitioner analysis Experience-backed implementation context

Resource	Published at	Contribution	Evidence
📝 How to build a better agent harness with traces and evals Blog	2026 · Arize AI Aaron Winston	Trace-evaluate-debug-refine loop for improving agent behavior from real runs.	Practitioner analysis Experience-backed implementation context
📝 Better Harness: A Recipe for Harness Hill-Climbing with Evals Blog	LangChain	LangChain's recipe for using evals as the learning signal for harness improvement.	Practitioner analysis Experience-backed implementation context
📝 Improving Deep Agents with harness engineering Blog	LangChain	Practical discussion of self-verification, traces, middleware, and loop detection for coding agents.	Practitioner analysis Experience-backed implementation context
📄 Agentic Harness Engineering: Observability-Driven Automatic Evolution of Coding-Agent Harnesses Paper	2026 · arXiv Jiahang Lin et al.	Closed loop that turns each harness edit into a falsifiable contract verified against trajectory outcomes, so the harness evolves from observability rather than trial and error.	Research preprint Preprint; inspect methods and evaluation
📄 Meta-Harness: End-to-End Optimization of Model Harnesses Paper	2026 · arXiv Yoonho Lee et al.	Optimizes the surrounding harness (tools, prompts, control flow) end to end against task outcomes, turning harness tuning into a measurable improvement loop instead of manual trial and error.	Research preprint Preprint; inspect methods and evaluation
🧰 HALO (Hierarchical Agent Loop Optimizer) Tool	2026 · GitHub context-labs/halo	Analyzes production agent traces to find harness-level failure modes, hands its report to a coding agent to apply fixes, and repeats the collect-analyze-fix-redeploy cycle, reporting AppWorld gains from harness changes alone.	Source implementation Inspectable source and runtime behavior
📄 Harness-Aware Self-Evolving: Co-Evolving Model Weights, Harness, and Task Solutions Paper	2026 · arXiv Haochen Luo et al.	Agentic RL framework in which one model both solves tasks and edits its own harness, including repairing faulty evaluation code, co-evolving weights, harness, and solutions so a trained Qwen3-8B matches a much larger baseline.	Research preprint Preprint; inspect methods and evaluation
🧰 auto-harness Tool	2026 · GitHub neosigmaai/auto-harness · License: MIT	Bring-your-own-agent framework for self-improving agentic systems that mines failures from runs, optimizes the harness in response, and gates every change behind regression checks.	Source implementation Inspectable source and runtime behavior

Resource	Published at	Contribution	Evidence
📚 OpenAI agent evals Docs	OpenAI Developers	Evaluation guidance for moving from traces to repeatable grading of agent workflows.	Official documentation Primary product or standard behavior
🧰 Promptfoo OpenAI Agents provider Tool	promptfoo.dev	Testing and assertions for multi-turn agent workflows, tools, state, handoffs, sandboxes, and traces.	Implementation Working implementation or runtime
🧰 Inspect AI Tool	2023 · GitHub UKGovernmentBEIS/inspect_ai · License: MIT	UK AISI evaluation framework with solvers, scorers, sandboxing, tool use, MCP, and log viewing.	Source implementation Inspectable source and runtime behavior
📚 OpenTelemetry Semantic Conventions for Generative AI Systems Docs	OpenTelemetry	Portable tracing conventions for model calls, tool calls, and agent workflows.	Official documentation Primary product or standard behavior
🧰 AgentOps Tool	2023 · GitHub AgentOps-AI/agentops · License: MIT	Monitoring, replay, cost tracking, benchmarking, and tracing for agent sessions.	Source implementation Inspectable source and runtime behavior
🧰 Langfuse Tool	2023 · GitHub langfuse/langfuse	Open-source LLM engineering platform with tracing, evaluations, and metrics that loops can read back as feedback signals.	Source implementation Inspectable source and runtime behavior
🧰 LangSmith Tool	LangChain	Tracing, evaluation, and monitoring platform for inspecting and grading agent runs across iterations.	Implementation Working implementation or runtime
🧰 Arize Phoenix Tool	2022 · GitHub Arize-ai/phoenix	Open-source AI observability for tracing, evaluating, and debugging agent behavior from real runs.	Source implementation Inspectable source and runtime behavior
🧰 Braintrust Tool	Braintrust	Evaluation and observability platform with experiments, datasets, and CI integration for gating agent changes.	Implementation Working implementation or runtime
🧰 Weave Tool	Weights & Biases Documentation	Weights & Biases toolkit for tracing, evaluating, and monitoring agent applications over time.	Implementation Working implementation or runtime
🧰 agentops (boshu2) Tool	2025 · GitHub boshu2/agentops · License: Apache-2.0	Independent verification layer for coding agents where a change only counts as done after a different model or a real test checks it, with the verdict recorded in the repo via a tamper-evident ledger.	Source implementation Inspectable source and runtime behavior
🧰 SkillSpec Tool	2026 · GitHub modiqo/skillspec · License: Apache-2.0	CLI that makes agent skills followable, testable, and provable by converting prose skills into structured contracts, scoring follow-through risk, and generating execution traces of which steps ran, were skipped, and what evidence exists.	Source implementation Inspectable source and runtime behavior
🧰 Shepherd Tool	2026 · GitHub shepherd-agents/shepherd · License: MIT	Python runtime that records agent execution as reversible, Git-like traces so meta-agents or humans can observe, fork, replay, and revert any run before results touch files, with copy-on-write forking, roughly 95% cache reuse on replay, and syscall-level permission enforcement.	Source implementation Inspectable source and runtime behavior
🧰 grill-for-unknowns Tool	2026 · GitHub nicobailon/grill-for-unknowns · License: MIT	Portable SKILL.md agent skill that gates long-running subagent and coding-agent launches behind plan interrogation: it inspects the real territory (docs, source, tests, config) first, sorts what's known into facts, decisions, domain language, and unknowns across known/unknown quadrants, then emits a launch packet with assumptions, verification steps, and rollback risks before dispatch.	Source implementation Inspectable source and runtime behavior
🧰 Fable Harness Tool	2026 · GitHub Miguok/fable-harness · License: MIT	Drop-in behavior protocol kit (hooks, a skill, and sub-agents auto-injected into every Claude Code session) enforcing a verify-first process: gather evidence before answering and verify changes before declaring done.	Source implementation Inspectable source and runtime behavior
🧰 Mindwalk Tool	2026 · GitHub cosmtrek/mindwalk · License: MIT	Local visualization tool that replays Claude Code and Codex session logs as light moving across a 3D map of the repository, making long agent runs inspectable after the fact.	Source implementation Inspectable source and runtime behavior
🧰 Waggle Tool	2026 · GitHub modiqo/waggle · License: Apache-2.0	MCP-native reference layer for agent handoffs: instead of pasting full context between agents, it passes a compact attributed, resolvable reference token that the receiving agent expands on demand.	Source implementation Inspectable source and runtime behavior
🧰 Jacquard Tool	2026 · GitHub jbwinters/jacquard-lang · License: Apache-2.0	Research language designed around the machine-writes, human-verifies contract, using effect-typed signatures so an agent's generated code carries checkable declarations of what it is allowed to touch.	Source implementation Inspectable source and runtime behavior

Resource	Published at	Contribution	Evidence
📄 Agentic Verification of Software Systems Paper	2026 · Proceedings of the ACM on Software Engineering 3 (FSE) Haoxin Tu et al.	Pairs a coding agent with a theorem prover (AutoRocq) in a generate-and-validate loop, turning formal proof into the exit gate for trusted automatic programming.	Research paper Published or accepted research record
📄 A Trace-Based Assurance Framework for Agentic AI Orchestration: Contracts, Testing, and Governance Paper	2026 · Proceedings of the 21st International Conference on Evaluation of Novel Approaches to Software Engineering (ENASE) Ciprian Paduraru et al.	Treats execution traces as the assurance substrate, pairing machine-checkable contracts, testing, and governance so recurring agent orchestration stays verifiable and auditable.	Research paper Published or accepted research record
📄 Self-Evolving Agents with Anytime-Valid Certificates Paper	2026 · arXiv Biswa Sengupta	Confines self-modification to a small steering adapter around a frozen base model and gates each change with anytime-valid statistical tests that emit auditable certificates, reporting solve-count gains and logged regression prevention on a SWE-bench Verified subset.	Research preprint Preprint; inspect methods and evaluation
📄 Delayed Verification Destabilizes Multi-Agent LLM Belief Paper	2026 · arXiv Igor Itkin	Models verifier-corrector loops in multi-agent LLM systems as delayed consensus, deriving a stability threshold where verification that is too strong or too late turns factual consensus into oscillation, plus a greedy corrector-placement algorithm validated on five open models.	Research preprint Preprint; inspect methods and evaluation
📄 Lean4Agent: Formal Modeling and Verification for Agent Workflow and Trajectory Paper	2026 · arXiv Ruida Wang et al.	Models agent workflows and trajectories in Lean 4 dependent types so semantic consistency is machine-checked rather than judged by an LLM, with verification-passing workflows outperforming failing ones by an average of 11.94% on software-engineering benchmarks.	Research preprint Preprint; inspect methods and evaluation
📄 Regimes: An Auditable, Held-Out-Gated Improvement Loop Paper	2026 · arXiv Yohei Nakajima	Event-sourced agent runtime whose self-improvement loop gates every proposed repair behind static checks, sandbox execution, and held-out evaluation before adoption, keeping the full decision trail replayable.	Research preprint Preprint; inspect methods and evaluation
📄 Agentic CLEAR: Automating Multi-Level Evaluation of LLM Agents Paper	2026 · Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics: System Demonstrations (ACL) Asaf Yehudai et al.	Automated evaluation framework from IBM Research that grades agent behavior at system, trace, and node granularity without predefined error taxonomies, producing feedback aligned with human-annotated errors and predictive of task success.	Research paper Published or accepted research record
📄 Diagnosis-Driven Automatic Repair for Agentic Workflow via Symbolic Inference Paper	2026 · arXiv Xuyan Ma et al.	FlowFixer converts runs of platform-built agentic workflows (Dify, Coze, n8n) into symbolic traces, infers correctness specs and node dependencies to localize root-cause failures, and generates targeted repairs at a 71.3% success rate.	Research preprint Preprint; inspect methods and evaluation
📄 SkillCoach: Self-Evolving Rubrics for Evaluating and Enhancing Agentic Skill-Use Paper	2026 · arXiv Jiayin Zhu et al.	Self-evolving rubric framework that scores agent trajectories on skill selection, following, composition, and reflection, exposing failures that pass/fail outcome checks miss and beating outcome-only filtering as a training signal.	Research preprint Preprint; inspect methods and evaluation
📄 SWE-Doctor: Guiding Software Engineering Agents with Runtime Diagnosis from Bug Reproduction Tests Paper	2026 · arXiv Yaoqi Guo et al.	Shows that naively feeding bug-reproduction tests to software-engineering agents can mislead them, and instead pipes runtime diagnosis from multi-faceted reproduction tests into patch generation, reaching 75.7% on SWE-bench Verified.	Research preprint Preprint; inspect methods and evaluation
📄 AgentTether: Graph-Guided Diagnosis and Runtime Intervention for Reliable LLM Agent Operation Paper	2026 · arXiv Chenyu Zhao et al.	Runtime repair layer that abstracts agent runs into a dependency-aware critical-transition graph, localizes failure-critical subtrajectories after a run, and guides recovery on re-execution without modifying the underlying agent.	Research preprint Preprint; inspect methods and evaluation
📄 SWE-Review: Closing the Loop on Issue Resolution with Agentic Code Review Paper	2026 · arXiv Ruoyu Wang et al.	Replaces one-shot PR generation with a generate-review-revise loop in which a reviewer agent explores the repository, accepts or rejects the PR, and feeds structured feedback into revision, with an accompanying benchmark and trajectory dataset.	Research preprint Preprint; inspect methods and evaluation
📄 Reason Less, Verify More: Deterministic Gates Recover a Silent Policy-Violation Failure Mode Paper	2026 · arXiv Vikas Reddy et al.	Finds that 78% of observed agent failures in a tau^2-bench domain are silent wrong-state failures invisible to both the tool and the agent's self-report, and that deterministic read-only pre-execution gates in the loop recover them.	Research preprint Preprint; inspect methods and evaluation
📄 Harnessing Code Agents for Automatic Software Verification Paper	2026 · arXiv Shuangxiang Kan et al.	Wraps a general code agent in a verification harness and lets it run until every targeted Coq lemma is proved, beating fixed human-designed proof strategies and reaching full lemma coverage with no expert intervention.	Research preprint Preprint; inspect methods and evaluation
📄 LLM-as-a-Verifier: A General-Purpose Verification Framework Paper	2026 · arXiv Jacky Kwok et al.	Treats verification as a scaling axis and builds a training-free framework that computes continuous scores from token logits for fine-grained agentic feedback, scaled via score granularity, repeated evaluation, and criteria decomposition.	Research preprint Preprint; inspect methods and evaluation
📄 From Prompts to Contracts: Harness Engineering for Auditable Enterprise LLM Agents Paper	2026 · arXiv Joongho Ahn & Moonsoo Kim	Moves deterministic agent behavior out of prompts into code, schemas, and behavior contracts, wrapping validation around a replaceable model boundary so enterprise agents remain auditable and safe across model substitutions.	Research preprint Preprint; inspect methods and evaluation
📄 From Noisy Traces to Root Causes: Structural Trajectory Analysis and Causal Extraction for Agent Optimization Paper	2026 · arXiv Ying Chang et al.	STRACE structures redundant, heterogeneous agent execution traces by mining batch-level failure patterns and performing causal localization over a textual dependency graph, handing root causes rather than noisy trajectories to the reflection-based optimizer and lifting success on a formal verification task from 42.5% to 58.5%.	Research preprint Preprint; inspect methods and evaluation
📄 Who Broke the System? Failure Localization in LLM-Based Multi-Agent Systems Paper	2026 · Conference on Language Modeling (COLM) Yufei Xia et al.	AgentLocate attributes failures in LLM multi-agent trajectories to both the responsible agent and the earliest decisive step, pairing LLM-based evaluation with independent assessor verification and confidence-weighted aggregation to outperform prior attribution methods on two benchmarks, the diagnose side of the verify step for dispatched-agent loops.	Research paper Published or accepted research record
📄 3100 Opinions on Code Review in an AI World: Building Causal Theory from Practitioner Discourse Paper	2026 · arXiv Shyam Agarwal et al.	Builds a causal theory of 26 constructs and 67 relationships from 3,100 coded practitioner documents on how AI-authored pull requests reshape code review, arguing review is the control point through which a coding agent's effect on software is decided and that outcomes hinge on team expertise and review process structure rather than AI itself.	Research preprint Preprint; inspect methods and evaluation
📄 Persuasion Attacks Can Decrease Effectiveness of CoT Monitoring Paper	2026 · arXiv Jennifer Za et al.	Stress-tests chain-of-thought monitoring as an in-loop safety gate: adversarial agents arguing for policy-violating proposals turn the scratchpad into a persuasion channel, with monitor access to the agent's reasoning increasing approval of harmful actions by 9.5% on average, while pairing monitor and fact-checker from different model families cuts violating approvals by up to 45%.	Research preprint Preprint; inspect methods and evaluation
📄 Physics-Audited Agentic Discovery in Scientific Machine Learning Paper	2026 · arXiv Diab W. Abueidda et al.	Verification-first workflow (PA-SciML) for agentic model discovery in scientific ML: fixes the scoring evaluator before search, derives machine-checkable physics requirements (boundary conditions, superposition, stiffness scaling, causality), audits every trained candidate's predicted fields against them, and separately searches prescribed input ranges for high-violation cases, reporting a surrogate as verified only under the stated checks; a domain-specific case of verification-gated agentic search.	Research preprint Preprint; inspect methods and evaluation
📄 Bug Report Specification Refinement with Trajectory Guidance for Automated Program Repair Paper	2026 · arXiv S M Farah Al Fahim et al.	TrajSpec runs a trajectory-collection agent over the pre-fix repository and mines the unverified trajectory for specification evidence, refining vague bug reports into structured specifications that guide automated program-repair loops.	Research preprint Preprint; inspect methods and evaluation
📄 Failure as a Process: An Anatomy of CLI Coding Agent Trajectories Paper	2026 · arXiv Xiangxin Zhao et al.	Empirical anatomy of 3,843 CLI coding-agent trajectories across seven models and three scaffolds (OpenHands, MiniSWE, Terminus2), with 1,794 fully annotated over 63,000+ manually reviewed steps; models failure as a temporal process of onset, evolution, and recovery and finds failures dominated by epistemic errors that begin within the first few steps yet stay undetected until recovery is impossible, arguing for in-loop validation and intervention over final-outcome evaluation.	Research preprint Preprint; inspect methods and evaluation
📄 Agentic Proof and Property-Based Testing via Property-Templates Paper	2026 · arXiv Seongmin Lee et al.	Dual-track verification-in-the-loop for AI-generated code: shared property templates drive both formal proof in Lean 4 and executable property-based tests for PySpark, raising agentic proof success up to 2.6x and cutting proof hallucinations by 59%.	Research preprint Preprint; inspect methods and evaluation
📄 AgentCheck: A Reproduce-Intervene-Mitigate Workbench for LLM Agents over MCP Paper	2026 · arXiv Aritra Mazumder & Nusrat jahan Lia	Workbench that reproduces an agent failure, intervenes at the point it went wrong, and tests mitigations, turning one-off agent bugs into a repeatable diagnose-and-fix loop over MCP tool use.	Research preprint Preprint; inspect methods and evaluation
📄 Latent Programming Horizons in Coding Agents Paper	2026 · arXiv André Silva et al.	Shows a coding agent's hidden states linearly encode program properties like correctness and test outcomes and predict future edits up to 25 steps ahead, a latent signal that could gate or steer verification loops before edits materialize.	Research preprint Preprint; inspect methods and evaluation
📚 Why evaluate agents Docs	Google Agent Development Kit	Official ADK guide to evaluating final responses and trajectories, defining test cases, selecting criteria, and running repeatable agent evaluations locally or in CI.	Official documentation Primary product or standard behavior
📄 Structured Feedback Improves Repair in an LLM Agent Loop Paper	2026 · arXiv Jaideep Ray & Ankit Goyal	In 50 paired TextWorld tasks under a four-call budget, feedback containing the failure location, observed value, and admissible alternatives raises repair success from 14/50 to 36/50 for one model and 8/50 to 29/50 for another; ablations identify alternatives, not JSON syntax, as the main driver.	Research preprint Preprint; inspect methods and evaluation
📄 Copy-on-Write Scoring: Application-Specific Agent Evaluations Paper	2026 · ICML Workshop on Agents in the Wild: Safety Security and Beyond Joanna Roy & Sven Hoelzel	Uses PostgreSQL copy-on-write isolation to let an agent modify a realistic application state while a scorer evaluates the resulting operations safely; the Plane case study also exposes tool-surface defects that simpler task checks miss.	Research paper Published or accepted research record
📄 The Prover Is the Judge: Verified Security Software from AI Coding Agents in Ada/SPARK Paper	2026 · arXiv Tobias Philipp	Places formal proof obligations inside a coding-agent repair loop and reports 49,280 discharged obligations with 20-40x less supervision; the paper also states that proofs must be paired with known-answer tests, interoperability checks, and human specification review.	Research preprint Preprint; inspect methods and evaluation
📄 Verified LLM-Driven Synthesis for Concept Design Paper	2026 · arXiv Alcino Cunha	Combines formal concept-and-reaction semantics with a counterexample-guided LLM synthesis loop whose candidates must satisfy machine-checked invariants; experiments on three applications show scenarios steer the loop more consistently than natural-language prompts, while sparse scenarios overfit and nondeterministic omissions still limit coverage.	Research preprint Preprint; inspect methods and evaluation
📄 AEGIS: Assay-Aware Protocol Validation and Runtime Monitoring for Open-Source Liquid Handling Robots Paper	2026 · arXiv Priyanka V. Setty et al.	Pairs preflight LLM checks against machine-readable assay rules with runtime visual monitoring of physical execution; reports adjusted F1 0.97 for protocol validation and average precision 0.89 for trajectory monitoring, while explicitly surfacing the small-pipette and transparent-liquid limits.	Research preprint Preprint; inspect methods and evaluation

Resource	Published at	Contribution	Evidence
📄 GLEAN: Guideline-Grounded Evidence Accumulation for High-Stakes Agent Verification Paper	2026 · arXiv Yichi Zhang et al.	Compiles expert guidelines into step-wise trajectory checks, calibrates accumulated evidence into correctness probabilities, and triggers additional verification when uncertainty remains high.	Research preprint Preprint; inspect methods and evaluation
📄 Zombie Agents: Detecting Semantic Livelock in Long-Horizon Autonomous Software Paper	2026 · Proceedings of the 3rd ACM International Conference on AI-Powered Software (AIware '26) Simarjot Khanna	Defines semantic livelock as continued agent activity without progress and proposes an independent embedding-based convergence monitor that detected the pattern in 25% of the analyzed long-duration SWE-agent failures.	Research paper The linked source required access at the latest check

Securing Unattended Loops

A loop that runs while nobody watches needs stronger boundaries than an interactive session. These resources cover the main risks: untrusted intake content, over-broad permissions, and unsandboxed execution.

Resource	Published at	Contribution	Evidence
⚠️ The lethal trifecta for AI agents Critique	2025 · Simon Willison’s Weblog Simon Willison	Simon Willison's rule of thumb: private data, untrusted content, and an exfiltration channel must never meet inside one unattended agent.	Risk analysis Failure modes, limits, or adoption cautions
⚠️ Prompt injection series Critique	Simon Willison’s Weblog Simon Willison	Ongoing series on the core unsolved vulnerability for loops whose intake includes content written by strangers.	Risk analysis Failure modes, limits, or adoption cautions
📚 Agentic AI - Threats and Mitigations Docs	OWASP Gen AI Security Project	OWASP threat model for agentic systems, useful when reviewing intake, memory, tool, and delegation boundaries.	Technical documentation Technical reference from the source
📚 Designing AI agents to resist prompt injection Docs	OpenAI	OpenAI's official defense-in-depth guidance: least privilege, sandboxed tools, output verification, and human confirmation for the high-impact actions an unattended loop might take.	Technical documentation The linked source required access at the latest check
🧰 sandbox-runtime Tool	2025 · GitHub anthropic-experimental/sandbox-runtime · License: Apache-2.0	Anthropic's OS-level filesystem and network sandboxing for arbitrary processes without requiring a container.	Source implementation Inspectable source and runtime behavior
🧰 E2B Tool	2023 · GitHub e2b-dev/E2B · License: Apache-2.0	Open-source isolated cloud sandboxes for running untrusted, AI-generated code inside agent loops.	Source implementation Inspectable source and runtime behavior
📚 Modal Sandboxes Docs	Modal	Secure sandboxed execution for agent-driven code with resource limits and network controls.	Technical documentation Technical reference from the source
🧰 Daytona Tool	daytona.io	Infrastructure for running AI-generated code in fast, isolated sandboxes.	Implementation Working implementation or runtime
🧰 peerd Tool	2026 · GitHub NotASithLord/peerd · License: Apache-2.0	Browser-extension harness that runs the agent loop entirely client-side with user-supplied keys, sandboxed compute, and per-environment actor agents that hold only their tools and no API keys, isolating the orchestrator from untrusted content as a prompt-injection boundary.	Source implementation Inspectable source and runtime behavior
📄 When Claws Remember but Do Not Tell: Stealthy Memory Injection in Persistent Personal Agents Paper	2026 · arXiv Yechao Zhang et al.	Shows one poisoned email can write hidden entries into a persistent personal agent's long-term memory that silently alter future unattended runs, introducing the 108-case WhisperBench evaluation and the MemGhost attack that reaches 87.5% success.	Research preprint Preprint; inspect methods and evaluation
📄 Your Agent's Memories Are Not Its Own: Forged Reasoning Attacks on LLM Agent Memory and Defenses Paper	2026 · arXiv Neeraj Karamchandani et al.	Introduces FARMA, an attack that plants forged reasoning traces in an agent's persistent memory so poisoned rationales carry into future runs, and SENTINEL, a reasoning-guard defense that cut attack success from up to 100% to zero in evaluation.	Research preprint Preprint; inspect methods and evaluation
📄 Distributed Attacks in Persistent-State AI Control Paper	2026 · arXiv Josh Hills et al.	Extends AI-control evaluation to coding agents shipping code that persists across sessions, showing a misaligned agent can spread an attack across successive PRs to evade per-transcript monitors, and adds a stateful link-tracker monitor that cuts evasion from 93% to 47%.	Research preprint Preprint; inspect methods and evaluation
📄 ElephantAgent: Contextual State Continuity in Agentic Systems Paper	2026 · arXiv Jiankai Jin et al.	Verification protocol that recomputes state digests before each query and logs authorized changes to a trusted-hardware ledger, so an agent's persistent memory and tool descriptions cannot be covertly poisoned between runs and can be rolled back to the last verified state.	Research preprint Preprint; inspect methods and evaluation
🧰 Cloudflare security-audit-skill Tool	2026 · GitHub Cloudflare/security-audit-skill · License: MIT	Cloudflare's open-sourced six-phase audit pipeline in which separate validation agents try to disprove each finding and fresh agents independently verify every claim against source code, emitting schema-validated findings that accumulate across repeated runs.	Source implementation Inspectable source and runtime behavior
📄 The Balkanization of Execution-Security Research for AI Coding Agents Paper	2026 · arXiv Mohammadreza Rashidi	Systematizes 39 papers on the execution layer around coding agents, spanning sandbox isolation, capability control, TOCTOU races, MCP threats, and egress control, surfacing five cross-cutting gaps and four verified CVEs in production agent harnesses.	Research preprint Preprint; inspect methods and evaluation
📄 Context-to-Execution Integrity for LLM Agents Paper	2026 · arXiv Igor Santos-Grueiro	Execution-boundary system where a deterministic gate admits a tool call only after field authority, exact-effect authorization, and invocation authority all bind to the same action manifest, protecting loops that read attacker-writable context.	Research preprint Preprint; inspect methods and evaluation
📄 When Agents Remember Too Much: Memory Poisoning Attacks on Large Language Model Agents Paper	2026 · arXiv George Torres et al.	GhostWriter is a two-phase attack that poisons the long-term memory store of tool-using personal agents so injected content persists across runs and activates in later tasks.	Research preprint Preprint; inspect methods and evaluation
📄 Token-Flow Firewall: Semantic Runtime Auditing for Persistent AI Agents Paper	2026 · arXiv Puji Wang et al.	Proposes TokenWall, a runtime firewall that audits a long-lived agent's semantic flows (memory updates, tool arguments, inter-component messages) before they reach privileged sinks, reporting attack success reduced to 12.5% with a 97.4% benign pass rate and 0.69s added latency.	Research preprint Preprint; inspect methods and evaluation
📄 Prismata: Confining Cross-Site Prompt Injection in Web Agents Paper	2026 · arXiv Corban Villa et al.	Applies contextual least privilege to web agents by dynamically labeling page content with trust levels and mechanically confining what the agent can see and do, cutting cross-site prompt-injection attack success on benign pages without requiring developer annotations.	Research preprint Preprint; inspect methods and evaluation
📄 TRACE: A Two-Channel Robust Attribution Watermark via Complementary Embeddings for LLM-Agent Trajectories Paper	2026 · arXiv Zheng Gao et al.	Embeds a two-channel attribution watermark in LLM-agent trajectory logs (one channel keyed on content for deletion resistance, one on log structure for rewrite resistance) so provenance survives an adversary with full read/write access, reporting detection scores near z = 100 on long-horizon ToolBench and ALFWorld trajectories with no loss of agent performance.	Research preprint Preprint; inspect methods and evaluation
📄 Beyond Attack-Success Rate: Action-Graded Severity Scale for Tool-Using AI Agents Paper	2026 · arXiv Harry Owiredu-Ashley	Replaces binary attack-success red-teaming metrics with a seven-level ordinal severity rubric (L0-L6) that grades harm along the agent's tool-call trajectory by action reversibility, scope expansion, and privilege escalation, validated with deterministic analysis and frontier-model judges across multiple victim models and defenses.	Research preprint Preprint; inspect methods and evaluation
📄 Beware of Agentic Botnets: Scalable Untargeted Promptware Attacks via Universal and Transferable Adversarial HalluSquatting Paper	2026 · arXiv Aya Spira et al.	Introduces adversarial hallucination squatting, in which attackers pre-register resource names LLMs predictably hallucinate (at rates up to 85-100%) and plant universal, cross-model-transferable promptware payloads on the open web, reaching agent loops that autonomously ingest internet content with no direct injection channel.	Research preprint Preprint; inspect methods and evaluation
📝 GitLost: How We Tricked GitHub's AI Agent into Leaking Private Repos Blog	noma.security	Noma Labs researcher Sasi Levi shows how hidden plain-English instructions in a malicious GitHub Issue make an issue-triggered GitHub Agentic Workflows agent exfiltrate private-repo contents into public comments, bypassing GitHub's data-leak guardrails with a one-word reframe, disclosed responsibly to GitHub.	Practitioner analysis Experience-backed implementation context
🧪 ScopeJudge: Cost-Aware Pre-Execution Gating for Offensive Security Agents Benchmark	2026 · arXiv Shane Caldwell et al.	Benchmark of 4,897 tool calls from offensive-security agent trajectories, labeled by professional penetration testers, for studying pre-execution gating where a cheap trusted LLM judge accepts or rejects each proposed call before it runs and the engagement boundary must be inferred from the request rather than a fixed policy.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data
📄 Multi-Agent AI Control: Distributed Attacks Hamper Per-Instance Monitors Paper	2026 · arXiv Oliver Makins et al.	Studies AI control when several agents operating jointly on shared infrastructure pursue a malicious goal, evaluated on FakeLab (synthetic AI-lab codebase: 9 services, 86 benign tasks, 4 attack scenarios); finds a fragmentation effect (the more agents coordinate an attack, the less likely per-agent monitors catch any single attacker) and that explicit planners amplify attack success, directly relevant to monitoring fleets of background agents.	Research preprint Preprint; inspect methods and evaluation
📄 Mitigating Taint-Style Vulnerabilities in MCP Servers via Security-Aware Tool Descriptions Paper	2026 · arXiv Yang Shi et al.	Finds taint-style flaws make up a substantial fraction of MCP-server vulnerabilities and normally demand context-specific code fixes, then proposes SPELLSMITH, which hardens tool descriptions with security-aware behavioral guidance so the agent's own self-reflection steers it away from triggering the vulnerable flows, mitigating multiple vulnerability classes at the tool-protocol layer without code-level patches.	Research preprint Preprint; inspect methods and evaluation
📝 Factory Droid Shield 2.0: Learned Secret Detection for Autonomous Commits Blog	2026 · Factory Factory	Factory upgrades the verification gate on every autonomous Droid commit with a two-model pipeline flanking the deterministic secret scanner, pairing a high-recall risk model with a precision referee.	Practitioner analysis Experience-backed implementation context
🧰 destructive_command_guard Tool	2026 · GitHub Dicklesworthstone/destructive_command_guard	Rust safety hook that intercepts and blocks destructive Git and shell commands (hard resets, recursive deletes, database drops) before AI coding agents execute them, across Claude Code and other harnesses.	Source implementation Inspectable source and runtime behavior
📄 Friendly Fire: Hijacking Defensive Cyber AI Agents for Remote Code Execution Paper	2026 · AI Now Institute Boyan Milanov	Proof-of-concept showing prompt injections spread across ordinary repository files can hijack defensive security agents into remote code execution, demonstrating that even security-focused agent loops inherit the untrusted-content attack surface.	Research paper Published or accepted research record
📝 How We Contain Claude Across Products Blog	Anthropic	Anthropic engineering on capping agent blast radius with three containment architectures matched to threat models, including ephemeral sandbox containers for untrusted code execution.	Practitioner analysis Experience-backed implementation context
📄 Rethinking MCP Security: A Large-Scale Study of Runtime MCP Servers and Scanner Reliability Paper	2026 · arXiv Pei Chen et al.	Large-scale study of live MCP servers finding widespread security weaknesses and that existing MCP security scanners miss or misreport many of them, a gap for anyone gating agent tool access on scanner output.	Research preprint Preprint; inspect methods and evaluation
📄 Agent Hacks Agent: Autoresearch for Production-Agent Red-Teaming Paper	2026 · arXiv Xutao Mao et al.	Uses an autonomous research loop to red-team production agents, having one agent iteratively discover, reproduce, and refine attacks against another, turning red-teaming itself into a recurring verified loop.	Research preprint Preprint; inspect methods and evaluation
📄 Temporary Authority, Permanent Effects: Commit-Time Authorization for LLM Agents Paper	2026 · arXiv Igor Santos-Grueiro	Proposes binding an agent's authority to the moment of commit rather than the moment of request, so a permission granted mid-run cannot be replayed later to cause irreversible effects in unattended execution.	Research preprint Preprint; inspect methods and evaluation
📄 ANCHOR: Automated Alignment Auditing for CLI Agents on Real-World Harm Paper	2026 · Proceedings of the 43rd International Conference on Machine Learning (ICML) Kefan Song & Yanjun Qi	Automated auditing framework that probes CLI coding agents for real-world harmful behavior and grades alignment, giving unattended-agent operators a repeatable safety check rather than manual spot review.	Research paper Published or accepted research record
🧰 Clawk Tool	2026 · GitHub clawkwork/clawk · License: Apache-2.0	Runs coding agents inside disposable, network-restricted Linux VMs so an unattended or untrusted agent's blast radius is confined to a throwaway sandbox.	Source implementation Inspectable source and runtime behavior
📝 Auto-Review of Agent Actions Without Synchronous Human Oversight Blog	2026 · OpenAI Maja Trębacz et al.	OpenAI's alignment team on reviewing agent actions asynchronously with automated reviewers when a human cannot watch every step, so oversight scales with agent throughput instead of gating it.	Practitioner analysis Experience-backed implementation context
📄 SAFETY SENTRY: Context-Aware Human Intervention via EXECUTE-ASK-REFUSE Routing Paper	2026 · arXiv Tianyu Chen et al.	Routes each proposed action among execute, ask a human, and refuse, with one threshold controlling the deployment's risk posture; experiments report stronger overall accuracy and safety recall than the compared baselines.	Research preprint Preprint; inspect methods and evaluation
📄 CAVA: Canonical Action Verification and Attestation for Runtime Governance of Agentic AI Systems Paper	2026 · arXiv Zexun Wang	Normalizes heterogeneous tool calls into a canonical runtime action object that can be verified and attested before execution; evaluation spans 96 seeds and 384 variants covering approval binding, tampering, and runtime portability.	Research preprint Preprint; inspect methods and evaluation
📄 How Agents Ask for Permission: User Permissions for AI Agents, from Interfaces to Enforcement Paper	2026 · arXiv Alexandra E. Michael & Franziska Roesner	Surveys 21 permission proposals and compares five commercial agents, producing a taxonomy that connects what users see in permission interfaces to how authority is represented and enforced at runtime.	Research preprint Preprint; inspect methods and evaluation
📄 Stop Means Stop: Measuring and Repairing the Enforcement Gap in Agent-Framework Control Primitives Paper	2026 · arXiv Sajjad Khan	Tests six open-source frameworks and finds their stop or approval controls do not behave as execution barriers; 215 of 1,200 live runs performed a side effect during an approval pause, while the proposed admission gate blocks all measured violations with roughly 1 ms overhead.	Research preprint Preprint; inspect methods and evaluation
📄 Bad Memory: Evaluating Prompt Injection Risks from Memory in Agentic Systems Paper	2026 · arXiv Soham Gadgil et al.	Evaluates planted memory payloads in Claude Code and Codex across four models, showing that malicious state can affect both current and future sessions and can persist differently across harnesses.	Research preprint Preprint; inspect methods and evaluation
📄 Setup Complete, Now You Are Compromised: Weaponizing Setup Instructions Against AI Coding Agents Paper	2026 · arXiv Aadesh Bagmar & Pushkar Saraf	Demonstrates five setup-instruction attack classes in 12 scenarios across production coding harnesses, including README and dependency attacks; a deterministic pre-install check closes most of the measured gap.	Research preprint Preprint; inspect methods and evaluation
📄 SeerGuard: A Safety Framework for Mobile GUI Agents via World Model Prediction Paper	2026 · arXiv Xue Yu et al.	Screens instructions and predicts the consequences of proposed GUI actions before execution with a safety-augmented world model; on Qwen3-VL-8B-Instruct, the reported safety-utility score rises from 0.191 to 0.596 while risk cost falls from 0.347 to 0.130 under the stated settings.	Research preprint Preprint; inspect methods and evaluation
📄 Do Agents Dream of False Memories? Black-box Visual Attacks on Long-term Memory in Multimodal AI Agents Paper	2026 · arXiv Halima Bouzidi et al.	Shows that image-only, black-box perturbations can poison or inject persistent memories across five multimodal memory architectures, with reported attack success rates of 61.6% and 58.4%; persistent visual evidence therefore needs provenance and validation before later loops reuse it.	Research preprint Preprint; inspect methods and evaluation
📄 MemoGuard: An Adaptive Runtime for Guarding Against Memory Traps in Communication-Limited Robot Navigation Paper	2026 · IEEE/ACM ESWEEK (CODES) 2026 Rajat Bhattacharjya et al.	Validates retrieved episodic memories against topology, resource, and outcome contracts before reuse, invoking local reasoning only when a check fails; in simulation it reduces battery violations 76.6% versus similarity-only retrieval and fallback calls 21.4% versus always reasoning.	Research paper Published or accepted research record

Resource	Published at	Contribution	Evidence
📄 OS-Sentinel: Towards Safety-Enhanced Mobile GUI Agents via Hybrid Validation in Realistic Workflows Paper	2026 · Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers) Qiushi Sun et al.	Combines a formal verifier for explicit system violations with a contextual VLM judge, backed by the MobileRisk-Live sandbox and trajectory benchmark for realistic mobile-agent safety.	Research paper Published or accepted research record

State, Memory, And Context Persistence

For durable loop state and cross-run context, use the resources below. For context-window design within one run, see the adjacent Context Engineering lists.

Resource	Published at	Contribution	Evidence
📚 Effective Context Engineering for AI Agents Docs	Anthropic	Anthropic guide to context as managed runtime state rather than a prompt dump.	Technical documentation Technical reference from the source
📝 Agent Harnesses: the Infrastructure Layer Your LLM Agent Actually Needs Blog	ninadpathak.com	Covers execution loops, state, checkpointing, observers, and replayability.	Practitioner analysis Experience-backed implementation context
📝 The Agent Loop Is the New OS Blog	2026 · Harness.io	Frames the agent loop as an OS-like boundary with context as RAM and tools as I/O.	Practitioner analysis Experience-backed implementation context
📝 Harness engineering for coding agent users Blog	martinfowler.com	Martin Fowler article on feedforward, feedback, and outer harnesses for coding agents.	Practitioner analysis Experience-backed implementation context
📝 Context Engineering Blog	2025 · Simon Willison’s Weblog Simon Willison	Simon Willison's framing of context engineering, useful for distinguishing context state from loop orchestration.	Practitioner analysis Experience-backed implementation context
📝 Agentic Coding in 2026 Blog	Sourcegraph	Sourcegraph on supplying deterministic, large-codebase context and code intelligence so recurring agent runs reuse durable repository state instead of rediscovering it each time.	Practitioner analysis Experience-backed implementation context
📝 Agentic AI State Management with ScyllaDB and LangGraph Blog	2026 · ScyllaDB Cynthia Dunlop	Durable agent state with checkpointers, write-ahead logs, and time-travel branching.	Practitioner analysis Experience-backed implementation context
🧰 Mem0 Tool	2023 · GitHub mem0ai/mem0 · License: Apache-2.0	Open-source memory layer for retaining user, session, and agent state across repeated agent sessions.	Source implementation Inspectable source and runtime behavior
🧰 Letta Tool	2023 · GitHub letta-ai/letta · License: Apache-2.0	Stateful agent framework from the MemGPT line with persistent, self-editing memory across runs.	Source implementation Inspectable source and runtime behavior
🧰 Zep Tool	2023 · GitHub getzep/zep · License: Apache-2.0	Temporal knowledge graph memory that tracks how facts about users and systems change across sessions.	Source implementation Inspectable source and runtime behavior
🧰 LangMem Tool	2025 · GitHub langchain-ai/langmem · License: MIT	SDK for extracting, consolidating, and retrieving long-term agent memory between loop runs.	Source implementation Inspectable source and runtime behavior
🧰 Beads Tool	2025 · GitHub steveyegge/beads · License: MIT	Git-plus-SQLite issue and memory store that agents read and write with a bd CLI, giving recurring loops durable task state and progress that survives context resets.	Source implementation Inspectable source and runtime behavior
📄 ARC: Active and Reflection-driven Context Management for Long-Horizon Agents Paper	2026 · Findings of the Association for Computational Linguistics: ACL Yilun Yao et al.	Treats context as a managed runtime artifact, reorganizing the working context when degradation or context rot is detected across a long run.	Research paper Published or accepted research record
📄 Memory for Autonomous LLM Agents: Mechanisms, Evaluation, and Emerging Frontiers Paper	2026 · arXiv Pengfei Du	Formalizes agent memory as a write-manage-read loop and surveys compression, retrieval, reflective self-improvement, and policy-learned management across recurring runs.	Research preprint Preprint; inspect methods and evaluation
📄 Externalization in LLM Agents: A Unified Review of Memory, Skills, Protocols and Harness Engineering Paper	2026 · arXiv Chenyu Zhou et al.	Reviews how durable state, reusable skills, protocols, and the harness move out of model weights into external infrastructure, the substrate that lets loops persist progress and reuse capability across runs.	Research preprint Preprint; inspect methods and evaluation
📄 Meta Context Engineering via Agentic Skill Evolution Paper	2026 · arXiv Haoran Ye et al.	A bi-level loop where a meta-agent evolves reusable skills while a base-agent optimizes context, co-evolving the harness and context artifacts across runs (ICML 2026).	Research preprint Preprint; inspect methods and evaluation
📄 Are We Ready for an Agent-Native Memory System? Paper	2026 · arXiv Wei Zhou et al.	Evaluates twelve agent memory systems across five workloads from a data-management perspective, decomposing memory into representation, extraction, retrieval, and maintenance modules and finding localized maintenance more cost-efficient than global reorganization.	Research preprint Preprint; inspect methods and evaluation
📄 Self-Evolving World Models for LLM Agent Planning Paper	2026 · arXiv Xuan Zhang et al.	Evolves a deployment-time world model while the agent and model weights stay frozen, retrieving observed transitions, distilling rules from prediction-observation mismatches, and filtering low-confidence forecasts so each run's errors improve later planning.	Research preprint Preprint; inspect methods and evaluation
📄 Rethinking Continual Experience Internalization for Self-Evolving LLM Agents Paper	2026 · arXiv Jingwen Chen et al.	Finds that naively re-internalizing accumulated experience causes progressive capability collapse across self-improvement iterations, and identifies what keeps the loop stable: principle-level abstractions, step-wise injection for tool use, and off-policy distillation from stronger teacher trajectories.	Research preprint Preprint; inspect methods and evaluation
🧰 GenericAgent Tool	2026 · GitHub lsdefine/GenericAgent · License: MIT	Self-evolving agent that grows a skill tree from a small seed, crystallizing completed runs into layered memory and reusable skills, with a master-worker mode for long-horizon goals.	Source implementation Inspectable source and runtime behavior
📄 Self-GC: Self-Governing Context for Long-Horizon LLM Agents Paper	2026 · arXiv Xubin Hao et al.	Governs long-horizon agent context as indexed lifecycle objects in an explicit nod to garbage collection, with a side-channel planner proposing fold, mask, and prune actions under harness-enforced recoverable sidecars, cutting production input tokens by 10-15%.	Research preprint Preprint; inspect methods and evaluation
📄 CompactionRL: Reinforcement Learning with Context Compaction for Long-Horizon Agents Paper	2026 · arXiv Yujiang Li et al.	Reinforcement-learning method that jointly optimizes task execution and compaction-summary generation so long-horizon agents can continue past finite context windows, lifting GLM-4.5-Air to 66.8% on SWE-bench Verified and shipping in the GLM-5.2 pipeline.	Research preprint Preprint; inspect methods and evaluation
📄 SelfMem: Self-Optimizing Memory for AI Agents Paper	2026 · arXiv Shu Yang et al.	Memory framework in which the agent autonomously optimizes its own storage, retrieval, and summarization strategies per task instead of a fixed pipeline, improving BEAM's official score over the strongest baseline by 48.7%, 40.8%, and 41.9% at 100K, 500K, and 1M tokens, respectively.	Research preprint Preprint; inspect methods and evaluation
📄 Memory-Orchestrated Semantic System (MOSS): An Auditable Agentic Memory Architecture Paper	2026 · arXiv Serge Lacasse et al.	Model-, storage-, and API-agnostic agent memory architecture where the agent drives symbolic retrieval over a structured relational database, making long-term memory auditable and reproducible instead of opaque embedding search, validated in a year-long deployment.	Research preprint Preprint; inspect methods and evaluation
📄 The Log Is the Agent: Event-Sourced Reactive Graphs for Auditable, Forkable Agentic Systems Paper	2026 · arXiv Yohei Nakajima	BabyAGI creator Yohei Nakajima makes an append-only event log the source of truth and the working graph a deterministic projection, giving long-running loops deterministic replay, cheap forking at any event, and end-to-end causal lineage from goal to model call.	Research preprint Preprint; inspect methods and evaluation
📝 Agentics: Memorizing Session Transcripts Isn't Useful Blog	12gramsofcarbon.com theahura	From thousands of agent sessions at Nori, reports zero coding-task benefit from giving agents search over prior session transcripts and argues loop state belongs in distilled artifacts like commits and docs because agents never prune stale context.	Practitioner analysis Experience-backed implementation context
📝 Long-Running Agents Blog	Substack Addy Osmani	Addy Osmani's essay on the infrastructure behind agents that run for hours or days, naming three walls (finite context, missing persistent state, unreliable self-verification) and the patterns that address them: durable event logs, checkpoint-and-resume, external state, and a planner/worker/judge split.	Practitioner analysis Experience-backed implementation context
📄 StateFuse: Deterministic Conflict-Preserving Memory for Multi-Agent Systems Paper	2026 · arXiv Sergey Volkov et al.	Conflict-aware replicated memory contract with immutable history, explicit conflict objects, and projection-time resolution, so agent systems that accumulate contradictory observations across branches, retries, and replicas record state auditably instead of silently overwriting it.	Research preprint Preprint; inspect methods and evaluation
📄 Remember When It Matters: Proactive Memory Agent for Long-Horizon Agents Paper	2026 · arXiv Yifan Wu et al.	Names the failure mode "behavioral state decay" (decision-relevant state such as prior attempts, diagnoses, and open subgoals gets buried or evicted as trajectories grow) and pairs the action agent with a proactive memory agent that maintains a structured memory bank and injects memory-grounded reminders only when needed, gaining +8.3 points on Terminal-Bench 2.0 and +6.8 on τ²-Bench.	Research preprint Preprint; inspect methods and evaluation
📄 What to Keep, What to Forget: A Rate-Distortion View of Memory Compaction Paper	2026 · arXiv Ashwin Gerard Colaco & Nada Lahjouji	Rate-distortion framing that unifies KV-cache eviction, prompt compression, recurrent state, and cross-session agent memory compaction under a single objective with a layer-agnostic lower bound, showing why attention- and recency-based eviction discards information before future queries reveal what mattered.	Research preprint Preprint; inspect methods and evaluation
📄 A Hierarchical Memory Architecture Overcomes Context Limits in Long-Horizon Multi-Agent Modeling Paper	2026 · arXiv Shivendra G. Tewari & Holly Kimko	Three-layer hierarchical memory keeps injected context bounded and roughly constant across multi-session, long-horizon multi-agent workflows, demonstrated by the Ensemble QSP framework autonomously selecting pharmacokinetic-pharmacodynamic models across 104 runs with overseer agents handling verification and troubleshooting.	Research preprint Preprint; inspect methods and evaluation
📄 SkillCenter: A Large-Scale Source-Grounded Skill Library for Autonomous AI Agents Paper	2026 · arXiv Tianming Sha et al.	Claims the largest open skill library for agents (216,938 structured skills across 24 domain bundles), built with an LLM quality gate (SkillGate) and iterative source-grounding that maps each retained claim to an exact source quotation, and shipped as offline-searchable SQLite FTS5 bundles, infrastructure for skills-as-persistent-state that agent loops accumulate and reuse.	Research preprint Preprint; inspect methods and evaluation
📝 How version control will evolve for the agent boom Blog	2026 · Entire	Thomas Dohmke (former GitHub CEO, now founder of Entire) argues that agent session logs (prompts, tool calls, and decision checkpoints) are becoming the most important artifact in software development and should be versioned alongside code so agent fleets stop repeating mistakes, and that Git hosting must re-decentralize for agent-scale parallelism.	Practitioner analysis Experience-backed implementation context
🧰 self-learning-skills Tool	2026 · GitHub Kulaxyz/self-learning-skills · License: MIT	Meta-skill for Claude Code, Cursor, and AGENTS.md-compatible agents that recognizes when a session has earned a hard-won golden path (or hit a dead-end worth remembering), distills the procedure including failed approaches, and persists it as a skill or rule auto-loaded next run, turning each session's discoveries into durable cross-session loop state.	Source implementation Inspectable source and runtime behavior
📄 GitLake: Git-for-data for the agentic lakehouse Paper	2026 · DASHSys Workshop at the International Conference on Very Large Data Bases (VLDB) Weiming Sheng et al.	Git-for-data design for an agent-first lakehouse that lifts single-table Iceberg snapshots into lakehouse-wide commits, branches, and merges, so agents work on isolated branches while humans review and publish, and pipeline outputs become visible atomically or not at all, with production lessons and correctness insights from a preliminary Alloy model of the core abstractions.	Research paper Published or accepted research record
📄 Shared Selective Persistent Memory for Agentic LLM Systems Paper	2026 · arXiv Sanjana Pedada et al.	Architecture that selectively persists four categories of reusable context (task specifications, data schemas, tool configurations, output constraints) across agent sessions while discarding session-specific reasoning traces, with cross-user sharing under access controls and a zero-token refresh path for recurring data updates, reporting 96% task completion vs 79% without memory and 71% with full-history carryover.	Research preprint Preprint; inspect methods and evaluation
📄 Scoped Verification for Reliable Long-Horizon Agentic Context Evolution Paper	2026 · arXiv Dan C. Hsu & Luke Lu	GRACE represents an agent's persistent instructions as a typed semantic graph and runs scoped verification over the local neighborhood of each proposed edit before committing it, so accumulated context evolves reliably across long-horizon deployment under distribution shift instead of drifting as flat text; evaluated on telecom agent tasks.	Research preprint Preprint; inspect methods and evaluation
🧰 AgentMemory Tool	2026 · GitHub rohitg00/agentmemory · License: Apache-2.0	Persistent cross-session memory for coding agents: auto-capture lifecycle hooks, an MCP server, and a REST API so progress, decisions, and context survive across runs and tools.	Source implementation Inspectable source and runtime behavior
🧰 TencentDB-Agent-Memory Tool	2026 · GitHub TencentCloud/TencentDB-Agent-Memory	Tencent Cloud's open-source local-first long-term memory for AI agents: a four-tier progressive pipeline from capture through consolidation with zero external API dependencies.	Source implementation Inspectable source and runtime behavior
🧰 agent-memory (Neo4j Labs) Tool	2026 · GitHub neo4j-labs/agent-memory · License: Apache-2.0	Official Neo4j Labs graph-native memory system that stores conversations, builds knowledge graphs from agent interactions, and lets agents learn from their own reasoning traces.	Source implementation Inspectable source and runtime behavior
🧰 re_gent Tool	2026 · GitHub regent-vcs/re_gent · License: Apache-2.0	Agent-native version control layered on top of Git that records agent activity at the prompt level, so you can answer why the agent did something and undo agent work without losing your own.	Source implementation Inspectable source and runtime behavior
📄 StructAgent: Harness Long-Horizon Digital Agents with Unified Causal Structure Paper	2026 · arXiv Wenyi Wu et al.	State-centered framework that structures a long-horizon computer-use agent's state around a unified causal representation of task progress, regulating every update through verifier-backed state transitions with checkpointing and targeted failure recovery, lifting Qwen3.5-27B from 31.6% to 62.2% on OSWorld-Verified.	Research preprint Preprint; inspect methods and evaluation
📄 The Compliance Trap: Diagnosing How AI Agents Consume Conflicting Memory Paper	2026 · arXiv Yixiong Chen et al.	Diagnoses how agents resolve contradictions in their own persistent memory, finding they tend to comply with the most recent or most assertive entry rather than the correct one, a failure mode for any loop that accumulates state across runs.	Research preprint Preprint; inspect methods and evaluation
📚 Conversational Context: Session, State, and Memory Docs	Google Agent Development Kit	Official ADK model separating a conversation thread, its mutable state, and searchable cross-session memory, with service backends for durable persistence.	Official documentation Primary product or standard behavior
📚 Persistence Docs	LangGraph	Official LangGraph checkpoint model: save state at every super-step, retain pending writes, recover interrupted execution, support human review, and enable memory and time travel.	Official documentation Primary product or standard behavior
📚 Workflow checkpoints Docs	Microsoft Agent Framework	Official checkpointing guide covering super-step state, pending messages and requests, shared state, in-memory and durable storage providers, and resuming long-running workflows.	Official documentation Primary product or standard behavior
📚 Agent state Docs	Strands Agents	Official state guide separating conversation, agent, and invocation lifetimes, with validation hooks and cross-session persistence for durable agent behavior.	Official documentation Primary product or standard behavior
📄 Memory as a Controlled Process: Learned Adaptive Memory Management for LLM Agents Paper	2026 · arXiv Eric Hanchen Jiang et al.	Learns when to retrieve, consolidate, and forget rather than treating memory as passive storage; across six benchmarks, three frameworks, and three LLMs, it reports up to 15.2 points higher task success with 5-20% fewer tokens.	Research preprint Preprint; inspect methods and evaluation
📄 Why Git Is the Memory Solution for the Agentic Development Lifecycle Paper	2026 · arXiv Frank Guo	Binds agent memory to versioned Git artifacts and evaluates retrieval across eight corpora; reported best retrieval reaches about 0.31 MRR and decision synthesis 0.83 sufficiency at 382-980 tokens per query, with capture quality still the main constraint.	Research preprint Preprint; inspect methods and evaluation
🧪 ContinuityBench: A Benchmark and Systems Study of Stateful Failover in Multi-Provider LLM Routing Benchmark	2026 · arXiv Vishal Pandey & Gopal Singh	Defines continuity-preservation and latency-overhead metrics for provider failover and evaluates a state-forwarding proxy over 750 failover events; reported context preservation reaches 99.20% versus near zero for stateless routing, with asynchronous backoff and jitter preventing retry storms.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data
📄 Presentation, Not Mechanism: A Render Confound in Deprecation-Aware Memory Evaluation Paper	2026 · arXiv Zhaoyang Jiang et al.	Uses a render-matched control over 2,907 evidence-revision questions to show that an apparent +0.182 structured-memory gain is mostly presentation, leaving a +0.021 to +0.025 mechanism residual indistinguishable from zero; memory evaluations should hold rendering fixed and prefer the coarsest retained state that answers the target queries.	Research preprint Preprint; inspect methods and evaluation

Resource	Published at	Contribution	Evidence
📄 ReasoningBank: Scaling Agent Self-Evolving with Reasoning Memory Paper	2026 · International Conference on Learning Representations (ICLR) Siru Ouyang et al.	Distills successful and failed trajectories into reusable reasoning memories, then uses memory-aware test-time scaling to turn additional exploration into better guidance for future runs.	Research paper Published or accepted research record
📄 Scaling Long-Horizon LLM Agent via Context-Folding Paper	2025 · arXiv Weiwei Sun et al.	Lets an agent branch into temporary sub-trajectories and fold completed work into compact continuation state, pairing the mechanism with FoldGRPO to operate under a 32K active-context budget.	Research preprint Preprint; inspect methods and evaluation

Orchestration And Multi-Agent Delegation

Coordinating multiple agents inside one loop: planners, workers, judges, worktree isolation, and merge gates.

Resource	Published at	Contribution	Evidence
🧰 AutoGen Tool	2023 · GitHub microsoft/autogen · License: CC-BY-4.0	Multi-agent programming framework for conversations, tool use, and orchestration; active development has moved to the Microsoft Agent Framework.	Source implementation Inspectable source and runtime behavior
🧰 Microsoft Agent Framework Tool	2025 · GitHub microsoft/agent-framework · License: MIT	Microsoft's successor to AutoGen and Semantic Kernel for building and orchestrating multi-agent workflows in Python and .NET.	Source implementation Inspectable source and runtime behavior
🧰 LangGraph Tool	2023 · GitHub langchain-ai/langgraph · License: MIT	Graph-based framework for controllable agent workflows, persistence, and human-in-the-loop steps.	Source implementation Inspectable source and runtime behavior
🧰 CrewAI Tool	2023 · GitHub crewAIInc/crewAI · License: MIT	Framework for multi-agent workflows organized around roles, tasks, and crews.	Source implementation Inspectable source and runtime behavior
📚 LlamaIndex Workflows Docs	Developer Documentation	Event-driven workflow abstraction for agentic applications.	Technical documentation Technical reference from the source
📚 OpenAI Agents SDK handoffs Docs	openai.github.io	First-class delegation between specialized agents.	Official documentation Primary product or standard behavior
📚 Agent Protocol Docs	AgentProtocol.ai	API protocol for agent interaction, useful for separating loop managers from agent runtimes.	Technical documentation Technical reference from the source
🧰 AgentKit Tool	2024 · GitHub inngest/agent-kit · License: Apache-2.0	TypeScript toolkit for durable, event-driven agents on workflow infrastructure.	Source implementation Inspectable source and runtime behavior
🧰 deepagents Tool	2025 · GitHub langchain-ai/deepagents · License: MIT	LangChain project for deeper, longer-running agents with middleware and harness patterns.	Source implementation Inspectable source and runtime behavior
📚 Temporal for AI Docs	temporal.io	Durable execution for long-running agent workflows: crash-proof state, automatic retries, and human-in-the-loop signals.	Technical documentation Technical reference from the source
🧰 Restate Tool	Restate	Durable execution runtime for building resilient, stateful agents and workflows that survive failures mid-loop.	Implementation Working implementation or runtime
🧰 DBOS Tool	dbos.dev	Lightweight PostgreSQL-backed durable execution library for crash-proof agent workflows, queues, and scheduled triggers.	Implementation Working implementation or runtime
🧰 Composio Agent Orchestrator Tool	2026 · GitHub ComposioHQ/agent-orchestrator · License: Apache-2.0	Orchestrates parallel coding agents in isolated worktrees that plan tasks, fix CI failures, respond to reviews, and manage their own PR lifecycle.	Source implementation Inspectable source and runtime behavior
🧰 Omnigent Tool	2026 · GitHub omnigent-ai/omnigent · License: Apache-2.0	Databricks' open-source meta-harness and control plane that runs Claude Code, Codex, Cursor, and Pi under shared policies, with budget caps and human-approval gates enforced at the harness layer rather than in prompts.	Source implementation Inspectable source and runtime behavior
📄 From Agent Loops to Structured Graphs: A Scheduler-Theoretic Framework for LLM Agent Execution Paper	2026 · arXiv Hu Wei	Replaces opaque agent loops with immutable plan-version DAGs and a planning-execution-recovery split, giving inspectable scheduling, deterministic recovery, escalation, and termination guarantees.	Research preprint Preprint; inspect methods and evaluation
🧰 Eve Tool	2026 · GitHub Vercel/eve · License: Apache-2.0	Vercel's TypeScript-native agent framework with durable execution, sandboxed compute, and OpenTelemetry tracing built in, so recurring agent work persists, replays, and is observable across runs by default.	Source implementation Inspectable source and runtime behavior
📄 Verified Multi-Agent Orchestration: A Plan-Execute-Verify-Replan Framework Paper	2026 · ICLR Workshop on Multi-Agent Learning: Generalization and Adaptation in Intelligence (MALGAI) Xing Zhang et al.	Decomposes work into a dependency-aware DAG, runs domain agents in parallel, and uses an LLM verifier to drive adaptive replanning with configurable stop conditions, the verify-and-replan core of a reliable loop.	Research paper Published or accepted research record
📄 From Static Templates to Dynamic Runtime Graphs: A Survey of Workflow Optimization for LLM Agents Paper	2026 · arXiv Ling Yue et al.	Organizes how agent workflows are fixed ahead of time or generated and revised per run, and which evaluation signals drive that choice, a map of the design space for recurring loops.	Research preprint Preprint; inspect methods and evaluation
🧰 Agent-as-a-Router Tool	2026 · GitHub LanceZPF/agent-as-a-router · License: MIT	Agentic model routing for coding agents reframed as a context-action-feedback loop (ACRouter: orchestrator, verifier, memory) that learns which LLM to route each task to from execution feedback rather than frozen priors, with the CodeRouterBench benchmark across 8 frontier models.	Source implementation Inspectable source and runtime behavior
📝 Amp: Custom Agents Blog	ampcode.com	Amp's plugin-defined custom agents that run as the main agent or as subagents, spawn parallel workers, join tool pipelines, and use thread actions to build background review threads that report results back to a parent thread.	Practitioner analysis Experience-backed implementation context
🧰 AgentsMesh Tool	2026 · GitHub AgentsMesh/AgentsMesh	Self-hosted control plane for running fleets of coding agents across your own machines, with scheduling, per-pod Git worktree isolation, Kanban work tracking, and merge-request integration.	Source implementation Inspectable source and runtime behavior
🧰 Bernstein Tool	2026 · GitHub sipyourdrink-ltd/bernstein · License: Apache-2.0	Deterministic Python orchestrator that runs parallel CLI coding agents in isolated Git worktrees, gates merges on tests, lint, and type checks, and records every scheduling decision in a tamper-evident audit log.	Source implementation Inspectable source and runtime behavior
🧰 Aeon Tool	2026 · GitHub aaronjmars/aeon · License: MIT	Autonomous agent framework that runs Claude Code unattended on GitHub Actions, dispatching skills on cron or reactive triggers with per-run quality scoring, persistent memory, and self-healing skill repair.	Source implementation Inspectable source and runtime behavior
🧰 h5i Tool	2026 · GitHub h5i-dev/h5i · License: Apache-2.0	Gives each coding agent an isolated sandboxed Git worktree, dispatches one task to a team that peer-reviews each other's candidates, then replays and tests each candidate with a neutral verifier before merging the winner.	Source implementation Inspectable source and runtime behavior
📄 SwarmResearch: Orchestrating Coding Agents for Open-Ended Discovery Paper	2026 · arXiv Yuvraj Virk et al.	A shepherd agent with global context steers a population of search agents that each work in their own Git branch with local context, countering the context accumulation of solo long-running agents and matching or beating baselines on 13 of 15 open-ended discovery tasks.	Research preprint Preprint; inspect methods and evaluation
📝 Scaling Long-Running Autonomous Coding Blog	Cursor Wilson Lin	Cursor traces the coordination designs behind week-long autonomous coding runs, from flat agents with locking to optimistic concurrency to a planner/worker/judge hierarchy, letting hundreds of concurrent workers push to one branch on projects exceeding a million lines.	Practitioner analysis Experience-backed implementation context
🧰 babysitter Tool	2026 · GitHub a5c-ai/babysitter · License: MIT	Harness-agnostic orchestration framework that runs agent workflows as process-as-code with mandatory enforcement stops after every step, quality-convergence loops that re-run verify-and-refine until thresholds pass, human-approval breakpoints, and an immutable event-sourced journal for deterministic replay across 12 coding harnesses.	Source implementation Inspectable source and runtime behavior
🧰 claude-code-merge-queue Tool	2026 · GitHub funador/claude-code-merge-queue · License: MIT	Local FIFO merge queue that serializes parallel Claude Code agents landing on a shared codebase, with a machine-wide build lock and a landing gate that blocks the integration branch until a configured check command passes, wired into the WorktreeCreate hook.	Source implementation Inspectable source and runtime behavior
📝 Devin can now manage Devins Blog	2026 · cognition.com	Cognition's multi-Devin architecture where a coordinator Devin scopes a task into pieces, delegates each to a managed Devin running in its own isolated VM with terminal, browser, and dev environment, monitors progress, resolves conflicts, compiles the results, and reads workers' full trajectories to learn what worked and where they got stuck.	Practitioner analysis Experience-backed implementation context
🧰 pilotfish Tool	2026 · GitHub Nanako0129/pilotfish · License: MIT	Multi-model orchestration layer for Claude Code where the frontier model plans, decides, and reviews while cheaper models execute volume work through six global subagent roles, with quality guarded by fresh-context verifier subagents rather than expensive models everywhere and graceful degradation when the frontier model is unavailable, shipped as three config files with no runtime code.	Source implementation Inspectable source and runtime behavior
🧰 fable-advisor Tool	2026 · GitHub DannyMac180/fable-advisor · License: MIT	Claude Code plugin implementing an architect pattern where Fable 5 owns specs, decomposition, and verification while routing implementation to cheaper lanes (Grok 4.5 by default, GPT-5.6 via Codex CLI, or Sonnet/Opus fallback), with cross-vendor review and optional racing of two implementers on the same spec.	Source implementation Inspectable source and runtime behavior
🧰 agent-chief Tool	2026 · GitHub SmileLikeYe/agent-chief · License: MIT	Local-first chief-of-staff layer that guards human attention across a fleet of agents and alerts: hard rules kill noise fast while a cache-stable LLM judge batches, blocks, or escalates what remains.	Source implementation Inspectable source and runtime behavior
🧰 OpenTag Tool	2026 · GitHub amplifthq/opentag · License: MIT	Turns an existing work thread into a governed agent work loop: @-mention a coding agent from Slack, GitHub, GitLab, Linear, Lark, Telegram, or Discord, and OpenTag curates the context and manages the run.	Source implementation Inspectable source and runtime behavior
🧰 herdr Tool	2026 · GitHub ogulcancelik/herdr	Single-binary terminal multiplexer purpose-built for running fleets of coding agents (Claude Code, Codex, Copilot CLI, Cursor Agent, and 15+ others) with per-agent state tracking.	Source implementation Inspectable source and runtime behavior
🧰 Orca Tool	2026 · GitHub stablyai/orca · License: MIT	Open-source agent development environment for orchestrating a fleet of parallel coding agents (20+ backends) on your own subscriptions, with per-agent workspaces and review flow.	Source implementation Inspectable source and runtime behavior
📄 Agentic Routing: The Harness-Native Data Flywheel Paper	2026 · arXiv Xinchen Liu et al.	Argues model routing must live inside the execution harness rather than in single-turn cost-quality tradeoffs, making step-level model selections from execution state and logging each decision as structured telemetry that feeds back to improve both routers and models.	Research preprint Preprint; inspect methods and evaluation
📄 A Formal Hierarchical Architecture for Agentic Orchestration with Stack-Based Execution Paper	2026 · arXiv Prashant Devadiga et al.	Formal orchestration architecture that runs agent workflows on a call stack with lazy capability discovery, giving multi-agent loops explicit, inspectable control flow instead of implicit prompt-driven handoffs.	Research preprint Preprint; inspect methods and evaluation
📄 The Honest Quorum Problem: Epistemic Byzantine Fault Tolerance for Agentic Infrastructure Paper	2026 · arXiv Jun He & Deying Yu	Formalizes how protocol-compliant reasoning agents can still agree on a semantically invalid transition, especially when they share models, prompts, or tools; derives separate safety and liveness budgets and shows that adding agents helps only when measured error correlation falls.	Research preprint Preprint; inspect methods and evaluation
📚 Graph-based agent workflows Docs	Google Agent Development Kit	Official ADK 2.0 graph runtime for explicit, deterministic workflows that mix agents, tools, and code with branching, state, human input, and bounded cycles.	Official documentation Primary product or standard behavior
📚 Flows Docs	CrewAI	Official event-driven workflow layer with typed state, branching and loops, persistence decorators, and resume or fork operations for long-running executions.	Official documentation Primary product or standard behavior
📚 Graph Docs	Strands Agents	Official deterministic graph pattern for multi-agent dependencies and cycles, with shared execution state and explicit execution limits.	Official documentation Primary product or standard behavior

Resource	Published at	Contribution	Evidence
📄 Towards a Science of Scaling Agent Systems Paper	2025 · arXiv Yubin Kim et al.	Controls 260 configurations across six agentic benchmarks to show how coordination, model capability, task parallelism, and tool load shape performance and error amplification.	Research preprint Preprint; inspect methods and evaluation

Benchmarks And Evaluation

How to measure loops rather than single runs: long-horizon, multi-session, reliability, and verifier-quality benchmarks.

Resource	Published at	Contribution	Evidence
🧪 SWE-bench Benchmark	swebench.com	Benchmark for resolving real GitHub issues through code editing and tests.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data
📄 SWE-bench: Can Language Models Resolve Real-World GitHub Issues? Paper	2024 · International Conference on Learning Representations (ICLR) Carlos E. Jimenez et al.	Original SWE-bench paper.	Research paper Published or accepted research record
📄 SWE-bench Goes Live Paper	2025 · Advances in Neural Information Processing Systems 38: Datasets and Benchmarks Track (NeurIPS) Linghao Zhang et al.	Dynamic benchmark designed to reduce overfitting to static issue sets.	Research paper Published or accepted research record
🧪 Terminal-Bench Benchmark	Terminal-Bench	Benchmark for agents operating in terminal environments.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data
🧰 Terminal-Bench repository Tool	2025 · GitHub harbor-framework/terminal-bench · License: Apache-2.0	Open-source benchmark and harness for hard terminal tasks.	Source implementation Inspectable source and runtime behavior
📄 AgentBench Paper	2024 · International Conference on Learning Representations (ICLR) Xiao Liu et al.	Multi-environment benchmark for evaluating LLMs as agents.	Research paper Published or accepted research record
📄 WebArena Paper	2024 · International Conference on Learning Representations (ICLR) Shuyan Zhou et al.	Realistic web environment for autonomous agents.	Research paper Published or accepted research record
📄 OSWorld Paper	2024 · Advances in Neural Information Processing Systems 37: Datasets and Benchmarks Track (NeurIPS) Tianbao Xie et al.	Benchmark for multimodal agents operating full computer environments.	Research paper Published or accepted research record
📄 ToolBench Paper	2024 · International Conference on Learning Representations (ICLR) Yujia Qin et al.	Tool-use benchmark and dataset for tool-augmented agents.	Research paper Published or accepted research record
📄 GAIA Paper	2023 · arXiv Grégoire Mialon et al.	Benchmark for general AI assistants requiring reasoning, tool use, and multi-step work.	Research preprint Preprint; inspect methods and evaluation
📄 Tau-bench Paper	2024 · arXiv Shunyu Yao et al.	Benchmark for tool-agent-user interactions in realistic domains.	Research preprint Preprint; inspect methods and evaluation
📄 VisualWebArena Paper	2024 · Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (ACL) Jing Yu Koh et al.	Visually grounded web-agent benchmark extending WebArena.	Research paper Published or accepted research record
📄 AppWorld Paper	2024 · Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (ACL) Harsh Trivedi et al.	Benchmark of interactive app tasks with state-based and execution-based evaluation.	Research paper Published or accepted research record
📄 Vending-Bench Paper	2025 · arXiv Axel Backlund & Lukas Petersson	Benchmark for long-term coherence of autonomous agents; documents how small errors compound over very long loop horizons.	Research preprint Preprint; inspect methods and evaluation
🧪 Vending-Bench leaderboard Benchmark	andonlabs.com	Live long-horizon coherence results from Andon Labs.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data
🧪 SWE-EVO: Benchmarking Coding Agents in Long-Horizon Software Evolution Scenarios Benchmark	2025 · arXiv Tue Le et al.	Release-note-derived evolution tasks where agents score far below isolated-issue benchmarks, quantifying the long-horizon gap loops must manage.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data
📄 EvoSkills: Self-Evolving Agent Skills via Co-Evolutionary Verification Paper	2026 · arXiv Hanrong Zhang et al.	A skill generator and a co-evolving surrogate verifier improve multi-file skill packages over iterations, evaluated on the SkillsBench benchmark of structured skill bundles.	Research preprint Preprint; inspect methods and evaluation
🧪 SaaSBench: Coding Agents in Long-Horizon Enterprise SaaS Engineering Benchmark	2026 · arXiv Qingnan Ren et al.	Benchmark for agents on multi-dependency, interactive enterprise tasks, with automated evaluation that probes where long-horizon loops break down.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data
🧪 RoadmapBench: Evaluating Long-Horizon Agentic Software Development Across Version Upgrades Benchmark	2026 · arXiv Xinbo Xu et al.	115 real version-upgrade tasks across 17 repositories requiring multi-file changes (median ~3,700 lines), stressing how far agent loops sustain coherent, large-scale work.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data
🧪 RefactorBench: Evaluating Stateful Reasoning in Language Agents Through Code Benchmark	2025 · International Conference on Learning Representations (ICLR) Dhruv Gautam et al.	Multi-file refactoring tasks that require tracking and carrying state across many steps, isolating the durable-state weakness that breaks long agent loops.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data
🧪 RigorBench: Benchmarking Engineering Process Discipline in Autonomous AI Coding Agents Benchmark	2026 · arXiv Meher Bhaskar Madiraju & Meher Sai Preetam Madiraju	Scores planning, verification coverage, recovery, abstention, and atomic transitions (not just whether code passes), measuring the loop discipline that separates reliable agents from reckless trial-and-error.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data
🧪 SlopCodeBench: Benchmarking How Coding Agents Degrade Over Long-Horizon Iterative Tasks Benchmark	2026 · arXiv Gabriel Orlanski et al.	Quantifies structural erosion and verbosity creep across iteration checkpoints in native harnesses like Claude Code and Codex, evidence for why loops need verification and budgets.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data
🧪 LongCLI-Bench: A Preliminary Benchmark for Long-horizon Agentic Programming in Command-Line Interfaces Benchmark	2026 · Findings of the Association for Computational Linguistics: ACL Yukang Feng et al.	Long-horizon CLI tasks where most runs stall below 30% completion, mapping where unattended loops break down.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data
🧪 Can LLM-as-a-Judge Reliably Verify Rubrics in Agentic Scenarios? Benchmark	2026 · arXiv Yangda Peng et al.	Benchmark of 2,458 instances across research and coding domains measuring how reliably LLM judges verify rubrics on agent outputs, finding substantial noise even in strong models and quantifying the trade-offs of prompt design, batched evaluation, and majority voting.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data
🧪 SentinelBench: A Benchmark for Long-Running Monitoring Agents Benchmark	2026 · arXiv Matheus Kunzler Maldaner et al.	Microsoft Research benchmark of 100 tasks across 10 synthetic web environments that evaluates long-running monitoring agents on whether they wait or act appropriately, scoring task completion, response speed, and resource efficiency.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data
🧪 SWE-Together: Evaluating Coding Agents in Interactive User Sessions Benchmark	2026 · arXiv Yifan Wu et al.	Multi-session coding benchmark of 109 repository-level tasks reconstructed from 11,260 recorded user-agent sessions, replayed with an LLM user simulator and scored on final correctness and the number of corrective feedback turns.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data
🧪 The Long-Horizon Task Mirage? Diagnosing Where and Why Agentic Systems Break Benchmark	2026 · arXiv Xinyu Jessica Wang et al.	Cross-domain diagnostic benchmark that scales task horizon through depth and breadth extension, then attributes failures across 3,100+ agent trajectories to a seven-category taxonomy via a trajectory-grounded LLM judge validated against human annotation.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data
📄 Beyond pass@1: A Reliability Science Framework for Long-Horizon LLM Agents Paper	2026 · arXiv Aaditya Khanal et al.	Reliability metrics for long-horizon agents (reliability decay, variance amplification, graceful degradation, meltdown onset) measured over 23,392 episodes across 10 models, showing capability and reliability rankings diverge as tasks lengthen.	Research preprint Preprint; inspect methods and evaluation
🧪 SEAGym: An Evaluation Environment for Self-Evolving LLM Agents Benchmark	2026 · arXiv Congjie Zheng et al.	Evaluation environment that measures whether a self-evolving agent's modifications to prompts, memory, and tools generalize to held-out tasks, using train, validation, and test splits and cost metrics on Terminal-Bench 2.0 and HLE.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data
🧪 EvoCode-Bench: Evaluating Coding Agents in Multi-Turn Iterative Interactions Benchmark	2026 · arXiv Haiyang Shen et al.	Benchmark of 26 evolving coding tasks across 227 evaluation rounds using cumulative executable tests to check that agents keep prior requirements working as specifications change, with top agents reaching only about 50% on multi-turn success metrics.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data
📄 On the Reliability of Computer Use Agents Paper	2026 · arXiv Gonzalo Gonzalez-Pumariega et al.	Repeated-execution study on OSWorld decomposing why computer-use agents fail tasks they previously completed, separating execution stochasticity, task-specification ambiguity, and behavioral variability as distinct causes of unreliability.	Research preprint Preprint; inspect methods and evaluation
📄 AgentLens: Revealing the Lucky Pass Problem in SWE-Agent Evaluation Paper	2026 · arXiv Priyam Sahoo et al.	Grades 2,614 SWE-agent trajectories across eight models to show that 10.7% of passing trajectories in its 1,815-trajectory evaluation subset are lucky trial-and-error successes, replacing binary pass/fail with process-quality tiers that shift model rankings.	Research preprint Preprint; inspect methods and evaluation
🧪 ORLoopBench: Solver-in-the-Loop Benchmarks for Self-Correction Benchmark	2026 · Proceedings of the 43rd International Conference on Machine Learning (ICML), PMLR 306 Ruicheng Ao et al.	Formalizes infeasible-model debugging as a solver-in-the-loop process where each action triggers solver re-execution and infeasibility recomputation, giving deterministic verification for iterative repair in operations research.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data
🧪 LongDS-Bench: On the Failure of Long-Horizon Agentic Data Analysis Benchmark	2026 · arXiv Kewei Xu et al.	Benchmark of 68 real-world data-analysis tasks built from Kaggle notebooks spanning 2,225 interactive turns, finding that long-horizon errors account for 52-69% of agent failures and that maintaining a correct analytical state is the core bottleneck.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data
🧪 MemoryArena: Benchmarking Agent Memory in Interdependent Multi-Session Agentic Tasks Benchmark	2026 · arXiv Zexue He et al.	Multi-session benchmark of interdependent agentic tasks where agents must distill earlier sessions into memory and use it to guide later actions, showing that near-saturated scores on long-context memory benchmarks fail to transfer.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data
🧪 Momento: Evaluating Persistent Memory and Reasoning with Multi-Session Agentic Conversations Benchmark	2026 · arXiv Adril Putra Merin et al.	Benchmark for persistent, tool-mediated task completion across multiple sessions, finding that agents fail by treating prior-session history as current context instead of stale state that needs re-validation.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data
🧪 π-Bench: Evaluating Proactive Personal Assistant Agents in Long-Horizon Workflows Benchmark	2026 · arXiv Haoran Zhang et al.	Benchmark of 100 multi-turn tasks across 5 user personas with hidden intents, inter-task dependencies, and cross-session continuity, measuring agent proactivity separately from task completion in long-horizon trajectories.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data
🧪 Can LLM Agents Be CFOs? Benchmarking Long-Horizon Resource Allocation Benchmark	2026 · arXiv Yi Han et al.	A 132-month CFO simulation where agents repeat a monthly cycle of liquidity management, financial closings, and financing decisions with compounding state, and only 15.4% of trials survive the full horizon.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data
🧪 EvoAgentBench: Benchmarking Agent Self-Evolution via Ability Transfer Benchmark	2026 · arXiv Xingze Gao et al.	Benchmark isolating whether agents transfer reusable procedures such as searching, debugging, and verification across episodes in four long-horizon domains linked by ability graphs, finding curated experience transfers but no automatic method yields consistent gains.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data
🧪 AgenticSTS: A Bounded-Memory Testbed for Long-Horizon LLM Agents Benchmark	2026 · arXiv Xiangchen Cheng et al.	Bounded-memory testbed built on Slay the Spire 2 where every agent decision is made from a fresh prompt assembled by typed retrieval over recorded state, keeping prompt size bounded across runs of any length, with 298 documented trajectories released.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data
📄 Is Three the Magic Number? An Empirical Evaluation of LLM-Based Repair Loops Paper	2026 · arXiv Tobias Kiecker et al.	Empirical evaluation of iteration budgets for generate-validate-repair loops across code generation, test generation, and translation, finding the first three to four iterations capture most gains and that orchestration and feedback design matter more than the model.	Research preprint Preprint; inspect methods and evaluation
🧪 DeepSWE: Measuring Frontier Coding Agents on Original, Long-Horizon Engineering Tasks Benchmark	2026 · arXiv Wenqi Huang et al.	113 from-scratch, contamination-free long-horizon software-engineering tasks with custom verifiers that accept any correct implementation, built to sidestep SWE-bench-style pretraining recall and better differentiate frontier coding agents.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data
🧪 PERFOPT-Bench: Evaluating Coding Agents on Software Performance Optimization Benchmark	2026 · arXiv Yingyun Cui et al.	Benchmarks the profile-diagnose-edit-verify loop where the verifier is a profiler rather than a test suite: agents must deliver measured, reproducible speedups without breaking correctness, and across seven agent configurations the framework choice shifts results even with identical models.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data
🧪 Benchmarking coding agents on Databricks' multi-million line codebase Benchmark	2026 · Databricks	Databricks engineering post (July 8, 2026, authors including Matei Zaharia and Patrick Wendell) on an internal benchmark built from real merged PRs with test-suite verification, finding that models cluster into three capability tiers, token price is a poor proxy for end-to-end task cost, and harness choice matters, with their Pi harness sending about 3x less context per turn at equal quality.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data
🧪 UniClawBench: A Universal Benchmark for Proactive Agents on Real-World Tasks Benchmark	2026 · arXiv Zhekai Chen et al.	Capability-driven benchmark of 400 bilingual tasks for proactive agents operating everyday tools in live Docker environments with step-level checkpoints, decomposed into five foundational capabilities, skill usage, exploration, long-context reasoning, multimodal understanding, and cross-platform coordination, so failures localize to a root-cause capability instead of mixing capabilities per task, with closed-loop evaluation using multiple agent roles to simulate human feedback without leaking grading criteria.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data
🧪 SLBench: Evaluating How LLM Agents Follow Logical Relations in Skills Benchmark	2026 · arXiv Xuan Chen et al.	Benchmark for whether agent loops respect the logical relations inside skill files (preconditions, constraints, fallbacks): 70% of 5,000+ public skills contain at least one such relation, and on 86 executable cases leading coding agents show unsafe-behavior rates up to 70%, with an inference-time scaffold cutting violations by 63%.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data
🧪 SWE-Milestone: Evaluating AI Agents on Continuous Software Evolution Benchmark	2026 · Proceedings of the 43rd International Conference on Machine Learning (ICML) Gangda Deng et al.	Commit-history-derived milestone task streams where agents must preserve system integrity across successive runs - frontier-model scores collapse from >80% on isolated tasks to at most 38% in continuous settings, quantifying the error-accumulation gap loop engineering targets.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data
🧪 AgentAbstain: Do LLM Agents Know When Not to Act? Benchmark	2026 · arXiv Xun Liu et al.	Benchmark measuring whether agents correctly abstain from acting when a task is underspecified, unsafe, or impossible, rather than proceeding anyway, a capability every unattended loop depends on for safe exits.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data
🧪 Agents Don't Just Agree, They Remember: Benchmarking Persistent Sycophancy Benchmark	2026 · arXiv Xutao Mao et al.	Benchmark showing that once a stateful personal agent is nudged into a sycophantic stance, it persists across later sessions through memory, so single-turn sycophancy tests understate the risk in long-running agents.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data
🧪 Set-shifting Behavioral Test for Harnessed Agents Benchmark	2026 · arXiv Ziwei Ye	Tests whether harnessed agents adapt when hidden tool reliability changes, paired with no-shift controls that separate genuine adaptation failures from ordinary task errors and expose routine lock-in.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data
🧪 MCPEvol-Bench: Benchmarking LLM Agent Performance Across Dynamic Evolutions of MCP Servers Benchmark	2026 · arXiv Huanxi Liu et al.	Applies 11 server-evolution mutations to 123 MCP servers and evaluates 12 LLMs; reported performance drops include 13.7% for GPT-5.4 and 14.4% for Claude Sonnet 4.6, quantifying tool-interface drift.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data
🧪 MM-IssueLoc: A Controlled Benchmark for Evaluating Visual Evidence in Multimodal Repository-Level Issue Localization Benchmark	2026 · arXiv Shaoxiong Zhan et al.	Provides 652 issue-PR instances across 23 languages, seven image categories, and four relevance levels; the strongest evaluated agent reaches 38.96 file Acc@5 and 22.45 function Acc@10, leaving substantial room for visual-evidence-aware repair loops.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data
🧪 ToolVerse: Unlocking Massive Environments and Long-Horizon Tasks for Agentic Reinforcement Learning Benchmark	2026 · arXiv Shuaiyu Zhou et al.	Builds executable long-horizon training environments from nearly 400 MCP servers and about 4,500 tools, generates tasks from tool-dependency graphs, and introduces turn-aware credit assignment for agentic reinforcement learning in large, dynamic tool spaces.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data

Resource	Published at	Contribution	Evidence
🧪 MobileWorld: Benchmarking Autonomous Mobile Agents in Agent-User Interaction and MCP-Augmented Tasks Benchmark	2026 · Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers) Quyu Kong et al.	Evaluates long-horizon mobile work that requires clarification and MCP tool use in reproducible self-hosted environments with deterministic backend, storage, and callback verification.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data
🧪 AGENCYBENCH: Benchmarking the Frontiers of Autonomous Agents Benchmark	2026 · Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers) Keyu Li et al.	Provides 138 high-fidelity tasks across six capabilities whose average rollout exceeds one million tokens and 90 tool calls, exposing context-retention and long-horizon execution limits.	Benchmark or evaluation Repeatable tasks, scores, or evaluation data

Operations Playbooks

Running loops in production: cost control, incident handling, and promoting validated agent behavior into cheaper deterministic paths.

Resource	Published at	Contribution	Evidence
📝 Agentic Engineering: The Agent Loop Blog	junpingyi.com	Minimal mental model for the loop underlying agent operation.	Practitioner analysis Experience-backed implementation context
📝 The agent loop: ReAct, plan-and-execute, reflection Blog	kunwar.page	Practical walkthrough of the base loop and common variants.	Practitioner analysis Experience-backed implementation context
📝 How to Build an Agent Blog	ampcode.com	Thorsten Ball's demystification of the inner agent loop: a model, a loop, and enough tokens.	Practitioner analysis Experience-backed implementation context
📝 Agentic Coding Recommendations Blog	2025 · Armin Ronacher's Thoughts and Writings	Armin Ronacher's field notes on which practices hold up when agents do most of the work.	Practitioner analysis Experience-backed implementation context
📝 Coding Agents 101: The Art of Actually Getting Things Done Blog	devin.ai	Practical delegation guidance from the Devin team on scoping tasks agents can actually finish.	Practitioner analysis Experience-backed implementation context
📝 How Anthropic teams use Claude Code Blog	Claude	Cross-team field report of real recurring agent workflows in engineering, security, and data science.	Practitioner analysis Experience-backed implementation context
📝 How Boris Uses Claude Code Blog	How Boris Uses Claude Code @CarolinaCherry	Unofficial but concrete compilation of Boris Cherny's autonomous setups: parallel worktrees, auto mode, /loop, /schedule, dynamic workflows, and /goal completion conditions.	Practitioner analysis Experience-backed implementation context
📝 Agent of the Day: Copilot Agent PR Analysis Blog	2026 · GitHub Agentic Workflows	Official walkthrough of a daily scheduled agentic workflow that ingests PR data, analyzes it, and publishes findings to a Discussion, a concrete recurring loop with trigger, intake, analysis, and output.	Practitioner analysis Experience-backed implementation context
📄 Progressive Crystallization: Turning Agent Exploration into Deterministic, Lower-Cost Workflows Paper	2026 · arXiv Arun Malik	Production lifecycle in which repeatedly validated agent-loop behaviors are promoted into deterministic workflows and demoted on regression, cutting per-incident agent cost by over 70% across eight months of a cloud AIOps system.	Research preprint Preprint; inspect methods and evaluation
📄 Tool-Making and Self-Evolving LLM Agents in Low-Latency Systems Paper	2026 · arXiv Kalle Kujanpää et al.	Production tool-making pipeline that mines live execution traces to compile recurring SOP steps into validated, versioned tools agents call instead of regenerating code, cutting median latency 42% and errors up to 53% in a fulfillment-center alarm-triage deployment.	Research preprint Preprint; inspect methods and evaluation
📝 AI Loop Engineering: Build Autonomous Agents with Claude Code /goal and Routines Blog	sabrina.dev Sabrina Ramonov 🍄	Sabrina Ramonov's practitioner walkthrough of building verified loops with Claude Code /goal and cloud routines: a six-part loop-engineering framework, five worked examples each with a verifiable end state, and a production daily support-ticket cleanup routine whose independent checker agents illustrate why the checker is the hard part.	Practitioner analysis Experience-backed implementation context
📄 Agent Delivery Engineering Predictive Reliability Framework Paper	2026 · arXiv Dexing Liu	Proactive health-trajectory prediction for long-horizon multi-agent systems, aggregating 20 heterogeneous signals across five layers into a trust-margin metric with 8-hour forecasts at 76.8% direction accuracy, detecting degradation concealed by normal surface metrics across 15 days of production traffic.	Research preprint Preprint; inspect methods and evaluation
📄 CADAQUES: A Cost-Aware Dual Architecture for Query-Efficient Autonomous Discovery Paper	2026 · arXiv Jorge Bravo-Abad	Makes cost part of the loop contract: an Oracle executes queries, a Driver chooses them, a shared vector budget covers wall time, CPU, money, and LLM tokens, and an append-only ledger records declared versus settled cost for every transaction. The Ising-model case study shows how mixed-fidelity scheduling can outperform high fidelity throughout at the tested budget.	Research preprint Preprint; inspect methods and evaluation
🧰 rocketplaneIO Tool	2026 · GitHub olemeyer/rocketplaneIO · License: Apache-2.0	Self-hosted AI SRE for Kubernetes whose copilot investigates autonomously via eBPF traces, logs, and live service maps, but can only act through named, reversible, risk-graded operations.	Source implementation Inspectable source and runtime behavior
📝 Migrating a Production AI Agent to GPT-5.6 Blog	Ploy	Lorenzo Gentile's July 2026 case study of swapping the model inside Ploy's production website-building agent (plans pages, writes components, screenshots its own work, decides when done): roughly a third of initial cross-model eval failures traced to Opus-specific harness assumptions rather than the new model, GPT-5.6 invented placeholder values for optional tool parameters (fixed via required-but-nullable schemas, after 52-64% of file reads silently returned empty), cache keys needed workspace scoping (0% to 83.7% first-call hits), and reasoning state moved to self-contained encrypted blobs, concrete evidence that eval harnesses and regression gates are the load-bearing layer when changing the model inside a production loop.	Practitioner analysis Experience-backed implementation context
📄 Coding-agents can replicate scientific machine learning papers Paper	2026 · arXiv Atharva Hans & Ilias Bilionis	Runs coding agents independently 12 times across four scientific machine-learning papers; all workspaces satisfy the study's completion criteria, and 158 implementation targets are linked to report evidence, offering a concrete playbook for evidence-backed research replication.	Research preprint Preprint; inspect methods and evaluation

Templates And Patterns

Reusable patterns that contributors can turn into future examples, templates, or playbooks.

Resource	Published at	Contribution	Evidence
🧾 Resource entry template Template	2026 · GitHub Template library	Format for adding a single resource with evidence quality and category fit.	Project artifact Schema, example, guide, or repository documentation
🧾 Loop pattern template Template	2026 · GitHub Template library	Template for documenting an operational loop such as PR babysitting, CI repair, or feedback clustering.	Project artifact Schema, example, guide, or repository documentation
🧾 Loop contract schema Template	2026 · GitHub Schema	Machine-readable schema for portable loop specs.	Project artifact Schema, example, guide, or repository documentation
🧾 Loop contract preview script Template	2026 · GitHub Repository utility	Dependency-free demo that validates and renders a loop contract JSON file.	Project artifact Schema, example, guide, or repository documentation
🧾 Translation guide Template	2026 · GitHub Project documentation	How to add or maintain a language translation without drifting from the full English guide.	Project artifact Schema, example, guide, or repository documentation
🧾 Pattern library index Template	2026 · GitHub Pattern library	Practical loop patterns with triggers, state, verification gates, budgets, and escalation paths.	Project artifact Schema, example, guide, or repository documentation

All 20 documented patterns span build, operate, optimize, and govern use cases. Each has a full write-up, worked scenario, matching JSON contract, and side-by-side comparison in the matrix.

Examples And Schema

Concrete examples make the loop contract easier to adapt to real repositories.

Resource	Published at	Contribution	Evidence
🔁 Loop contract catalog Pattern	2026 · GitHub Example library	Connects all 20 patterns to schema-valid contracts, deterministic gates, durable receipts, and four worked implementation paths.	Project artifact Schema, example, guide, or repository documentation
🧾 Loop contract library Template	2026 · GitHub Example library	Adaptable contracts for build, operate, optimize, and govern loops, checked against the shared schema with explicit permissions, budgets, and handoffs.	Project artifact Schema, example, guide, or repository documentation
🧾 Runnable test-repair loop Template	2026 · GitHub Runnable example	Repeats a failing deterministic check with durable progress, duplicate-failure detection, and a hard retry budget.	Project artifact Schema, example, guide, or repository documentation
🧾 Runnable loop guide Template	2026 · GitHub Runnable example	Compares 8 starters by trigger, state, gate, and runtime, including executable test-repair, threshold-monitor, and queue-worker loops.	Project artifact Schema, example, guide, or repository documentation

Preview an example locally:

python3 scripts/preview_loop_contract.py examples/pr-babysitter-loop.json

Community Gallery

Study concrete loop designs or contribute a real, realistic, or safely anonymized example.

Running a real loop? Share it, real or anonymized, in the patterns discussion under Shape What Comes Next. Use the minimum useful case study and anonymization checklists so others can learn from it safely.

Resource	Published at	Contribution	Evidence
🧾 Loop gallery guide Template	2026 · GitHub Community gallery	Quality bar for contributed loop examples with receipts and lessons learned.	Project artifact Schema, example, guide, or repository documentation
🧾 Loop gallery template Template	2026 · GitHub Community gallery	Markdown template for sharing a loop's trigger, intake, state, verification, escalation, and safety notes.	Project artifact Schema, example, guide, or repository documentation
🔁 PR babysitter reference loop Pattern	2026 · GitHub Community gallery	Reference gallery entry for keeping a pull request moving.	Project artifact Schema, example, guide, or repository documentation
🔁 CI repair reference loop Pattern	2026 · GitHub Community gallery	Reference gallery entry for turning failing CI into a verified patch or escalation.	Project artifact Schema, example, guide, or repository documentation
🔁 Docs drift reference loop Pattern	2026 · GitHub Community gallery	Reference gallery entry for recurring docs/code consistency checks.	Project artifact Schema, example, guide, or repository documentation

Critiques, Risks, And Limitations

Skeptical takes and measured failure modes, because a loop that cannot fail safely should not run unattended.

Resource	Published at	Contribution	Evidence
⚠️ Most Developers Do Not Need Agent Loops Yet Critique	Substack AlphaSignal AI	Useful caution against adopting loops before the task, signal, and economics justify them.	Risk analysis Failure modes, limits, or adoption cautions
⚠️ Engineering Agentic Systems for Reliability Critique	Sans Serif Systems Shailesh Rawat	Cautions that agentic systems fail at boundaries when permissions, verification, traceability, and escalation are weak.	Risk analysis Failure modes, limits, or adoption cautions
⚠️ Self-Correcting Agents: Reflexion, CRITIC, and ReAct Loops Compared Critique	2026 · CallSphere CallSphere	Compares self-correction patterns and their cost/failure tradeoffs.	Risk analysis Failure modes, limits, or adoption cautions
⚠️ How to Build an AI Agent Harness: A 2026 Complete Guide Critique	atlan.com	Broad guide with useful warnings on data readiness, permissions, context management, and evaluation.	Risk analysis Failure modes, limits, or adoption cautions
⚠️ Harness Engineering vs Prompt Engineering vs Context Engineering Explained Critique	2026 · Medium Vishal Mysore	Adjacent framing that helps avoid confusing loop engineering with the surrounding harness discipline.	Risk analysis Failure modes, limits, or adoption cautions
📄 Position: Coding Benchmarks Are Misaligned with Agentic Software Engineering Paper	2026 · arXiv Maria I. Gorinova et al.	Argues benchmark scores conflate the model with the harness and penalize valid alternatives, so headline numbers hide which loop and harness choices actually move performance.	Research preprint Preprint; inspect methods and evaluation
📄 Understanding the Challenges in Iterative Generative Optimization with LLMs Paper	2026 · arXiv Allen Nie et al.	Empirically isolates three hidden design choices that make self-improving agent loops succeed or fail - starting artifacts, credit horizons over execution traces, and batching strategy - explaining why iterative refinement loops stay brittle in production.	Research preprint Preprint; inspect methods and evaluation
📄 The Illusion of Multi-Agent Advantage Paper	2026 · arXiv Prathyusha Jwalapuram et al.	Systematic evaluation showing automatically generated multi-agent systems consistently underperform chain-of-thought self-consistency while costing up to 10x more, cautioning that auto-designed orchestration adds complexity without functional benefit.	Research preprint Preprint; inspect methods and evaluation
⚠️ The Coming Loop Critique	2026 · Armin Ronacher's Thoughts and Writings	Flask creator Armin Ronacher's skeptical essay on harness loops, examining what continuously re-driving agents past their natural stopping points does to code quality, review capacity, and human understanding of the resulting systems.	Risk analysis Failure modes, limits, or adoption cautions
⚠️ Loop Engineering, the Latest AI Buzzword, Still Needs Humans in the Loop Critique	2026 · theregister	The Register's report on the June 2026 loop-engineering discussion, collecting the Steinberger, Osmani, and Cherny quotes while arguing that vendor token-consumption incentives and model non-determinism keep humans in the loop.	Risk analysis Failure modes, limits, or adoption cautions
📄 When Agents Do Not Stop: Uncovering Infinite Agentic Loops in LLM Agents Paper	2026 · arXiv Xinyi Hou et al.	Characterizes infinite agentic loops, a failure class where unbounded feedback paths make agents repeat calls, tools, or handoffs forever, and ships IAL-Scan, a static analyzer that confirmed 68 real cases across 47 of 6,549 scanned agent projects at 91.9% precision.	Research preprint Preprint; inspect methods and evaluation
📄 The Blind Curator: How a Biased Judge Silently Disables Skill Retirement in Self-Evolving Agents Paper	2026 · arXiv Xing Zhang et al.	Shows via corrupted-reward analysis that false-pass bias in an LLM judge silently disables the skill-retirement mechanism that keeps a self-evolving agent's growing skill library from drifting below the no-skill baseline.	Research preprint Preprint; inspect methods and evaluation
📄 Do LLM-Generated Skills Make Better AI Data Scientists? A Component Ablation Across Data-Science Workflows Paper	2026 · KDD Workshop on AI Data Scientist Wei-Jung Huang	Negative result for low-curation skill libraries: across four data-science lifecycle stages (56 tasks), fully LLM-generated skill files show no reliable improvement over plain task prompting, and component ablations find no skill part that helps either (all p > 0.396). Useful counterweight to the skill-generation enthusiasm in self-evolving agent stacks, curation still matters.	Research paper Published or accepted research record
📄 The Verification Horizon: No Silver Bullet for Coding Agent Rewards Paper	2026 · arXiv Binghai Wang et al.	Position paper arguing verification has become harder than generation for coding agents: every verifier is only a proxy for underspecified human intent, so reward design faces a horizon that no single verification mechanism crosses.	Research preprint Preprint; inspect methods and evaluation
⚠️ Write Code Like a Human Will Maintain It Critique	2026 · Unstack	Argues that agent-driven codebases create a compounding feedback loop where every merged shortcut becomes training signal for the next generation of changes, so code quality standards matter more, not less, under automation.	Risk analysis Failure modes, limits, or adoption cautions
📝 Claude Code Sends 33k Tokens Before Reading the Prompt Blog	2026 · Systima Systima	July 12, 2026 proxy-interception study of per-turn harness overhead: Claude Code sends ~33k tokens of scaffolding before user input versus OpenCode's ~7k (a 4.7x gap that narrows to 3.3x on newer models), mid-session cache-block rewrites produce up to 54x more cache-write tokens on identical tasks, a 72KB instruction file adds ~20k tokens per request, five MCP servers add 5-7k more, and subagent delegation alone multiplied total cost 4.2x. Directly quantifies the per-iteration economics that compound across recurring loops, with transparent methodology of identical-outcome tasks and a logging proxy capturing exact request payloads.	Practitioner analysis Experience-backed implementation context
📄 Rethinking the Evaluation of Harness Evolution for Agents Paper	2026 · arXiv Yike Wang et al.	Re-evaluates harness evolution on Terminal-Bench 2.1 with GPT-5.4 and Claude Opus 4.6, finding that evolved harnesses do not consistently beat budget-matched search and transfer only weakly to held-out tasks.	Research preprint Preprint; inspect methods and evaluation
📄 Compaction as Epistemic Failure: How Agentic LLM Tools Fabricate Confirmed Results from Killed Processes Paper	2026 · arXiv Hiroki Tamba	Documents a Claude Code failure in which partial output from a process killed with exit 143 becomes a confirmed claim after context compaction, without re-verification, showing why receipts and process status must survive summarization.	Research preprint Preprint; inspect methods and evaluation
📄 Do Agent Optimizers Compound? A Continual-Learning Evaluation on Terminal-Bench 2.0 Paper	2026 · arXiv Wenxiao Wang et al.	Compares GEPA, Meta Harness, and RELAI-VCL under matched continual-learning budgets; only the regression-controlled method keeps improving, reaching 76.4% lifelong performance versus 66.0%, 64.6%, and 58.7% for the reported alternatives.	Research preprint Preprint; inspect methods and evaluation
📄 Does Multi-Agent Debate Improve AI Feedback on Research Papers? Paper	2026 · arXiv Tomas Havranek & Zuzana Irsova	In a preregistered masked study with authors of 44 meta-analyses, participants prefer single-pass feedback to two multi-agent debate systems, one using about 30x more tokens; AI judges reverse the human preference, warning against self-evaluation alone.	Research preprint Preprint; inspect methods and evaluation

Future Directions

The Future Directions agenda turns fifteen open problems into scoped studies, runtime projects, product pilots, and shared standards. Every workstream defines the decision it unlocks, a minimum useful artifact, core measures, a starter slice, and a completion gate.

Build in this order	What must be proved	Start with
🧱 Foundation	Verification resists false completion; state survives interruption; execution is idempotent, observable, and contained	Verifier challenge set, crash injection, receipt schema, state replay, and least-privilege policy
📐 Scale	Gains remain after factorized ablations, matched budgets, long-horizon failures, runtime changes, and full cost accounting	Benchmark harness, stopping-policy replay, portable contract profile, and cost-quality frontier
🚀 Adoption	Operators can understand, interrupt, hand off, update, and retire a useful domain loop	Shadow pilot, evidence-rich handoff, promotion gates, incident drill, and lifecycle owner

Start with one recurring task, freeze its Loop Contract, compare current operation plus single-pass and fixed-retry baselines, inject failures, then publish every run, receipt, cost, and negative result. Use the shared evaluation protocol, follow a 90-day role plan, or open a direction proposal.

Adjacent Awesome Lists

Related directories and reading lists for the layers around loop engineering.

Resource	Published at	Contribution	Evidence
🧭 Awesome Harness Engineering by ai-boost List	2026 · GitHub ai-boost/awesome-harness-engineering	Comprehensive list for the agent harness layer that Loop Engineering builds on.	Discovery index Broader ecosystem coverage for finding related work
🧭 Awesome Harness Engineering by walkinglabs List	2026 · GitHub walkinglabs/awesome-harness-engineering	High-signal harness list with strong categories for context, guardrails, specs, evals, runtimes, and benchmarks.	Discovery index Broader ecosystem coverage for finding related work
🧭 Awesome Agent Harness List	2026 · GitHub AutoJunjie/awesome-agent-harness	Curated tools and resources for environments, constraints, and feedback around coding agents.	Discovery index Broader ecosystem coverage for finding related work
🧭 Awesome Context Engineering List	2025 · GitHub Meirtz/Awesome-Context-Engineering · License: MIT	Survey-style list for context engineering across LLMs and agents.	Discovery index Broader ecosystem coverage for finding related work
🧭 Awesome Prompt Engineering List	2023 · GitHub promptslab/Awesome-Prompt-Engineering · License: Apache-2.0	Classic adjacent list for prompt techniques and prompting resources.	Discovery index Broader ecosystem coverage for finding related work
🧭 Awesome LLM Agents List	2023 · GitHub kaushikb11/awesome-llm-agents	General list of LLM agent papers, frameworks, and applications.	Discovery index Broader ecosystem coverage for finding related work
🧭 Awesome AI Agents List	2023 · GitHub e2b-dev/awesome-ai-agents	Broad AI agent ecosystem map.	Discovery index Broader ecosystem coverage for finding related work
🧭 Awesome CLI Coding Agents List	2026 · GitHub bradAGI/awesome-cli-coding-agents	Directory of terminal-native coding agents, parallel runners, autonomous loops, and the harnesses that orchestrate them.	Discovery index Broader ecosystem coverage for finding related work
🧭 Awesome Self-Evolving Agents List	2026 · GitHub XMUDeepLIT/Awesome-Self-Evolving-Agents	Survey-style list of agents that improve themselves over repeated runs, an adjacent angle on long-running loops with memory and verification.	Discovery index Broader ecosystem coverage for finding related work
🧭 Awesome AI Agent Papers List	2026 · GitHub VoltAgent/awesome-ai-agent-papers · License: MIT	Curated 2026 research collection across agent engineering, memory, evaluation, workflows, and autonomous systems, a paper-level feeder for loop-design foundations.	Discovery index Broader ecosystem coverage for finding related work
🧭 awesome-ralph List	2026 · GitHub snwfdhmp/awesome-ralph	Curated directory for the Ralph technique, collecting official resources, implementations, playbooks, tutorials, and community channels for running coding agents in automated loops until specifications are fulfilled.	Discovery index Broader ecosystem coverage for finding related work
🧭 Awesome Agent Loops List	2026 · GitHub serenakeyitan/awesome-agent-loops · License: CC-BY-4.0	Curated collection of /loop, /goal, and /schedule commands for Claude Code and Codex sourced from practitioner posts, organized around trigger, condition, and skill structure.	Discovery index Broader ecosystem coverage for finding related work
🧭 Awesome Loop Models List	2026 · GitHub huskydoge/Awesome-Loop-Models · License: MIT	Dedicated catalog of architectures that reuse a learned layer, block, module, or operator within one forward process; use it for deeper model-level coverage while this repository focuses on the bridge to operational agent loops.	Discovery index Broader ecosystem coverage for finding related work

Explore And Reuse

Browse interactively, query structured exports, or reuse the publishing components.

Resource	Published at	Contribution	Evidence
🧾 Resource Atlas Template	chaoyue0307.github.io	Filter 601 resources by goal, loop layer, lifecycle stage, artifact type, evidence class, and search query.	Reusable artifact Adaptable template, schema, or guide
🧭 Hugging Face dataset List	Hugging Face	Query the full collection as generated CSV and JSONL tables with publication, evidence, and lifecycle fields.	Discovery index Broader ecosystem coverage for finding related work
🧾 Dataset export guide Template	2026 · GitHub Project documentation	Load, query, regenerate, and audit the CSV, JSONL, and Resource Atlas data.	Project artifact Schema, example, guide, or repository documentation
🧾 Runtime selection guide Template	2026 · GitHub Project operations guide	Compare session, scheduled, CI, cron, and durable runtimes by persistence, isolation, permissions, and state.	Project artifact Schema, example, guide, or repository documentation
🧾 Future Directions agenda Template	2026 · GitHub Project documentation	Turn 15 open problems into measurable studies, runtime projects, product pilots, and shared standards.	Project artifact Schema, example, guide, or repository documentation

Load the resources directly from Hugging Face:

from datasets import load_dataset
resources = load_dataset("cy0307/awesome-loop-engineering", "resources", split="train")

Shape What Comes Next

Track upcoming work, inspect release history, propose evidence, or share an operating lesson.

Resource	Published at	Contribution	Evidence
🧾 Release notes Template	2026 · GitHub Releases License: CC0-1.0	Versioned changelog of new resources, patterns, and repository changes.	Reusable artifact Adaptable template, schema, or guide
🧾 Roadmap Template	2026 · GitHub Project documentation	Near-term work, pattern priorities, gallery goals, and open questions.	Project artifact Schema, example, guide, or repository documentation
🧾 Launch article Template	2026 · GitHub Project article	Concise explanation of the concept, implementation kit, and evidence base.	Project artifact Schema, example, guide, or repository documentation
🧾 Discussion guide Template	2026 · GitHub Project operations guide	Suggested discussion categories, starter prompts, and moderation standard.	Project artifact Schema, example, guide, or repository documentation
🔁 Show your Loop Engineering patterns Pattern	2026 · GitHub Discussions License: CC0-1.0	Community discussion for real or anonymized loop examples.	Operational pattern Transferable operating practice

Build From This

Move from evidence to a working loop.

▶️ Run locally	Follow the test-repair walkthrough, then switch to the runtime that owns your trigger and isolation.
🧾 Adapt a contract	Start from the CI repair contract and replace its objective, intake, checks, budget, and escalation rules.
✅ Validate a contract	Use the loop-contract-schema package in CI or call the JSON Schema from your own validator.
📊 Analyze the field	Follow the dataset reproduction steps to work with the CSV, JSONL, source-check results, and Resource Atlas payload.
➕ Contribute one source	Use the resource suggestion form or the under-five-minute contribution path.
🔁 Share a real loop	Use the case-study form to contribute a public or anonymized operating example without preparing a pull request.

Fork the contracts, runtime starters, and dataset schema for your own loop system.

Contributing

Contribute an original or official source, an evidence-backed correction, or a loop you have run. Read CONTRIBUTING.md before opening a pull request.

New contributors can start with a good first issue, a help wanted task, or the case-study form.

The resource selection guide explains what belongs, which evidence to include, how to write useful summaries, and how corrections are handled. The maintenance guide explains link checks and releases.

For community expectations and support channels, see CODE_OF_CONDUCT.md, SUPPORT.md, and SECURITY.md.

Fast path for adding a resource:

• Check that it is about AI/coding-agent Loop Engineering or a direct foundation for it.
• Search the README to avoid duplicates.
• Pick the most specific category.
• Add one entry using this format:

| 📄 **[Title](https://example.com)**<br><sub>Paper</sub> | **2026** · arXiv<br><sub>First Author et al.</sub> | One sentence explaining the resource's concrete contribution, result, or limitation. | **Research preprint**<br><sub>Preprint; inspect methods and evaluation</sub> |

• Open a pull request and explain the category fit, source type, and why builders should care.

Fast path for contributing a loop pattern: start from the loop pattern template or loop contract schema, include trigger, discover/intake, delegation, workspace, context, verification, durable state, budget, escalation, and exit, then open a pattern suggestion issue if you want feedback before writing the full pattern.

Good submissions should answer three questions:

1. Is this about the new AI/coding-agent meaning of Loop Engineering or a direct foundation for it?
2. Does it help someone design, run, verify, evaluate, or critique recurring agent systems that coordinate prompting, context, harnesses, verification, and state?
3. Is the source stable, public, and specific enough to be useful?

Citation

Cite the field guide with:

@misc{chaoyue2026awesome_loop_engineering,
  author       = {He, Chaoyue},
  title        = {Awesome Loop Engineering},
  year         = {2026},
  howpublished = {\url{https://github.com/ChaoYue0307/awesome-loop-engineering}},
  note         = {Field guide and implementation kit for Loop Engineering, version 0.9.0}
}

Reusable blurb (for blog posts, talks, internal docs, or community posts):

Loop Engineering is the practice of designing recurring AI-agent and coding-agent systems that discover work, delegate to agents, verify results, persist state, and retry or escalate on a cadence or until a goal is reached. Awesome Loop Engineering connects 601 papers, docs, tools, benchmarks, and guides with 20 operating patterns, 20 adaptable contracts, and 8 runtime starters: github.com/ChaoYue0307/awesome-loop-engineering

Star History

_{Every star helps more researchers and builders discover the field guide. Star the repository to follow its growth.}