Canonical Definition

Provides a reusable project artifact: Short definition, positioning, minimal loop test, and citation note.

Repository-native artifact that makes an otherwise informal practice concrete and reusable.

Clarifies the scope, vocabulary, and boundaries of Loop Engineering so the list does not drift into generic agent material.

Repository-native artifact maintained in this project; signal comes from local validation and reuse.


Loop Engineering Manifesto

Provides a reusable project artifact: Concise statement of the concept, commitments, non-goals, and success standard.


Loop Engineering Taxonomy

Provides a reusable project artifact: Classification by trigger, intake, verification, state model, topology, and operating domain.


Loop Engineering Anti-Patterns

Names a risk or boundary condition: Common failure modes such as prompt loops with no contract, infinite retries, model self-approval, hidden state, and unsafe autonomy.


Comparison Guide

Provides a reusable project artifact: Distinguishes Loop Engineering from prompt engineering, context engineering, harness engineering, workflow automation, agent workflows, and evaluation loops.


Sourced Signals And Quotes

Provides a reusable project artifact: Short sourced signals from linked public materials that anchor the emerging concept.


Outreach Kit

Provides a reusable project artifact: Conservative messages for inviting corrections, sources, and real-world loop patterns.


Loop Engineering

Addy Osmani's framing of loop engineering as the layer above manually prompting coding agents, with concrete primitives across Codex and Claude Code.

Captures the early community framing of Loop Engineering as repeated agent delegation rather than prompt craft.

Gives readers the origin story and first-principles framing for the new AI/coding-agent use of Loop Engineering.

Practitioner essay or field note; signal comes from concrete experience, framing, examples, or adoption discussion.


Loop Engineering

Substack version of the same essay; useful for the original discussion trail and quotations from Peter Steinberger and Boris Cherny.


Peter Steinberger on designing loops

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.


Boris Cherny: five tips for running Opus autonomously for hours or days

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.

The agent workflow includes explicit self-checking or gated completion.


Loop Engineering

Concise explanation of the shift from prompting agents to designing loops that discover work, delegate, verify, persist, and continue.

State persistence is explicit enough for repeated runs and handoff.


Loop Engineering: The Guide for AI Agents

Practical guide that breaks the pattern into automations, worktrees, skills, connectors, subagents, and state.

Workspace isolation is part of the loop design, not an afterthought.


Stop Prompting. Design the Loop.

Practical breakdown of loop building blocks - automations, worktrees, skills, connectors, subagents - plus external memory and verification through oracles such as tests and builds.


Writing Loops, Not Prompts, Explained

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.


Loop Engineering: A Guide for Engineers and Practitioners

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.

The resource is directly reusable as a starting artifact.


Loop Engineering: When Generation Gets Cheap, Judgment Gets Expensive

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.


Andrew Ng on Loop Engineering and the Three Loops of AI-Native Product Development

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.


From Prompting Agents to Loop Engineering

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.


I Now Just Write Loops To Prompt Claude Code: Claude Code Creator Boris Cherny

Coverage of Boris Cherny's "my job is to write loops" workflow.


My Lord! AI Programming Undergoes Another Major Shift

Broad coverage of the Boris Cherny and Peter Steinberger discussion, including the distinction between cold-start scripts and persistent agent loops.


The Anthropic leader who built Claude Code ditched prompting - now he writes loops

The New Stack's report on Boris Cherny's shift from prompting to loop writing and what it changes about developer workflow.


Engineering for Agents That Never Sleep

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.


PR babysitter

Provides a reusable loop pattern: Repeatedly checks review comments, CI, merge conflicts, stale threads, and readiness to merge.

Turns common recurring-agent jobs into named patterns with gates, budgets, and escalation paths.

Translates the abstract loop contract into operational patterns with triggers, gates, budgets, and escalation paths.


CI repair loop

Provides a reusable loop pattern: Reproduces failing checks, patches narrowly, reruns evidence, and escalates when failures are outside scope.


Docs drift collector

Provides a reusable loop pattern: Finds mismatches between docs and code, proposes small patches, and verifies examples.


Deploy verifier

Provides a reusable loop pattern: Watches rollout signals, compares them with release expectations, and stops on anomalies.

Verification is promoted from a final check to a loop-control signal.


Feedback clusterer

Provides a reusable loop pattern: Periodically groups GitHub, Linear, Slack, support, or social feedback into actionable themes.


Dependency triage loop

Provides a reusable loop pattern: Classifies dependency updates, applies safe groups, verifies them, and escalates risky upgrades.


Evaluation regression loop

Provides a reusable loop pattern: Investigates degraded agent evals with baseline traces, targeted reruns, and repair proposals.

Evaluation data is used as the feedback signal for improving loop behavior.


Security review loop

Provides a reusable loop pattern: Reviews sensitive diffs with evidence-backed findings, safe permissions, and human approval boundaries.


Cost-control loop

Provides a reusable loop pattern: Monitors agent workflow spend, identifies waste, proposes scoped savings, and preserves quality gates.


Bug hunting loop

Provides a reusable loop pattern: Discovers, reproduces, minimizes, and reports bugs with concrete evidence.


Enterprise approval loop

Provides a reusable loop pattern: Drives a permissioned change through required gates and approvers with a full audit trail.


Incident response loop

Provides a reusable loop pattern: Triages an alert into an owned, evidence-backed incident with a postmortem seed.


Data-quality loop

Provides a reusable loop pattern: Validates each dataset refresh against quality rules and quarantines bad versions.

The list is made machine-readable as a tabular dataset rather than only a Markdown page.


Release-note loop

Provides a reusable loop pattern: Drafts release notes from merged commits, issues, and PRs with linked evidence.


Model-routing loop

Provides a reusable loop pattern: Routes tasks across models on measured quality, latency, privacy, and cost.


Automations - Codex app

Codex background automations for recurring tasks, triage inboxes, skills, and worktree isolation.

Turns the concept into concrete loop mechanics: triggers, state, tools, worktrees, permissions, and recurring execution.

Primary official documentation for a platform, SDK, or standard.


Follow a goal - Codex use cases

Official guidance for durable objectives with stopping conditions, validation commands, checkpoints, and progress logs.

Primary-source operational guidance rather than commentary.


Worktrees - Codex app

Codex worktree model for isolated parallel tasks and handoffs between local and background workspaces.


Prompting - Codex

Explains the Codex loop, threads, context, and `/goal` mode.

Context is managed as durable loop state rather than a single prompt payload.


Customization - Codex

Maps `AGENTS.md`, memories, skills, MCP, and subagents into a coherent customization stack.

Persistent memory is treated as an external runtime artifact.


Agent Skills - Codex

Official skill format for reusable workflows, scripts, MCP dependencies, invocation policy, and plugin packaging.


Plugins - Codex

Bundles skills, app integrations, and MCP servers into reusable loop capabilities.

Breaks loop design into operational primitives that can be combined across agents and runtimes.


dotskills

Provides an implementation surface for loop builders: 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 repository or implementation artifact that can be inspected directly.


Slash commands in Codex CLI

CLI commands for switching agent threads, browsing skills, inspecting MCP tools, and using subagent workflows.

The work separates roles across agents, verifiers, or orchestration layers.


Autonomous Loops

Provides a reusable loop pattern: Claude Code pattern using task files, stop hooks, restart behavior, hard limits, and a kill switch.

Operational pattern or playbook; signal comes from reusable loop structure and practical transferability.


Claude Code Glossary

Defines the agentic loop, hooks, subagents, skills, MCP, and related primitives in Claude Code terminology.


Keep Claude working toward a goal

`/goal` runs turn after turn until a completion condition is met by a verifier.


Run prompts on a schedule

`/loop`, scheduled tasks, reminders, monitor tools, and session-scoped recurring prompts.

The trigger or cadence is explicit, making the workflow recurring rather than one-off.


Automate work with routines

Claude Code routines: persistent cloud automations triggered by schedules, API calls, or GitHub events, with connectors, scoped environments, and branch-push limits.


Desktop scheduled tasks

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.


Run parallel sessions with worktrees

Worktree isolation for parallel sessions and subagents so concurrent edits do not collide.


Automate actions with hooks

Claude Code hooks guide for deterministic lifecycle control around model actions.


Hooks reference

Event-level reference for session, turn, tool-call, and subagent hooks.


Common workflows - Claude Code

Practical workflows for worktrees, subagents, CI, batch processing, planning, and resuming prior work.


Manage multiple agents with agent view

Dashboard for dispatching, monitoring, and attaching to background agent sessions.


Run agents in parallel

Compares agent view, subagents, agent teams, worktrees, tasks, and workflows for parallel work.


Orchestrate subagents at scale with dynamic workflows

Moves loop state and branching into workflow scripts so large tasks do not overload the conversation context.


Create plugins

Packaging model-invoked skills, agents, hooks, MCP servers, monitors, and settings as shareable loop components.


Model Context Protocol

Standard protocol for exposing tools and data sources to agent loops.


Allowing GitHub Copilot CLI to work autonomously

Copilot CLI autopilot mode plus `/every` and `/after` scheduling, turning the CLI into an unattended loop that runs steps until a task is complete.


opencode-scheduler

Provides an implementation surface for loop builders: 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.


Agent-Loop-Skills

Provides an implementation surface for loop builders: 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.


launch-your-agent

Provides an implementation surface for loop builders: 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.


Run long horizon tasks with Codex

OpenAI's runbook for plan-edit-test-observe-repair-document-repeat work, including specs, plans, status logs, and validation gates.

Shows how production platforms expose loops through concrete tools, permissions, skills, agents, and automation features.

Anchors implementation choices in primary vendor and framework documentation instead of second-hand summaries.


Best practices - Codex

Official best practices for context, `AGENTS.md`, MCP, skills, subagents, and automations.


Agents SDK

OpenAI guide for agent orchestration, tool execution, approvals, state, guardrails, and observability.

Orchestration and control flow are made explicit and inspectable.


Agents - OpenAI Agents SDK

SDK primitives for agents, tools, handoffs, guardrails, and runner-managed loops.

Primary documentation from a platform, SDK, standard, or framework; strong implementation signal.


Running agents

OpenAI guide to turns, state, approvals, sessions, and continuation in the SDK runtime loop.


Integrations and observability

OpenAI guide to MCP wiring and traces as the basis for debugging and evaluation loops.


Sandbox Agents

Splits the harness control plane from the sandbox execution plane for long-running file and command work.

Execution isolation and permission boundaries are part of the design.


Guardrails and human review

Approval and validation boundaries for sensitive agent actions.


Building agents with the Claude Agent SDK

Claude SDK overview for tool-using agents, subagents, state, permissions, and streaming.


How the agent loop works

Official walkthrough of the inner agent loop that outer recurring loops build on.


Extend Claude with skills

Claude Code skill system for reusable loop instructions and assets.


Create custom subagents

Claude Code custom subagents with isolated context, model choice, and tool permissions.


GitHub Agentic Workflows

Repository automation that runs coding agents in GitHub Actions on events or schedules with guardrails.


GitHub Agentic Workflows technical preview

Changelog announcement for Markdown-defined agentic workflows in GitHub Actions.


Continuous AI

GitHub Next's umbrella framing for CI/CD-style AI automation across the software lifecycle, the category that agentic workflows demonstrate.


Automate repository tasks with GitHub Agentic Workflows

Official walkthrough of writing Markdown-defined agentic workflows with guardrails for triage, QA, and docs chores.


Continuous AI in practice: What developers can automate today with agentic CI

Concrete agentic-CI automations available today, with recurring patterns for triage, review, and documentation upkeep.


About GitHub Copilot coding agent

GitHub's autonomous coding agent: assign an issue, the agent works in an isolated Actions-powered workspace, and a reviewable pull request comes back.


GitHub Copilot: Meet the new coding agent

Launch overview of the issue-to-PR delegation loop, including iteration on review feedback.


Jules

Google's asynchronous coding agent that plans, executes tasks in isolated cloud VMs, and returns reviewable diffs.


Cursor cloud agents

Remote agents that work asynchronously in isolated environments and hand results back for review.


Devin Docs

Documentation for a long-running autonomous software engineer with sessions, playbooks, knowledge, and review boundaries.


Writing effective tools for AI agents

Anthropic's guidance on evaluating and improving tool specs using agentic loops and realistic tasks.


Introducing advanced tool use on the Claude Developer Platform

Tool search, programmatic tool calling, and tool-use examples for scaling large tool libraries without flooding context.


Effective harnesses for long-running agents

Anthropic's guidance for agents that work across many context windows: durable progress artifacts, environment setup, and self-verification.

Durable execution and replay are treated as first-class loop infrastructure.


Claude Code best practices

Widely cited workflow guidance that underlies many recurring Claude Code loops.


Cursor 3.8: Improvements to Cursor Automations

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.


GitHub Copilot for Jira Is Now Generally Available

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.


Claude Managed Agents: Scheduled Deployments and Vaults

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.


Copilot Agent Session Streaming (Public Preview)

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.


Expanding Our Long-Running Agents Research Preview

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.


ReAct: Synergizing Reasoning and Acting in Language Models

Foundational reason-act-observe loop for tool-using language agents.

Connects Loop Engineering to prior agent-loop and feedback-loop research.

Connects Loop Engineering to prior work on agent loops, planning, reflection, feedback, and long-horizon autonomy.

Research preprint with stable arXiv identifier.


Reflexion: Language Agents with Verbal Reinforcement Learning

Converts environment feedback into written reflections stored in memory for future attempts.


Self-Refine: Iterative Refinement with Self-Feedback

Generate-feedback-refine loop where a model improves outputs over repeated passes.


CRITIC: Large Language Models Can Self-Correct with Tool-Interactive Critiquing

Uses tools to ground critique and correction rather than relying only on introspection.


Tree of Thoughts

Search over multiple reasoning branches; relevant when loop design needs exploration before committing.


Graph of Thoughts

Generalizes thought structures beyond chains and trees, useful for complex loop planning and aggregation.

Control flow is represented as an inspectable graph rather than an opaque prompt loop.


Language Agent Tree Search Unifies Reasoning Acting and Planning in Language Models

Combines search, action, and environment feedback for language agents.


Voyager: An Open-Ended Embodied Agent with Large Language Models

Demonstrates lifelong skill acquisition through iterative exploration, feedback, and a skill library.


Generative Agents: Interactive Simulacra of Human Behavior

Introduces reflection and memory mechanisms for long-running agent behavior.


Measuring AI Ability to Complete Long Software Tasks

METR's task-length time horizon metric; grounds why loop budgets, checkpoints, and escalation matter as autonomous work gets longer.

Checkpointed state makes long-running agent work recoverable across failures.


Measuring AI Ability to Complete Long Tasks

Accessible summary of the 50% task-completion time horizon and its doubling trend.


Reflection-Driven Control for Trustworthy Code Agents

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.


Hyperagents

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.


PARC: An Autonomous Self-Reflective Coding Agent for Robust Execution of Long-Horizon Tasks

Hierarchical plan-execute-assess loops that detect and correct strategic errors during multi-hour autonomous runs.

The work targets tasks that exceed a single context window or prompt session.


When the Specification Emerges: Benchmarking Faithfulness Loss in Long-Horizon Coding Agents

Measures how agents drift from intent when specifications arrive incrementally across a long loop, and proposes a mitigation that recovers most of the loss.


Reflexion code

Provides an implementation surface for loop builders: Reference implementation and experiments for verbal reinforcement loops.


Stop Hand-Holding Your Coding Agent: Engineering the Loops that Replace Step-by-Step Prompting

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.

Verification is promoted from a final check to a loop-control signal.


From Question Answering to Task Completion: A Survey on Agent System and Harness Design

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.


MOSS: Self-Evolution through Source-Level Rewriting in Autonomous Agent Systems

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.


METR Time Horizon 1.1

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.


MetaSkill-Evolve: Recursive Self-Improvement via Two-Timescale Meta-Skill Evolution

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.


SkillOpt-Lite: Better and Faster Agent Self-Evolution via One Line of Vibe

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.


Building Effective Agents

Anthropic's canonical guide to workflows and agents, including evaluator-optimizer and orchestrator-workers patterns.

Shows reusable architecture patterns that compose agents, evaluators, workers, and durable workflow control.


How we built our multi-agent research system

Detailed orchestrator-worker system with planning, memory, subagents, citation passes, and iterative research loops.


Building Effective AI Agents: Architecture Patterns and Implementation Frameworks

PDF overview of agent architecture patterns, including generator-evaluator loops.

Distills reusable agent-control patterns that are not tied to a single vendor implementation.

Research paper or preprint; strongest signal when the entry contributes a method, benchmark, measurement, or formal framing.


AI Agent Architectures

System-design overview of ReAct, reflection, planning, tool use, memory, and control strategies.


What Are Agentic Workflows?

Accessible taxonomy of planning, tool use, reflection, and memory patterns.


Agent Planning & Reflection Patterns

Visual explanation of plan-execute, observe, reflect, retry, and stop patterns.


Agentic Design Patterns

Practical overview of ReAct, reflection, tool use, planning, and how to combine them in real-world agents.


12 Factor Agents

Provides a reusable loop pattern: Operating principles for production agents, including explicit prompts, state ownership, and pause-resume behavior.

State persistence is explicit enough for repeated runs and handoff.


Durable Execution for Agentic Workflows

Provides a reusable loop pattern: Explains checkpointing, event-sourced journals, replay, and recovery for long-running agent workflows.


Code as Agent Harness

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.


Agentic Agile-V: From Vibe Coding to Verified Engineering

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.


Harness Engineering for Language Agents: The Harness Layer as Control, Agency, and Runtime

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.


Agentic Software Engineering: Foundational Pillars and a Research Roadmap

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.


The Art of Loop Engineering

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.


Loopy

Provides an implementation surface for loop builders: Library of reusable AI-agent loops with verification checks and stopping conditions, plus an installable skill for finding, adapting, and designing repeatable agent workflows.


SWE-agent

Provides an implementation surface for loop builders: Agent-computer interface and autonomous software engineering agent for repository tasks.

Uses real automated software-engineering systems as evidence for practical loop architectures.

Grounds the practice in real coding-agent systems, bare loops, orchestration tools, and long-running software tasks.


SWE-agent: Agent-Computer Interfaces Enable Automated Software Engineering

Paper behind SWE-agent and its interface design.


mini-SWE-agent

Provides an implementation surface for loop builders: Minimal coding agent that is useful for understanding the core loop without a large framework.

Working implementation, framework, runtime, or repository; signal comes from usable code and ecosystem adoption.


OpenHands

Provides an implementation surface for loop builders: Open platform for AI software developers as generalist agents.


OpenHands: An Open Platform for AI Software Developers as Generalist Agents

Paper describing OpenHands, CodeActAgent, benchmarks, and generalist agent evaluation.

Evaluation data is used as the feedback signal for improving loop behavior.


Agentless

Provides an implementation surface for loop builders: Workflow-based approach for software issue resolution using localization, repair, and patch validation.


Agentless: Demystifying LLM-based Software Engineering Agents

Useful contrast case: strong results through structured workflow rather than a fully open-ended agent.


AutoCodeRover

Provides an implementation surface for loop builders: Autonomous program improvement system for issue localization, patch generation, and validation.


AutoCodeRover: Autonomous Program Improvement

Paper on autonomous code repair loops over real repositories.


Ralph

Provides a reusable loop pattern: 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.

Persistent memory is treated as an external runtime artifact.


everything is a ralph loop

Provides a reusable loop pattern: 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.


how-to-ralph-wiggum

Provides an implementation surface for loop builders: Reference repository documenting the Ralph Wiggum technique end to end, from the bare loop script to guardrails and conventions.


A Brief History of Ralph

Traces how the bare-loop technique spread from a provocation to a production practice among early adopters.


Ralph Copilot

Provides a reusable loop pattern: Language-agnostic Ralph loop implementation using fresh context, filesystem memory, `PRD.md`, and `PROGRESS.md`.


Compound Engineering

Provides a reusable loop pattern: 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.


Gas Town

Provides an implementation surface for loop builders: 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.


Amp

Provides an implementation surface for loop builders: Agentic coding tool built around threads, subagents, and an opinionated harness, with an owner's manual that documents loop-style operating practices.


karl

Provides an implementation surface for loop builders: Autonomous multi-agent development loop with planner, reviewer, architect, tester, developer, deployment, and retry phases.


joelclaw agent-loop skill

Provides a reusable loop pattern: Durable Planner-Implementor-Reviewer-Judge coding loops via Inngest events and progress files.


SWE-bench reading list

Maps adjacent resources and ecosystems: Maintained map of software engineering agent systems and related papers.


TraceCoder: A Trace-Driven Multi-Agent Framework for Automated Debugging of LLM-Generated Code

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.


The Kitchen Loop: User-Spec-Driven Development for a Self-Evolving Codebase

A production loop where an agent exercises a spec surface as a synthetic power user behind ground-truth tests and quality gates, sustaining 285+ self-correcting iterations and 1,000+ merged PRs with zero detected regressions.


Inside the Scaffold: A Source-Code Taxonomy of Coding Agent Architectures

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.


A Self-Improving Coding Agent

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.


Factory 2.0: From Coding Agents to Software Factories

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.


Ralph

Provides an implementation surface for loop builders: 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.


ARIS (Auto-Research-In-Sleep)

Provides an implementation surface for loop builders: 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.


ralph-claude-code

Provides an implementation surface for loop builders: 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.


AutoAgent

Provides an implementation surface for loop builders: 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.

The work turns loop quality into a measurable task or score.


ralph-orchestrator

Provides an implementation surface for loop builders: 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.


zeroshot

Provides an implementation surface for loop builders: CLI that runs a planner, an implementer, and independent validators in isolated environments, looping until a change is verified or rejected with reproducible failures.


ralphex

Provides an implementation surface for loop builders: 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.


Loki Mode

Provides an implementation surface for loop builders: 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.


ralph (iannuttall)

Provides an implementation surface for loop builders: 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.


ralph-loop-agent

Provides an implementation surface for loop builders: 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.


Open Ralph Wiggum

Provides an implementation surface for loop builders: 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.

Context is managed as durable loop state rather than a single prompt payload.


Superpowers 6

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


Don't Blame the Large Language Model: How Scaffolding Evolution Shapes Coding Agent Quality

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.


Introducing Devin Security Swarm

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.

The trigger or cadence is explicit, making the workflow recurring rather than one-off.


Towards Self-Driving Codebases

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.


Looper

Provides an implementation surface for loop builders: 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.


Agent Apprenticeship

Provides an implementation surface for loop builders: 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.

The list is made machine-readable as a tabular dataset rather than only a Markdown page.


Scholar Loop

Provides an implementation surface for loop builders: 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.

The work separates roles across agents, verifiers, or orchestration layers.


Why Agentic Systems Must Produce Deterministic Outputs to Scale

Argues for deterministic boundaries, contracts, and execution gates around probabilistic agent reasoning.

Treats feedback, telemetry, and deterministic artifacts as loop-control gates.

Identifies the feedback signals that make recurring agent work measurable, retryable, and safe to stop.


Stop Babysitting Your Coding Agent. Give It Backpressure.

Provides a reusable loop pattern: Explains how to turn tests, linters, builds, traces, and other signals into feedback loops for coding agents.


How to Build a Self-Verification Loop in Claude Code

Provides a reusable loop pattern: Uses hooks to enforce syntax, intent, and regression checks before an agent can finish.

The agent workflow includes explicit self-checking or gated completion.


How to build a better agent harness with traces and evals

Trace-evaluate-debug-refine loop for improving agent behavior from real runs.


Better Harness: A Recipe for Harness Hill-Climbing with Evals

LangChain's recipe for using evals as the learning signal for harness improvement.


Improving Deep Agents with harness engineering

Practical discussion of self-verification, traces, middleware, and loop detection for coding agents.


OpenAI agent evals

Evaluation guidance for moving from traces to repeatable grading of agent workflows.


Promptfoo OpenAI Agents provider

Provides an implementation surface for loop builders: Testing and assertions for multi-turn agent workflows, tools, state, handoffs, sandboxes, and traces.

Execution isolation and permission boundaries are part of the design.


Inspect AI

Provides an implementation surface for loop builders: UK AISI evaluation framework with solvers, scorers, sandboxing, tool use, MCP, and log viewing.


OpenTelemetry Semantic Conventions for Generative AI Systems

Portable tracing conventions for model calls, tool calls, and agent workflows.


AgentOps

Provides an implementation surface for loop builders: Monitoring, replay, cost tracking, benchmarking, and tracing for agent sessions.

Durable execution and replay are treated as first-class loop infrastructure.


Langfuse

Provides an implementation surface for loop builders: Open-source LLM engineering platform with tracing, evaluations, and metrics that loops can read back as feedback signals.


LangSmith

Provides an implementation surface for loop builders: Tracing, evaluation, and monitoring platform for inspecting and grading agent runs across iterations.


Arize Phoenix

Provides an implementation surface for loop builders: Open-source AI observability for tracing, evaluating, and debugging agent behavior from real runs.


Braintrust

Provides an implementation surface for loop builders: Evaluation and observability platform with experiments, datasets, and CI integration for gating agent changes.


Weave

Provides an implementation surface for loop builders: Weights & Biases toolkit for tracing, evaluating, and monitoring agent applications over time.


Agentic Verification of Software Systems

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.


Agentic Harness Engineering: Observability-Driven Automatic Evolution of Coding-Agent Harnesses

A closed loop that turns each harness edit into a falsifiable contract verified against trajectory outcomes, so the harness evolves from observability instead of trial and error.


A Trace-Based Assurance Framework for Agentic AI Orchestration: Contracts, Testing, and Governance

Treats execution traces as the assurance substrate, pairing machine-checkable contracts, testing, and governance so recurring agent orchestration stays verifiable and auditable.

Orchestration and control flow are made explicit and inspectable.


Meta-Harness: End-to-End Optimization of Model Harnesses

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.


Self-Evolving Agents with Anytime-Valid Certificates

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.


Delayed Verification Destabilizes Multi-Agent LLM Belief

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.


Lean4Agent: Formal Modeling and Verification for Agent Workflow and Trajectory

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 about 12% on software-engineering benchmarks.


Regimes: An Auditable, Held-Out-Gated Improvement Loop

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.


Agentic CLEAR: Automating Multi-Level Evaluation of LLM Agents

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.


Agentic Code Review

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.


Using DSPy to Evaluate and Improve Datasette Agent's SQL System Prompts

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.


agentops

Provides an implementation surface for loop builders: 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.


HALO (Hierarchical Agent Loop Optimizer)

Provides an implementation surface for loop builders: 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.


Harness-Aware Self-Evolving: Co-Evolving Model Weights, Harness, and Task Solutions

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.


Diagnosis-Driven Automatic Repair for Agentic Workflow via Symbolic Inference

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.


SkillCoach: Self-Evolving Rubrics for Evaluating and Enhancing Agentic Skill-Use

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.


SWE-Doctor: Guiding Software Engineering Agents with Runtime Diagnosis from Bug Reproduction Tests

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.


Agentic coding notes

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.


Understanding Is the New Bottleneck

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.


Verifying Agentic Development at Scale

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.


Loop Engineering Without Verification Is Just Automation

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.


SkillSpec

Provides an implementation surface for loop builders: 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.


Shepherd

Provides an implementation surface for loop builders: 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.


The lethal trifecta for AI agents

Names a risk or boundary condition: Simon Willison's rule of thumb: private data, untrusted content, and an exfiltration channel must never meet inside one unattended agent.

Untrusted intake is treated as a loop-level security boundary.

Surfaces the security boundaries needed when loops ingest untrusted content or act without constant human supervision.

Risk or limitation analysis; signal comes from boundary conditions, failure modes, and adoption cautions.


Prompt injection series

Names a risk or boundary condition: Ongoing series on the core unsolved vulnerability for loops whose intake includes content written by strangers.


Agentic AI - Threats and Mitigations

OWASP threat model for agentic systems, useful when reviewing intake, memory, tool, and delegation boundaries.


Designing AI agents to resist prompt injection

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.

Primary-source operational guidance rather than commentary.


sandbox-runtime

Provides an implementation surface for loop builders: Anthropic's OS-level filesystem and network sandboxing for arbitrary processes without requiring a container.


E2B

Provides an implementation surface for loop builders: Open-source isolated cloud sandboxes for running untrusted, AI-generated code inside agent loops.


Modal Sandboxes

Secure sandboxed execution for agent-driven code with resource limits and network controls.


Daytona

Provides an implementation surface for loop builders: Infrastructure for running AI-generated code in fast, isolated sandboxes.


peerd

Provides an implementation surface for loop builders: 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.


When Claws Remember but Do Not Tell: Stealthy Memory Injection in Persistent Personal Agents

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.


Your Agent's Memories Are Not Its Own: Forged Reasoning Attacks on LLM Agent Memory and Defenses

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.


Distributed Attacks in Persistent-State AI Control

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


ElephantAgent: Contextual State Continuity in Agentic Systems

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.

Verification is promoted from a final check to a loop-control signal.


Cloudflare security-audit-skill

Provides an implementation surface for loop builders: 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.

The contribution is machine-readable and validation-friendly.


Effective Context Engineering for AI Agents

Anthropic guide to context as managed runtime state rather than a prompt dump.

Explains how loop state survives across runs through memory, checkpointers, progress files, and context management.


Agent Harnesses: the Infrastructure Layer Your LLM Agent Actually Needs

Covers execution loops, state, checkpointing, observers, and replayability.

Checkpointed state makes long-running agent work recoverable across failures.


The Agent Loop Is the New OS

Frames the agent loop as an OS-like boundary with context as RAM and tools as I/O.


Harness engineering for coding agent users

Martin Fowler article on feedforward, feedback, and outer harnesses for coding agents.

Makes persistence and context management visible as runtime design choices.


Context Engineering

Simon Willison's framing of context engineering, useful for distinguishing context state from loop orchestration.


Agentic Coding in 2026

Sourcegraph on supplying deterministic, large-codebase context and code intelligence so recurring agent runs reuse durable repository state instead of rediscovering it each time.


Agentic AI State Management with ScyllaDB and LangGraph

Durable agent state with checkpointers, write-ahead logs, and time-travel branching.


Mem0

Provides an implementation surface for loop builders: Open-source memory layer for retaining user, session, and agent state across repeated agent sessions.

Persistent memory is treated as an external runtime artifact.


Letta

Provides an implementation surface for loop builders: Stateful agent framework from the MemGPT line with persistent, self-editing memory across runs.


Zep

Provides an implementation surface for loop builders: Temporal knowledge graph memory that tracks how facts about users and systems change across sessions.

Control flow is represented as an inspectable graph rather than an opaque prompt loop.


LangMem

Provides an implementation surface for loop builders: SDK for extracting, consolidating, and retrieving long-term agent memory between loop runs.


Beads

Provides an implementation surface for loop builders: 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.


ARC: Active and Reflection-driven Context Management for Long-Horizon Agents

Treats context as a managed runtime artifact, reorganizing the working context when degradation or context rot is detected across a long run.

Context is managed as durable loop state rather than a single prompt payload.


Memory for Autonomous LLM Agents: Mechanisms, Evaluation, and Emerging Frontiers

Formalizes agent memory as a write-manage-read loop and surveys compression, retrieval, reflective self-improvement, and policy-learned management across recurring runs.

Evaluation data is used as the feedback signal for improving loop behavior.


Externalization in LLM Agents: A Unified Review of Memory, Skills, Protocols and Harness Engineering

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.


Meta Context Engineering via Agentic Skill Evolution

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


Are We Ready for an Agent-Native Memory System?

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.


Self-Evolving World Models for LLM Agent Planning

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.


Rethinking Continual Experience Internalization for Self-Evolving LLM Agents

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.


GenericAgent

Provides an implementation surface for loop builders: 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.


Self-GC: Self-Governing Context for Long-Horizon LLM Agents

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


CompactionRL: Reinforcement Learning with Context Compaction for Long-Horizon Agents

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.


SelfMem: Self-Optimizing Memory for AI Agents

Memory framework in which the agent autonomously optimizes its own storage, retrieval, and summarization strategies per task instead of a fixed pipeline, reporting 40-49% gains over baselines on the BEAM benchmark at 100K-1M token contexts.

The work turns loop quality into a measurable task or score.


Memory-Orchestrated Semantic System (MOSS): An Auditable Agentic Memory Architecture

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.


The Log Is the Agent: Event-Sourced Reactive Graphs for Auditable, Forkable Agentic Systems

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.


Agentics: Memorizing Session Transcripts Isn't Useful

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.


Long-Running Agents

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.


Orchestration And Multi-Agent Delegation

AutoGen

Provides an implementation surface for loop builders: Multi-agent programming framework for conversations, tool use, and orchestration; active development has moved to the Microsoft Agent Framework.

The work separates roles across agents, verifiers, or orchestration layers.

Maps the runtimes and coordination patterns used to split loop work across specialized agents and durable workflows.


Microsoft Agent Framework

Provides an implementation surface for loop builders: Microsoft's successor to AutoGen and Semantic Kernel for building and orchestrating multi-agent workflows in Python and .NET.


LangGraph

Provides an implementation surface for loop builders: Graph-based framework for controllable agent workflows, persistence, and human-in-the-loop steps.


CrewAI

Provides an implementation surface for loop builders: Framework for multi-agent workflows organized around roles, tasks, and crews.


LlamaIndex Workflows

Event-driven workflow abstraction for agentic applications.

Shows how delegation, handoff, and workflow control turn one agent into a coordinated loop.


OpenAI Agents SDK handoffs

First-class delegation between specialized agents.


Agent Protocol

API protocol for agent interaction, useful for separating loop managers from agent runtimes.


AgentKit

Provides an implementation surface for loop builders: TypeScript toolkit for durable, event-driven agents on workflow infrastructure.


deepagents

Provides an implementation surface for loop builders: LangChain project for deeper, longer-running agents with middleware and harness patterns.


Temporal for AI

Durable execution for long-running agent workflows: crash-proof state, automatic retries, and human-in-the-loop signals.


Restate

Provides an implementation surface for loop builders: Durable execution runtime for building resilient, stateful agents and workflows that survive failures mid-loop.


DBOS

Provides an implementation surface for loop builders: Lightweight Postgres-backed durable execution library for crash-proof agent workflows, queues, and scheduled triggers.


Composio Agent Orchestrator

Provides an implementation surface for loop builders: Orchestrates parallel coding agents in isolated worktrees that plan tasks, fix CI failures, respond to reviews, and manage their own PR lifecycle.

Workspace isolation is part of the loop design, not an afterthought.


Omnigent

Provides an implementation surface for loop builders: 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.


From Agent Loops to Structured Graphs: A Scheduler-Theoretic Framework for LLM Agent Execution

Replaces opaque agent loops with immutable plan-version DAGs and a planning-execution-recovery split, giving inspectable scheduling, deterministic recovery, escalation, and termination guarantees.


Eve

Provides an implementation surface for loop builders: 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.


Verified Multi-Agent Orchestration: A Plan-Execute-Verify-Replan Framework

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.


From Static Templates to Dynamic Runtime Graphs: A Survey of Workflow Optimization for LLM Agents

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.


Agent-as-a-Router

Provides an implementation surface for loop builders: 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.


Amp: Custom Agents

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.


AgentsMesh

Provides an implementation surface for loop builders: 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.


Bernstein

Provides an implementation surface for loop builders: 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.


Aeon

Provides an implementation surface for loop builders: 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.


h5i

Provides an implementation surface for loop builders: 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.


SwarmResearch: Orchestrating Coding Agents for Open-Ended Discovery

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.


Scaling Long-Running Autonomous Coding

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.


babysitter

Provides an implementation surface for loop builders: 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.


claude-code-merge-queue

Provides an implementation surface for loop builders: 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.


SWE-bench

Provides an evaluation signal for loop builders: Benchmark for resolving real GitHub issues through code editing and tests.

Provides measurement targets for long-horizon, tool-using, coding, web, and terminal agents.

Evaluation artifact or leaderboard; signal comes from measurable tasks and repeatable scoring.


SWE-bench: Can Language Models Resolve Real-World GitHub Issues?

Original SWE-bench paper.

Links loop design to measurable tasks where progress and failure can be compared.


SWE-bench Goes Live

Dynamic benchmark designed to reduce overfitting to static issue sets.


Terminal-Bench

Provides an evaluation signal for loop builders: Benchmark for agents operating in terminal environments.


Terminal-Bench repository

Provides an implementation surface for loop builders: Open-source benchmark and harness for hard terminal tasks.


AgentBench

Multi-environment benchmark for evaluating LLMs as agents.


WebArena

Realistic web environment for autonomous agents.


OSWorld

Benchmark for multimodal agents operating full computer environments.


ToolBench

Tool-use benchmark and dataset for tool-augmented agents.

The list is made machine-readable as a tabular dataset rather than only a Markdown page.


GAIA

Benchmark for general AI assistants requiring reasoning, tool use, and multi-step work.


Tau-bench

Benchmark for tool-agent-user interactions in realistic domains.


VisualWebArena

Visually grounded web-agent benchmark extending WebArena.


AppWorld

Benchmark of interactive app tasks with state-based and execution-based evaluation.


Vending-Bench

Benchmark for long-term coherence of autonomous agents; documents how small errors compound over very long loop horizons.


Vending-Bench leaderboard

Provides an evaluation signal for loop builders: Live long-horizon coherence results from Andon Labs.


SWE-EVO: Benchmarking Coding Agents in Long-Horizon Software Evolution Scenarios

Release-note-derived evolution tasks where agents score far below isolated-issue benchmarks, quantifying the long-horizon gap loops must manage.


EvoSkills: Self-Evolving Agent Skills via Co-Evolutionary Verification

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.


SaaSBench: Coding Agents in Long-Horizon Enterprise SaaS Engineering

Benchmark for agents on multi-dependency, interactive enterprise tasks, with automated evaluation that probes where long-horizon loops break down.


RoadmapBench: Evaluating Long-Horizon Agentic Software Development Across Version Upgrades

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.

The work targets tasks that exceed a single context window or prompt session.


RefactorBench: Evaluating Stateful Reasoning in Language Agents Through Code

Multi-file refactoring tasks that require tracking and carrying state across many steps, isolating the durable-state weakness that breaks long agent loops.

Durable execution and replay are treated as first-class loop infrastructure.


RigorBench: Benchmarking Engineering Process Discipline in Autonomous AI Coding Agents

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.


SlopCodeBench: Benchmarking How Coding Agents Degrade Over Long-Horizon Iterative Tasks

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.


LongCLI-Bench: A Preliminary Benchmark for Long-horizon Agentic Programming in Command-Line Interfaces

Long-horizon CLI tasks where most runs stall below 30% completion, mapping where unattended loops break down.


Can LLM-as-a-Judge Reliably Verify Rubrics in Agentic Scenarios?

Provides an evaluation signal for loop builders: 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.


SentinelBench: A Benchmark for Long-Running Monitoring Agents

Provides an evaluation signal for loop builders: 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.


SWE-Together: Evaluating Coding Agents in Interactive User Sessions

Provides an evaluation signal for loop builders: 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.


The Long-Horizon Task Mirage? Diagnosing Where and Why Agentic Systems Break

Provides an evaluation signal for loop builders: 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.


Beyond pass@1: A Reliability Science Framework for Long-Horizon LLM Agents

Reliability metrics for long-horizon agents (reliability decay, variance amplification, graceful degradation, meltdown onset) measured over roughly 24,000 episodes across 10 models, showing capability and reliability rankings diverge as tasks lengthen.


SEAGym: An Evaluation Environment for Self-Evolving LLM Agents

Provides an evaluation signal for loop builders: 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.


EvoCode-Bench: Evaluating Coding Agents in Multi-Turn Iterative Interactions

Provides an evaluation signal for loop builders: 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.


On the Reliability of Computer Use Agents

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.


AgentLens: Revealing the Lucky Pass Problem in SWE-Agent Evaluation

Grades over 2,600 SWE-agent trajectories across eight models to show that a meaningful share of passes are lucky trial-and-error successes, replacing binary pass/fail with process-quality tiers that shift model rankings.


ORLoopBench: Solver-in-the-Loop Benchmarks for Self-Correction

Provides an evaluation signal for loop builders: 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.


LongDS-Bench: On the Failure of Long-Horizon Agentic Data Analysis

Provides an evaluation signal for loop builders: 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.


MemoryArena: Benchmarking Agent Memory in Interdependent Multi-Session Agentic Tasks

Provides an evaluation signal for loop builders: 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.


Momento: Evaluating Persistent Memory and Reasoning with Multi-Session Agentic Conversations

Provides an evaluation signal for loop builders: 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.


π-Bench: Evaluating Proactive Personal Assistant Agents in Long-Horizon Workflows

Provides an evaluation signal for loop builders: 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.


Can LLM Agents Be CFOs? Benchmarking Long-Horizon Resource Allocation

Provides an evaluation signal for loop builders: 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.


EvoAgentBench: Benchmarking Agent Self-Evolution via Ability Transfer

Provides an evaluation signal for loop builders: 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.


AgenticSTS: A Bounded-Memory Testbed for Long-Horizon LLM Agents

Provides an evaluation signal for loop builders: 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.


Is Three the Magic Number? An Empirical Evaluation of LLM-Based Repair Loops

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.


Agentic Engineering: The Agent Loop

Minimal mental model for the loop underlying agent operation.

Translates agent-loop ideas into operator-facing workflows for repeated delegated work.

Collects practitioner workflows for running agents as delegated work systems rather than isolated prompts.


The agent loop: ReAct, plan-and-execute, reflection

Practical walkthrough of the base loop and common variants.


How to Build an Agent

Thorsten Ball's demystification of the inner agent loop: a model, a loop, and enough tokens.


Agentic Coding Recommendations

Armin Ronacher's field notes on which practices hold up when agents do most of the work.


Coding Agents 101: The Art of Actually Getting Things Done

Practical delegation guidance from the Devin team on scoping tasks agents can actually finish.


How Anthropic teams use Claude Code

Cross-team field report of real recurring agent workflows in engineering, security, and data science.


How Boris Uses Claude Code

Unofficial but concrete compilation of Boris Cherny's autonomous setups: parallel worktrees, auto mode, `/loop`, `/schedule`, dynamic workflows, and `/goal` completion conditions.


Agent of the Day: Copilot Agent PR Analysis

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.

Primary-source operational guidance rather than commentary.


Resource entry template

Provides a reusable project artifact: Format for adding a single resource with evidence quality and category fit.

The resource is directly reusable as a starting artifact.

Provides reusable repository-native artifacts that contributors can adapt into loop specs, resources, and examples.


Loop pattern template

Provides a reusable project artifact: Template for documenting an operational loop such as PR babysitting, CI repair, or feedback clustering.


Loop contract schema

Provides a reusable project artifact: Machine-readable schema for portable loop specs.

The contribution is machine-readable and validation-friendly.


Loop contract preview script

Provides a reusable project artifact: Dependency-free demo that validates and renders a loop contract JSON file.


Translation guide

Provides a reusable project artifact: How to add or maintain a language translation without drifting from the canonical English list.


Pattern library index

Provides a reusable project artifact: Practical loop patterns with triggers, state, verification gates, budgets, and escalation paths.

Verification is promoted from a final check to a loop-control signal.


Example loop specs

Provides a reusable loop pattern: Human-readable walkthroughs for PR babysitting, CI repair, and docs drift collection.

Repository-native artifact that makes an otherwise informal practice concrete and reusable.

Makes the loop contract executable and portable through validated JSON examples and runnable reference loops.


Loop contract library

Provides a reusable project artifact: Schema-validated loop contracts for every pattern-library loop, from PR babysitting to model routing.


Runnable test-repair loop

Provides a reusable project artifact: Dependency-light reference loop script with a verification gate, retry budget, durable progress log, repeat-failure detection, and escalation exit.


Runnable loop guide

Provides a reusable project artifact: Maps the script line by line to the Loop Contract and shows how to drive it with Claude Code, Codex CLI, or any agent CLI.


Loop gallery guide

Provides a reusable project artifact: Quality bar for contributed loop examples with receipts and lessons learned.

Gives contributors a format for publishing real or anonymized loop cases with receipts and lessons learned.


Loop gallery template

Provides a reusable project artifact: Markdown template for sharing a loop's trigger, intake, state, verification, escalation, and safety notes.


PR babysitter reference loop

Provides a reusable loop pattern: Reference gallery entry for keeping a pull request moving.

Turns loop adoption into shareable cases with enough structure to compare lessons learned.


CI repair reference loop

Provides a reusable loop pattern: Reference gallery entry for turning failing CI into a verified patch or escalation.


Docs drift reference loop

Provides a reusable loop pattern: Reference gallery entry for recurring docs/code consistency checks.


Most Developers Do Not Need Agent Loops Yet

Names a risk or boundary condition: Useful caution against adopting loops before the task, signal, and economics justify them.

Keeps adoption grounded in known failure modes, economics, and operational limits.

Preserves cautionary evidence so adoption stays proportional to task risk, signal quality, and economics.


Engineering Agentic Systems for Reliability

Names a risk or boundary condition: Cautions that agentic systems fail at boundaries when permissions, verification, traceability, and escalation are weak.


Self-Correcting Agents: Reflexion, CRITIC, and ReAct Loops Compared

Names a risk or boundary condition: Compares self-correction patterns and their cost/failure tradeoffs.


How to Build an AI Agent Harness: A 2026 Complete Guide

Names a risk or boundary condition: Broad guide with useful warnings on data readiness, permissions, context management, and evaluation.

Evaluation data is used as the feedback signal for improving loop behavior.


Harness Engineering vs Prompt Engineering vs Context Engineering Explained

Names a risk or boundary condition: Adjacent framing that helps avoid confusing loop engineering with the surrounding harness discipline.

Context is managed as durable loop state rather than a single prompt payload.


Position: Coding Benchmarks Are Misaligned with Agentic Software Engineering

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.

The work turns loop quality into a measurable task or score.


Understanding the Challenges in Iterative Generative Optimization with LLMs

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.


The Illusion of Multi-Agent Advantage

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.


The Coming Loop

Names a risk or boundary condition: 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.


Loop Engineering, the Latest AI Buzzword, Still Needs Humans in the Loop

Names a risk or boundary condition: 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.


When Agents Do Not Stop: Uncovering Infinite Agentic Loops in LLM Agents

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.


Awesome Harness Engineering

Maps adjacent resources and ecosystems: Comprehensive list for the agent harness layer that Loop Engineering builds on.

Connects neighboring ecosystems while preserving Loop Engineering as a narrower operating concept.

Connects readers to neighboring ecosystems while keeping Loop Engineering's scope distinct.


Awesome Harness Engineering

Maps adjacent resources and ecosystems: High-signal harness list with strong categories for context, guardrails, specs, evals, runtimes, and benchmarks.


Awesome Agent Harness

Maps adjacent resources and ecosystems: Curated tools and resources for environments, constraints, and feedback around coding agents.


Awesome Context Engineering

Maps adjacent resources and ecosystems: Survey-style list for context engineering across LLMs and agents.


Awesome Prompt Engineering

Maps adjacent resources and ecosystems: Classic adjacent list for prompt techniques and prompting resources.


Awesome LLM Agents

Maps adjacent resources and ecosystems: General list of LLM agent papers, frameworks, and applications.


Awesome AI Agents

Broad AI agent ecosystem map.

Maps adjacent resources and ecosystems: Broad AI agent ecosystem map.


Awesome CLI Coding Agents

Maps adjacent resources and ecosystems: Directory of terminal-native coding agents, parallel runners, autonomous loops, and the harnesses that orchestrate them.

Orchestration and control flow are made explicit and inspectable.


Awesome Self-Evolving Agents

Maps adjacent resources and ecosystems: Survey-style list of agents that improve themselves over repeated runs, an adjacent angle on long-running loops with memory and verification.


Awesome AI Agent Papers

Maps adjacent resources and ecosystems: Curated 2026 research collection across agent engineering, memory, evaluation, workflows, and autonomous systems, a paper-level feeder for loop-design foundations.


awesome-ralph

Maps adjacent resources and ecosystems: 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.


Landing page

Provides a reusable project artifact: SEO-friendly entry point for the repository.

Makes the project discoverable as both documentation and machine-readable data.

Documents how the project itself is packaged, indexed, mirrored, and made discoverable.

Repository-native template, schema, checklist, or guide; signal comes from reuse inside this project.


Hugging Face dataset mirror

Maps adjacent resources and ecosystems: Synced dataset repo with the full project plus generated `data/resources.csv` and `data/resources.jsonl` resource sheets.

The list is made machine-readable as a tabular dataset rather than only a Markdown page.

Adjacent curated collection; signal comes from ecosystem coverage rather than a single technical claim.


Landing page source

Source for the static landing page.

Provides a reusable project artifact: Source for the static landing page.


Sitemap

Provides a reusable project artifact: Crawl hints for the landing page and core repository pages.


Robots file

Provides a reusable project artifact: Allows indexing and points crawlers to the sitemap.


Roadmap

Provides a reusable project artifact: Near-term work, pattern priorities, gallery goals, and open questions.

Keeps community evolution and evidence gathering part of the project surface.

Keeps future work, community feedback, and pattern submissions visible.


Launch article

Provides a reusable project artifact: Shareable explanation of the concept and repository.


Discussion guide

Provides a reusable project artifact: Suggested discussion categories, starter prompts, and moderation standard.


Show your Loop Engineering patterns

Provides a reusable loop pattern: Community discussion for real or anonymized loop examples.