Working Definition

Makes an otherwise informal practice concrete and reusable. Short definition, positioning, minimal loop test, and citation note.

Use Working Definition to understand the evidence, vocabulary, and lineage behind recurring agent systems.

Repository file; inspect the linked schema, example, guide, or implementation.

Understand the field and its boundaries.


Loop Engineering Manifesto

Makes an otherwise informal practice concrete and reusable. Concise statement of the concept, commitments, non-goals, and success standard.

Use Loop Engineering Manifesto to understand the evidence, vocabulary, and lineage behind recurring agent systems.


Loop Engineering Taxonomy

Makes an otherwise informal practice concrete and reusable. Classification by trigger, intake, verification, state model, topology, and operating domain.

Use Loop Engineering Taxonomy to understand the evidence, vocabulary, and lineage behind recurring agent systems.


Loop Engineering Anti-Patterns

Makes an otherwise informal practice concrete and reusable. Common failure modes such as prompt loops with no contract, infinite retries, model self-approval, hidden state, and unsafe autonomy.

Use Loop Engineering Anti-Patterns to understand the evidence, vocabulary, and lineage behind recurring agent systems.


Comparison Guide

Makes an otherwise informal practice concrete and reusable. Distinguishes Loop Engineering from prompt engineering, context engineering, harness engineering, workflow automation, agent workflows, and evaluation loops.

Use Comparison Guide to understand the evidence, vocabulary, and lineage behind recurring agent systems.


Sourced Signals And Quotes

Makes an otherwise informal practice concrete and reusable. Short sourced signals from linked public materials that anchor the emerging concept.

Use Sourced Signals And Quotes to understand the evidence, vocabulary, and lineage behind recurring agent systems.


Outreach Kit

Makes an otherwise informal practice concrete and reusable. Conservative messages for inviting corrections, sources, and real-world loop patterns.

Use Outreach Kit to understand the evidence, vocabulary, and lineage behind recurring agent systems.


Loop Engineering by Addy Osmani

Captures the early community framing of Loop Engineering as repeated agent delegation rather than prompt craft. Addy Osmani's framing of loop engineering as the layer above manually prompting coding agents, with concrete primitives across Codex and Claude Code; also on [Substack](https://addyo.substack.com/p/loop-engineering) with the original discussion trail and Steinberger and Cherny quotations.

Use Loop Engineering by Addy Osmani to understand the evidence, vocabulary, and lineage behind recurring agent systems.

Contextual source from addyosmani.com; useful for practice signals or boundary conditions, not independent validation.

You don't really need to be good at prompting anymore. The thing to get good at is the loop that does the prompting for you. It's five building blocks plus s...


Peter Steinberger on designing loops

Captures the early community framing of Loop Engineering as repeated agent delegation rather than prompt craft. 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.

Use Peter Steinberger on designing loops to understand the evidence, vocabulary, and lineage behind recurring agent systems.

Contextual source from x.com; useful for practice signals or boundary conditions, not independent validation.

Peter Steinberger 🦞 on X: "Here’s your monthly reminder that you shouldn’t be prompting coding agents anymore. You should be designing loops that prompt your agents." / X


The agent workflow includes explicit self-checking or gated completion. 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.

Use Boris Cherny: five tips for running Opus autonomously for hours or days to understand the evidence, vocabulary, and lineage behind recurring agent systems.

Boris Cherny on X: "Seeing a number of benchmarks showing Opus is the best model for long-running work. Five tips for running Opus autonomously for hours/days: 1. Use auto mode for permissions, so Claude doesn’t ask for approval 2. Use dynamic workflows, to have Claude orchestrate" / X


Loop Engineering by Cobus Greyling

State persistence is explicit enough for repeated runs and handoff. Concise explanation of the shift from prompting agents to designing loops that discover work, delegate, verify, persist, and continue.

Use Loop Engineering by Cobus Greyling to understand the evidence, vocabulary, and lineage behind recurring agent systems.

Contextual source from cobusgreyling.substack.com; useful for practice signals or boundary conditions, not independent validation.


Stop Prompting. Design the Loop.

Workspace isolation is part of the loop design, not an afterthought. Practical breakdown of loop building blocks - automations, worktrees, skills, connectors, subagents - plus external memory and verification through oracles such as tests and builds.

Use Stop Prompting. Design the Loop. to understand the evidence, vocabulary, and lineage behind recurring agent systems.

Contextual source from www.pulumi.com; useful for practice signals or boundary conditions, not independent validation.

Stop Prompting. Design the Loop. | Pulumi Blog

The unit of work moved from the prompt to the loop. The five pieces of loop engineering, the memory that makes it compound, and what it won't do for you.


Writing Loops, Not Prompts, Explained

Captures the early community framing of Loop Engineering as repeated agent delegation rather than prompt craft. 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.

Use Writing Loops, Not Prompts, Explained to understand the evidence, vocabulary, and lineage behind recurring agent systems.

Contextual source from rico.codes; useful for practice signals or boundary conditions, not independent validation.

Writing Loops, Not Prompts, Explained | rico.codes

Loop engineering is not about abandoning prompts. It is about moving repeated steering work into verifiable systems so attention can stay on judgment, review, and taste.


The resource is directly reusable as a starting artifact. 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.

Use Loop Engineering: A Guide for Engineers and Practitioners to understand the evidence, vocabulary, and lineage behind recurring agent systems.

Contextual source from medium.com; useful for practice signals or boundary conditions, not independent validation.


Captures the early community framing of Loop Engineering as repeated agent delegation rather than prompt craft. 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.

Use Loop Engineering: When Generation Gets Cheap, Judgment Gets Expensive to understand the evidence, vocabulary, and lineage behind recurring agent systems.

Contextual source from sderosiaux.substack.com; useful for practice signals or boundary conditions, not independent validation.

Agentic loops make code, plans, and PRs abundant. The scarce part is knowing what is right.


State persistence is explicit enough for repeated runs and handoff. 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.

Use Andrew Ng on Loop Engineering and the Three Loops of AI-Native Product Development to understand the evidence, vocabulary, and lineage behind recurring agent systems.

Andrew Ng on X: "“Loop engineering” is a hot buzzphrase after mentions of it by Boris Cherny (Claude Code’s creator) and Peter Steinberger (OpenClaw's creator) went viral on social media. Loops are now a key part of how we get AI agents to iterate at length to build software. In this letter, I’d https://t.co/bhuRw8lrFC" / X


Captures the early community framing of Loop Engineering as repeated agent delegation rather than prompt craft. 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.

Use From Prompting Agents to Loop Engineering to understand the evidence, vocabulary, and lineage behind recurring agent systems.

elvis on X: "https://t.co/d8LgEwfVH6" / X


State persistence is explicit enough for repeated runs and handoff. Broad coverage of the Boris Cherny and Peter Steinberger discussion, including the distinction between cold-start scripts and persistent agent loops.

Use My Lord! AI Programming Undergoes Another Major Shift to understand the evidence, vocabulary, and lineage behind recurring agent systems.

Contextual source from eu.36kr.com; useful for practice signals or boundary conditions, not independent validation.

My Lord! AI Programming Undergoes Another Major Shift: Claude Code Father & Lobster Founder Endorse New Paradigm - Could It Kill Prompt Engineering?

Stop writing prompts for programming agents now.


Captures the early community framing of Loop Engineering as repeated agent delegation rather than prompt craft. The New Stack's report on Boris Cherny's shift from prompting to loop writing and what it changes about developer workflow.

Use The Anthropic leader who built Claude Code ditched prompting - now he writes loops to understand the evidence, vocabulary, and lineage behind recurring agent systems.

Contextual source from thenewstack.io; useful for practice signals or boundary conditions, not independent validation.

The Anthropic leader who built Claude Code says he ditched prompting — now he just writes loops. - The New Stack

Loop engineering — the practice of designing automated agent workflows instead of prompting manually — is reshaping how developers use Claude Code and OpenAI Codex in 2026.


Engineering for Agents That Never Sleep

Captures the early community framing of Loop Engineering as repeated agent delegation rather than prompt craft. 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.

Use Engineering for Agents That Never Sleep to understand the evidence, vocabulary, and lineage behind recurring agent systems.

Contextual source from nader.substack.com; useful for practice signals or boundary conditions, not independent validation.

Engineering for Agents That Never Sleep - by Nader Dabit


Loop Engineering Orange Book

The resource is directly reusable as a starting artifact. Plain-language bilingual (Chinese and English) field guide to loop engineering by HuaShu, framing the discipline as one floor above harness engineering: the outer system that decides when and why agents run.

Use Loop Engineering Orange Book to understand the evidence, vocabulary, and lineage behind recurring agent systems.

Inspectable GitHub source (1,075 stars; 105 forks; NOASSERTION license; updated 2026-08-06); popularity is context, not proof of reliability.

GitHub - alchaincyf/loop-engineering-orange-book: 别再问我什么是 Loop Engineering — 橙皮书系列。A plain-language guide to loop engineering (中文 + English PDF). Free. · GitHub

别再问我什么是 Loop Engineering — 橙皮书系列。A plain-language guide to loop engineering (中文 + English PDF). Free. - alchaincyf/loop-engineering-orange-book


The trigger or cadence is explicit, making the workflow recurring rather than one-off. Mozilla distinguished engineer Brian Grinstead demonstrates goal-based and scheduled loops, including a daily PR-review loop with per-PR subagents, on Lenny's Newsletter.

Use How I AI: How to Write AI Agent Loops in Claude Code and Codex to understand the evidence, vocabulary, and lineage behind recurring agent systems.

Contextual source from www.lennysnewsletter.com; useful for practice signals or boundary conditions, not independent validation.

🎙 How I AI: How to write AI agent loops in Claude Code and Codex + How Claude Mythos found a 15-year-old bug in Mozilla Firefox | Brian Grinstead

Your weekly listens from How I AI, part of the Lenny’s Podcast Network


Evaluation data is used as the feedback signal for improving loop behavior. Defines evidence-gated lifecycle control for agent loops and reports zero false-DONE outcomes across 10 scenarios and zero accepts across 18 tampering classes; its 9,240-cell ablation identifies which gates prevent error amplification, while noting the evaluation covers one model family and 24 tasks.

Use Proof-or-Stop: Don't Trust the Agent, Trust the Evidence -- Loop Engineering for Verifiable Evidence-Gated Lifecycle Control to understand the evidence, vocabulary, and lineage behind recurring agent systems.

Research source arXiv:2607.14890; inspect its method and evaluation before treating results as production evidence.

[2607.14890] Proof-or-Stop: Don't Trust the Agent, Trust the Evidence -- Loop Engineering for Verifiable Evidence-Gated Lifecycle Control

Autonomous coding agents increasingly execute multi-step software work, but lifecycle states such as reviewed, tested, DONE, and ready-to-merge remain claims unless supported by current evidence. We present Proof-or-Stop Lifecycle Control, a method that permits lifecycle transitions only when fresh, tracked-source-state-bound, mechanically verifiable evidence satisfies the relevant gate. The method treats agent outputs as claims rather than lifecycle state, and uses proof operationally to mean gate-admissible evidence under a stated trust model, not semantic program correctness. We evaluate an open-source implementation through mechanism tests, a powered control-policy ablation, and operated self-application evidence. The unattended-loop engine passed 10 of 10 scenarios with zero false-DONE, and local-key receipt bundles rejected 18 tamper classes with zero false accepts. In a 9,240-cell ablation, the pre-registered A4 versus A2-prime comparison reduced visible-pass/hidden-fail amplification from 31 of 1,800 injected cells under a compute-budgeted naive loop to 2 of 1,800 under the gated loop, a 1.6 percentage-point improvement in not-amplified rate with a 95 percent confidence interval of [0.8, 2.5]. A near-compute A3 versus A4 comparison, 14 of 1,800 versus 2 of 1,800, indicates that the gain is associated with enforcing review as a lifecycle gate rather than merely adding a reviewer. The self-application corpus contains 565 stories and 1,007 review findings, with 94.8 percent resolved, plus a 68-row high/critical cross-vendor exhibit. These results support Proof-or-Stop as a model-agnostic, host-neutral control layer for deciding which autonomous-agent claims a lifecycle may act on. The evaluation is limited to one model family, 24 ablation tasks, and a self-hosted corpus.

Jek Huang; Jeffery Hsia; Jiayi Sun; Freddie Shi; Wei Huang; Ian H. White

48 pages, 10 figures, 29 numbered tables. Preprint v1


PR babysitter

Turns common recurring-agent jobs into named patterns with gates, budgets, and escalation paths. Repeatedly checks review comments, CI, merge conflicts, stale threads, and readiness to merge.

Use PR babysitter to turn a recurring-agent idea into an explicit loop contract.

Specify a loop contract and operating pattern.


CI repair loop

Turns common recurring-agent jobs into named patterns with gates, budgets, and escalation paths. Reproduces failing checks, patches narrowly, reruns evidence, and escalates when failures are outside scope.

Use CI repair loop to turn a recurring-agent idea into an explicit loop contract.


Docs drift collector

Turns common recurring-agent jobs into named patterns with gates, budgets, and escalation paths. Finds mismatches between docs and code, proposes small patches, and verifies examples.

Use Docs drift collector to turn a recurring-agent idea into an explicit loop contract.


Deploy verifier

Verification is promoted from a final check to a loop-control signal. Watches rollout signals, compares them with release expectations, and stops on anomalies.

Use Deploy verifier to turn a recurring-agent idea into an explicit loop contract.


Feedback clusterer

Turns common recurring-agent jobs into named patterns with gates, budgets, and escalation paths. Periodically groups GitHub, Linear, Slack, support, or social feedback into actionable themes.

Use Feedback clusterer to turn a recurring-agent idea into an explicit loop contract.


Dependency triage loop

Turns common recurring-agent jobs into named patterns with gates, budgets, and escalation paths. Classifies dependency updates, applies safe groups, verifies them, and escalates risky upgrades.

Use Dependency triage loop to turn a recurring-agent idea into an explicit loop contract.


Evaluation regression loop

Evaluation data is used as the feedback signal for improving loop behavior. Investigates degraded agent evals with baseline traces, targeted reruns, and repair proposals.

Use Evaluation regression loop to turn a recurring-agent idea into an explicit loop contract.


Benchmark optimization loop

The work turns loop quality into a measurable task or score. Runs bounded experiments against a frozen benchmark and accepts only reproducible gains with correctness intact.

Use Benchmark optimization loop to turn a recurring-agent idea into an explicit loop contract.


Security review loop

Turns common recurring-agent jobs into named patterns with gates, budgets, and escalation paths. Reviews sensitive diffs with evidence-backed findings, safe permissions, and human approval boundaries.

Use Security review loop to turn a recurring-agent idea into an explicit loop contract.


Adversarial red-team loop

Execution isolation and permission boundaries are part of the design. Discovers agent failures inside an authorized sandbox, then independently reproduces, minimizes, and reports them.

Use Adversarial red-team loop to turn a recurring-agent idea into an explicit loop contract.


Accessibility regression loop

Turns common recurring-agent jobs into named patterns with gates, budgets, and escalation paths. Repairs reproducible accessibility regressions while preserving required human review for non-automatable criteria.

Use Accessibility regression loop to turn a recurring-agent idea into an explicit loop contract.


Cost-control loop

Turns common recurring-agent jobs into named patterns with gates, budgets, and escalation paths. Monitors agent workflow spend, identifies waste, proposes scoped savings, and preserves quality gates.

Use Cost-control loop to turn a recurring-agent idea into an explicit loop contract.


Performance regression loop

Turns common recurring-agent jobs into named patterns with gates, budgets, and escalation paths. Profiles a measured regression and verifies a narrow fix against the same controlled workload and correctness gates.

Use Performance regression loop to turn a recurring-agent idea into an explicit loop contract.


Bug hunting loop

Turns common recurring-agent jobs into named patterns with gates, budgets, and escalation paths. Discovers, reproduces, minimizes, and reports bugs with concrete evidence.

Use Bug hunting loop to turn a recurring-agent idea into an explicit loop contract.


Enterprise approval loop

Turns common recurring-agent jobs into named patterns with gates, budgets, and escalation paths. Drives a permissioned change through required gates and approvers with a full audit trail.

Use Enterprise approval loop to turn a recurring-agent idea into an explicit loop contract.


Incident response loop

Turns common recurring-agent jobs into named patterns with gates, budgets, and escalation paths. Triages an alert into an owned, evidence-backed incident with a postmortem seed.

Use Incident response loop to turn a recurring-agent idea into an explicit loop contract.


Data-quality loop

Packages the evidence as queryable CSV and JSONL rather than only a rendered page. Validates each dataset refresh against quality rules and quarantines bad versions.

Use Data-quality loop to turn a recurring-agent idea into an explicit loop contract.


Knowledge freshness loop

Turns common recurring-agent jobs into named patterns with gates, budgets, and escalation paths. Rebuilds a versioned retrieval corpus and promotes it only after provenance, freshness, quality, and leakage gates pass.

Use Knowledge freshness loop to turn a recurring-agent idea into an explicit loop contract.


Agent memory lifecycle loop

Persistent memory is treated as an external runtime artifact. Carries governed memory between recurring runs: explicit writes, scoped recall, audits, consolidation, and logged, reversible deletion.

Use Agent memory lifecycle loop to turn a recurring-agent idea into an explicit loop contract.


Fleet coordination loop

Verification is promoted from a final check to a loop-control signal. Lands many parallel agent changes on one codebase through claim ledgers, isolated workspaces, and a verified serial merge queue.

Use Fleet coordination loop to turn a recurring-agent idea into an explicit loop contract.


Release-note loop

Turns common recurring-agent jobs into named patterns with gates, budgets, and escalation paths. Drafts release notes from merged commits, issues, and PRs with linked evidence.

Use Release-note loop to turn a recurring-agent idea into an explicit loop contract.


Model-routing loop

Turns common recurring-agent jobs into named patterns with gates, budgets, and escalation paths. Routes tasks across models on measured quality, latency, privacy, and cost.

Use Model-routing loop to turn a recurring-agent idea into an explicit loop contract.


Scheduled tasks - ChatGPT Learn

Primary-source operational guidance rather than commentary. Official guidance for recurring background tasks, triage inboxes, skills, and isolated workspaces.

Use Scheduled tasks - ChatGPT Learn to turn a recurring-agent idea into an explicit loop contract.

Primary official documentation from learn.chatgpt.com; use it for current product or standard behavior.


Follow a goal - ChatGPT Learn

Primary-source operational guidance rather than commentary. Official guidance for durable objectives with stopping conditions, validation commands, checkpoints, and progress logs.

Use Follow a goal - ChatGPT Learn to turn a recurring-agent idea into an explicit loop contract.

Use `/goal` when a task needs Codex to keep working across turns toward a verifiable stopping condition.


Git worktrees - ChatGPT Learn

Primary-source operational guidance rather than commentary. Official worktree model for isolated parallel tasks and handoffs between local and background workspaces.

Use Git worktrees - ChatGPT Learn to turn a recurring-agent idea into an explicit loop contract.

Use Git worktrees in Codex in the ChatGPT desktop app to run chats in parallel


Prompting - ChatGPT Learn

Context is managed as durable loop state rather than a single prompt payload. Explains the Codex loop, threads, context, and goal-oriented prompting.

Use Prompting - ChatGPT Learn to turn a recurring-agent idea into an explicit loop contract.

Write useful prompts for Chat, ChatGPT Work, and Codex


Customization overview - ChatGPT Learn

Persistent memory is treated as an external runtime artifact. Maps `AGENTS.md`, memories, skills, MCP, and subagents into a coherent customization stack.

Use Customization overview - ChatGPT Learn to turn a recurring-agent idea into an explicit loop contract.

How to customize Codex with project guidance, skills, MCP, and subagents


Build skills - ChatGPT Learn

Primary-source operational guidance rather than commentary. Official skill format for reusable workflows, scripts, MCP dependencies, invocation policy, and plugin packaging.

Use Build skills - ChatGPT Learn to turn a recurring-agent idea into an explicit loop contract.

Give ChatGPT and Codex new capabilities and expertise


Plugins - ChatGPT Learn

Breaks loop design into operational primitives that can be combined across agents and runtimes. Bundles skills, app integrations, and MCP servers into reusable loop capabilities.

Use Plugins - ChatGPT Learn to turn a recurring-agent idea into an explicit loop contract.

Browse, install, and use plugins on supported ChatGPT and Codex surfaces


dotskills

Breaks loop design into operational primitives that can be combined across agents and runtimes. 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.

Use dotskills to turn a recurring-agent idea into an explicit loop contract.

Inspectable GitHub source (99 stars; 10 forks; MIT license; updated 2026-08-03); popularity is context, not proof of reliability.

GitHub - vincentkoc/dotskills: 🐙 A curated set of Codex and OpenClaw skills for workflow automation, technical debugging, and agent-assisted development patterns. · GitHub

🐙 A curated set of Codex and OpenClaw skills for workflow automation, technical debugging, and agent-assisted development patterns. - vincentkoc/dotskills


Developer commands - ChatGPT Learn

The work separates roles across agents, verifiers, or orchestration layers. CLI commands for switching agent threads, browsing skills, inspecting MCP tools, and using subagent workflows.

Use Developer commands - ChatGPT Learn to turn a recurring-agent idea into an explicit loop contract.

Reference for commands and slash commands in Codex developer surfaces


Autonomous Loops

Breaks loop design into operational primitives that can be combined across agents and runtimes. Claude Code pattern using task files, stop hooks, restart behavior, hard limits, and a kill switch.

Use Autonomous Loops to turn a recurring-agent idea into an explicit loop contract.

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

Claude Code Autonomous Loops | Claude Code Guide

Point Claude Code at a problem, walk away, come back to a green build. Task templates, kill switches, and why boundaries matter more than anything else.


Claude Code Glossary

The work separates roles across agents, verifiers, or orchestration layers. Defines the agentic loop, hooks, subagents, skills, MCP, and related primitives in Claude Code terminology.

Use Claude Code Glossary to turn a recurring-agent idea into an explicit loop contract.

Primary official documentation from code.claude.com; use it for current product or standard behavior.


Keep Claude working toward a goal

Verification is promoted from a final check to a loop-control signal. `/goal` runs turn after turn until a completion condition is met by a verifier.

Use Keep Claude working toward a goal to turn a recurring-agent idea into an explicit loop contract.

Keep Claude working toward a goal - Claude Code Docs

Set a completion condition with /goal and Claude keeps working across turns until the condition is met.


Run prompts on a schedule

The trigger or cadence is explicit, making the workflow recurring rather than one-off. `/loop`, scheduled tasks, reminders, monitor tools, and session-scoped recurring prompts.

Use Run prompts on a schedule to turn a recurring-agent idea into an explicit loop contract.

Run prompts on a schedule - Claude Code Docs

Use /loop and the cron scheduling tools to run prompts repeatedly, poll for status, or set one-time reminders within a Claude Code session.


Automate work with routines

The trigger or cadence is explicit, making the workflow recurring rather than one-off. Claude Code routines: persistent cloud automations triggered by schedules, API calls, or GitHub events, with connectors, scoped environments, and branch-push limits.

Use Automate work with routines to turn a recurring-agent idea into an explicit loop contract.

Automate work with routines - Claude Code Docs

Put Claude Code on autopilot. Define routines that run on a schedule, trigger on API calls, or react to GitHub events from cloud infrastructure.


Desktop scheduled tasks

Workspace isolation is part of the loop design, not an afterthought. 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.

Use Desktop scheduled tasks to turn a recurring-agent idea into an explicit loop contract.

Schedule recurring tasks in Claude Code Desktop - Claude Code Docs

Set up scheduled tasks in Claude Code Desktop to run Claude automatically on a recurring basis for daily code reviews, dependency audits, or morning briefings.


Run parallel sessions with worktrees

Workspace isolation is part of the loop design, not an afterthought. Worktree isolation for parallel sessions and subagents so concurrent edits do not collide.

Use Run parallel sessions with worktrees to turn a recurring-agent idea into an explicit loop contract.

Run parallel sessions with worktrees - Claude Code Docs

Isolate parallel Claude Code sessions in separate git worktrees so changes don't collide. Covers the --worktree flag, subagent isolation, .worktreeinclude, cleanup, and non-git VCS hooks.


Automate actions with hooks

The resource is directly reusable as a starting artifact. Claude Code hooks guide for deterministic lifecycle control around model actions.

Use Automate actions with hooks to turn a recurring-agent idea into an explicit loop contract.

Automate actions with hooks - Claude Code Docs

Run shell commands automatically when Claude Code edits files, finishes tasks, or needs input. Format code, send notifications, validate commands, and enforce project rules.


Hooks reference

The work separates roles across agents, verifiers, or orchestration layers. Event-level reference for session, turn, tool-call, and subagent hooks.

Use Hooks reference to turn a recurring-agent idea into an explicit loop contract.


Common workflows - Claude Code

Workspace isolation is part of the loop design, not an afterthought. Practical workflows for worktrees, subagents, CI, batch processing, planning, and resuming prior work.

Use Common workflows - Claude Code to turn a recurring-agent idea into an explicit loop contract.

Step-by-step guides for exploring codebases, fixing bugs, refactoring, testing, and other everyday tasks with Claude Code.


Manage multiple agents with agent view

Breaks loop design into operational primitives that can be combined across agents and runtimes. Dashboard for dispatching, monitoring, and attaching to background agent sessions.

Use Manage multiple agents with agent view to turn a recurring-agent idea into an explicit loop contract.


Run agents in parallel

Workspace isolation is part of the loop design, not an afterthought. Compares agent view, subagents, agent teams, worktrees, tasks, and workflows for parallel work.

Use Run agents in parallel to turn a recurring-agent idea into an explicit loop contract.


Context is managed as durable loop state rather than a single prompt payload. Moves loop state and branching into workflow scripts so large tasks do not overload the conversation context.

Use Orchestrate subagents at scale with dynamic workflows to turn a recurring-agent idea into an explicit loop contract.

Orchestrate subagents at scale with dynamic workflows - Claude Code Docs

Dynamic workflows orchestrate many subagents from a script Claude writes and you can rerun. Use them for codebase audits, large migrations, and cross-checked research.


Create plugins

Breaks loop design into operational primitives that can be combined across agents and runtimes. Packaging model-invoked skills, agents, hooks, MCP servers, monitors, and settings as shareable loop components.

Use Create plugins to turn a recurring-agent idea into an explicit loop contract.

Create custom plugins to extend Claude Code with skills, agents, hooks, and MCP servers.


Model Context Protocol

Context is managed as durable loop state rather than a single prompt payload. Standard protocol for exposing tools and data sources to agent loops.

Use Model Context Protocol to turn a recurring-agent idea into an explicit loop contract.

Primary official documentation from modelcontextprotocol.io; use it for current product or standard behavior.

What is the Model Context Protocol (MCP)? - Model Context Protocol


The trigger or cadence is explicit, making the workflow recurring rather than one-off. Copilot CLI autopilot mode plus `/every` and `/after` scheduling, turning the CLI into an unattended loop that runs steps until a task is complete.

Use Allowing GitHub Copilot CLI to work autonomously to turn a recurring-agent idea into an explicit loop contract.

Primary official documentation from docs.github.com; use it for current product or standard behavior.

Allowing GitHub Copilot CLI to work autonomously - GitHub Docs

The CLI's autopilot mode lets Copilot CLI work autonomously on a task, carrying out multiple steps until the task is complete.


opencode-scheduler

Breaks loop design into operational primitives that can be combined across agents and runtimes. 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.

Use opencode-scheduler to turn a recurring-agent idea into an explicit loop contract.

Inspectable GitHub source (462 stars; 34 forks; MIT license; updated 2026-08-06); popularity is context, not proof of reliability.

GitHub - different-ai/opencode-scheduler: OpenCode plugin for scheduling recurring jobs using launchd (Mac) or systemd (Linux) · GitHub

OpenCode plugin for scheduling recurring jobs using launchd (Mac) or systemd (Linux) - different-ai/opencode-scheduler


Agent-Loop-Skills

Verification is promoted from a final check to a loop-control signal. 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.

Use Agent-Loop-Skills to turn a recurring-agent idea into an explicit loop contract.

Inspectable GitHub source (147 stars; 19 forks; MIT license; updated 2026-08-04); popularity is context, not proof of reliability.

GitHub - gaasher/Agent-Loop-Skills: Loop until it's better — drop-in agentic loops (autoresearch, scientific writing, data analysis, code/SQL/prompt optimization, red-teaming) as open-standard Agent Skills. Verification-gated; native on Claude Code, portable across Codex, Cursor & other Skills hosts. · GitHub

Loop until it's better — drop-in agentic loops (autoresearch, scientific writing, data analysis, code/SQL/prompt optimization, red-teaming) as open-standard Agent Skills. Verification-gated; native on Claude Code, portable across Codex, Cursor & other Skills hosts. - gaasher/Agent-Loop-Skills


launch-your-agent

Primary-source operational guidance rather than commentary. 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.

Use launch-your-agent to turn a recurring-agent idea into an explicit loop contract.

Inspectable GitHub source (906 stars; 174 forks; Apache-2.0 license; updated 2026-08-07); popularity is context, not proof of reliability.

GitHub - anthropics/launch-your-agent: Claude Code skills that take a founder from idea to a live Claude Managed Agent: interview, scope a v0, launch in their own account, grade it, iterate, and schedule it · GitHub

Claude Code skills that take a founder from idea to a live Claude Managed Agent: interview, scope a v0, launch in their own account, grade it, iterate, and schedule it - anthropics/launch-your-agent


kanban-md

Durable execution and replay are treated as first-class loop infrastructure. File-based kanban board for autonomous agent loops: a CLI and TUI over plain Markdown files that gives multi-agent work a durable, inspectable work-intake queue.

Use kanban-md to turn a recurring-agent idea into an explicit loop contract.

Inspectable GitHub source (183 stars; 25 forks; MIT license; updated 2026-08-06); popularity is context, not proof of reliability.

GitHub - antopolskiy/kanban-md: File-based kanban board for autonomous agentic loop. CLI and TUI for multi-agent workflows. Skills included. · GitHub

File-based kanban board for autonomous agentic loop. CLI and TUI for multi-agent workflows. Skills included. - antopolskiy/kanban-md


Run long horizon tasks with Codex

Shows how production platforms expose loops through concrete tools, permissions, skills, agents, and automation features. OpenAI's runbook for plan-edit-test-observe-repair-document-repeat work, including specs, plans, status logs, and validation gates.

Use Run long horizon tasks with Codex to choose an implementation surface for repeatable agent work.

Primary official documentation from developers.openai.com; use it for current product or standard behavior.

Choose runtimes, tools, and delegation surfaces.

Run long horizon tasks with Codex | OpenAI Developers


Best practices - ChatGPT Learn

Primary-source operational guidance rather than commentary. Official best practices for context, `AGENTS.md`, MCP, skills, subagents, and automations.

Use Best practices - ChatGPT Learn to choose an implementation surface for repeatable agent work.

Getting started with Codex and proven practices for better results


Agents SDK

Orchestration and control flow are made explicit and inspectable. OpenAI guide for agent orchestration, tool execution, approvals, state, guardrails, and observability.

Use Agents SDK to choose an implementation surface for repeatable agent work.

Learn how the OpenAI Agents SDK fits together and which docs to read next.


Agents - OpenAI Agents SDK

Shows how production platforms expose loops through concrete tools, permissions, skills, agents, and automation features. SDK primitives for agents, tools, handoffs, guardrails, and runner-managed loops.

Use Agents - OpenAI Agents SDK to choose an implementation surface for repeatable agent work.

Primary official documentation from openai.github.io; use it for current product or standard behavior.


Running agents

State persistence is explicit enough for repeated runs and handoff. OpenAI guide to turns, state, approvals, sessions, and continuation in the SDK runtime loop.

Use Running agents to choose an implementation surface for repeatable agent work.

Learn how to run agents, stream output, and choose the right conversation-state strategy in the OpenAI Agents SDK.


Integrations and observability

Evaluation data is used as the feedback signal for improving loop behavior. OpenAI guide to MCP wiring and traces as the basis for debugging and evaluation loops.

Use Integrations and observability to choose an implementation surface for repeatable agent work.

Integrations and observability | OpenAI API

Learn how to integrate MCP into Agents SDK workflows and how to trace and debug runs.


Sandbox Agents

Execution isolation and permission boundaries are part of the design. Splits the harness control plane from the sandbox execution plane for long-running file and command work.

Use Sandbox Agents to choose an implementation surface for repeatable agent work.

Learn how sandboxes fit into Agents SDK workflows, when to use them, and how orchestration stays separate from execution.


Guardrails and human review

Shows how production platforms expose loops through concrete tools, permissions, skills, agents, and automation features. Approval and validation boundaries for sensitive agent actions.

Use Guardrails and human review to choose an implementation surface for repeatable agent work.

Guardrails and human review | OpenAI API

Learn how to use guardrails and human review in the OpenAI Agents SDK for safer, more controlled workflows.


ChatGPT Work and the Codex Desktop App

The work targets tasks that exceed a single context window or prompt session. OpenAI's July 9, 2026 launch of ChatGPT Work, a GPT-5.6-powered agent that stays with a project for hours by breaking a goal into smaller steps and completing them independently across apps and files, alongside Codex merging into the ChatGPT desktop app with in-sidebar PR review and cross-repository projects, extending the long-horizon coding-agent loop pattern to general knowledge work.

Use ChatGPT Work and the Codex Desktop App to choose an implementation surface for repeatable agent work.

Contextual source from openai.com; useful for practice signals or boundary conditions, not independent validation.

ChatGPT is now a partner for your most ambitious work | OpenAI

ChatGPT Work is an agent that can take action across your apps and files, stay with a project for hours if needed, and turn a goal into finished work.


The work separates roles across agents, verifiers, or orchestration layers. Claude SDK overview for tool-using agents, subagents, state, permissions, and streaming.

Use Building agents with the Claude Agent SDK to choose an implementation surface for repeatable agent work.


How the agent loop works

Primary-source operational guidance rather than commentary. Official walkthrough of the inner agent loop that outer recurring loops build on.

Use How the agent loop works to choose an implementation surface for repeatable agent work.

How the agent loop works - Claude Code Docs

Understand the message lifecycle, tool execution, context window, and architecture that power your SDK agents.


Extend Claude with skills

Shows how production platforms expose loops through concrete tools, permissions, skills, agents, and automation features. Claude Code skill system for reusable loop instructions and assets.

Use Extend Claude with skills to choose an implementation surface for repeatable agent work.

Extend Claude with skills - Claude Code Docs

Create, manage, and share skills to extend Claude's capabilities in Claude Code. Includes custom commands and bundled skills.


Create custom subagents

Context is managed as durable loop state rather than a single prompt payload. Claude Code custom subagents with isolated context, model choice, and tool permissions.

Use Create custom subagents to choose an implementation surface for repeatable agent work.

Create custom subagents - Claude Code Docs

Create and use specialized AI subagents in Claude Code for task-specific workflows and improved context management.


Writing effective tools for AI agents

Shows how production platforms expose loops through concrete tools, permissions, skills, agents, and automation features. Anthropic's guidance on evaluating and improving tool specs using agentic loops and realistic tasks.

Use Writing effective tools for AI agents to choose an implementation surface for repeatable agent work.

Primary official documentation from www.anthropic.com; use it for current product or standard behavior.

Writing effective tools for AI agents—using AI agents \ Anthropic


Context is managed as durable loop state rather than a single prompt payload. Tool search, programmatic tool calling, and tool-use examples for scaling large tool libraries without flooding context.

Use Introducing advanced tool use on the Claude Developer Platform to choose an implementation surface for repeatable agent work.

Introducing advanced tool use on the Claude Developer Platform \ Anthropic

Claude can now discover, learn, and execute tools dynamically to enable agents that take action in the real world. Here’s how.


Durable execution and replay are treated as first-class loop infrastructure. Anthropic's guidance for agents that work across many context windows: durable progress artifacts, environment setup, and self-verification.

Use Effective harnesses for long-running agents to choose an implementation surface for repeatable agent work.

Effective harnesses for long-running agents \ Anthropic

Anthropic is an AI safety and research company that's working to build reliable, interpretable, and steerable AI systems.


Claude Code best practices

Shows how production platforms expose loops through concrete tools, permissions, skills, agents, and automation features. Widely cited workflow guidance that underlies many recurring Claude Code loops.

Use Claude Code best practices to choose an implementation surface for repeatable agent work.

Best practices for Claude Code - Claude Code Docs

Tips and patterns for getting the most out of Claude Code, from configuring your environment to scaling across parallel sessions.


The trigger or cadence is explicit, making the workflow recurring rather than one-off. 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.

Use Claude Managed Agents: Scheduled Deployments and Vaults to choose an implementation surface for repeatable agent work.

Primary official documentation from claude.com; use it for current product or standard behavior.

New in Claude Managed Agents: run agents on a schedule and store environment variables in vaults | Claude by Anthropic

Claude Managed Agents now supports scheduled deployments and vaults: run agents on a cron schedule and securely authenticate CLI tools and other services.


Getting Started with Loops

Primary-source operational guidance rather than commentary. Official Claude Code team guide by Delba de Oliveira and Michael Segner (June 30, 2026) that defines loops as agents repeating cycles of work until a stop condition is met, categorizes turn-based, goal-based (/goal), time-based (/loop, /schedule), and proactive loops by trigger and stop criteria, and recommends encoding verification as skills with quantitative success criteria alongside token-spend management.

Use Getting Started with Loops to choose an implementation surface for repeatable agent work.

Contextual source from claude.com; useful for practice signals or boundary conditions, not independent validation.

Loop engineering: Getting started with loops | Claude by Anthropic

Loop engineering with Anthropic's Claude Code: design turn-based, goal, time, and proactive agent loops that run to a stop condition.


Claude Code What's New, Week 28

Shows how production platforms expose loops through concrete tools, permissions, skills, agents, and automation features. Weekly digest whose loop-integrity features include auto mode blocking tampering with session transcript files and confirmation prompts before destructive operations in unattended runs.

Use Claude Code What's New, Week 28 to choose an implementation surface for repeatable agent work.

Week 28 · July 6–10, 2026 - Claude Code Docs

Browse external sites from the Desktop app's built-in browser, run a full setup checkup with /doctor, and pick up auto mode transcript protections and agent view upgrades.


GitHub Agentic Workflows

The trigger or cadence is explicit, making the workflow recurring rather than one-off. Repository automation that runs coding agents in GitHub Actions on events or schedules with guardrails.

Use GitHub Agentic Workflows to choose an implementation surface for repeatable agent work.

Primary official documentation from github.github.com; use it for current product or standard behavior.

GitHub Agentic Workflows (gh-aw) lets you write repository automation in plain Markdown and run AI coding agents — GitHub Copilot, Claude Code, OpenAI Codex, or Google Gemini — inside GitHub Actions, with sandboxed execution, read-only defaults, and safe outputs for writes.


Continuous AI

Shows how production platforms expose loops through concrete tools, permissions, skills, agents, and automation features. GitHub Next's umbrella framing for CI/CD-style AI automation across the software lifecycle, the category that agentic workflows demonstrate.

Use Continuous AI to choose an implementation surface for repeatable agent work.

Primary official documentation from githubnext.com; use it for current product or standard behavior.

Exploring LLM-powered automation in platform-based software collaboration


Primary-source operational guidance rather than commentary. Official walkthrough of writing Markdown-defined agentic workflows with guardrails for triage, QA, and docs chores, announced in the [technical preview changelog](https://github.blog/changelog/2026-02-13-github-agentic-workflows-are-now-in-technical-preview/).

Use Automate repository tasks with GitHub Agentic Workflows to choose an implementation surface for repeatable agent work.

Contextual source from github.blog; useful for practice signals or boundary conditions, not independent validation.

Automate repository tasks with GitHub Agentic Workflows - The GitHub Blog LinkedIn icon Instagram icon YouTube icon X icon TikTok icon Twitch icon GitHub icon

Build automations using coding agents in GitHub Actions to handle triage, documentation, code quality, and more.


Shows how production platforms expose loops through concrete tools, permissions, skills, agents, and automation features. Concrete agentic-CI automations available today, with recurring patterns for triage, review, and documentation upkeep.

Use Continuous AI in practice: What developers can automate today with agentic CI to choose an implementation surface for repeatable agent work.

Continuous AI in practice: What developers can automate today with agentic CI - The GitHub Blog LinkedIn icon Instagram icon YouTube icon X icon TikTok icon Twitch icon GitHub icon

Think of Continuous AI as background agents that operate in your repository for tasks that require reasoning.


About GitHub Copilot coding agent

Shows how production platforms expose loops through concrete tools, permissions, skills, agents, and automation features. GitHub's autonomous coding agent: assign an issue, the agent works in an isolated Actions-powered workspace, and a reviewable pull request comes back.

Use About GitHub Copilot coding agent to choose an implementation surface for repeatable agent work.

About GitHub Copilot cloud agent - GitHub Docs

Copilot can research a repository, create an implementation plan, and make code changes on a branch. You can review the diff, iterate, and create a pull request when you're ready.


Shows how production platforms expose loops through concrete tools, permissions, skills, agents, and automation features. Launch overview of the issue-to-PR delegation loop, including iteration on review feedback.

Use GitHub Copilot: Meet the new coding agent to choose an implementation surface for repeatable agent work.

GitHub Copilot: Meet the new coding agent - The GitHub Blog LinkedIn icon Instagram icon YouTube icon X icon TikTok icon Twitch icon GitHub icon

GitHub Copilot has a new feature: a coding agent that can implement a task or issue, run in the background with GitHub Actions, and more.


Shows how production platforms expose loops through concrete tools, permissions, skills, agents, and automation features. 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.

Use GitHub Copilot for Jira Is Now Generally Available to choose an implementation surface for repeatable agent work.

Primary official documentation from github.blog; use it for current product or standard behavior.

GitHub Copilot for Jira is now generally available - GitHub Changelog LinkedIn icon Instagram icon YouTube icon X icon TikTok icon Twitch icon GitHub icon

GitHub Copilot for Jira is now generally available. Since launching the public preview in March 2026, we have shipped a series of enhancements based on your feedback, including model selection,…


Shows how production platforms expose loops through concrete tools, permissions, skills, agents, and automation features. 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.

Use Copilot Agent Session Streaming (Public Preview) to choose an implementation surface for repeatable agent work.

Copilot agent session streaming is now in public preview - GitHub Changelog LinkedIn icon Instagram icon YouTube icon X icon TikTok icon Twitch icon GitHub icon

GitHub Enterprise Cloud customers with enterprise managed users can now access GitHub Copilot agent session data across all Copilot clients, including: Cloud agents operating on github.com and data resident deployments…


Shows how production platforms expose loops through concrete tools, permissions, skills, agents, and automation features. Changelog adding on-demand security reviews inside the Copilot app, so an agent's proposed changes can be scanned for vulnerabilities before they are merged.

Use Security Reviews in the GitHub Copilot App to choose an implementation surface for repeatable agent work.

Security reviews now available in the GitHub Copilot app - GitHub Changelog LinkedIn icon Instagram icon YouTube icon X icon TikTok icon Twitch icon GitHub icon

You can now run a security review on your in-flight code changes directly from the GitHub Copilot app. The /security-review slash command is shipping in public preview, bringing the same…


Cursor cloud agents

Shows how production platforms expose loops through concrete tools, permissions, skills, agents, and automation features. Remote agents that work asynchronously in isolated environments and hand results back for review.

Use Cursor cloud agents to choose an implementation surface for repeatable agent work.

Primary official documentation from cursor.com; use it for current product or standard behavior.

Run Agent in the cloud for continuous coding assistance.


Shows how production platforms expose loops through concrete tools, permissions, skills, agents, and automation features. 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.

Use Cursor 3.8: Improvements to Cursor Automations to choose an implementation surface for repeatable agent work.

Improvements to Cursor Automations · Cursor


Shows how production platforms expose loops through concrete tools, permissions, skills, agents, and automation features. 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.

Use Expanding Our Long-Running Agents Research Preview to choose an implementation surface for repeatable agent work.

Contextual source from cursor.com; useful for practice signals or boundary conditions, not independent validation.

Expanding our long-running agents research preview · Cursor

Long-running agents are now available in the Cursor web app for Ultra, Teams, and Enterprise users.


The work separates roles across agents, verifiers, or orchestration layers. Cursor changelog adding cloud-agent hooks (before-submit, after-response, after-thought, stop, and subagent-start) that the platform pitches for gating and observing background agent runs.

Use Cursor 3.11: Side Chats, Transcript Search, and Cloud Agent Hooks to choose an implementation surface for repeatable agent work.

Side Chats and Conversation Search · Cursor


Jules

Shows how production platforms expose loops through concrete tools, permissions, skills, agents, and automation features. Google's asynchronous coding agent that plans, executes tasks in isolated cloud VMs, and returns reviewable diffs.

Use Jules to choose an implementation surface for repeatable agent work.

Primary official documentation from jules.google; use it for current product or standard behavior.


Devin Docs

Shows how production platforms expose loops through concrete tools, permissions, skills, agents, and automation features. Documentation for a long-running autonomous software engineer with sessions, playbooks, knowledge, and review boundaries.

Use Devin Docs to choose an implementation surface for repeatable agent work.

Primary official documentation from docs.devin.ai; use it for current product or standard behavior.

Devin is the AI software engineer, built to help ambitious engineering teams crush their backlogs.


Amp: Agents, Anywhere

Shows how production platforms expose loops through concrete tools, permissions, skills, agents, and automation features. Amp launches remote agent creation on any machine with shell access plus a headless runner mode that lets multiple agents run concurrently without a terminal UI.

Use Amp: Agents, Anywhere to choose an implementation surface for repeatable agent work.

Contextual source from ampcode.com; useful for practice signals or boundary conditions, not independent validation.

Remotely start agents anywhere you can run 'amp'


Amp: Right on Schedule

The trigger or cadence is explicit, making the workflow recurring rather than one-off. Amp adds scheduled agent runs, letting recurring work fire on a cadence with results reported back, moving the platform from on-demand sessions toward standing loops.

Use Amp: Right on Schedule to choose an implementation surface for repeatable agent work.

Agents can now set their own schedules, wake themselves up, and keep working.


Claude Code What's New, Week 29

Shows how production platforms expose loops through concrete tools, permissions, skills, agents, and automation features. Weekly digest of Claude Code changes relevant to recurring agent work, following the Week 28 loop-integrity updates.

Use Claude Code What's New, Week 29 to choose an implementation surface for repeatable agent work.

Primary official documentation from code.claude.com; use it for current product or standard behavior.

Week 29 · July 13–17, 2026 - Claude Code Docs

Pull live data into published artifacts through MCP connectors, and use Claude Code with a screen reader in the new screen reader mode.


Shows how production platforms expose loops through concrete tools, permissions, skills, agents, and automation features. Changelog adding customization and configurability to Copilot code review, sharpening the automated review gate teams put between agent-written changes and merge.

Use Copilot Code Review: Customization and Configurability to choose an implementation surface for repeatable agent work.

Copilot code review: Customization and configurability improvements - GitHub Changelog LinkedIn icon Instagram icon YouTube icon X icon TikTok icon Twitch icon GitHub icon

Copilot code review now utilizes a firewall, custom setup steps, and independent runner configurations. It now reads custom instructions from the head branch to allow for easy testing and validation…


Amp: Event Driven Orbs

Durable execution and replay are treated as first-class loop infrastructure. Amp's July 23, 2026 launch letting orbs react to outside events: a plugin registers a durable webhook endpoint, each incoming event's signature is verified, and the configured handler runs in an orb thread seeded with trusted event metadata, turning GitHub CI failures, Linear issues, and Discord messages into event-triggered agent loops that post results back to external tools.

Use Amp: Event Driven Orbs to choose an implementation surface for repeatable agent work.

Orbs can now receive requests and react to outside events.


Scan Your Codebase for Vulnerabilities

Verification is promoted from a final check to a loop-control signal. Anthropic's Claude Security plugin runs a multi-agent deep scan of a repository or diff inside a Claude Code session: dynamic workflows orchestrate agents that map the architecture, build a threat model, and hunt vulnerabilities, with independent verifier agents gating every finding before it reaches the report. Revision stamps tie each report to the exact commit scanned, and patches are reviewed by an agent separate from the one that wrote them but never applied without human approval.

Use Scan Your Codebase for Vulnerabilities to choose an implementation surface for repeatable agent work.

Scan your codebase for vulnerabilities - Claude Code Docs

Install the Claude Security plugin to scan your codebase for vulnerabilities in a Claude Code session and turn findings into patches you review and apply.


Shows how production platforms expose loops through concrete tools, permissions, skills, agents, and automation features. Public preview that puts approval gates on autonomous issue triage: agents driven by Agentic Workflows or the Copilot cloud agent suggest label, field, issue-type, assignee, and close actions with a stated rationale, high-confidence actions apply automatically while lower-confidence ones queue for human accept/decline, and every change carries an audit trail.

Use Agent Automation Controls in GitHub Issues to choose an implementation surface for repeatable agent work.

Agent automation controls in GitHub Issues in public preview - GitHub Changelog LinkedIn icon Instagram icon YouTube icon X icon TikTok icon Twitch icon GitHub icon

Agent automations increasingly label, type, assign, and close issues for you. GitHub Issues now shows the reason behind each change and lets you review them before they’re applied, so you…


Shows how production platforms expose loops through concrete tools, permissions, skills, agents, and automation features. General availability of Copilot cloud agent for Linear: assign a Linear issue to the agent, which analyzes it, opens a draft pull request from an ephemeral GitHub Actions environment, streams progress to the Linear activity timeline, and accepts mid-task steering via comments, with model selection, custom agent, and branch controls.

Use Copilot Cloud Agent for Linear Is Now Generally Available to choose an implementation surface for repeatable agent work.

Copilot cloud agent for Linear is now generally available - GitHub Changelog LinkedIn icon Instagram icon YouTube icon X icon TikTok icon Twitch icon GitHub icon

You can now assign issues in Linear to Copilot cloud agent, our asynchronous, autonomous background agent. When you assign a Linear issue to Copilot, it will: Analyze the issue contents…


Primary-source operational guidance rather than commentary. Official Anthropic post (Jul 24, 2026) by Thariq Shihipar (MTS): Anthropic removed over 80% of Claude Code's system prompt for Opus 5/Fable 5 with no measurable eval loss, and lays out five shifts, rules-to-judgment, example-to-interface tool design, progressive disclosure, concise tool descriptions, and manual-to-automatic memory systems, plus the /doctor command for auto-optimizing harness configs. Core harness/loop-engineering doctrine from the vendor itself.

Use The New Rules of Context Engineering for Claude 5 Generation Models to choose an implementation surface for repeatable agent work.

The new rules of context engineering for Claude 5 generation models | Claude by Anthropic

We removed over 80% of Claude Code's system prompt for more advanced models. How to apply the lessons we learned to your own context engineering in Claude Code and with your own agents.


Claude Cookbook

Evaluation data is used as the feedback signal for improving loop behavior. Anthropic's hosted cookbook of runnable recipes for building with Claude, including agent loops with tool use, memory management, context editing, and evaluation harnesses, kept current with each model generation as the reference implementation source.

Use Claude Cookbook to choose an implementation surface for repeatable agent work.

Primary official documentation from platform.claude.com; use it for current product or standard behavior.

Practical guides and code examples for building with Claude. Learn prompting techniques, tool use, multimodal capabilities, and more.


The 2026-07-28 MCP Specification

Primary-source operational guidance rather than commentary. Official MCP release announcement (Jul 28, 2026) by lead maintainers David Soria Parra and Den Delimarsky, publishing the 2026-07-28 spec as final after a ten-week release-candidate validation window.

Use The 2026-07-28 MCP Specification to choose an implementation surface for repeatable agent work.

Primary official documentation from blog.modelcontextprotocol.io; use it for current product or standard behavior.

The 2026-07-28 Specification | Model Context Protocol Blog

The 2026-07-28 Model Context Protocol specification is out, bringing a stateless protocol core, Multi Round-Trip Requests, header-based routing, cacheable list results, authorization hardening, a formal extensions framework, and updated Tier 1 SDKs.

David Soria Parra (Lead Maintainer), Den Delimarsky (Lead Maintainer)


MCP Tasks Extension

Primary-source operational guidance rather than commentary. Normative documentation for io.modelcontextprotocol/tasks (SEP-2663), promoted out of experimental core into an official extension with the 2026-07-28 spec and redesigned around durable handles instead of session-bound objects.

Use MCP Tasks Extension to choose an implementation surface for repeatable agent work.

Primary official documentation from modelcontextprotocol.io; use it for current product or standard behavior.

Asynchronous task execution for long-running MCP operations


Antigravity CLI

Shows how production platforms expose loops through concrete tools, permissions, skills, agents, and automation features. Google's Antigravity CLI release of Jul 28, 2026 turns the agent into a programmable component rather than a terminal session.

Use Antigravity CLI to choose an implementation surface for repeatable agent work.

Primary official documentation from github.com; use it for current product or standard behavior.

GitHub - google-antigravity/antigravity-cli: Antigravity CLI brings the reasoning, execution, and orchestration capabilities of Antigravity agent harness directly into your terminal. · GitHub

Antigravity CLI brings the reasoning, execution, and orchestration capabilities of Antigravity agent harness directly into your terminal. - google-antigravity/antigravity-cli


The contribution is machine-readable and validation-friendly. GitHub changelog (Jul 27, 2026) extending managed-settings.json governance, previously limited to interactive CLI and VS Code clients, to the Copilot cloud agent, the autonomous background worker that opens PRs from issue assignments.

Use Enterprise Managed Settings Now Apply to the GitHub Copilot App to choose an implementation surface for repeatable agent work.

Enterprise managed settings in the GitHub Copilot app and Copilot cloud agent - GitHub Changelog LinkedIn icon Instagram icon YouTube icon X icon TikTok icon Twitch icon GitHub icon

You can now govern the GitHub Copilot app and Copilot cloud agent with enterprise managed settings, the same centrally managed policies you use to control Copilot across your enterprise. With…


Workspace isolation is part of the loop design, not an afterthought. The Agents window (public preview) gets the observability and isolation primitives that parallel agent operation needs. Sessions can now be started in a Git worktree, and notably for Copilot, Claude, or Codex sessions, not just Copilot's own, giving each concurrent agent its own checkout instead of contending over one working tree.

Use GitHub Copilot in Visual Studio Code, July 2026 Releases to choose an implementation surface for repeatable agent work.

GitHub Copilot in Visual Studio Code, July 2026 releases - GitHub Changelog LinkedIn icon Instagram icon YouTube icon X icon TikTok icon Twitch icon GitHub icon

This changelog covers VS Code v1.127 through v1.131, shipped throughout July 2026. These releases improve how you work with agents, review changes, use chat, and navigate VS Code. They also…


Connects Loop Engineering to prior agent-loop and feedback-loop research. Foundational reason-act-observe loop for tool-using language agents.

Use ReAct: Synergizing Reasoning and Acting in Language Models to understand the evidence, vocabulary, and lineage behind recurring agent systems.

Research source arXiv:2210.03629; inspect its method and evaluation before treating results as production evidence.

[2210.03629] ReAct: Synergizing Reasoning and Acting in Language Models

While large language models (LLMs) have demonstrated impressive capabilities across tasks in language understanding and interactive decision making, their abilities for reasoning (e.g. chain-of-thought prompting) and acting (e.g. action plan generation) have primarily been studied as separate topics. In this paper, we explore the use of LLMs to generate both reasoning traces and task-specific actions in an interleaved manner, allowing for greater synergy between the two: reasoning traces help the model induce, track, and update action plans as well as handle exceptions, while actions allow it to interface with external sources, such as knowledge bases or environments, to gather additional information. We apply our approach, named ReAct, to a diverse set of language and decision making tasks and demonstrate its effectiveness over state-of-the-art baselines, as well as improved human interpretability and trustworthiness over methods without reasoning or acting components. Concretely, on question answering (HotpotQA) and fact verification (Fever), ReAct overcomes issues of hallucination and error propagation prevalent in chain-of-thought reasoning by interacting with a simple Wikipedia API, and generates human-like task-solving trajectories that are more interpretable than baselines without reasoning traces. On two interactive decision making benchmarks (ALFWorld and WebShop), ReAct outperforms imitation and reinforcement learning methods by an absolute success rate of 34% and 10% respectively, while being prompted with only one or two in-context examples. Project site with code: https://react-lm.github.io

Shunyu Yao; Jeffrey Zhao; Dian Yu; Nan Du; Izhak Shafran; Karthik Narasimhan; Yuan Cao

Published in International Conference on Learning Representations (ICLR); the linked arXiv record remains available for open access.


Persistent memory is treated as an external runtime artifact. Converts environment feedback into written reflections stored in memory for future attempts.

Use Reflexion: Language Agents with Verbal Reinforcement Learning to understand the evidence, vocabulary, and lineage behind recurring agent systems.

Research source arXiv:2303.11366; inspect its method and evaluation before treating results as production evidence.

[2303.11366] Reflexion: Language Agents with Verbal Reinforcement Learning

Large language models (LLMs) have been increasingly used to interact with external environments (e.g., games, compilers, APIs) as goal-driven agents. However, it remains challenging for these language agents to quickly and efficiently learn from trial-and-error as traditional reinforcement learning methods require extensive training samples and expensive model fine-tuning. We propose Reflexion, a novel framework to reinforce language agents not by updating weights, but instead through linguistic feedback. Concretely, Reflexion agents verbally reflect on task feedback signals, then maintain their own reflective text in an episodic memory buffer to induce better decision-making in subsequent trials. Reflexion is flexible enough to incorporate various types (scalar values or free-form language) and sources (external or internally simulated) of feedback signals, and obtains significant improvements over a baseline agent across diverse tasks (sequential decision-making, coding, language reasoning). For example, Reflexion achieves a 91% pass@1 accuracy on the HumanEval coding benchmark, surpassing the previous state-of-the-art GPT-4 that achieves 80%. We also conduct ablation and analysis studies using different feedback signals, feedback incorporation methods, and agent types, and provide insights into how they affect performance.

Noah Shinn; Federico Cassano; Edward Berman; Ashwin Gopinath; Karthik Narasimhan; Shunyu Yao

Neural Information Processing Systems Foundation

Published in Advances in Neural Information Processing Systems 36 (NeurIPS); the linked arXiv record remains available for open access.


Connects Loop Engineering to prior agent-loop and feedback-loop research. Generate-feedback-refine loop where a model improves outputs over repeated passes.

Use Self-Refine: Iterative Refinement with Self-Feedback to understand the evidence, vocabulary, and lineage behind recurring agent systems.

Research source arXiv:2303.17651; inspect its method and evaluation before treating results as production evidence.

[2303.17651] Self-Refine: Iterative Refinement with Self-Feedback

Like humans, large language models (LLMs) do not always generate the best output on their first try. Motivated by how humans refine their written text, we introduce Self-Refine, an approach for improving initial outputs from LLMs through iterative feedback and refinement. The main idea is to generate an initial output using an LLMs; then, the same LLMs provides feedback for its output and uses it to refine itself, iteratively. Self-Refine does not require any supervised training data, additional training, or reinforcement learning, and instead uses a single LLM as the generator, refiner, and feedback provider. We evaluate Self-Refine across 7 diverse tasks, ranging from dialog response generation to mathematical reasoning, using state-of-the-art (GPT-3.5, ChatGPT, and GPT-4) LLMs. Across all evaluated tasks, outputs generated with Self-Refine are preferred by humans and automatic metrics over those generated with the same LLM using conventional one-step generation, improving by ~20% absolute on average in task performance. Our work demonstrates that even state-of-the-art LLMs like GPT-4 can be further improved at test time using our simple, standalone approach.

Aman Madaan; Niket Tandon; Prakhar Gupta; Skyler Hallinan; Luyu Gao; Sarah Wiegreffe; Uri Alon; Nouha Dziri; Shrimai Prabhumoye; Yiming Yang; Shashank Gupta; Bodhisattwa Prasad Majumder; Katherine Hermann; Sean Welleck; Amir Yazdanbakhsh; Peter Clark


Connects Loop Engineering to prior agent-loop and feedback-loop research. Uses tools to ground critique and correction rather than relying only on introspection.

Use CRITIC: Large Language Models Can Self-Correct with Tool-Interactive Critiquing to understand the evidence, vocabulary, and lineage behind recurring agent systems.

Research source arXiv:2305.11738; inspect its method and evaluation before treating results as production evidence.

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

Recent developments in large language models (LLMs) have been impressive. However, these models sometimes show inconsistencies and problematic behavior, such as hallucinating facts, generating flawed code, or creating offensive and toxic content. Unlike these models, humans typically utilize external tools to cross-check and refine their initial content, like using a search engine for fact-checking, or a code interpreter for debugging. Inspired by this observation, we introduce a framework called CRITIC that allows LLMs, which are essentially "black boxes" to validate and progressively amend their own outputs in a manner similar to human interaction with tools. More specifically, starting with an initial output, CRITIC interacts with appropriate tools to evaluate certain aspects of the text, and then revises the output based on the feedback obtained during this validation process. Comprehensive evaluations involving free-form question answering, mathematical program synthesis, and toxicity reduction demonstrate that CRITIC consistently enhances the performance of LLMs. Meanwhile, our research highlights the crucial importance of external feedback in promoting the ongoing self-improvement of LLMs.

Zhibin Gou; Zhihong Shao; Yeyun Gong; Yelong Shen; Yujiu Yang; Nan Duan; Weizhu Chen


Tree of Thoughts

Connects Loop Engineering to prior agent-loop and feedback-loop research. Search over multiple reasoning branches; relevant when loop design needs exploration before committing.

Use Tree of Thoughts to understand the evidence, vocabulary, and lineage behind recurring agent systems.

Research source arXiv:2305.10601; inspect its method and evaluation before treating results as production evidence.

[2305.10601] Tree of Thoughts: Deliberate Problem Solving with Large Language Models

Language models are increasingly being deployed for general problem solving across a wide range of tasks, but are still confined to token-level, left-to-right decision-making processes during inference. This means they can fall short in tasks that require exploration, strategic lookahead, or where initial decisions play a pivotal role. To surmount these challenges, we introduce a new framework for language model inference, Tree of Thoughts (ToT), which generalizes over the popular Chain of Thought approach to prompting language models, and enables exploration over coherent units of text (thoughts) that serve as intermediate steps toward problem solving. ToT allows LMs to perform deliberate decision making by considering multiple different reasoning paths and self-evaluating choices to decide the next course of action, as well as looking ahead or backtracking when necessary to make global choices. Our experiments show that ToT significantly enhances language models' problem-solving abilities on three novel tasks requiring non-trivial planning or search: Game of 24, Creative Writing, and Mini Crosswords. For instance, in Game of 24, while GPT-4 with chain-of-thought prompting only solved 4% of tasks, our method achieved a success rate of 74%. Code repo with all prompts: https://github.com/princeton-nlp/tree-of-thought-llm.

Shunyu Yao; Dian Yu; Jeffrey Zhao; Izhak Shafran; Thomas L. Griffiths; Yuan Cao; Karthik Narasimhan


Graph of Thoughts

Control flow is represented as an inspectable graph rather than an opaque prompt loop. Generalizes thought structures beyond chains and trees, useful for complex loop planning and aggregation.

Use Graph of Thoughts to understand the evidence, vocabulary, and lineage behind recurring agent systems.

Research source arXiv:2308.09687; inspect its method and evaluation before treating results as production evidence.

[2308.09687] Graph of Thoughts: Solving Elaborate Problems with Large Language Models

We introduce Graph of Thoughts (GoT): a framework that advances prompting capabilities in large language models (LLMs) beyond those offered by paradigms such as Chain-of-Thought or Tree of Thoughts (ToT). The key idea and primary advantage of GoT is the ability to model the information generated by an LLM as an arbitrary graph, where units of information ("LLM thoughts") are vertices, and edges correspond to dependencies between these vertices. This approach enables combining arbitrary LLM thoughts into synergistic outcomes, distilling the essence of whole networks of thoughts, or enhancing thoughts using feedback loops. We illustrate that GoT offers advantages over state of the art on different tasks, for example increasing the quality of sorting by 62% over ToT, while simultaneously reducing costs by >31%. We ensure that GoT is extensible with new thought transformations and thus can be used to spearhead new prompting schemes. This work brings the LLM reasoning closer to human thinking or brain mechanisms such as recurrence, both of which form complex networks.

Maciej Besta; Nils Blach; Ales Kubicek; Robert Gerstenberger; Michal Podstawski; Lukas Gianinazzi; Joanna Gajda; Tomasz Lehmann; Hubert Niewiadomski; Piotr Nyczyk; Torsten Hoefler

Association for the Advancement of Artificial Intelligence (AAAI)

Published in Proceedings of the AAAI Conference on Artificial Intelligence 38 (AAAI); the linked arXiv record remains available for open access.


Connects Loop Engineering to prior agent-loop and feedback-loop research. Combines search, action, and environment feedback for language agents.

Use Language Agent Tree Search Unifies Reasoning Acting and Planning in Language Models to understand the evidence, vocabulary, and lineage behind recurring agent systems.

Research source arXiv:2310.04406; inspect its method and evaluation before treating results as production evidence.

[2310.04406] Language Agent Tree Search Unifies Reasoning Acting and Planning in Language Models

While language models (LMs) have shown potential across a range of decision-making tasks, their reliance on simple acting processes limits their broad deployment as autonomous agents. In this paper, we introduce Language Agent Tree Search (LATS) -- the first general framework that synergizes the capabilities of LMs in reasoning, acting, and planning. By leveraging the in-context learning ability of LMs, we integrate Monte Carlo Tree Search into LATS to enable LMs as agents, along with LM-powered value functions and self-reflections for proficient exploration and enhanced decision-making. A key feature of our approach is the incorporation of an environment for external feedback, which offers a more deliberate and adaptive problem-solving mechanism that surpasses the constraints of existing techniques. Our experimental evaluation across diverse domains, including programming, interactive question-answering (QA), web navigation, and math, validates the effectiveness and generality of LATS in decision-making while maintaining competitive or improved reasoning performance. Notably, LATS achieves state-of-the-art pass@1 accuracy (92.7%) for programming on HumanEval with GPT-4 and demonstrates gradient-free performance (average score of 75.9) comparable to gradient-based fine-tuning for web navigation on WebShop with GPT-3.5. Code can be found at https://github.com/lapisrocks/LanguageAgentTreeSearch

Andy Zhou; Kai Yan; Michal Shlapentokh-Rothman; Haohan Wang; Yu-Xiong Wang

Published in Proceedings of the 41st International Conference on Machine Learning (ICML); the linked arXiv record remains available for open access.


Connects Loop Engineering to prior agent-loop and feedback-loop research. Demonstrates lifelong skill acquisition through iterative exploration, feedback, and a skill library.

Use Voyager: An Open-Ended Embodied Agent with Large Language Models to understand the evidence, vocabulary, and lineage behind recurring agent systems.

Research source arXiv:2305.16291; inspect its method and evaluation before treating results as production evidence.

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

We introduce Voyager, the first LLM-powered embodied lifelong learning agent in Minecraft that continuously explores the world, acquires diverse skills, and makes novel discoveries without human intervention. Voyager consists of three key components: 1) an automatic curriculum that maximizes exploration, 2) an ever-growing skill library of executable code for storing and retrieving complex behaviors, and 3) a new iterative prompting mechanism that incorporates environment feedback, execution errors, and self-verification for program improvement. Voyager interacts with GPT-4 via blackbox queries, which bypasses the need for model parameter fine-tuning. The skills developed by Voyager are temporally extended, interpretable, and compositional, which compounds the agent's abilities rapidly and alleviates catastrophic forgetting. Empirically, Voyager shows strong in-context lifelong learning capability and exhibits exceptional proficiency in playing Minecraft. It obtains 3.3x more unique items, travels 2.3x longer distances, and unlocks key tech tree milestones up to 15.3x faster than prior SOTA. Voyager is able to utilize the learned skill library in a new Minecraft world to solve novel tasks from scratch, while other techniques struggle to generalize. We open-source our full codebase and prompts at https://voyager.minedojo.org/.

Guanzhi Wang; Yuqi Xie; Yunfan Jiang; Ajay Mandlekar; Chaowei Xiao; Yuke Zhu; Linxi Fan; Anima Anandkumar

Published in Transactions on Machine Learning Research (TMLR); the linked arXiv record remains available for open access.


Persistent memory is treated as an external runtime artifact. Introduces reflection and memory mechanisms for long-running agent behavior.

Use Generative Agents: Interactive Simulacra of Human Behavior to understand the evidence, vocabulary, and lineage behind recurring agent systems.

Research source arXiv:2304.03442; inspect its method and evaluation before treating results as production evidence.

[2304.03442] Generative Agents: Interactive Simulacra of Human Behavior

Believable proxies of human behavior can empower interactive applications ranging from immersive environments to rehearsal spaces for interpersonal communication to prototyping tools. In this paper, we introduce generative agents--computational software agents that simulate believable human behavior. Generative agents wake up, cook breakfast, and head to work; artists paint, while authors write; they form opinions, notice each other, and initiate conversations; they remember and reflect on days past as they plan the next day. To enable generative agents, we describe an architecture that extends a large language model to store a complete record of the agent's experiences using natural language, synthesize those memories over time into higher-level reflections, and retrieve them dynamically to plan behavior. We instantiate generative agents to populate an interactive sandbox environment inspired by The Sims, where end users can interact with a small town of twenty five agents using natural language. In an evaluation, these generative agents produce believable individual and emergent social behaviors: for example, starting with only a single user-specified notion that one agent wants to throw a Valentine's Day party, the agents autonomously spread invitations to the party over the next two days, make new acquaintances, ask each other out on dates to the party, and coordinate to show up for the party together at the right time. We demonstrate through ablation that the components of our agent architecture--observation, planning, and reflection--each contribute critically to the believability of agent behavior. By fusing large language models with computational, interactive agents, this work introduces architectural and interaction patterns for enabling believable simulations of human behavior.

Joon Sung Park; Joseph C. O'Brien; Carrie J. Cai; Meredith Ringel Morris; Percy Liang; Michael S. Bernstein

Published in Proceedings of the 36th ACM Symposium on User Interface Software and Technology (UIST); the linked arXiv record remains available for open access.


Checkpointed state makes long-running agent work recoverable across failures. METR's task-length time horizon metric; grounds why loop budgets, checkpoints, and escalation matter as autonomous work gets longer.

Use Measuring AI Ability to Complete Long Software Tasks to understand the evidence, vocabulary, and lineage behind recurring agent systems.

Research source arXiv:2503.14499; inspect its method and evaluation before treating results as production evidence.

[2503.14499] Measuring AI Ability to Complete Long Software Tasks

Despite rapid progress on AI benchmarks, the real-world meaning of benchmark performance remains unclear. To quantify the capabilities of AI systems in terms of human capabilities, we propose a new metric: 50%-task-completion time horizon. This is the time humans typically take to complete tasks that AI models can complete with 50% success rate. We first timed humans with relevant domain expertise on a combination of RE-Bench, HCAST, and 66 novel shorter tasks. On these tasks, current frontier AI models such as Claude 3.7 Sonnet have a 50% time horizon of around 50 minutes. Furthermore, frontier AI time horizon has been doubling approximately every seven months since 2019, though the trend may have accelerated in 2024. The increase in AI models' time horizons seems to be primarily driven by greater reliability and ability to adapt to mistakes, combined with better logical reasoning and tool use capabilities. We discuss the limitations of our results -- including their degree of external validity -- and the implications of increased autonomy for dangerous capabilities. If these results generalize to real-world software tasks, extrapolation of this trend predicts that within 5 years, AI systems will be capable of automating many software tasks that currently take humans a month.

Thomas Kwa; Ben West; Joel Becker; Amy Deng; Katharyn Garcia; Max Hasin; Sami Jawhar; Megan Kinniment; Nate Rush; Sydney Von Arx; Ryan Bloom; Thomas Broadley; Haoxing Du; Brian Goodrich; Nikola Jurkovic; Luke Harold Miles; Seraphina Nix; Tao Lin; Chris Painter; Neev Parikh; David Rein; Lucas Jun Koba Sato; Hjalmar Wijk; Daniel M. Ziegler; Elizabeth Barnes; Lawrence Chan

Published in Advances in Neural Information Processing Systems 38 (NeurIPS); the linked arXiv record remains available for open access.


Connects Loop Engineering to prior agent-loop and feedback-loop research. Accessible summary of the 50% task-completion time horizon and its doubling trend.

Use Measuring AI Ability to Complete Long Tasks to understand the evidence, vocabulary, and lineage behind recurring agent systems.

Contextual source from metr.org; useful for practice signals or boundary conditions, not independent validation.

Measuring AI Ability to Complete Long Software Tasks - METR

We propose measuring AI performance in terms of the *length* of tasks AI agents can complete. We show that this metric has been consistently exponentially increasing over the past 6 years, with a doubling time of around 7 months. Extrapolating this trend predicts that, in under a decade, we will see AI agents that can independently complete a large fraction of software tasks that currently take humans days or weeks.


Connects Loop Engineering to prior agent-loop and feedback-loop research. 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.

Use Reflection-Driven Control for Trustworthy Code Agents to understand the evidence, vocabulary, and lineage behind recurring agent systems.

Research source arXiv:2512.21354; inspect its method and evaluation before treating results as production evidence.

[2512.21354] Reflection-Driven Control for Trustworthy Code Agents

Contemporary large language model (LLM) agents are remarkably capable, but they still lack reliable safety controls and can produce unconstrained, unpredictable, and even actively harmful outputs. To address this, we introduce Reflection-Driven Control, a standardized and pluggable control module that can be seamlessly integrated into general agent architectures. Reflection-Driven Control elevates "self-reflection" from a post hoc patch into an explicit step in the agent's own reasoning process: during generation, the agent continuously runs an internal reflection loop that monitors and evaluates its own decision path. When potential risks are detected, the system retrieves relevant repair examples and secure coding guidelines from an evolving reflective memory, injecting these evidence-based constraints directly into subsequent reasoning steps. We instantiate Reflection-Driven Control in the setting of secure code generation and systematically evaluate it across eight classes of security-critical programming tasks. Empirical results show that Reflection-Driven Control substantially improves the security and policy compliance of generated code while largely preserving functional correctness, with minimal runtime and token overhead. Taken together, these findings indicate that Reflection-Driven Control is a practical path toward trustworthy AI coding agents: it enables designs that are simultaneously autonomous, safer by construction, and auditable.

Bin Wang; Jiazheng Quan; Xingrui Yu; Hansen Hu; Yuhao; Ivor Tsang

Published in AAAI Workshop on Trust and Control in Agentic AI (TrustAgent); the linked arXiv record remains available for open access.


Hyperagents

Connects Loop Engineering to prior agent-loop and feedback-loop research. 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.

Use Hyperagents to understand the evidence, vocabulary, and lineage behind recurring agent systems.

Research source arXiv:2603.19461; inspect its method and evaluation before treating results as production evidence.

Self-improving AI systems aim to reduce reliance on human engineering by learning to improve their own learning and problem-solving processes. Existing approaches to self-improvement rely on fixed, handcrafted meta-level mechanisms, fundamentally limiting how fast such systems can improve. The Darwin G\"odel Machine (DGM) demonstrates open-ended self-improvement in coding by repeatedly generating and evaluating self-modified variants. Because both evaluation and self-modification are coding tasks, gains in coding ability can translate into gains in self-improvement ability. However, this alignment does not generally hold beyond coding domains. We introduce \textbf{hyperagents}, self-referential agents that integrate a task agent (which solves the target task) and a meta agent (which modifies itself and the task agent) into a single editable program. Crucially, the meta-level modification procedure is itself editable, enabling metacognitive self-modification, improving not only the task-solving behavior, but also the mechanism that generates future improvements. We instantiate this framework by extending DGM to create DGM-Hyperagents (DGM-H), eliminating the assumption of domain-specific alignment between task performance and self-modification skill to potentially support self-accelerating progress on any computable task. Across diverse domains, the DGM-H improves performance over time and outperforms baselines without self-improvement or open-ended exploration, as well as prior self-improving systems. Furthermore, the DGM-H improves the process by which it generates new agents (e.g., persistent memory, performance tracking), and these meta-level improvements transfer across domains and accumulate across runs. DGM-Hyperagents offer a glimpse of open-ended AI systems that do not merely search for better solutions, but continually improve their search for how to improve.

Jenny Zhang; Bingchen Zhao; Wannan Yang; Jakob Foerster; Jeff Clune; Minqi Jiang; Sam Devlin; Tatiana Shavrina


The work targets tasks that exceed a single context window or prompt session. Hierarchical plan-execute-assess loops that detect and correct strategic errors during multi-hour autonomous runs.

Use PARC: An Autonomous Self-Reflective Coding Agent for Robust Execution of Long-Horizon Tasks to understand the evidence, vocabulary, and lineage behind recurring agent systems.

Research source arXiv:2512.03549; inspect its method and evaluation before treating results as production evidence.

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

We introduce PARC, a coding agent for the autonomous and robust execution of long-horizon computational tasks. PARC is built on a hierarchical multi-agent architecture incorporating task planning, execution, and a mechanism that evaluates its own actions and their outcomes from an independent context and provides feedback, namely self-assessment and self-feedback. This design enables PARC to detect and correct high-level strategic errors and sustain progress without human intervention. We evaluate PARC across computational science and data science tasks. In materials science, it autonomously reproduces key results from studies on lithium-ion conduction and alloy segregation. In particular, it coordinates dozens of parallel simulation tasks, each requiring roughly 43 hours of computation, managing orchestration, monitoring, and error correction end-to-end. In Kaggle-based experiments, starting from minimal natural-language instructions, PARC conducts data analysis and implements search strategies, producing solutions competitive with human-engineered baselines. These results highlight the potential of integrating a hierarchical multi-agent system with self-assessment and self-feedback to enable AI systems capable of independent, large-scale scientific and analytical work.

Yuki Orimo; Iori Kurata; Hodaka Mori; Ryuhei Okuno; Ryohto Sawada; Daisuke Okanohara