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.


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.


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.


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.


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.


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.


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.


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.

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


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.

The resource is directly reusable as a starting artifact.


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.


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.

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


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.


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.


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.


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.


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.

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


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.

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


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.


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.


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.


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.


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.


Effective Context Engineering for AI Agents

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

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

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.


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.

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


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.


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.


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.


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


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.

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.

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


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.


SWE-bench

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

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

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.


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.

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


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.


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.


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.


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.

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.


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.


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.


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.


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.


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.


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.