Sync awesome-loop-engineering

Initial sync from GitHub repository ChaoYue0307/awesome-loop-engineering.

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+assets/awesome-loop-engineering-cover.png filter=lfs diff=lfs merge=lfs -text

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,11 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Community pattern discussion
+    url: https://github.com/ChaoYue0307/awesome-loop-engineering/issues/1
+    about: Share real-world Loop Engineering patterns, examples, and lessons learned.
+  - name: Open a pull request
+    url: https://github.com/ChaoYue0307/awesome-loop-engineering/compare
+    about: If you already know where the resource belongs, a pull request is preferred.
+  - name: Support guide
+    url: https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/SUPPORT.md
+    about: Choose the right support, correction, translation, or security channel.

.github/ISSUE_TEMPLATE/pattern-suggestion.yml

@@ -0,0 +1,91 @@
+name: Loop pattern suggestion
+description: Suggest a recurring AI-agent loop pattern for the pattern library.
+title: "[Pattern]: "
+labels:
+  - pattern-suggestion
+body:
+  - type: input
+    id: name
+    attributes:
+      label: Pattern name
+      description: Short name for the loop pattern.
+      placeholder: PR babysitter
+    validations:
+      required: true
+  - type: textarea
+    id: objective
+    attributes:
+      label: Objective
+      description: What outcome should this loop optimize for?
+      placeholder: Keep an open PR moving toward merge readiness without repeated human polling.
+    validations:
+      required: true
+  - type: textarea
+    id: trigger
+    attributes:
+      label: Trigger
+      description: What starts the loop?
+      placeholder: Schedule, webhook, failed check, new review comment, release event, or manual bootstrap command.
+    validations:
+      required: true
+  - type: textarea
+    id: intake
+    attributes:
+      label: Discover / intake
+      description: Where does the loop find work?
+      placeholder: GitHub PR comments, CI failures, Linear tickets, logs, alerts, feedback streams.
+    validations:
+      required: true
+  - type: textarea
+    id: delegation
+    attributes:
+      label: Agents and delegation
+      description: Which agent roles are involved and how is work handed off?
+      placeholder: Explorer identifies blockers, Implementer patches, Reviewer checks scope, Judge decides next action.
+    validations:
+      required: true
+  - type: textarea
+    id: verification
+    attributes:
+      label: Verification gates
+      description: What says yes or no?
+      placeholder: Required checks pass, examples run, dashboard thresholds hold, reviewer approves, trace grader passes.
+    validations:
+      required: true
+  - type: textarea
+    id: state
+    attributes:
+      label: Durable state
+      description: What survives the next run?
+      placeholder: Progress file, issue comment, database checkpoint, trace, status report, processed IDs.
+    validations:
+      required: true
+  - type: textarea
+    id: budget
+    attributes:
+      label: Budget and exit
+      description: When should the loop stop?
+      placeholder: Max retries, max runtime, success condition, stop-without-success condition.
+    validations:
+      required: true
+  - type: textarea
+    id: escalation
+    attributes:
+      label: Escalation
+      description: When should a human take over and where should the loop report?
+      placeholder: Missing credentials, architecture judgment, production approval, repeated failure, unclear ownership.
+    validations:
+      required: true
+  - type: checkboxes
+    id: checklist
+    attributes:
+      label: Checklist
+      options:
+        - label: This is a recurring AI-agent loop, not a one-off prompt or generic automation.
+          required: true
+        - label: The pattern includes trigger, intake, delegation, verification, durable state, budget, escalation, and exit.
+          required: true
+        - label: The pattern has at least one concrete verification gate stronger than model self-assessment.
+          required: true
+        - label: Sensitive actions are human-approved or explicitly out of scope.
+          required: true

.github/ISSUE_TEMPLATE/resource-suggestion.yml

@@ -0,0 +1,110 @@
+name: Resource suggestion
+description: Suggest a paper, blog, note, tool, benchmark, or critique for the list.
+title: "[Resource]: "
+labels:
+  - resource-suggestion
+body:
+  - type: input
+    id: title
+    attributes:
+      label: Resource title
+      description: The title of the resource.
+      placeholder: Loop Engineering
+    validations:
+      required: true
+  - type: input
+    id: url
+    attributes:
+      label: URL
+      description: Public, stable URL for the resource.
+      placeholder: https://example.com
+    validations:
+      required: true
+  - type: dropdown
+    id: category
+    attributes:
+      label: Suggested category
+      options:
+        - Start Here
+        - Core Loop Primitives
+        - Official Runtime Guides
+        - Research Foundations
+        - Agent Workflow Patterns
+        - Coding-Agent Loop Systems
+        - Verification And Feedback Gates
+        - State, Memory, And Context Persistence
+        - Orchestration And Multi-Agent Delegation
+        - Benchmarks And Evaluation
+        - Operations Playbooks
+        - Templates And Patterns
+        - Critiques, Risks, And Limitations
+        - Adjacent Awesome Lists
+        - Not sure
+    validations:
+      required: true
+  - type: dropdown
+    id: source_type
+    attributes:
+      label: Resource type
+      options:
+        - 📄 Paper
+        - 📝 Blog
+        - 📚 Docs
+        - 🧰 Tool
+        - 🧪 Benchmark
+        - 🔁 Pattern
+        - 🧾 Template
+        - 🧭 List
+        - ⚠️ Critique
+        - Other
+    validations:
+      required: true
+  - type: dropdown
+    id: quality_label
+    attributes:
+      label: Quality label
+      description: Choose the strongest reason this source is useful.
+      options:
+        - Primary source
+        - Official docs
+        - Implementation-heavy
+        - Foundational
+        - Cautionary
+        - Adjacent
+        - Not sure
+    validations:
+      required: true
+  - type: textarea
+    id: relevance
+    attributes:
+      label: Why it belongs
+      description: Explain how this resource helps people design recurring agent systems above prompt, context, and harness engineering.
+      placeholder: This belongs because...
+    validations:
+      required: true
+  - type: dropdown
+    id: evidence_quality
+    attributes:
+      label: Evidence quality
+      description: Prefer primary, practical, and implementation-oriented sources.
+      options:
+        - Tier A - primary source or official docs
+        - Tier B - practitioner write-up with implementation detail
+        - Tier C - curated survey or high-quality explainer
+        - Tier D - commentary or news coverage
+        - Not sure
+    validations:
+      required: true
+  - type: checkboxes
+    id: checklist
+    attributes:
+      label: Checklist
+      options:
+        - label: This is about AI/coding-agent Loop Engineering or a direct foundation for recurring agent systems.
+          required: true
+        - label: If this is adjacent prompt, context, or harness content, it clearly connects to repeated runs, state, verification, or escalation.
+          required: true
+        - label: This is not about unrelated event loops, growth loops, or generic automation.
+          required: true
+        - label: I checked that the resource is not already listed.
+          required: true

.github/ISSUE_TEMPLATE/translation.yml

@@ -0,0 +1,41 @@
+name: Translation proposal
+description: Propose a new translation or volunteer to maintain one.
+title: "[Translation]: "
+labels:
+  - translation
+body:
+  - type: input
+    id: language
+    attributes:
+      label: Language
+      description: Which language do you want to add or maintain?
+      placeholder: Japanese
+    validations:
+      required: true
+  - type: input
+    id: file
+    attributes:
+      label: Proposed file name
+      description: See TRANSLATIONS.md for suggested names.
+      placeholder: README.ja.md
+    validations:
+      required: true
+  - type: textarea
+    id: scope
+    attributes:
+      label: Translation scope
+      description: What will you translate first?
+      placeholder: Introduction, Loop Contract, maturity model, contribution instructions...
+    validations:
+      required: true
+  - type: checkboxes
+    id: checklist
+    attributes:
+      label: Checklist
+      options:
+        - label: I will preserve the narrow AI/coding-agent scope.
+          required: true
+        - label: I will link back to the canonical English README.
+          required: true
+        - label: I will keep resource URLs unchanged.
+          required: true

.github/pull_request_template.md

@@ -0,0 +1,92 @@
+# Pull Request
+
+## What Changed
+
+Select all that apply.
+
+- [ ] Added or updated resource entries
+- [ ] Added or updated a loop pattern
+- [ ] Added or updated a translation
+- [ ] Improved docs, templates, or repository presentation
+- [ ] Fixed links, typos, or formatting
+
+## Resource Summary
+
+List the resources, patterns, or translation files changed.
+
+- Title and URL:
+
+## Relevance To Loop Engineering
+
+Explain how this PR relates to the new AI/coding-agent meaning of Loop Engineering: the layer above prompt, context, and harness engineering where recurring systems trigger agents, provide context, bound actions, verify results, persist state, retry, and escalate.
+
+## Category
+
+Which README section did you update?
+
+- [ ] Start Here
+- [ ] Core Loop Primitives
+- [ ] Official Runtime Guides
+- [ ] Research Foundations
+- [ ] Agent Workflow Patterns
+- [ ] Coding-Agent Loop Systems
+- [ ] Verification And Feedback Gates
+- [ ] State, Memory, And Context Persistence
+- [ ] Orchestration And Multi-Agent Delegation
+- [ ] Benchmarks And Evaluation
+- [ ] Operations Playbooks
+- [ ] Templates And Patterns
+- [ ] Critiques, Risks, And Limitations
+- [ ] Adjacent Awesome Lists
+- [ ] Translation or repository docs
+
+## Source Type
+
+- [ ] 📄 Paper
+- [ ] 📝 Blog
+- [ ] 📚 Docs
+- [ ] 🧰 Tool
+- [ ] 🧪 Benchmark
+- [ ] 🔁 Pattern
+- [ ] 🧾 Template
+- [ ] 🧭 List
+- [ ] ⚠️ Critique
+
+## Quality Labels
+
+- [ ] Direct Loop Engineering source
+- [ ] Paper or technical report
+- [ ] Official documentation
+- [ ] Engineering blog or field note
+- [ ] Tool, framework, or repository
+- [ ] Benchmark or evaluation resource
+- [ ] Critique or limitation analysis
+- [ ] Adjacent awesome list
+- [ ] Primary source
+- [ ] Implementation-heavy
+- [ ] Foundational
+- [ ] Cautionary
+- [ ] Translation
+- [ ] Repository maintenance
+
+## Evidence Quality
+
+- [ ] Tier A: primary source or official docs
+- [ ] Tier B: practitioner write-up with implementation detail
+- [ ] Tier C: curated survey or high-quality explainer
+- [ ] Tier D: commentary or news coverage
+
+## Checklist
+
+- [ ] I searched the README for duplicates.
+- [ ] The resource is public and has a stable URL.
+- [ ] The entry is in the most specific category.
+- [ ] The entry includes the correct resource type label, such as `📄 **Paper**` or `📚 **Docs**`.
+- [ ] The annotation explains why the resource matters for loop design.
+- [ ] Adjacent prompt, context, or harness resources explicitly connect to repeated agent runs, state, verification, or escalation.
+- [ ] The entry follows the format: `- 📄 **Paper** [Title](https://example.com) - One sentence annotation.`
+- [ ] The resource is not about unrelated event loops, growth loops, control theory, or generic automation.
+- [ ] New loop patterns include trigger, discover/intake, delegation, state, verification gates, retry budget, escalation path, and loop instruction or automation artifact.
+- [ ] I agree that my contribution to this repository is released under `CC0-1.0`.
+- [ ] I did not copy third-party content into this repository without the right to do so.
+- [ ] Any translation links back to the canonical English README.

.github/workflows/quality.yml

@@ -0,0 +1,80 @@
+name: Quality
+
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+  schedule:
+    - cron: "17 3 * * 1"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: quality-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  docs:
+    name: Docs quality gates
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      issues: write
+    env:
+      FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: "true"
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+
+      - name: Check Markdown formatting
+        uses: DavidAnson/markdownlint-cli2-action@v17
+        with:
+          globs: "**/*.md"
+
+      - name: Check Awesome list standards
+        run: npx --yes awesome-lint
+
+      - name: Check license text
+        run: python scripts/check_license.py
+
+      - name: Check resource type labels
+        run: python scripts/check_resource_labels.py README.md
+
+      - name: Check loop contract examples
+        run: |
+          python scripts/check_loop_contract_examples.py
+          python scripts/preview_loop_contract.py examples/pr-babysitter-loop.json >/tmp/pr-babysitter-preview.md
+
+      - name: Check Pages metadata
+        run: python scripts/check_pages_metadata.py
+
+      - name: Check internal links
+        run: python scripts/check_internal_links.py
+
+      - name: Check translation sync markers
+        run: python scripts/check_translation_sync.py
+
+      - name: Check links
+        run: python scripts/verify_urls.py . --timeout 12 --workers 20
+
+      - name: Check main commit identity
+        if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+        run: python scripts/check_commit_identity.py
+
+      - name: Open an issue when a scheduled run fails
+        if: failure() && github.event_name == 'schedule'
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          gh issue create \
+            --repo "$GITHUB_REPOSITORY" \
+            --title "Scheduled quality run failed on $(date -u +%Y-%m-%d)" \
+            --body "The weekly quality workflow failed, most likely a dead link or a stale translation sync marker. See the run: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}"

.gitignore

@@ -0,0 +1,2 @@
+__pycache__/
+*.py[cod]

.markdownlint.json

@@ -0,0 +1,5 @@
+{
+  "MD013": false,
+  "MD033": false,
+  "MD060": false
+}

AGENTS.md

@@ -0,0 +1,62 @@
+# Repository Guidance For AI Agents
+
+This repository curates resources for the new AI/coding-agent meaning of **Loop Engineering**.
+
+## Scope
+
+Include resources that help readers design, run, verify, evaluate, or critique recurring AI-agent systems that sit above prompt, context, and harness engineering. A good entry should explain how a loop discovers work, delegates to agents, supplies context, bounds tools and permissions, verifies results, persists state, decides next actions, retries, or escalates.
+
+Do not include unrelated uses of "loop":
+
+- software event loops;
+- UI/game loops;
+- control theory;
+- growth loops;
+- generic workflow automation;
+- non-AI feedback loops.
+
+## Editing Rules
+
+- Keep `README.md` as the canonical English source.
+- Preserve the four-layer framing when editing the intro, scope, or mental model: prompt, context, and harness engineering improve one run; Loop Engineering governs repeated agent work over time.
+- Keep annotations short, specific, and builder-oriented.
+- Prefer primary sources, official docs, papers, and implementation-heavy write-ups.
+- If a resource is generic agent, prompt, context, or harness content, include it only when the annotation clearly explains its loop-design relevance.
+- Update `README.zh-CN.md` only for translated overview content; do not let it drift into a separate resource list unless maintained.
+- When adding a new category, update `README.md`, `CONTRIBUTING.md`, PR templates, and issue templates together.
+- Do not add generated marketing copy or unsupported hype.
+
+## Commit Identity Rule
+
+Never create commits with AI-assistant co-author trailers or any non-owner author/committer identity. All commits in this repository must be authored and committed as `ChaoYue0307 <hechaoyue0307@gmail.com>`.
+
+When committing from an AI agent, do not use plain `git commit` if the environment may append co-author trailers. Create commits with explicit identity instead:
+
+```sh
+git add <files>
+PARENT="$(git rev-parse HEAD)"
+TREE="$(git write-tree)"
+NEW="$(GIT_AUTHOR_NAME='ChaoYue0307' GIT_AUTHOR_EMAIL='hechaoyue0307@gmail.com' GIT_COMMITTER_NAME='ChaoYue0307' GIT_COMMITTER_EMAIL='hechaoyue0307@gmail.com' git commit-tree "$TREE" -p "$PARENT" -m "Commit message")"
+git update-ref refs/heads/main "$NEW" "$PARENT"
+```
+
+Before pushing, verify:
+
+```sh
+python scripts/check_commit_identity.py
+```
+
+## Entry Format
+
+```md
+- 📄 **Paper** [Title](https://example.com) - One sentence explaining the resource's contribution to Loop Engineering.
+```
+
+## Quality Preference
+
+When two sources overlap, prefer:
+
+1. primary source or official docs;
+2. implementation details over commentary;
+3. stable URLs over social posts;
+4. practical loop design over broad AI-agent trend coverage.

ANTI-PATTERNS.md

@@ -0,0 +1,75 @@
+# Loop Engineering Anti-Patterns
+
+Use this page to reject unsafe, vague, or misleading loop designs.
+
+## Prompt Loop With No Contract
+
+**Symptom:** A script repeatedly asks an agent to "keep improving" without a named objective, intake, state, verification, or exit condition.
+
+**Why it fails:** The loop becomes a manual prompting habit disguised as automation.
+
+**Better:** Define the loop contract before running: objective, trigger, intake, workspace, context, delegation, verification, state, budget, escalation, and exit.
+
+## Infinite Retry Loop
+
+**Symptom:** The loop keeps feeding failures back to the agent indefinitely.
+
+**Why it fails:** Cost grows, context degrades, and the loop may repeatedly damage the same files.
+
+**Better:** Set retry budgets per blocker, stop on repeated failures, and escalate with evidence.
+
+## Model Self-Approval
+
+**Symptom:** The same agent that made the change decides that the work is complete.
+
+**Why it fails:** Models can rationalize their own mistakes and miss regressions they introduced.
+
+**Better:** Use deterministic checks, a separate verifier agent, or human review for completion gates.
+
+## Hidden State
+
+**Symptom:** The only memory is inside the conversation.
+
+**Why it fails:** The next run cannot reliably know what was tried, what passed, what failed, or what remains.
+
+**Better:** Persist state in files, issues, comments, checkpoints, traces, or workflow state.
+
+## Unsafe Production Autonomy
+
+**Symptom:** A loop can deploy, roll back, change config, rotate secrets, or modify data without explicit approval boundaries.
+
+**Why it fails:** A small model error can become an operational incident.
+
+**Better:** Make sensitive actions approval-gated and document rollback, escalation, and owner rules.
+
+## Generic Automation Rebranded As Loop Engineering
+
+**Symptom:** A cron job or workflow runs without agentic reasoning, context loading, verification, or stateful next-action decisions.
+
+**Why it fails:** It blurs Loop Engineering with ordinary automation.
+
+**Better:** Call ordinary automation ordinary automation. Use Loop Engineering when repeated agent work is actually being triggered, bounded, verified, persisted, and rerun.
+
+## Context Dump Loop
+
+**Symptom:** Each run gives the agent a huge context bundle instead of a curated state contract.
+
+**Why it fails:** The loop becomes slow, expensive, and hard to debug.
+
+**Better:** Separate durable state from supporting context. Load only the state, docs, examples, and receipts needed for the current objective.
+
+## No Escalation Path
+
+**Symptom:** The loop keeps acting even when it lacks credentials, sees ambiguous product requirements, hits flaky infrastructure, or needs architectural judgment.
+
+**Why it fails:** The agent spends budget where a human decision is required.
+
+**Better:** Define escalation triggers and include the evidence a human needs to take over.
+
+## No Receipts
+
+**Symptom:** The loop says it is done without commands, logs, changed files, trace IDs, dashboard snapshots, reviewer decisions, or links.
+
+**Why it fails:** Maintainers cannot audit the loop or trust its result.
+
+**Better:** Require receipts as part of the exit gate.

CITATION.bib

@@ -0,0 +1,7 @@
+@misc{chaoyue2026awesome_loop_engineering,
+  author       = {He, Chaoyue},
+  title        = {Awesome Loop Engineering},
+  year         = {2026},
+  howpublished = {\url{https://github.com/ChaoYue0307/awesome-loop-engineering}},
+  note         = {Curated resources for Loop Engineering}
+}

CITATION.cff

@@ -0,0 +1,16 @@
+cff-version: 1.2.0
+message: "If this repository is useful in your work, please cite it as below."
+title: "Awesome Loop Engineering"
+type: software
+authors:
+  - family-names: "He"
+    given-names: "Chaoyue"
+repository-code: "https://github.com/ChaoYue0307/awesome-loop-engineering"
+url: "https://chaoyue0307.github.io/awesome-loop-engineering/"
+abstract: "Curated resources and practical patterns for Loop Engineering with AI and coding agents."
+keywords:
+  - loop-engineering
+  - ai-agents
+  - coding-agents
+  - agentic-workflows
+license: CC0-1.0

CODE_OF_CONDUCT.md

@@ -0,0 +1,27 @@
+# Code Of Conduct
+
+Awesome Loop Engineering is a technical curation project. Contributors should help keep discussions accurate, specific, and useful for builders.
+
+## Expected Behavior
+
+- Be respectful and assume good intent.
+- Keep feedback concrete and evidence-based.
+- Prefer primary sources and verifiable claims.
+- Disclose caveats such as vendor bias, paywalls, unstable links, or weak evidence.
+- Respect maintainers' scope decisions when a resource is not specific to AI/coding-agent Loop Engineering.
+
+## Unacceptable Behavior
+
+- Harassment, insults, threats, or discriminatory language.
+- Spam, link farming, or promotional submissions without technical substance.
+- Posting secrets, private customer data, credentials, or internal-only links.
+- Misrepresenting a source, author, benchmark, tool, or affiliation.
+- Repeatedly pushing unrelated event-loop, growth-loop, control-theory, or generic automation content into scope.
+
+## Enforcement
+
+Maintainers may edit, close, or remove issues, pull requests, comments, or links that violate this code of conduct or the repository scope. Serious or repeated violations may lead to blocked participation.
+
+## Reporting
+
+If a discussion becomes unsafe or inappropriate, open an issue with sensitive details removed, or contact the maintainer through GitHub. For security-sensitive concerns, follow `SECURITY.md`.

COMPARISON.md

@@ -0,0 +1,64 @@
+# Comparison Guide
+
+Loop Engineering is easiest to understand by separating it from nearby practices.
+
+## Prompt Engineering vs Loop Engineering
+
+**Prompt Engineering** asks: what should I say to the model now?
+
+**Loop Engineering** asks: what system should discover work, delegate to agents, verify results, persist state, decide next actions, and rerun?
+
+Prompt engineering can be part of a loop instruction, but a good prompt alone is not a loop.
+
+## Context Engineering vs Loop Engineering
+
+**Context Engineering** asks: what state, memory, documents, examples, and tool results should the model see?
+
+**Loop Engineering** asks: when should context be loaded, what state should survive across runs, and how should that state affect the next run?
+
+Context engineering improves the input to an agent. Loop Engineering governs recurring agent work over time.
+
+## Harness Engineering vs Loop Engineering
+
+**Harness Engineering** asks: what tools, permissions, sandboxes, tests, traces, and feedback surround one agent run?
+
+**Loop Engineering** asks: how should repeated agent runs use those harnesses to act, verify, record receipts, retry, and escalate?
+
+Harness engineering makes a run safer and more observable. Loop Engineering decides when and why that run happens again.
+
+## Workflow Automation vs Loop Engineering
+
+**Workflow automation** executes predefined steps.
+
+**Loop Engineering** coordinates agentic work that may require discovery, delegation, tool use, verification, state updates, and next-action decisions.
+
+Many loops use workflow automation. Not every workflow automation is Loop Engineering.
+
+## Agent Workflow vs Loop Engineering
+
+**Agent workflows** describe how models, tools, and agents solve a task.
+
+**Loop Engineering** describes how work recurs: what triggers it, what state persists, what gates completion, when retry is allowed, and when humans take over.
+
+An agent workflow can be the inner mechanism. The loop is the operating system around repeated work.
+
+## Evaluation Loop vs Operational Loop
+
+**Evaluation loops** repeatedly measure and improve prompts, tools, models, or harnesses.
+
+**Operational loops** repeatedly perform engineering work such as PR babysitting, CI repair, docs drift collection, feedback clustering, or deploy verification.
+
+Both are valid Loop Engineering patterns when they have a clear trigger, state, verification, budget, and exit.
+
+## Quick Test
+
+Ask these questions before calling something Loop Engineering:
+
+1. Does it run more than once by design?
+1. Does it discover or receive work from a real source?
+1. Does it delegate work to one or more agents?
+1. Does it verify results with explicit gates?
+1. Does it persist state or receipts outside the model context?
+1. Does it decide whether to repeat, report, escalate, or stop?
+
+If the answer is mostly no, it may be prompt engineering, context engineering, harness engineering, or automation, but it is probably not Loop Engineering.

CONTRIBUTING.md

@@ -0,0 +1,172 @@
+# Contributing
+
+Thanks for helping improve Awesome Loop Engineering.
+
+This repository is intentionally narrow. It tracks the new AI and coding-agent meaning of **Loop Engineering**: the layer above prompt, context, and harness engineering where teams design systems that discover work, delegate to agents, verify outcomes, persist state, decide next actions, and run again on a cadence or until a goal is met.
+
+Before submitting, read the [curation standard](meta/CURATION.md). Maintainers use it to decide whether a resource is specific, stable, and useful enough for the list.
+
+## Quick PR Flow
+
+1. Search `README.md` for the resource title, author, project, and URL.
+1. Confirm the resource is about AI/coding-agent Loop Engineering or a direct foundation for it.
+1. Pick the most specific category.
+1. Add one entry with a resource type label:
+
+```md
+- 📄 **Paper** [Title](https://example.com) - One sentence explaining the resource's contribution to Loop Engineering.
+```
+
+1. Open a PR using the template and explain:
+   - why the resource belongs;
+   - which category it updates;
+   - whether it is a primary source, official documentation, paper, tool, benchmark, playbook, critique, or adjacent list;
+   - the evidence quality tier and resource type label;
+   - any caveat such as vendor bias, paywall, early-stage status, or weak evidence.
+
+## License For Contributions
+
+By contributing to this repository, you agree that your contribution to this repository's curation text, annotations, templates, patterns, metadata, and documentation is released under [CC0-1.0](LICENSE).
+
+Do not copy third-party articles, papers, images, documentation, code, or other content into this repository unless you have the right to do so. Prefer stable links and short original annotations. External resources keep their own licenses and terms.
+
+## What Belongs Here
+
+Good additions usually fit one of these groups:
+
+- Direct explanations of Loop Engineering in the AI/coding-agent sense.
+- Papers that introduce agent loops, reflection, critique, verification, planning, tool use, or memory patterns used by looped agents.
+- Official docs for agent runtimes, hooks, subagents, skills, guardrails, observability, MCP, worktrees, automations, goals, or state persistence.
+- Engineering blogs with concrete implementation details, failure modes, or production lessons.
+- Benchmarks and eval systems for long-horizon, tool-using, or coding agents.
+- Playbooks for recurring agent work such as PR babysitting, CI repair, issue triage, deploy verification, bug hunting, docs drift collection, and feedback clustering.
+- Critiques that clarify when loops are risky, wasteful, or not yet justified.
+- Translation improvements that make the concept accessible without changing the scope.
+
+## What Does Not Belong Here
+
+Please avoid submitting:
+
+- Software event loops, UI event loops, game loops, control theory loops, growth loops, or generic feedback-loop content unless it is explicitly applied to AI agent loops.
+- Generic prompt engineering resources with no loop, tool, verification, state, or scheduling angle.
+- Generic context or harness engineering resources unless they directly explain how repeated agent runs are triggered, verified, persisted, or governed.
+- Resources that only improve single-turn prompts belong in prompt-engineering lists unless they show scheduling, state, verification, retries, or escalation.
+- Generic agent news, product launches, or listicles without technical substance.
+- Private, unstable, or paywalled sources that most readers cannot inspect.
+- Duplicate resources already covered by an existing entry.
+- Pure marketing pages with no reusable technical insight.
+
+## Evidence Quality
+
+Prefer higher tiers when two resources cover the same idea.
+
+| Tier | Source type | Examples |
+| --- | --- | --- |
+| A | Primary source or official docs | Tool docs, paper, project README, author write-up |
+| B | Practitioner write-up with implementation detail | Field notes, playbooks, postmortems |
+| C | Curated survey or high-quality explainer | Taxonomy, comparison, tutorial |
+| D | Commentary or news coverage | Useful only when it documents origin, adoption, or debate |
+
+If two links say the same thing, prefer the more primary, practical, stable, and implementation-oriented one.
+
+## Quality Labels
+
+Use these labels in PR descriptions and issue suggestions when they help reviewers understand why a resource belongs:
+
+- **Primary source**: written by the original author, project, vendor, or research team.
+- **Official docs**: documentation for a runtime, SDK, API, benchmark, or platform.
+- **Implementation-heavy**: includes code, architecture, commands, traces, or operational details.
+- **Foundational**: explains a core loop mechanism such as ReAct, reflection, planning, state, or verification.
+- **Cautionary**: clarifies limitations, risks, cost, safety, or when not to use loops.
+- **Adjacent**: useful context from prompt, context, harness, eval, or agent engineering.
+
+## Category Guidance
+
+- Use **Start Here** only for direct Loop Engineering explainers.
+- Use **The Loop Contract** and **Loop Maturity Model** only for framework-level content, not individual links.
+- Use **Core Loop Primitives** for automations, goals, worktrees, hooks, skills, connectors, subagents, and state files.
+- Use **Official Runtime Guides** for primary-source docs from tool builders.
+- Use **Research Foundations** for papers and reference implementations that explain the mechanics behind agent loops.
+- Use **Agent Workflow Patterns** for general workflow architecture, durable execution, and official guidance.
+- Use **Coding-Agent Loop Systems** for systems that run agents over repositories, terminals, code, or software issues.
+- Use **Verification And Feedback Gates** for tests, evals, CI, tracing, guardrails, deterministic checks, and LLM-as-judge caveats.
+- Use **State, Memory, And Context Persistence** for durable state, checkpoints, context, progress files, and memory.
+- Use **Orchestration And Multi-Agent Delegation** for subagents, handoffs, manager-worker loops, and workflow runtimes.
+- Use **Benchmarks And Evaluation** for benchmarks that measure agent behavior over multi-step tasks.
+- Use **Operations Playbooks** for recurring engineering jobs run by agents.
+- Use **Templates And Patterns** for reusable pattern docs hosted in this repository.
+- Use **Critiques, Risks, And Limitations** for thoughtful warnings and failure analysis.
+- Use **Adjacent Awesome Lists** for neighboring maps, not individual resources.
+
+## Annotation Style
+
+Keep annotations short, specific, and builder-oriented.
+
+Use the resource type legend from `README.md`:
+
+- 📄 **Paper**
+- 📝 **Blog**
+- 📚 **Docs**
+- 🧰 **Tool**
+- 🧪 **Benchmark**
+- 🔁 **Pattern**
+- 🧾 **Template**
+- 🧭 **List**
+- ⚠️ **Critique**
+
+Prefer:
+
+```md
+- 🔁 **Pattern** [Autonomous Loops](https://example.com) - Shows how to combine task files, stop hooks, limits, and kill switches into a self-continuing agent loop.
+```
+
+Avoid:
+
+```md
+- 📝 **Blog** [Cool Agent Article](https://example.com) - Interesting article about AI.
+```
+
+## Adding A Loop Pattern
+
+For a practical loop pattern, use [`templates/loop-pattern.md`](templates/loop-pattern.md), optionally structure it with [`schemas/loop-contract.schema.json`](schemas/loop-contract.schema.json), and place the finished pattern in [`patterns/`](patterns/). A good pattern names:
+
+- objective;
+- trigger;
+- intake source;
+- agents and roles;
+- workspace and permissions;
+- verification gates;
+- durable state;
+- budget and exit conditions;
+- escalation path;
+- loop instruction, automation spec, hook config, or scheduled command;
+- failure modes.
+
+Pattern PRs should be concrete enough that a reader can adapt them to an agent runtime without guessing the loop contract. If you want feedback before writing the full pattern, open a loop pattern suggestion issue.
+
+## Translation Contributions
+
+See [TRANSLATIONS.md](TRANSLATIONS.md).
+
+Translation PRs should:
+
+- link back to the canonical English README;
+- preserve the narrow AI/coding-agent scope;
+- keep resource URLs unchanged;
+- update language navigation if a new language file is added;
+- explain who can help maintain the translation.
+
+## Issues
+
+If you do not want to open a PR, use the resource suggestion issue template. Please include:
+
+- title and URL;
+- suggested category;
+- resource type label;
+- evidence quality tier;
+- why it is relevant to Loop Engineering;
+- whether it is a direct Loop Engineering source, official docs, paper, engineering note, tool, benchmark, critique, or translation.
+
+## Review Standard
+
+Maintainers may ask for stronger relevance, a more precise category, a better annotation, or removal of promotional language. The goal is to keep the list useful for people designing real agent loops, not to collect every AI-agent link on the internet.

DEFINITION.md

@@ -0,0 +1,33 @@
+# Canonical Definition
+
+Use this page when you need a short, stable definition of Loop Engineering.
+
+## Short Definition
+
+**Loop Engineering** is the AI and coding-agent practice of designing recurring systems that discover work, delegate it to agents, verify results, persist state, decide next actions, and run again on a cadence, event, or until a verifiable goal is reached.
+
+## One-Sentence Positioning
+
+Prompt engineering improves what you ask the model, context engineering improves what the model can see, harness engineering improves the environment around one agent run, and Loop Engineering governs repeated agent work over time.
+
+## Longer Definition
+
+Loop Engineering sits above prompt, context, and harness engineering. It turns agent work from turn-by-turn human prompting into a reviewable operating contract: what starts the loop, where work comes from, which agents act, what context and tools they receive, how results are verified, what state survives, when retry is allowed, and when a human takes over.
+
+## Minimal Loop Test
+
+A system is probably practicing Loop Engineering when it can answer:
+
+1. What triggers the loop?
+1. How does it discover or receive work?
+1. What context and tools does it give the agent?
+1. What is the workspace and permission boundary?
+1. What verifies success or failure?
+1. What state persists across runs?
+1. What budget limits retries, time, or cost?
+1. What causes escalation?
+1. What condition ends the loop?
+
+## Citation Note
+
+If you cite this repository, use the BibTeX entry in [`README.md`](README.md#citation) or [`CITATION.bib`](CITATION.bib). If you quote the concept definition, prefer linking to this page so readers can see the scope boundary.

LICENSE

@@ -0,0 +1,121 @@
+Creative Commons Legal Code
+
+CC0 1.0 Universal
+
+    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+    HEREUNDER.
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator
+and subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for
+the purpose of contributing to a commons of creative, cultural and
+scientific works ("Commons") that the public can reliably and without fear
+of later claims of infringement build upon, modify, incorporate in other
+works, reuse and redistribute as freely as possible in any form whatsoever
+and for any purposes, including without limitation commercial purposes.
+These owners may contribute to the Commons to promote the ideal of a free
+culture and the further production of creative, cultural and scientific
+works, or to gain reputation or greater distribution for their Work in
+part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any
+expectation of additional consideration or compensation, the person
+associating CC0 with a Work (the "Affirmer"), to the extent that he or she
+is an owner of Copyright and Related Rights in the Work, voluntarily
+elects to apply CC0 to the Work and publicly distribute the Work under its
+terms, with knowledge of his or her Copyright and Related Rights in the
+Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not
+limited to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display,
+     communicate, and translate a Work;
+ ii. moral rights retained by the original author(s) and/or performer(s);
+iii. publicity and privacy rights pertaining to a person's image or
+     likeness depicted in a Work;
+ iv. rights protecting against unfair competition in regards to a Work,
+     subject to the limitations in paragraph 4(a), below;
+  v. rights protecting the extraction, dissemination, use and reuse of data
+     in a Work;
+ vi. database rights (such as those arising under Directive 96/9/EC of the
+     European Parliament and of the Council of 11 March 1996 on the legal
+     protection of databases, and under any national implementation
+     thereof, including any amended or successor version of such
+     directive); and
+vii. other similar, equivalent or corresponding rights throughout the
+     world based on applicable law or treaty, and any national
+     implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention
+of, applicable law, Affirmer hereby overtly, fully, permanently,
+irrevocably and unconditionally waives, abandons, and surrenders all of
+Affirmer's Copyright and Related Rights and associated claims and causes
+of action, whether now known or unknown (including existing as well as
+future claims and causes of action), in the Work (i) in all territories
+worldwide, (ii) for the maximum duration provided by applicable law or
+treaty (including future time extensions), (iii) in any current or future
+medium and for any number of copies, and (iv) for any purpose whatsoever,
+including without limitation commercial, advertising or promotional
+purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
+member of the public at large and to the detriment of Affirmer's heirs and
+successors, fully intending that such Waiver shall not be subject to
+revocation, rescission, cancellation, termination, or any other legal or
+equitable action to disrupt the quiet enjoyment of the Work by the public
+as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason
+be judged legally invalid or ineffective under applicable law, then the
+Waiver shall be preserved to the maximum extent permitted taking into
+account Affirmer's express Statement of Purpose. In addition, to the
+extent the Waiver is so judged Affirmer hereby grants to each affected
+person a royalty-free, non transferable, non sublicensable, non exclusive,
+irrevocable and unconditional license to exercise Affirmer's Copyright and
+Related Rights in the Work (i) in all territories worldwide, (ii) for the
+maximum duration provided by applicable law or treaty (including future
+time extensions), (iii) in any current or future medium and for any number
+of copies, and (iv) for any purpose whatsoever, including without
+limitation commercial, advertising or promotional purposes (the
+"License"). The License shall be deemed effective as of the date CC0 was
+applied by Affirmer to the Work. Should any part of the License for any
+reason be judged legally invalid or ineffective under applicable law, such
+partial invalidity or ineffectiveness shall not invalidate the remainder
+of the License, and in such case Affirmer hereby affirms that he or she
+will not (i) exercise any of his or her remaining Copyright and Related
+Rights in the Work or (ii) assert any associated claims and causes of
+action with respect to the Work, in either case contrary to Affirmer's
+express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+ a. No trademark or patent rights held by Affirmer are waived, abandoned,
+    surrendered, licensed or otherwise affected by this document.
+ b. Affirmer offers the Work as-is and makes no representations or
+    warranties of any kind concerning the Work, express, implied,
+    statutory or otherwise, including without limitation warranties of
+    title, merchantability, fitness for a particular purpose, non
+    infringement, or the absence of latent or other defects, accuracy, or
+    the present or absence of errors, whether or not discoverable, all to
+    the greatest extent permissible under applicable law.
+ c. Affirmer disclaims responsibility for clearing rights of other persons
+    that may apply to the Work or any use thereof, including without
+    limitation any person's Copyright and Related Rights in the Work.
+    Further, Affirmer disclaims responsibility for obtaining any necessary
+    consents, permissions or other rights required for any use of the
+    Work.
+ d. Affirmer understands and acknowledges that Creative Commons is not a
+    party to this document and has no duty or obligation with respect to
+    this CC0 or use of the Work.

MAINTAINER_PICKS.md

@@ -0,0 +1,28 @@
+# Maintainer Picks
+
+Start here if you want a compact path through the repository.
+
+## Concept
+
+- [Loop Engineering](https://addyosmani.com/blog/loop-engineering/) - Direct framing of Loop Engineering as the layer above manual prompting and one floor above harness engineering.
+- [Canonical Definition](DEFINITION.md) - Stable definition and scope test for quoting or explaining the concept.
+- [Loop Engineering Manifesto](MANIFESTO.md) - Short statement of principles, non-goals, and success criteria.
+
+## Practice
+
+- [Run long horizon tasks with Codex](https://developers.openai.com/blog/run-long-horizon-tasks-with-codex) - Practical plan-edit-test-observe-repair-document-repeat runbook.
+- [Run prompts on a schedule](https://code.claude.com/docs/en/scheduled-tasks) - Scheduled loop mechanics for recurring prompts, monitors, reminders, and `/loop`.
+- [PR babysitter pattern](patterns/pr-babysitter.md) - Concrete operational pattern for PR comments, CI, conflicts, and merge readiness.
+- [CI repair loop pattern](patterns/ci-repair-loop.md) - Concrete operational pattern for turning failing checks into narrow verified patches.
+
+## Reliability
+
+- [Stop Babysitting Your Coding Agent. Give It Backpressure.](https://generativeprogrammer.com/p/stop-babysitting-your-coding-agent) - Turns tests, linters, builds, traces, and other signals into feedback loops.
+- [Building effective agents](https://www.anthropic.com/engineering/building-effective-agents) - Canonical workflow patterns and caution against unnecessary complexity.
+- [Loop Engineering Anti-Patterns](ANTI-PATTERNS.md) - Failure modes to avoid before running agents repeatedly.
+
+## Reusable Artifacts
+
+- [Loop contract schema](schemas/loop-contract.schema.json) - Machine-readable contract for recurring agent loops.
+- [Example loop specs](examples/README.md) - Validated PR babysitter, CI repair, and docs drift loop examples.
+- [Loop Gallery](gallery/README.md) - Community format for sharing real or anonymized loop examples.

MANIFESTO.md

@@ -0,0 +1,42 @@
+# Loop Engineering Manifesto
+
+Loop Engineering is the practice of designing recurring AI-agent systems that sit above prompt, context, and harness engineering.
+
+Prompt engineering improves what you ask the model. Context engineering improves what the model can see. Harness engineering improves the tools, permissions, sandboxes, and checks around one agent run. Loop Engineering connects those layers over time: it defines when agents run, what work they discover, how work is delegated, how results are verified, what state survives, and when the system repeats, reports, or escalates.
+
+## Why It Exists
+
+The leverage point in agent work is moving from writing better one-off prompts to designing better recurring systems. A useful loop can notice work, load the right context, act in an isolated workspace, verify against explicit gates, record receipts, and continue later without relying on a human to remember every intermediate step.
+
+This does not remove engineering judgment. It moves judgment into the loop contract: objective, trigger, intake, workspace, context, delegation, verification, state, budget, escalation, and exit.
+
+## Core Commitments
+
+- **Design the system, not just the next prompt.** The human should specify the operating contract, not manually steer every turn.
+- **Make state external.** Progress files, issue comments, traces, checkpoints, and dashboards should outlive the model context.
+- **Separate maker from checker.** The system that acts should not be the only system that decides whether the work is done.
+- **Prefer deterministic gates.** Tests, typechecks, evals, dashboards, trace graders, and reviewer decisions are stronger than "looks good".
+- **Bound autonomy.** Loops need budgets, allowed actions, disallowed actions, stop conditions, and escalation paths.
+- **Keep receipts.** A loop should explain what it saw, what it changed, what it ran, what passed, what failed, and why it stopped.
+- **Stay responsible.** A loop can delegate work, but ownership of quality, safety, and product judgment remains human.
+
+## What It Is Not
+
+Loop Engineering is not a new name for every agent, cron job, workflow, or feedback system. It is not software event loops, growth loops, control theory, or generic automation. It is also not prompt engineering with repetition. A loop needs a trigger, work intake, durable state, verification, budget, and exit condition.
+
+## Success Standard
+
+A Loop Engineering artifact is useful when another builder can answer:
+
+1. What starts the loop?
+1. How does it discover work?
+1. Which agent or role does what?
+1. What context and tools are available?
+1. What can it change safely?
+1. What verifies success or failure?
+1. What state is persisted for the next run?
+1. What is the retry budget?
+1. When does it escalate?
+1. When is it done?
+
+If those answers are visible, the loop can be reviewed, shared, improved, and trusted.

QUOTES.md

@@ -0,0 +1,47 @@
+# Sourced Signals And Quotes
+
+This page records short sourced signals around the emerging Loop Engineering concept. It is not a substitute for the original sources. Use it to understand provenance, then read the linked material directly.
+
+## Addy Osmani
+
+Source: [Loop Engineering](https://addyosmani.com/blog/loop-engineering/)
+
+> "Loop engineering is replacing yourself as the person who prompts the agent. You design the system that does it instead."
+
+Why it matters: This is a direct definition of the shift from manual prompting to designing the recurring system that prompts, checks, and continues.
+
+The same article states:
+
+> "Loop engineering sits one floor above the harness."
+
+Why it matters: This anchors the repository's four-layer framing: prompt, context, and harness engineering improve agent runs; Loop Engineering governs repeated agent work over time.
+
+## Peter Steinberger
+
+Source: Addy Osmani's [Loop Engineering](https://addyosmani.com/blog/loop-engineering/) article reports this statement from Peter Steinberger.
+
+> "You shouldn’t be prompting coding agents anymore. You should be designing loops that prompt your agents."
+
+Why it matters: This is one of the clearest formulations of the human role moving from turn-by-turn prompting to loop design.
+
+## Boris Cherny
+
+Source: [I Now Just Write Loops To Prompt Claude Code: Claude Code Creator Boris Cherny](https://officechai.com/ai/i-now-just-write-loops-to-prompt-claude-code-claude-code-creator-boris-cherny/)
+
+> "Now it’s actually leveled up, I think, again, to the next wave of abstraction where I don’t prompt Claude anymore. I have loops that are running. They’re the ones that are prompting Claude and figuring out what to do. My job is to write loops."
+
+Why it matters: This is the practical workflow claim behind the concept: the developer designs the system that prompts, evaluates, and decides what to do next.
+
+## Anthropic
+
+Source: [Building effective agents](https://www.anthropic.com/engineering/building-effective-agents)
+
+> "Consistently, the most successful implementations use simple, composable patterns rather than complex frameworks."
+
+Why it matters: Loop Engineering should stay contract-driven and composable. The goal is not to add complexity for its own sake.
+
+The same article also states:
+
+> "When building applications with LLMs, we recommend finding the simplest solution possible, and only increasing complexity when needed."
+
+Why it matters: This supports a conservative maturity path: start with explicit state and verification before adding multi-agent orchestration or production autonomy.

README.de.md

@@ -0,0 +1,98 @@
+# Awesome Loop Engineering
+
+<!-- last-synced: 2026-06-11 -->
+
+<p align="center">
+  <img src="assets/awesome-loop-engineering-cover.png" alt="Awesome Loop Engineering cover" width="100%">
+</p>
+
+<p align="center">
+  <a href="README.md">English</a> |
+  <a href="README.zh-CN.md">中文</a> |
+  <a href="README.es.md">Español</a> |
+  <a href="README.fr.md">Français</a> |
+  <a href="README.de.md">Deutsch</a> |
+  <a href="README.ja.md">日本語</a> |
+  <a href="README.ko.md">한국어</a> |
+  <a href="README.pt-BR.md">Português</a> |
+  <a href="TRANSLATIONS.md">Beim Übersetzen helfen</a>
+</p>
+
+> Eine kuratierte, umsetzungsorientierte Liste für **Loop Engineering**: die Ebene oberhalb von Prompt Engineering, Context Engineering und Harness Engineering zum Entwerfen wiederkehrender KI-Agenten-Systeme.
+
+Prompt Engineering verbessert, was man dem Modell sagt. Context Engineering verbessert, was das Modell sehen kann. Harness Engineering verbessert Werkzeuge, Berechtigungen, Sandboxes und Prüfungen rund um einen einzelnen Agentenlauf. **Loop Engineering liegt über allen drei Ebenen**: Es entwirft Systeme, die Agenten auslösen, überwachen, Ergebnisse prüfen, Zustand speichern und erneut laufen.
+
+Ein Loop entdeckt Arbeit, übergibt sie an einen oder mehrere Agenten, prüft das Ergebnis, speichert Zustand, entscheidet den nächsten Schritt und läuft erneut nach Zeitplan oder bis ein überprüfbares Ziel erreicht ist.
+
+Dieses Repository behandelt die neue Bedeutung von Loop Engineering im Kontext von KI-Agenten und Coding Agents. Es geht nicht um Software-Event-Loops, Regelungstechnik, Growth Loops, generische Automatisierung oder nicht-KI-bezogene Feedback-Loops.
+
+## Mentales Modell
+
+- Prompt Engineering fragt: Was soll ich dem Modell sagen?
+- Context Engineering fragt: Welchen Zustand und welches Wissen soll das Modell sehen?
+- Harness Engineering fragt: Welche Werkzeuge, Berechtigungen, Tests, Sandboxes und Feedback-Signale sollen den Agenten umgeben?
+- Loop Engineering fragt: Welches wiederkehrende System soll Arbeit entdecken, an Agenten delegieren, Ergebnisse prüfen, Zustand speichern, nächste Aktionen entscheiden und erneut laufen?
+
+Prompt, Context und Harness Engineering verbessern einen einzelnen Lauf. Loop Engineering macht Agentenarbeit über Zeit wiederholbar, beobachtbar und steuerbar.
+
+## Loop Contract
+
+Ein nützlicher Loop macht normalerweise diese Bestandteile sichtbar:
+
+| Teil              | Designfrage                                      | Typisches Artefakt                                          |
+| ----------------- | ------------------------------------------------ | ----------------------------------------------------------- |
+| Objective         | Was soll der Loop optimieren?                    | Goal, issue, PRD, runbook                                   |
+| Trigger           | Wann läuft der Loop?                             | Schedule, webhook, `/loop`, `/goal`, automation             |
+| Discover / Intake | Wie findet der Loop Arbeit?                      | GitHub query, Linear filter, CI failure, feedback stream    |
+| Workspace         | Wo kann der Agent sicher handeln?                | Worktree, sandbox, branch, container                        |
+| Context           | Welches dauerhafte Wissen wird geladen?          | `AGENTS.md`, `CLAUDE.md`, `SKILL.md`, docs                  |
+| Delegation        | Welcher Agent übernimmt welche Aufgabe?          | Explorer, implementer, reviewer, judge                      |
+| Verification      | Was entscheidet über Erfolg oder Fehler?         | Tests, typecheck, lint, evals, trace graders                |
+| State             | Was bleibt für den nächsten Lauf erhalten?       | Progress file, checkpoint, trace, issue comment             |
+| Budget            | Wann soll der Loop aufhören zu verbrauchen?      | Max turns, max retries, token budget, time box              |
+| Escalation        | Wann übernimmt ein Mensch?                       | PR, issue, Slack alert, triage inbox                        |
+| Exit              | Woher weiß der Loop, dass er fertig ist?         | Acceptance criteria, passing checks, no work found          |
+
+## Reifegradmodell
+
+| Stufe | Name                       | Beschreibung                                                                                  |
+| ----- | -------------------------- | --------------------------------------------------------------------------------------------- |
+| 0     | Manual prompting           | Ein Mensch liest den Zustand und schreibt den nächsten Prompt.                                |
+| 1     | Scripted retry             | Ein Skript gibt Fehler an den Agenten zurück.                                                 |
+| 2     | Scheduled loop             | Der Agent läuft nach Zeitplan und berichtet Ergebnisse.                                       |
+| 3     | Stateful loop              | Fortschritt bleibt über Dateien, Issues, Checkpoints oder Traces erhalten.                    |
+| 4     | Self-verifying loop        | Deterministische Checks oder Evaluator-Agenten blockieren falsche Abschlüsse.                 |
+| 5     | Multi-agent loop           | Spezialisierte Agenten teilen Discovery, Implementierung, Review und Urteil auf.              |
+| 6     | Production-supervised loop | Observability, Budgets, Freigaben, Rollback und menschliche Eskalation sind zentral.          |
+
+## Erste Lektüre
+
+Die vollständige Ressourcenliste bleibt im kanonischen englischen README: [README.md](README.md).
+
+Empfohlene Einstiege:
+
+- [Loop Engineering](https://addyosmani.com/blog/loop-engineering/) - Direkte Definition des Wechsels von manuellem Prompting zu Systemen, die prompten, prüfen und fortsetzen.
+- [Run long horizon tasks with Codex](https://developers.openai.com/blog/run-long-horizon-tasks-with-codex) - Praktischer Leitfaden für plan-edit-test-observe-repair-document-repeat.
+- [Run prompts on a schedule](https://code.claude.com/docs/en/scheduled-tasks) - Offizielle Mechanik für `/loop`, geplante Aufgaben und wiederkehrende Prompts.
+- [Building Effective Agents](https://www.anthropic.com/engineering/building-effective-agents) - Komponierbare Patterns für Workflows und Agenten.
+
+## Beitragen
+
+Beiträge sind willkommen. Bitte lies [CONTRIBUTING.md](CONTRIBUTING.md), bevor du einen Pull Request öffnest.
+
+Schneller Ablauf:
+
+1. Prüfe, ob die Ressource Loop Engineering für KI-Agenten/Coding Agents oder eine direkte Grundlage dafür behandelt.
+1. Suche im README, um Duplikate zu vermeiden.
+1. Wähle die spezifischste Kategorie.
+1. Füge einen Eintrag in diesem Format hinzu:
+
+```md
+- 📄 **Paper** [Title](https://example.com) - One sentence explaining the resource's contribution to Loop Engineering.
+```
+
+1. Erkläre im PR Relevanz, Kategorie, Ressourcentyp und Nutzen für Builders.
+
+## Übersetzungen
+
+Wenn du eine Sprache pflegen oder hinzufügen möchtest, lies [TRANSLATIONS.md](TRANSLATIONS.md). Übersetzungen müssen den engen Scope bewahren und dürfen Event Loops, Growth Loops oder generische Automatisierung nicht in den Umfang ziehen.

README.es.md

@@ -0,0 +1,98 @@
+# Awesome Loop Engineering
+
+<!-- last-synced: 2026-06-11 -->
+
+<p align="center">
+  <img src="assets/awesome-loop-engineering-cover.png" alt="Awesome Loop Engineering cover" width="100%">
+</p>
+
+<p align="center">
+  <a href="README.md">English</a> |
+  <a href="README.zh-CN.md">中文</a> |
+  <a href="README.es.md">Español</a> |
+  <a href="README.fr.md">Français</a> |
+  <a href="README.de.md">Deutsch</a> |
+  <a href="README.ja.md">日本語</a> |
+  <a href="README.ko.md">한국어</a> |
+  <a href="README.pt-BR.md">Português</a> |
+  <a href="TRANSLATIONS.md">Ayudar a traducir</a>
+</p>
+
+> Una lista curada y orientada a la implementación para **Loop Engineering**: la capa por encima de prompt, context y harness engineering para diseñar sistemas recurrentes de agentes de IA.
+
+Prompt engineering mejora lo que le pides al modelo. Context engineering mejora lo que el modelo puede ver. Harness engineering mejora las herramientas, permisos, sandboxes y verificaciones alrededor de una ejecución de agente. **Loop Engineering está por encima de las tres**: diseña sistemas que activan agentes, los supervisan, verifican resultados, guardan estado y vuelven a ejecutarse.
+
+Un loop descubre trabajo, lo delega a uno o más agentes, verifica el resultado, registra estado, decide la siguiente acción y vuelve a ejecutarse con una cadencia o hasta alcanzar un objetivo verificable.
+
+Este repositorio se centra en el significado nuevo de Loop Engineering para agentes de IA y coding agents. No trata sobre event loops de software, teoría de control, growth loops, automatización genérica o feedback loops no relacionados con IA.
+
+## Modelo Mental
+
+- Prompt engineering pregunta: ¿qué debería decirle al modelo?
+- Context engineering pregunta: ¿qué estado y conocimiento debería ver el modelo?
+- Harness engineering pregunta: ¿qué herramientas, permisos, pruebas, sandboxes y feedback deberían rodear al agente?
+- Loop engineering pregunta: ¿qué sistema recurrente debería descubrir trabajo, delegarlo a agentes, verificar resultados, persistir estado, decidir siguientes acciones y volver a ejecutarse?
+
+Prompt, context y harness engineering mejoran una ejecución. Loop Engineering hace que el trabajo de agentes sea repetible, observable y gobernable en el tiempo.
+
+## Loop Contract
+
+Un loop útil normalmente necesita estas partes:
+
+| Parte             | Pregunta de diseño                         | Artefacto común                                             |
+| ----------------- | ------------------------------------------ | ----------------------------------------------------------- |
+| Objective         | ¿Qué debe optimizar el loop?               | Goal, issue, PRD, runbook                                   |
+| Trigger           | ¿Cuándo se ejecuta?                        | Schedule, webhook, `/loop`, `/goal`, automation             |
+| Discover / Intake | ¿Cómo encuentra trabajo?                   | GitHub query, Linear filter, CI failure, feedback stream    |
+| Workspace         | ¿Dónde puede actuar el agente con cuidado? | Worktree, sandbox, branch, container                        |
+| Context           | ¿Qué conocimiento durable debe cargar?     | `AGENTS.md`, `CLAUDE.md`, `SKILL.md`, docs                  |
+| Delegation        | ¿Qué agente hace cada parte?               | Explorer, implementer, reviewer, judge                      |
+| Verification      | ¿Qué decide éxito o fallo?                 | Tests, typecheck, lint, evals, trace graders                |
+| State             | ¿Qué sobrevive a la siguiente iteración?   | Progress file, checkpoint, trace, issue comment             |
+| Budget            | ¿Cuándo debe dejar de gastar?              | Max turns, max retries, token budget, time box              |
+| Escalation        | ¿Cuándo interviene una persona?            | PR, issue, Slack alert, triage inbox                        |
+| Exit              | ¿Cómo sabe que terminó?                    | Acceptance criteria, passing checks, no work found          |
+
+## Modelo de Madurez
+
+| Nivel | Nombre                     | Descripción                                                                               |
+| ----- | -------------------------- | ----------------------------------------------------------------------------------------- |
+| 0     | Manual prompting           | Una persona lee el estado y escribe el siguiente prompt.                                  |
+| 1     | Scripted retry             | Un script devuelve errores al agente.                                                     |
+| 2     | Scheduled loop             | El agente corre con una cadencia y reporta resultados.                                    |
+| 3     | Stateful loop              | El progreso sobrevive mediante archivos, issues, checkpoints o traces.                    |
+| 4     | Self-verifying loop        | Verificaciones deterministas o evaluadores bloquean un cierre incorrecto.                 |
+| 5     | Multi-agent loop           | Agentes especializados dividen descubrimiento, implementación, revisión y juicio.         |
+| 6     | Production-supervised loop | Observabilidad, presupuestos, aprobaciones, rollback y escalación humana son centrales.   |
+
+## Por Dónde Empezar
+
+La lista completa de recursos vive en el README canónico en inglés: [README.md](README.md).
+
+Recursos iniciales recomendados:
+
+- [Loop Engineering](https://addyosmani.com/blog/loop-engineering/) - Definición directa del cambio desde prompting manual hacia sistemas que prompt, verifican y continúan.
+- [Run long horizon tasks with Codex](https://developers.openai.com/blog/run-long-horizon-tasks-with-codex) - Guía práctica para ciclos plan-edit-test-observe-repair-document-repeat.
+- [Run prompts on a schedule](https://code.claude.com/docs/en/scheduled-tasks) - Mecánica oficial para `/loop`, tareas programadas y prompts recurrentes.
+- [Building Effective Agents](https://www.anthropic.com/engineering/building-effective-agents) - Patrones composables para workflows y agentes.
+
+## Contribuir
+
+Las contribuciones son bienvenidas. Lee [CONTRIBUTING.md](CONTRIBUTING.md) antes de abrir un pull request.
+
+Proceso rápido:
+
+1. Confirma que el recurso trata de Loop Engineering para agentes de IA/coding agents o de una base directa para ello.
+1. Busca en el README para evitar duplicados.
+1. Elige la categoría más específica.
+1. Añade una entrada con este formato:
+
+```md
+- 📄 **Paper** [Title](https://example.com) - One sentence explaining the resource's contribution to Loop Engineering.
+```
+
+1. Explica en el PR la relevancia, la categoría, el tipo de recurso y por qué ayuda a builders.
+
+## Traducciones
+
+Para mantener o añadir un idioma, lee [TRANSLATIONS.md](TRANSLATIONS.md). Las traducciones deben conservar el alcance estrecho: no mezclar event loops, growth loops ni automatización genérica.

README.fr.md

@@ -0,0 +1,98 @@
+# Awesome Loop Engineering
+
+<!-- last-synced: 2026-06-11 -->
+
+<p align="center">
+  <img src="assets/awesome-loop-engineering-cover.png" alt="Awesome Loop Engineering cover" width="100%">
+</p>
+
+<p align="center">
+  <a href="README.md">English</a> |
+  <a href="README.zh-CN.md">中文</a> |
+  <a href="README.es.md">Español</a> |
+  <a href="README.fr.md">Français</a> |
+  <a href="README.de.md">Deutsch</a> |
+  <a href="README.ja.md">日本語</a> |
+  <a href="README.ko.md">한국어</a> |
+  <a href="README.pt-BR.md">Português</a> |
+  <a href="TRANSLATIONS.md">Aider à traduire</a>
+</p>
+
+> Une liste organisée et orientée implémentation pour **Loop Engineering** : la couche au-dessus du prompt engineering, du context engineering et du harness engineering pour concevoir des systèmes récurrents d'agents IA.
+
+Le prompt engineering améliore ce que l'on demande au modèle. Le context engineering améliore ce que le modèle peut voir. Le harness engineering améliore les outils, permissions, sandboxes et vérifications autour d'une exécution d'agent. **Loop Engineering se situe au-dessus des trois** : il conçoit des systèmes qui déclenchent des agents, les supervisent, vérifient les résultats, persistent l'état et relancent le travail.
+
+Un loop découvre du travail, le délègue à un ou plusieurs agents, vérifie le résultat, enregistre l'état, décide de l'action suivante et se relance selon une cadence ou jusqu'à atteindre un objectif vérifiable.
+
+Ce dépôt concerne le nouveau sens de Loop Engineering dans le contexte des agents IA et coding agents. Il ne concerne pas les event loops logiciels, la théorie du contrôle, les growth loops, l'automatisation générique ou les feedback loops non liés à l'IA.
+
+## Modèle Mental
+
+- Prompt engineering demande : que faut-il dire au modèle ?
+- Context engineering demande : quel état et quelles connaissances le modèle doit-il voir ?
+- Harness engineering demande : quels outils, permissions, tests, sandboxes et signaux de feedback doivent entourer l'agent ?
+- Loop engineering demande : quel système récurrent doit découvrir le travail, déléguer aux agents, vérifier les résultats, persister l'état, décider des prochaines actions et se relancer ?
+
+Prompt, context et harness engineering améliorent une exécution. Loop Engineering rend le travail des agents répétable, observable et gouvernable dans le temps.
+
+## Loop Contract
+
+Un loop utile rend généralement visibles ces éléments :
+
+| Élément           | Question de conception                       | Artefact courant                                            |
+| ----------------- | -------------------------------------------- | ----------------------------------------------------------- |
+| Objective         | Que doit optimiser le loop ?                 | Goal, issue, PRD, runbook                                   |
+| Trigger           | Quand le loop s'exécute-t-il ?               | Schedule, webhook, `/loop`, `/goal`, automation             |
+| Discover / Intake | Comment le loop trouve-t-il le travail ?     | GitHub query, Linear filter, CI failure, feedback stream    |
+| Workspace         | Où l'agent peut-il agir en sécurité ?        | Worktree, sandbox, branch, container                        |
+| Context           | Quelles connaissances durables charger ?     | `AGENTS.md`, `CLAUDE.md`, `SKILL.md`, docs                  |
+| Delegation        | Quel agent fait quoi ?                       | Explorer, implementer, reviewer, judge                      |
+| Verification      | Qu'est-ce qui décide succès ou échec ?       | Tests, typecheck, lint, evals, trace graders                |
+| State             | Qu'est-ce qui survit au prochain passage ?   | Progress file, checkpoint, trace, issue comment             |
+| Budget            | Quand faut-il arrêter de consommer ?         | Max turns, max retries, token budget, time box              |
+| Escalation        | Quand une personne doit-elle reprendre ?     | PR, issue, Slack alert, triage inbox                        |
+| Exit              | Comment sait-on que le loop est terminé ?    | Acceptance criteria, passing checks, no work found          |
+
+## Modèle de Maturité
+
+| Niveau | Nom                        | Description                                                                                 |
+| ------ | -------------------------- | ------------------------------------------------------------------------------------------- |
+| 0      | Manual prompting           | Une personne lit l'état et écrit le prompt suivant.                                         |
+| 1      | Scripted retry             | Un script renvoie les erreurs à l'agent.                                                    |
+| 2      | Scheduled loop             | L'agent s'exécute selon une cadence et rapporte ses résultats.                              |
+| 3      | Stateful loop              | Le progrès survit via fichiers, issues, checkpoints ou traces.                              |
+| 4      | Self-verifying loop        | Des vérifications déterministes ou évaluateurs empêchent une fausse validation.             |
+| 5      | Multi-agent loop           | Des agents spécialisés séparent découverte, implémentation, revue et jugement.              |
+| 6      | Production-supervised loop | Observabilité, budgets, approbations, rollback et escalade humaine sont de premier ordre.   |
+
+## Premières Lectures
+
+La liste complète des ressources reste dans le README canonique en anglais : [README.md](README.md).
+
+Ressources recommandées pour commencer :
+
+- [Loop Engineering](https://addyosmani.com/blog/loop-engineering/) - Définition directe du passage du prompting manuel à des systèmes qui promptent, vérifient et continuent.
+- [Run long horizon tasks with Codex](https://developers.openai.com/blog/run-long-horizon-tasks-with-codex) - Guide pratique pour des cycles plan-edit-test-observe-repair-document-repeat.
+- [Run prompts on a schedule](https://code.claude.com/docs/en/scheduled-tasks) - Mécanismes officiels pour `/loop`, tâches planifiées et prompts récurrents.
+- [Building Effective Agents](https://www.anthropic.com/engineering/building-effective-agents) - Patterns composables pour workflows et agents.
+
+## Contribuer
+
+Les contributions sont bienvenues. Lis [CONTRIBUTING.md](CONTRIBUTING.md) avant d'ouvrir une pull request.
+
+Processus rapide :
+
+1. Vérifie que la ressource concerne Loop Engineering pour agents IA/coding agents ou une base directe.
+1. Recherche dans le README pour éviter les doublons.
+1. Choisis la catégorie la plus spécifique.
+1. Ajoute une entrée dans ce format :
+
+```md
+- 📄 **Paper** [Title](https://example.com) - One sentence explaining the resource's contribution to Loop Engineering.
+```
+
+1. Explique dans la PR la pertinence, la catégorie, le type de ressource et l'intérêt pour les builders.
+
+## Traductions
+
+Pour maintenir ou ajouter une langue, lis [TRANSLATIONS.md](TRANSLATIONS.md). Les traductions doivent préserver le périmètre : ne pas inclure les event loops, growth loops ou automatisations génériques.

README.ja.md

@@ -0,0 +1,98 @@
+# Awesome Loop Engineering
+
+<!-- last-synced: 2026-06-11 -->
+
+<p align="center">
+  <img src="assets/awesome-loop-engineering-cover.png" alt="Awesome Loop Engineering cover" width="100%">
+</p>
+
+<p align="center">
+  <a href="README.md">English</a> |
+  <a href="README.zh-CN.md">中文</a> |
+  <a href="README.es.md">Español</a> |
+  <a href="README.fr.md">Français</a> |
+  <a href="README.de.md">Deutsch</a> |
+  <a href="README.ja.md">日本語</a> |
+  <a href="README.ko.md">한국어</a> |
+  <a href="README.pt-BR.md">Português</a> |
+  <a href="TRANSLATIONS.md">翻訳に協力する</a>
+</p>
+
+> **Loop Engineering** のための、実装志向のキュレーションリストです。Loop Engineering は prompt、context、harness engineering の上位レイヤーとして、繰り返し実行される AI-agent システムを設計します。
+
+Prompt engineering はモデルに何を依頼するかを改善します。Context engineering はモデルが何を見られるかを改善します。Harness engineering は 1 回の agent 実行を取り巻くツール、権限、sandbox、検証を改善します。**Loop Engineering はその上位にあります**。agent を起動し、監督し、結果を検証し、状態を保存し、再実行するシステムを設計する実践です。
+
+Loop は作業を発見し、1 つ以上の agents に委任し、結果を確認し、状態を記録し、次の行動を決め、一定の cadence または検証可能な目標に到達するまで再実行されます。
+
+このリポジトリは AI agents / coding agents における新しい意味の Loop Engineering に限定しています。software event loop、制御理論、growth loop、一般的な workflow automation、非 AI の feedback loop は対象外です。
+
+## メンタルモデル
+
+- Prompt engineering: モデルに何を言うべきか？
+- Context engineering: モデルはどの状態や知識を見るべきか？
+- Harness engineering: agent の周囲にどのツール、権限、テスト、sandbox、feedback を置くべきか？
+- Loop engineering: 人間が内側のループから離れたとき、どの反復システムが作業を発見し、agent に委任し、結果を検証し、状態を永続化し、次の行動を決め、再実行するべきか？
+
+Prompt、context、harness engineering は 1 回の実行を良くします。Loop Engineering は agent の仕事を時間をまたいで反復可能、観測可能、統治可能にします。
+
+## Loop Contract
+
+有用な loop には通常、次の要素が必要です。
+
+| 要素                | 設計上の問い                                        | 一般的な成果物                                                     |
+| ----------------- | --------------------------------------------- | ----------------------------------------------------------- |
+| Objective         | loop は何を最適化するのか？                              | Goal, issue, PRD, runbook                                   |
+| Trigger           | いつ実行されるのか？                                    | Schedule, webhook, `/loop`, `/goal`, automation             |
+| Discover / Intake | どのように作業を発見するのか？                               | GitHub query, Linear filter, CI failure, feedback stream    |
+| Workspace         | agent はどこで安全に行動できるのか？                         | Worktree, sandbox, branch, container                        |
+| Context           | どの永続的な知識を読み込むのか？                              | `AGENTS.md`, `CLAUDE.md`, `SKILL.md`, docs                  |
+| Delegation        | どの agent が何を担当するのか？                           | Explorer, implementer, reviewer, judge                      |
+| Verification      | 何が成功または失敗を判断するのか？                             | Tests, typecheck, lint, evals, trace graders                |
+| State             | 次回の実行に何を残すのか？                                 | Progress file, checkpoint, trace, issue comment             |
+| Budget            | いつ消費を止めるのか？                                   | Max turns, max retries, token budget, time box              |
+| Escalation        | いつ人間に引き継ぐのか？                                  | PR, issue, Slack alert, triage inbox                        |
+| Exit              | loop はどう完了を判断するのか？                            | Acceptance criteria, passing checks, no work found          |
+
+## 成熟度モデル
+
+| レベル    | 名称                         | 説明                                                                                           |
+| ------ | -------------------------- | -------------------------------------------------------------------------------------------- |
+| 0      | Manual prompting           | 人間が状態を読み、次の prompt を書く。                                                                      |
+| 1      | Scripted retry             | script がエラーを agent に戻す。                                                                      |
+| 2      | Scheduled loop             | agent が一定の cadence で実行され、結果を報告する。                                                            |
+| 3      | Stateful loop              | ファイル、issue、checkpoint、trace によって進捗が残る。                                                       |
+| 4      | Self-verifying loop        | 決定的な check や evaluator agent が誤った完了を防ぐ。                                                      |
+| 5      | Multi-agent loop           | 専門 agents が discovery、implementation、review、judgment を分担する。                                  |
+| 6      | Production-supervised loop | observability、budget、approval、rollback、人間への escalation が一級の要素になる。                            |
+
+## はじめに読むもの
+
+完全なリソース一覧は英語の canonical README にあります: [README.md](README.md)。
+
+おすすめの入口:
+
+- [Loop Engineering](https://addyosmani.com/blog/loop-engineering/) - 手動 prompt から、prompt・検証・継続を行うシステム設計への移行を定義します。
+- [Run long horizon tasks with Codex](https://developers.openai.com/blog/run-long-horizon-tasks-with-codex) - plan-edit-test-observe-repair-document-repeat の実践的な runbook。
+- [Run prompts on a schedule](https://code.claude.com/docs/en/scheduled-tasks) - `/loop`、scheduled tasks、recurring prompts の公式メカニクス。
+- [Building Effective Agents](https://www.anthropic.com/engineering/building-effective-agents) - workflow と agents の composable patterns。
+
+## 貢献
+
+Pull request は歓迎です。まず [CONTRIBUTING.md](CONTRIBUTING.md) を読んでください。
+
+最短手順:
+
+1. そのリソースが AI/coding-agent 文脈の Loop Engineering、またはその直接的な基盤であることを確認する。
+1. README を検索して重複を避ける。
+1. 最も具体的なカテゴリを選ぶ。
+1. 次の形式で 1 行追加する。
+
+```md
+- 📄 **Paper** [Title](https://example.com) - One sentence explaining the resource's contribution to Loop Engineering.
+```
+
+1. PR で関連性、カテゴリ、リソース種別、builders にとっての価値を説明する。
+
+## 翻訳
+
+新しい言語を追加または維持したい場合は [TRANSLATIONS.md](TRANSLATIONS.md) を読んでください。翻訳では scope boundary を守り、event loop、growth loop、一般的な automation を混ぜないでください。

README.ko.md

@@ -0,0 +1,98 @@
+# Awesome Loop Engineering
+
+<!-- last-synced: 2026-06-11 -->
+
+<p align="center">
+  <img src="assets/awesome-loop-engineering-cover.png" alt="Awesome Loop Engineering cover" width="100%">
+</p>
+
+<p align="center">
+  <a href="README.md">English</a> |
+  <a href="README.zh-CN.md">中文</a> |
+  <a href="README.es.md">Español</a> |
+  <a href="README.fr.md">Français</a> |
+  <a href="README.de.md">Deutsch</a> |
+  <a href="README.ja.md">日本語</a> |
+  <a href="README.ko.md">한국어</a> |
+  <a href="README.pt-BR.md">Português</a> |
+  <a href="TRANSLATIONS.md">번역 돕기</a>
+</p>
+
+> **Loop Engineering** 을 위한 구현 중심 큐레이션 목록입니다. Loop Engineering 은 prompt, context, harness engineering 위의 레이어로, 반복 실행되는 AI-agent 시스템을 설계합니다.
+
+Prompt engineering 은 모델에게 무엇을 요청할지 개선합니다. Context engineering 은 모델이 무엇을 볼 수 있는지 개선합니다. Harness engineering 은 한 번의 agent 실행을 둘러싼 도구, 권한, sandbox, 검증을 개선합니다. **Loop Engineering 은 이 세 레이어 위에 있습니다**. agent 를 실행하고, 감독하고, 결과를 검증하고, 상태를 저장하고, 다시 실행하는 시스템을 설계하는 실천입니다.
+
+Loop 는 작업을 발견하고, 하나 이상의 agents 에게 위임하고, 결과를 확인하고, 상태를 기록하고, 다음 행동을 결정한 뒤, 일정 cadence 또는 검증 가능한 목표에 도달할 때까지 다시 실행됩니다.
+
+이 저장소는 AI agents / coding agents 맥락의 새로운 Loop Engineering 의미에만 집중합니다. software event loop, control theory, growth loop, 일반적인 workflow automation, 비 AI feedback loop 는 범위에 포함하지 않습니다.
+
+## 멘탈 모델
+
+- Prompt engineering: 모델에게 무엇을 말해야 하는가?
+- Context engineering: 모델이 어떤 상태와 지식을 봐야 하는가?
+- Harness engineering: agent 주변에 어떤 도구, 권한, 테스트, sandbox, feedback 이 있어야 하는가?
+- Loop engineering: 사람이 내부 루프에 있지 않을 때 어떤 반복 시스템이 작업을 발견하고, agents 에게 위임하고, 결과를 검증하고, 상태를 저장하고, 다음 행동을 결정하고, 다시 실행해야 하는가?
+
+Prompt, context, harness engineering 은 한 번의 실행을 더 좋게 만듭니다. Loop Engineering 은 agent 작업을 시간에 걸쳐 반복 가능하고, 관찰 가능하고, 거버넌스 가능하게 만듭니다.
+
+## Loop Contract
+
+유용한 loop 는 보통 다음 요소를 명확히 해야 합니다.
+
+| 요소                | 설계 질문                                          | 일반적인 산출물                                                    |
+| ----------------- | ---------------------------------------------- | ----------------------------------------------------------- |
+| Objective         | loop 는 무엇을 최적화하는가?                             | Goal, issue, PRD, runbook                                   |
+| Trigger           | 언제 실행되는가?                                      | Schedule, webhook, `/loop`, `/goal`, automation             |
+| Discover / Intake | 어떻게 작업을 발견하는가?                                 | GitHub query, Linear filter, CI failure, feedback stream    |
+| Workspace         | agent 는 어디에서 안전하게 행동하는가?                       | Worktree, sandbox, branch, container                        |
+| Context           | 어떤 지속 지식을 로드해야 하는가?                            | `AGENTS.md`, `CLAUDE.md`, `SKILL.md`, docs                  |
+| Delegation        | 어떤 agent 가 무엇을 담당하는가?                          | Explorer, implementer, reviewer, judge                      |
+| Verification      | 무엇이 성공 또는 실패를 판단하는가?                           | Tests, typecheck, lint, evals, trace graders                |
+| State             | 다음 실행까지 무엇이 남아야 하는가?                           | Progress file, checkpoint, trace, issue comment             |
+| Budget            | 언제 비용 소비를 멈춰야 하는가?                             | Max turns, max retries, token budget, time box              |
+| Escalation        | 언제 사람이 개입해야 하는가?                               | PR, issue, Slack alert, triage inbox                        |
+| Exit              | loop 는 어떻게 완료를 판단하는가?                          | Acceptance criteria, passing checks, no work found          |
+
+## 성숙도 모델
+
+| 레벨   | 이름                         | 설명                                                                                           |
+| ---- | -------------------------- | -------------------------------------------------------------------------------------------- |
+| 0    | Manual prompting           | 사람이 상태를 읽고 다음 prompt 를 작성합니다.                                                                |
+| 1    | Scripted retry             | script 가 오류를 agent 에게 다시 전달합니다.                                                              |
+| 2    | Scheduled loop             | agent 가 일정 cadence 로 실행되고 결과를 보고합니다.                                                         |
+| 3    | Stateful loop              | 파일, issue, checkpoint, trace 로 진행 상황이 유지됩니다.                                                 |
+| 4    | Self-verifying loop        | 결정적 check 또는 evaluator agent 가 잘못된 완료를 막습니다.                                                 |
+| 5    | Multi-agent loop           | 전문 agents 가 discovery, implementation, review, judgment 를 나눕니다.                              |
+| 6    | Production-supervised loop | observability, budget, approval, rollback, human escalation 이 핵심 요소가 됩니다.                    |
+
+## 시작하기
+
+전체 리소스 목록은 영어 canonical README 에 있습니다: [README.md](README.md).
+
+추천 시작 자료:
+
+- [Loop Engineering](https://addyosmani.com/blog/loop-engineering/) - 수동 prompting 에서 prompt, 검증, 지속을 수행하는 시스템 설계로 이동하는 흐름을 정의합니다.
+- [Run long horizon tasks with Codex](https://developers.openai.com/blog/run-long-horizon-tasks-with-codex) - plan-edit-test-observe-repair-document-repeat 작업을 위한 실용 runbook.
+- [Run prompts on a schedule](https://code.claude.com/docs/en/scheduled-tasks) - `/loop`, scheduled tasks, recurring prompts 의 공식 메커니즘.
+- [Building Effective Agents](https://www.anthropic.com/engineering/building-effective-agents) - workflows 와 agents 를 위한 composable patterns.
+
+## 기여하기
+
+Pull request 를 환영합니다. 먼저 [CONTRIBUTING.md](CONTRIBUTING.md) 를 읽어 주세요.
+
+빠른 절차:
+
+1. 리소스가 AI/coding-agent 맥락의 Loop Engineering 또는 직접적인 기반인지 확인합니다.
+1. README 에서 중복 여부를 검색합니다.
+1. 가장 구체적인 카테고리를 선택합니다.
+1. 다음 형식으로 한 줄을 추가합니다.
+
+```md
+- 📄 **Paper** [Title](https://example.com) - One sentence explaining the resource's contribution to Loop Engineering.
+```
+
+1. PR 에서 관련성, 카테고리, 리소스 타입, builders 에게 주는 가치를 설명합니다.
+
+## 번역
+
+새 언어를 추가하거나 유지하고 싶다면 [TRANSLATIONS.md](TRANSLATIONS.md) 를 읽어 주세요. 번역은 scope boundary 를 지켜야 하며 event loop, growth loop, 일반 automation 을 범위에 섞지 않아야 합니다.

README.md

@@ -0,0 +1,623 @@
+# Awesome Loop Engineering [![Awesome](https://awesome.re/badge.svg)](https://github.com/sindresorhus/awesome)
+
+<p align="center">
+  <img src="assets/awesome-loop-engineering-cover.png" alt="Awesome Loop Engineering cover" width="100%">
+</p>
+
+<p align="center">
+  <a href="README.md">English</a> |
+  <a href="README.zh-CN.md">中文</a> |
+  <a href="README.es.md">Español</a> |
+  <a href="README.fr.md">Français</a> |
+  <a href="README.de.md">Deutsch</a> |
+  <a href="README.ja.md">日本語</a> |
+  <a href="README.ko.md">한국어</a> |
+  <a href="README.pt-BR.md">Português</a> |
+  <a href="TRANSLATIONS.md">Help translate</a> |
+  <a href="https://chaoyue0307.github.io/awesome-loop-engineering/">Landing page</a>
+</p>
+
+> A curated, implementation-oriented list of resources for **Loop Engineering**: the layer above prompt, context, and harness engineering for designing recurring AI-agent systems.
+
+Prompt engineering improves what you ask the model. Context engineering improves what the model can see. Harness engineering improves the tools, permissions, sandboxes, and checks around one agent run. **Loop Engineering sits above all three**: it is the emerging AI and coding-agent practice of moving from manually prompting agents turn by turn to designing loops that do the prompting, supervision, verification, state updates, and re-triggering for you.
+
+A loop discovers work, hands it to one or more agents, checks the result, records state, decides what should happen next, and runs again on a cadence or until a verifiable goal is reached.
+
+This repository is about the new AI-agent meaning of Loop Engineering. It is **not** about software event loops, control theory, growth loops, generic workflow automation, or non-AI feedback systems.
+
+**Quick orientation for first-time visitors:**
+
+- **What it is:** Loop Engineering is the practice of designing recurring AI-agent and coding-agent systems—how work is discovered, delegated, verified, retried, and escalated over time, not just for a single run.
+- **Why it matters now:** As coding agents move from one-off prompts to background automation, the design challenge shifts from "what do I ask?" to "how does the system keep working reliably?" This list exists because no existing collection focused on that layer.
+- **Who this is for:** builders of AI agents, coding agents, and orchestration systems; reliability and eval engineers; teams adding recurring agent loops to production infrastructure.
+- **Where to start:** Canonical Definition, Loop Contract, Start Here, then Pattern Library.
+
+## Contents
+
+- [Why This Repo Exists](#why-this-repo-exists)
+- [Mental Model](#mental-model)
+- [How To Use This List](#how-to-use-this-list)
+- [Reading Paths](#reading-paths)
+- [Choose Your Loop](#choose-your-loop)
+- [Canonical Definition](#canonical-definition)
+- [Concept Guides](#concept-guides)
+- [Maintainer Picks](#maintainer-picks)
+- [Repository Highlights](#repository-highlights)
+- [Resource Type Legend](#resource-type-legend)
+- [Start Here](#start-here)
+- [Scope Boundary](#scope-boundary)
+- [The Loop Contract](#the-loop-contract)
+- [Loop Design Checklist](#loop-design-checklist)
+- [Loop Maturity Model](#loop-maturity-model)
+- [Core Loop Primitives](#core-loop-primitives)
+- [Official Runtime Guides](#official-runtime-guides)
+- [Research Foundations](#research-foundations)
+- [Agent Workflow Patterns](#agent-workflow-patterns)
+- [Coding-Agent Loop Systems](#coding-agent-loop-systems)
+- [Verification And Feedback Gates](#verification-and-feedback-gates)
+- [Securing Unattended Loops](#securing-unattended-loops)
+- [State, Memory, And Context Persistence](#state-memory-and-context-persistence)
+- [Orchestration And Multi-Agent Delegation](#orchestration-and-multi-agent-delegation)
+- [Benchmarks And Evaluation](#benchmarks-and-evaluation)
+- [Operations Playbooks](#operations-playbooks)
+- [Templates And Patterns](#templates-and-patterns)
+- [Examples And Schema](#examples-and-schema)
+- [Community Gallery](#community-gallery)
+- [Discovery And Distribution](#discovery-and-distribution)
+- [Roadmap And Discussion](#roadmap-and-discussion)
+- [Pattern Library](#pattern-library)
+- [Critiques, Risks, And Limitations](#critiques-risks-and-limitations)
+- [Adjacent Awesome Lists](#adjacent-awesome-lists)
+- [Citation](#citation)
+
+## Why This Repo Exists
+
+Loop Engineering is becoming a distinct craft because the leverage point is moving from better single prompts, richer context, and stronger harnesses to recurring systems that decide when and how agents should run. The best agent workflows now combine goals, state, work isolation, tool permissions, feedback gates, retries, escalation, and receipts. This list exists to make that craft easier to learn, compare, and practice without mixing it with unrelated loop concepts or generic AI-agent hype.
+
+## Mental Model
+
+Prompt engineering asks: **what should I say to the model?**
+
+Context engineering asks: **what state and knowledge should the model see?**
+
+Harness engineering asks: **what tools, permissions, tests, sandboxes, and feedback should surround the agent?**
+
+Loop engineering asks: **what recurring system should discover work, delegate to agents, verify results, persist state, decide next actions, and re-run when the human is no longer in the inner loop?**
+
+Prompt, context, and harness engineering make one agent run better. Loop Engineering makes agent work repeatable, observable, and governable over time.
+
+<p align="center">
+  <img src="assets/loop-engineering-stack.svg" alt="Loop Engineering stack" width="100%">
+</p>
+
+Loop shape:
+
+```text
+Objective
+  -> Trigger / cadence
+  -> Discover / intake work
+  -> Delegate to agents
+  -> Act in an isolated workspace
+  -> Verify with tests, evals, traces, or reviewers
+       -> if failed: feed back the evidence and retry
+       -> if passed: persist state and decide what happens next
+  -> Repeat, report, open a PR, or escalate to a human
+```
+
+<p align="center">
+  <img src="assets/loop-lifecycle.svg" alt="Loop Engineering lifecycle: Intake, Delegate, Act, Verify, Persist, Decide; Decide retries by feeding evidence back, escalates to a human, or exits when the goal is met" width="100%">
+</p>
+
+## How To Use This List
+
+Start with the first-read resources and the Loop Contract if the term is new. For implementation work, move through core primitives, runtime guides, templates, and patterns. For reliability work, focus on verification gates, state persistence, critiques, and limitations. Contributions should prefer primary sources, official docs, papers, and implementation-heavy write-ups.
+
+## Reading Paths
+
+Choose a path based on your intent.
+
+- Learn the concept: canonical definition, mental model, comparison guide, and the Loop Contract.
+- Implement a loop: core primitives, official runtime guides, the pattern library, and examples.
+- Improve reliability or evals: verification gates, benchmarks, critiques, and limitations.
+- Contribute: the community gallery, templates, and contribution guide.
+
+## Choose Your Loop
+
+Start from the problem you have, not the pattern you want. Find the pattern name below, then open its full write-up in the Pattern Library section, or compare every pattern in the [pattern matrix](patterns/MATRIX.md), which also links each one by symptom.
+
+| When you say...                  | Reach for the loop         |
+| -------------------------------- | -------------------------- |
+| "My PR is stuck"                 | PR babysitter              |
+| "CI keeps failing"               | CI repair loop             |
+| "The docs may be stale"          | Docs drift collector       |
+| "A deploy needs monitoring"      | Deploy verifier            |
+| "Feedback is noisy"              | Feedback clusterer         |
+| "Dependency updates pile up"     | Dependency triage loop     |
+| "Agent evals regressed"          | Evaluation regression loop |
+| "Sensitive changes need review"  | Security review loop       |
+| "Agent spend is rising"          | Cost-control loop          |
+| "I need recurring bug discovery" | Bug hunting loop           |
+| "A change needs sign-off"        | Enterprise approval loop   |
+| "An incident just paged"         | Incident response loop     |
+| "A dataset keeps drifting"       | Data-quality loop          |
+| "Release notes are a chore"      | Release-note loop          |
+| "Model choice is ad hoc"         | Model-routing loop         |
+
+Not sure which runtime should run it? See the [runtime selection guide](meta/RUNTIME_SELECTION.md).
+
+## Canonical Definition
+
+**Loop Engineering** is the AI and coding-agent practice of designing recurring systems that discover work, delegate it to agents, verify results, persist state, decide next actions, and run again on a cadence, event, or until a verifiable goal is reached.
+
+## Concept Guides
+
+These repository-native guides define the concept, boundaries, and practical artifacts without relying on vendor-specific terminology.
+
+- 🧾 **Template** [Canonical Definition](DEFINITION.md) - Short definition, positioning, minimal loop test, and citation note.
+- 🧾 **Template** [Loop Engineering Manifesto](MANIFESTO.md) - Concise statement of the concept, commitments, non-goals, and success standard.
+- 🧾 **Template** [Loop Engineering Taxonomy](TAXONOMY.md) - Classification by trigger, intake, verification, state model, topology, and operating domain.
+- ⚠️ **Critique** [Loop Engineering Anti-Patterns](ANTI-PATTERNS.md) - Common failure modes such as prompt loops with no contract, infinite retries, model self-approval, hidden state, and unsafe autonomy.
+- 🧾 **Template** [Comparison Guide](COMPARISON.md) - Distinguishes Loop Engineering from prompt engineering, context engineering, harness engineering, workflow automation, agent workflows, and evaluation loops.
+- 🧾 **Template** [Sourced Signals And Quotes](QUOTES.md) - Short sourced signals from linked public materials that anchor the emerging concept.
+- 🧾 **Template** [Outreach Kit](meta/OUTREACH.md) - Conservative messages for inviting corrections, sources, and real-world loop patterns.
+
+## Maintainer Picks
+
+- 🧾 **Template** [Maintainer Picks](MAINTAINER_PICKS.md) - Shortlist of concept, practice, reliability, and reusable artifact resources.
+
+## Repository Highlights
+
+Beyond the curated list, this repository ships its own artifacts: an operational pattern library, a schema-validated loop contract for every pattern, a runnable reference loop, a community gallery, eight language entry points, a standalone landing page, and an active discussion thread for real or anonymized Loop Engineering patterns.
+
+## Resource Type Legend
+
+- 📄 **Paper**: academic paper, preprint, or technical report.
+- 📝 **Blog**: essay, field note, article, or practitioner write-up.
+- 📚 **Docs**: official product, API, SDK, or platform documentation.
+- 🧰 **Tool**: repository, framework, SDK, runtime, or implementation.
+- 🧪 **Benchmark**: benchmark, eval suite, leaderboard, or evaluation dataset.
+- 🔁 **Pattern**: real-world loop pattern, operational playbook, or reusable workflow.
+- 🧾 **Template**: template, checklist, schema, repository guide, or contribution artifact.
+- 🧭 **List**: adjacent awesome list, ecosystem map, or curated collection.
+- ⚠️ **Critique**: risk analysis, limitation, caveat, or skeptical take.
+
+## Start Here
+
+Direct resources about the new AI/coding-agent meaning of Loop Engineering.
+
+- 📝 **Blog** [Loop Engineering](https://addyosmani.com/blog/loop-engineering/) - Addy Osmani's framing of loop engineering as the layer above manually prompting coding agents, with concrete primitives across Codex and Claude Code.
+- 📝 **Blog** [Loop Engineering](https://addyo.substack.com/p/loop-engineering) - Substack version of the same essay; useful for the original discussion trail and quotations from Peter Steinberger and Boris Cherny.
+- 📝 **Blog** [Loop Engineering](https://cobusgreyling.substack.com/p/loop-engineering) - Concise explanation of the shift from prompting agents to designing loops that discover work, delegate, verify, persist, and continue.
+- 📝 **Blog** [Loop Engineering: The Guide for AI Agents](https://lushbinary.com/blog/loop-engineering-ai-coding-agents-guide/) - Practical guide that breaks the pattern into automations, worktrees, skills, connectors, subagents, and state.
+- 🔁 **Pattern** [Codex Loops: What Boris Cherny Gets Right About Managing Agent Work](https://www.developersdigest.tech/blog/codex-loops-boris-cherny-agent-routines) - Engineering note on recurring agent loops for PR babysitting, CI repair, deploy verification, and feedback clustering.
+- 📝 **Blog** [I Now Just Write Loops To Prompt Claude Code: Claude Code Creator Boris Cherny](https://officechai.com/ai/i-now-just-write-loops-to-prompt-claude-code-claude-code-creator-boris-cherny/) - Coverage of Boris Cherny's "my job is to write loops" workflow.
+- 📝 **Blog** [My Lord! AI Programming Undergoes Another Major Shift](https://eu.36kr.com/en/p/3844224911346184) - Broad coverage of the Boris Cherny and Peter Steinberger discussion, including the distinction between cold-start scripts and persistent agent loops.
+- 📝 **Blog** [Peter Steinberger on designing loops](https://x.com/steipete/status/2063697162748260627) - 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.
+- 📝 **Blog** [The Anthropic leader who built Claude Code ditched prompting - now he writes loops](https://thenewstack.io/loop-engineering/) - The New Stack's report on Boris Cherny's shift from prompting to loop writing and what it changes about developer workflow.
+- 📝 **Blog** [Stop Prompting. Design the Loop.](https://www.pulumi.com/blog/stop-prompting-design-the-loop/) - Practical breakdown of loop building blocks - automations, worktrees, skills, connectors, subagents - plus external memory and verification through oracles such as tests and builds.
+- 📝 **Blog** [Boris Cherny: five tips for running Opus autonomously for hours or days](https://x.com/bcherny/status/2063792263067754658) - 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.
+
+## Scope Boundary
+
+| In scope                                                                                                            | Out of scope                                                    |
+| ------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------- |
+| AI/coding-agent loops that coordinate prompts, context, harnesses, verification, and state over repeated agent runs | Software event loops, UI/game loops, or control theory loops    |
+| Scheduled, goal-driven, or event-triggered agent work                                                               | Generic cron jobs with no agentic reasoning or verification     |
+| Agent loops with durable state, worktrees, checkpoints, traces, or progress files                                   | One-off prompt examples with no loop, state, or feedback signal |
+| Verification loops using tests, CI, evals, reviewers, or deterministic gates                                        | Pure AI news, generic product pages, or marketing copy          |
+| Multi-agent maker/checker/delegation patterns                                                                       | Broad agent lists without specific loop-design relevance        |
+
+## The Loop Contract
+
+A useful loop has a contract. If one of these is missing, the loop usually becomes either a manual prompt habit or an unsafe background automation. Prompt, context, and harness choices are ingredients; the loop contract is the operating layer that connects them over time.
+
+<p align="center">
+  <img src="assets/loop-contract-cards.svg" alt="Loop Contract cards" width="100%">
+</p>
+
+| Part              | Design question                        | Common artifact                                              |
+| ----------------- | -------------------------------------- | ------------------------------------------------------------ |
+| Objective         | What should the loop optimize for?     | Goal, issue, PRD, runbook                                    |
+| Trigger           | When does the loop run?                | Schedule, webhook, `/loop`, `/goal`, automation              |
+| Discover / Intake | How does the loop find work?           | GitHub queries, Linear filters, CI failures, feedback stream |
+| Workspace         | Where can the agent act safely?        | Worktree, sandbox, branch, container                         |
+| Context           | What durable knowledge should it load? | `AGENTS.md`, `CLAUDE.md`, `SKILL.md`, docs                   |
+| Delegation        | Which agent does which job?            | Explorer, implementer, reviewer, judge                       |
+| Verification      | What says "yes" or "no"?               | Tests, typecheck, lint, evals, trace graders                 |
+| State             | What survives the next run?            | Progress file, database checkpoint, trace, issue comment     |
+| Budget            | When should it stop spending?          | Max turns, max retries, token budget, time box               |
+| Escalation        | When does a human take over?           | PR, issue, Slack alert, triage inbox                         |
+| Exit              | How does the loop know it is done?     | Acceptance criteria, passing checks, no work found           |
+
+Good loop documentation should make the contract visible. A reader should be able to tell what triggers the loop, what state it reads, what it is allowed to change, how it verifies progress, and when it stops.
+
+## Loop Design Checklist
+
+| Check                           | Question                                                                                             |
+| ------------------------------- | ---------------------------------------------------------------------------------------------------- |
+| Name one objective              | Does the loop optimize for a specific outcome instead of a vague goal such as "improve the repo"?    |
+| Define the intake               | Where does work enter: PR comments, CI failures, issues, logs, eval failures, feedback, or schedule? |
+| Isolate execution               | Does the agent act in a worktree, sandbox, branch, container, or read-only mode?                     |
+| Write the feedback signal first | Do tests, typechecks, lint, evals, policy checks, or trace graders exist before retries begin?       |
+| Persist state outside the model | Does progress survive in files, issue comments, checkpoints, traces, or a database?                  |
+| Separate maker and checker      | Does something other than the acting agent decide whether the work is done?                          |
+| Put a budget on autonomy        | Are runtime, turns, retries, token spend, and concurrent workers capped?                             |
+| Design escalation               | Is it clear when the loop should open a PR, file an issue, ask a human, or stop?                     |
+| Keep receipts                   | Are commands, evidence, changed files, and stop reasons recorded?                                    |
+
+## Loop Maturity Model
+
+| Level | Name                       | Description                                                                        |
+| ----- | -------------------------- | ---------------------------------------------------------------------------------- |
+| 0     | Manual prompting           | A human reads state and writes the next prompt.                                    |
+| 1     | Scripted retry             | A shell/script loop feeds errors back to an agent.                                 |
+| 2     | Scheduled loop             | The agent runs on a cadence and reports findings.                                  |
+| 3     | Stateful loop              | Progress survives across sessions through files, issues, checkpoints, or traces.   |
+| 4     | Self-verifying loop        | Deterministic checks or evaluator agents gate completion.                          |
+| 5     | Multi-agent loop           | Specialized agents split discovery, implementation, review, and judgment.          |
+| 6     | Production-supervised loop | Observability, budgets, approvals, rollback, and human escalation are first-class. |
+
+Most teams should climb this model slowly. A reliable Level 3 loop with clear state and deterministic checks is usually more valuable than a flashy Level 5 loop with vague goals.
+
+## Core Loop Primitives
+
+These are the building blocks that make a loop more than a repeated prompt.
+
+- 📚 **Docs** [Automations - Codex app](https://developers.openai.com/codex/app/automations) - Codex background automations for recurring tasks, triage inboxes, skills, and worktree isolation.
+- 📚 **Docs** [Follow a goal - Codex use cases](https://developers.openai.com/codex/use-cases/follow-goals) - Official guidance for durable objectives with stopping conditions, validation commands, checkpoints, and progress logs.
+- 📚 **Docs** [Worktrees - Codex app](https://developers.openai.com/codex/app/worktrees) - Codex worktree model for isolated parallel tasks and handoffs between local and background workspaces.
+- 📚 **Docs** [Prompting - Codex](https://developers.openai.com/codex/prompting) - Explains the Codex loop, threads, context, and `/goal` mode.
+- 📚 **Docs** [Customization - Codex](https://developers.openai.com/codex/concepts/customization) - Maps `AGENTS.md`, memories, skills, MCP, and subagents into a coherent customization stack.
+- 📚 **Docs** [Agent Skills - Codex](https://developers.openai.com/codex/skills) - Official skill format for reusable workflows, scripts, MCP dependencies, invocation policy, and plugin packaging.
+- 📚 **Docs** [Plugins - Codex](https://developers.openai.com/codex/plugins) - Bundles skills, app integrations, and MCP servers into reusable loop capabilities.
+- 📚 **Docs** [Slash commands in Codex CLI](https://developers.openai.com/codex/cli/slash-commands) - CLI commands for switching agent threads, browsing skills, inspecting MCP tools, and using subagent workflows.
+- 🔁 **Pattern** [Autonomous Loops](https://claudecodeguide.dev/docs/patterns/autonomous-loops) - Claude Code pattern using task files, stop hooks, restart behavior, hard limits, and a kill switch.
+- 📚 **Docs** [Claude Code Glossary](https://code.claude.com/docs/en/glossary.md) - Defines the agentic loop, hooks, subagents, skills, MCP, and related primitives in Claude Code terminology.
+- 📚 **Docs** [Keep Claude working toward a goal](https://code.claude.com/docs/en/goal) - `/goal` runs turn after turn until a completion condition is met by a verifier.
+- 📚 **Docs** [Run prompts on a schedule](https://code.claude.com/docs/en/scheduled-tasks) - `/loop`, scheduled tasks, reminders, monitor tools, and session-scoped recurring prompts.
+- 📚 **Docs** [Automate work with routines](https://code.claude.com/docs/en/routines) - Claude Code routines: persistent cloud automations triggered by schedules, API calls, or GitHub events, with connectors, scoped environments, and branch-push limits.
+- 📚 **Docs** [Desktop scheduled tasks](https://code.claude.com/docs/en/desktop-scheduled-tasks) - Local recurring runs on your own machine, with the persistence, file-access, permission, worktree, and missed-run trade-offs that distinguish them from `/loop` and cloud routines.
+- 📚 **Docs** [Run parallel sessions with worktrees](https://code.claude.com/docs/en/worktrees) - Worktree isolation for parallel sessions and subagents so concurrent edits do not collide.
+- 📚 **Docs** [Automate actions with hooks](https://code.claude.com/docs/en/hooks-guide) - Claude Code hooks guide for deterministic lifecycle control around model actions.
+- 📚 **Docs** [Hooks reference](https://code.claude.com/docs/en/hooks.md) - Event-level reference for session, turn, tool-call, and subagent hooks.
+- 📚 **Docs** [Common workflows - Claude Code](https://code.claude.com/docs/en/common-workflows) - Practical workflows for worktrees, subagents, CI, batch processing, planning, and resuming prior work.
+- 📚 **Docs** [Manage multiple agents with agent view](https://code.claude.com/docs/en/agent-view.md) - Dashboard for dispatching, monitoring, and attaching to background agent sessions.
+- 📚 **Docs** [Run agents in parallel](https://code.claude.com/docs/en/agents.md) - Compares agent view, subagents, agent teams, worktrees, tasks, and workflows for parallel work.
+- 📚 **Docs** [Orchestrate subagents at scale with dynamic workflows](https://code.claude.com/docs/en/workflows) - Moves loop state and branching into workflow scripts so large tasks do not overload the conversation context.
+- 📚 **Docs** [Create plugins](https://code.claude.com/docs/en/plugins) - Packaging model-invoked skills, agents, hooks, MCP servers, monitors, and settings as shareable loop components.
+- 📚 **Docs** [Model Context Protocol](https://modelcontextprotocol.io/docs/getting-started/intro) - Standard protocol for exposing tools and data sources to agent loops.
+- 📚 **Docs** [Allowing GitHub Copilot CLI to work autonomously](https://docs.github.com/en/copilot/concepts/agents/copilot-cli/autopilot) - Copilot CLI autopilot mode plus `/every` and `/after` scheduling, turning the CLI into an unattended loop that runs steps until a task is complete.
+
+## Official Runtime Guides
+
+Primary-source docs from agent runtime vendors and framework builders.
+
+- 📚 **Docs** [Run long horizon tasks with Codex](https://developers.openai.com/blog/run-long-horizon-tasks-with-codex) - OpenAI's runbook for plan-edit-test-observe-repair-document-repeat work, including specs, plans, status logs, and validation gates.
+- 📚 **Docs** [Best practices - Codex](https://developers.openai.com/codex/learn/best-practices) - Official best practices for context, `AGENTS.md`, MCP, skills, subagents, and automations.
+- 📚 **Docs** [Agents SDK](https://developers.openai.com/api/docs/guides/agents) - OpenAI guide for agent orchestration, tool execution, approvals, state, guardrails, and observability.
+- 📚 **Docs** [Agents - OpenAI Agents SDK](https://openai.github.io/openai-agents-python/agents/) - SDK primitives for agents, tools, handoffs, guardrails, and runner-managed loops.
+- 📚 **Docs** [Running agents](https://developers.openai.com/api/docs/guides/agents/running-agents) - OpenAI guide to turns, state, approvals, sessions, and continuation in the SDK runtime loop.
+- 📚 **Docs** [Integrations and observability](https://developers.openai.com/api/docs/guides/agents/integrations-observability) - OpenAI guide to MCP wiring and traces as the basis for debugging and evaluation loops.
+- 📚 **Docs** [Sandbox Agents](https://developers.openai.com/api/docs/guides/agents/sandboxes) - Splits the harness control plane from the sandbox execution plane for long-running file and command work.
+- 📚 **Docs** [Guardrails and human review](https://developers.openai.com/api/docs/guides/agents/guardrails-approvals) - Approval and validation boundaries for sensitive agent actions.
+- 📚 **Docs** [Building agents with the Claude Agent SDK](https://code.claude.com/docs/en/agent-sdk/overview.md) - Claude SDK overview for tool-using agents, subagents, state, permissions, and streaming.
+- 📚 **Docs** [How the agent loop works](https://code.claude.com/docs/en/agent-sdk/agent-loop) - Official walkthrough of the inner agent loop that outer recurring loops build on.
+- 📚 **Docs** [Extend Claude with skills](https://code.claude.com/docs/en/skills) - Claude Code skill system for reusable loop instructions and assets.
+- 📚 **Docs** [Create custom subagents](https://code.claude.com/docs/en/sub-agents) - Claude Code custom subagents with isolated context, model choice, and tool permissions.
+- 📚 **Docs** [GitHub Agentic Workflows](https://github.github.com/gh-aw/) - Repository automation that runs coding agents in GitHub Actions on events or schedules with guardrails.
+- 📝 **Blog** [GitHub Agentic Workflows technical preview](https://github.blog/changelog/2026-02-13-github-agentic-workflows-are-now-in-technical-preview/) - Changelog announcement for Markdown-defined agentic workflows in GitHub Actions.
+- 📚 **Docs** [Continuous AI](https://githubnext.com/projects/continuous-ai/) - GitHub Next's umbrella framing for CI/CD-style AI automation across the software lifecycle, the category that agentic workflows demonstrate.
+- 📝 **Blog** [Automate repository tasks with GitHub Agentic Workflows](https://github.blog/ai-and-ml/automate-repository-tasks-with-github-agentic-workflows/) - Official walkthrough of writing Markdown-defined agentic workflows with guardrails for triage, QA, and docs chores.
+- 📝 **Blog** [Continuous AI in practice: What developers can automate today with agentic CI](https://github.blog/ai-and-ml/generative-ai/continuous-ai-in-practice-what-developers-can-automate-today-with-agentic-ci/) - Concrete agentic-CI automations available today, with recurring patterns for triage, review, and documentation upkeep.
+- 📚 **Docs** [About GitHub Copilot coding agent](https://docs.github.com/en/copilot/concepts/agents/coding-agent/about-coding-agent) - GitHub's autonomous coding agent: assign an issue, the agent works in an isolated Actions-powered workspace, and a reviewable pull request comes back.
+- 📝 **Blog** [GitHub Copilot: Meet the new coding agent](https://github.blog/news-insights/product-news/github-copilot-meet-the-new-coding-agent/) - Launch overview of the issue-to-PR delegation loop, including iteration on review feedback.
+- 📚 **Docs** [Jules](https://jules.google/docs) - Google's asynchronous coding agent that plans, executes tasks in isolated cloud VMs, and returns reviewable diffs.
+- 📚 **Docs** [Cursor cloud agents](https://cursor.com/docs/cloud-agent) - Remote agents that work asynchronously in isolated environments and hand results back for review.
+- 📚 **Docs** [Devin Docs](https://docs.devin.ai/get-started/devin-intro) - Documentation for a long-running autonomous software engineer with sessions, playbooks, knowledge, and review boundaries.
+- 📚 **Docs** [Writing effective tools for AI agents](https://www.anthropic.com/engineering/writing-tools-for-agents) - Anthropic's guidance on evaluating and improving tool specs using agentic loops and realistic tasks.
+- 📚 **Docs** [Introducing advanced tool use on the Claude Developer Platform](https://www.anthropic.com/engineering/advanced-tool-use?e45d281a_page=3) - Tool search, programmatic tool calling, and tool-use examples for scaling large tool libraries without flooding context.
+- 📚 **Docs** [Effective harnesses for long-running agents](https://www.anthropic.com/engineering/effective-harnesses-for-long-running-agents) - Anthropic's guidance for agents that work across many context windows: durable progress artifacts, environment setup, and self-verification.
+- 📚 **Docs** [Claude Code best practices](https://code.claude.com/docs/en/best-practices) - Widely cited workflow guidance that underlies many recurring Claude Code loops.
+
+## Research Foundations
+
+Loop Engineering is new as a practice name, but it builds on years of agent-loop, feedback, planning, and self-correction research.
+
+- 📄 **Paper** [ReAct: Synergizing Reasoning and Acting in Language Models](https://arxiv.org/abs/2210.03629) - Foundational reason-act-observe loop for tool-using language agents.
+- 📄 **Paper** [Reflexion: Language Agents with Verbal Reinforcement Learning](https://arxiv.org/abs/2303.11366) - Converts environment feedback into written reflections stored in memory for future attempts.
+- 📄 **Paper** [Self-Refine: Iterative Refinement with Self-Feedback](https://arxiv.org/abs/2303.17651) - Generate-feedback-refine loop where a model improves outputs over repeated passes.
+- 📄 **Paper** [CRITIC: Large Language Models Can Self-Correct with Tool-Interactive Critiquing](https://arxiv.org/abs/2305.11738) - Uses tools to ground critique and correction rather than relying only on introspection.
+- 📄 **Paper** [Tree of Thoughts](https://arxiv.org/abs/2305.10601) - Search over multiple reasoning branches; relevant when loop design needs exploration before committing.
+- 📄 **Paper** [Graph of Thoughts](https://arxiv.org/abs/2308.09687) - Generalizes thought structures beyond chains and trees, useful for complex loop planning and aggregation.
+- 📄 **Paper** [Language Agent Tree Search Unifies Reasoning Acting and Planning in Language Models](https://arxiv.org/abs/2310.04406) - Combines search, action, and environment feedback for language agents.
+- 📄 **Paper** [Voyager: An Open-Ended Embodied Agent with Large Language Models](https://arxiv.org/abs/2305.16291) - Demonstrates lifelong skill acquisition through iterative exploration, feedback, and a skill library.
+- 📄 **Paper** [Generative Agents: Interactive Simulacra of Human Behavior](https://arxiv.org/abs/2304.03442) - Introduces reflection and memory mechanisms for long-running agent behavior.
+- 📄 **Paper** [Measuring AI Ability to Complete Long Software Tasks](https://arxiv.org/abs/2503.14499) - METR's task-length time horizon metric; grounds why loop budgets, checkpoints, and escalation matter as autonomous work gets longer.
+- 📝 **Blog** [Measuring AI Ability to Complete Long Tasks](https://metr.org/blog/2025-03-19-measuring-ai-ability-to-complete-long-tasks/) - Accessible summary of the 50% task-completion time horizon and its doubling trend.
+- 📄 **Paper** [Reflection-Driven Control for Trustworthy Code Agents](https://arxiv.org/abs/2512.21354) - 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.
+- 📄 **Paper** [PARC: An Autonomous Self-Reflective Coding Agent for Robust Execution of Long-Horizon Tasks](https://arxiv.org/abs/2512.03549) - Hierarchical plan-execute-assess loops that detect and correct strategic errors during multi-hour autonomous runs.
+- 📄 **Paper** [When the Specification Emerges: Benchmarking Faithfulness Loss in Long-Horizon Coding Agents](https://arxiv.org/abs/2603.17104) - Measures how agents drift from intent when specifications arrive incrementally across a long loop, and proposes a mitigation that recovers most of the loss.
+- 🧰 **Tool** [Reflexion code](https://github.com/noahshinn/reflexion) - Reference implementation and experiments for verbal reinforcement loops.
+
+## Agent Workflow Patterns
+
+These resources are included when they help design the higher-level loop around agents, not merely because they describe agents in general.
+
+- 📚 **Docs** [Building Effective Agents](https://www.anthropic.com/engineering/building-effective-agents) - Anthropic's canonical guide to workflows and agents, including evaluator-optimizer and orchestrator-workers patterns.
+- 📝 **Blog** [How we built our multi-agent research system](https://www.anthropic.com/engineering/multi-agent-research-system) - Detailed orchestrator-worker system with planning, memory, subagents, citation passes, and iterative research loops.
+- 📄 **Paper** [Building Effective AI Agents: Architecture Patterns and Implementation Frameworks](https://resources.anthropic.com/hubfs/Building%20Effective%20AI%20Agents-%20Architecture%20Patterns%20and%20Implementation%20Frameworks.pdf) - PDF overview of agent architecture patterns, including generator-evaluator loops.
+- 📝 **Blog** [AI Agent Architectures](https://hld.handbook.academy/curriculum/ai-ml-system-design/ai-agent-architectures/) - System-design overview of ReAct, reflection, planning, tool use, memory, and control strategies.
+- 📝 **Blog** [What Are Agentic Workflows?](https://weaviate.io/blog/what-are-agentic-workflows) - Accessible taxonomy of planning, tool use, reflection, and memory patterns.
+- 📝 **Blog** [Agent Planning & Reflection Patterns](https://learnaivisually.com/tracks/ai-agents/planning-reflection) - Visual explanation of plan-execute, observe, reflect, retry, and stop patterns.
+- 📝 **Blog** [Agentic Design Patterns](https://addyosmani.com/agents/04-agentic-design-patterns/) - Practical overview of ReAct, reflection, tool use, planning, and how to combine them in real-world agents.
+- 🔁 **Pattern** [12 Factor Agents](https://github.com/humanlayer/12-factor-agents) - Operating principles for production agents, including explicit prompts, state ownership, and pause-resume behavior.
+- 🔁 **Pattern** [Durable Execution for Agentic Workflows](https://arizenai.com/durable-execution/) - Explains checkpointing, event-sourced journals, replay, and recovery for long-running agent workflows.
+
+## Coding-Agent Loop Systems
+
+- 🧰 **Tool** [SWE-agent](https://github.com/SWE-agent/SWE-agent) - Agent-computer interface and autonomous software engineering agent for repository tasks.
+- 📄 **Paper** [SWE-agent: Agent-Computer Interfaces Enable Automated Software Engineering](https://arxiv.org/abs/2405.15793) - Paper behind SWE-agent and its interface design.
+- 🧰 **Tool** [mini-SWE-agent](https://mini-swe-agent.com/latest/) - Minimal coding agent that is useful for understanding the core loop without a large framework.
+- 🧰 **Tool** [OpenHands](https://github.com/All-Hands-AI/OpenHands) - Open platform for AI software developers as generalist agents.
+- 📄 **Paper** [OpenHands: An Open Platform for AI Software Developers as Generalist Agents](https://arxiv.org/abs/2407.16741) - Paper describing OpenHands, CodeActAgent, benchmarks, and generalist agent evaluation.
+- 🧰 **Tool** [Agentless](https://github.com/OpenAutoCoder/Agentless) - Workflow-based approach for software issue resolution using localization, repair, and patch validation.
+- 📄 **Paper** [Agentless: Demystifying LLM-based Software Engineering Agents](https://arxiv.org/abs/2407.01489) - Useful contrast case: strong results through structured workflow rather than a fully open-ended agent.
+- 🧰 **Tool** [AutoCodeRover](https://github.com/AutoCodeRoverSG/auto-code-rover) - Autonomous program improvement system for issue localization, patch generation, and validation.
+- 📄 **Paper** [AutoCodeRover: Autonomous Program Improvement](https://arxiv.org/abs/2404.05427) - Paper on autonomous code repair loops over real repositories.
+- 🔁 **Pattern** [Ralph](https://ghuntley.com/ralph/) - Geoffrey Huntley's original Ralph technique: run one agent in a bare loop with fresh context per iteration and the filesystem plus specs as memory.
+- 🔁 **Pattern** [everything is a ralph loop](https://ghuntley.com/loop/) - Follow-up essay arguing the loop, not the agent, is the durable engineering unit: one task per iteration, deterministic context, and verification inside the loop.
+- 🧰 **Tool** [how-to-ralph-wiggum](https://github.com/ghuntley/how-to-ralph-wiggum) - Reference repository documenting the Ralph Wiggum technique end to end, from the bare loop script to guardrails and conventions.
+- 📝 **Blog** [A Brief History of Ralph](https://www.humanlayer.dev/blog/brief-history-of-ralph) - Traces how the bare-loop technique spread from a provocation to a production practice among early adopters.
+- 🔁 **Pattern** [Ralph Copilot](https://github.com/giocaizzi/ralph-copilot/tree/e5b2813cc876c73a8c9d3398c0115da0d15f63cf) - Language-agnostic Ralph loop implementation using fresh context, filesystem memory, `PRD.md`, and `PROGRESS.md`.
+- 🔁 **Pattern** [Compound Engineering](https://every.to/guides/compound-engineering) - Every's named plan-work-review-compound loop, where each run feeds lessons back into `AGENTS.md`-style memory so the next loop is easier; the self-improving counterpart to Ralph.
+- 🧰 **Tool** [Gas Town](https://github.com/steveyegge/gastown) - Steve Yegge's multi-agent orchestrator that runs 20-30 parallel coding agents with coordinator, worker, and merge-queue roles; the structured-orchestration end of the spectrum that Ralph anchors with bare iteration.
+- 🧰 **Tool** [Amp](https://ampcode.com/) - Agentic coding tool built around threads, subagents, and an opinionated harness, with an owner's manual that documents loop-style operating practices.
+- 🧰 **Tool** [karl](https://github.com/kayoslab/karl) - Autonomous multi-agent development loop with planner, reviewer, architect, tester, developer, deployment, and retry phases.
+- 🔁 **Pattern** [joelclaw agent-loop skill](https://github.com/joelhooks/joelclaw/blob/main/skills/agent-loop/SKILL.md) - Durable Planner-Implementor-Reviewer-Judge coding loops via Inngest events and progress files.
+- 🧭 **List** [SWE-bench reading list](https://github.com/SWE-bench/reading-list) - Maintained map of software engineering agent systems and related papers.
+
+## Verification And Feedback Gates
+
+These resources include harness and observability mechanisms that loops compose into exit gates, receipts, and retry signals.
+
+- 📝 **Blog** [Why Agentic Systems Must Produce Deterministic Outputs to Scale](https://streamzero.com/blog/posts/deep-dives-tools-technologies-architectures/agentic-patterns/why-agentic-systems-must-produce-deterministic-outputs-to-scale) - Argues for deterministic boundaries, contracts, and execution gates around probabilistic agent reasoning.
+- 🔁 **Pattern** [Stop Babysitting Your Coding Agent. Give It Backpressure.](https://generativeprogrammer.com/p/stop-babysitting-your-coding-agent) - Explains how to turn tests, linters, builds, traces, and other signals into feedback loops for coding agents.
+- 🔁 **Pattern** [How to Build a Self-Verification Loop in Claude Code](https://dev.to/shipwithaiio/how-to-build-a-self-verification-loop-in-claude-code-3-layers-20-minutes-m1p) - Uses hooks to enforce syntax, intent, and regression checks before an agent can finish.
+- 📝 **Blog** [How to build a better agent harness with traces and evals](https://arize.com/blog/improve-ai-agents-traces-evals-harness/) - Trace-evaluate-debug-refine loop for improving agent behavior from real runs.
+- 📝 **Blog** [Better Harness: A Recipe for Harness Hill-Climbing with Evals](https://www.langchain.com/blog/better-harness-a-recipe-for-harness-hill-climbing-with-evals) - LangChain's recipe for using evals as the learning signal for harness improvement.
+- 📝 **Blog** [Improving Deep Agents with harness engineering](https://www.langchain.com/blog/improving-deep-agents-with-harness-engineering) - Practical discussion of self-verification, traces, middleware, and loop detection for coding agents.
+- 📚 **Docs** [OpenAI agent evals](https://developers.openai.com/api/docs/guides/agent-evals) - Evaluation guidance for moving from traces to repeatable grading of agent workflows.
+- 🧰 **Tool** [Promptfoo OpenAI Agents provider](https://www.promptfoo.dev/docs/providers/openai-agents/) - Testing and assertions for multi-turn agent workflows, tools, state, handoffs, sandboxes, and traces.
+- 🧰 **Tool** [Inspect AI](https://github.com/UKGovernmentBEIS/inspect_ai) - UK AISI evaluation framework with solvers, scorers, sandboxing, tool use, MCP, and log viewing.
+- 📚 **Docs** [OpenTelemetry Semantic Conventions for Generative AI Systems](https://opentelemetry.io/docs/specs/semconv/gen-ai/) - Portable tracing conventions for model calls, tool calls, and agent workflows.
+- 🧰 **Tool** [AgentOps](https://github.com/AgentOps-AI/agentops) - Monitoring, replay, cost tracking, benchmarking, and tracing for agent sessions.
+- 🧰 **Tool** [Langfuse](https://github.com/langfuse/langfuse) - Open-source LLM engineering platform with tracing, evaluations, and metrics that loops can read back as feedback signals.
+- 🧰 **Tool** [LangSmith](https://www.langchain.com/langsmith) - Tracing, evaluation, and monitoring platform for inspecting and grading agent runs across iterations.
+- 🧰 **Tool** [Arize Phoenix](https://github.com/Arize-ai/phoenix) - Open-source AI observability for tracing, evaluating, and debugging agent behavior from real runs.
+- 🧰 **Tool** [Braintrust](https://www.braintrust.dev/) - Evaluation and observability platform with experiments, datasets, and CI integration for gating agent changes.
+- 🧰 **Tool** [Weave](https://docs.wandb.ai/weave) - Weights & Biases toolkit for tracing, evaluating, and monitoring agent applications over time.
+- 📄 **Paper** [Agentic Verification of Software Systems](https://arxiv.org/abs/2511.17330) - Pairs a coding agent with a theorem prover (AutoRocq) in a generate-and-validate loop, turning formal proof into the exit gate for trusted automatic programming.
+
+## Securing Unattended Loops
+
+A loop that runs while nobody watches needs stronger boundaries than an interactive session. These resources cover the main risks: untrusted intake content, over-broad permissions, and unsandboxed execution.
+
+- ⚠️ **Critique** [The lethal trifecta for AI agents](https://simonwillison.net/2025/Jun/16/the-lethal-trifecta/) - Simon Willison's rule of thumb: private data, untrusted content, and an exfiltration channel must never meet inside one unattended agent.
+- ⚠️ **Critique** [Prompt injection series](https://simonwillison.net/series/prompt-injection/) - Ongoing series on the core unsolved vulnerability for loops whose intake includes content written by strangers.
+- 📚 **Docs** [Agentic AI - Threats and Mitigations](https://genai.owasp.org/resource/agentic-ai-threats-and-mitigations/) - OWASP threat model for agentic systems, useful when reviewing intake, memory, tool, and delegation boundaries.
+- 🧰 **Tool** [sandbox-runtime](https://github.com/anthropic-experimental/sandbox-runtime) - Anthropic's OS-level filesystem and network sandboxing for arbitrary processes without requiring a container.
+- 🧰 **Tool** [E2B](https://github.com/e2b-dev/E2B) - Open-source isolated cloud sandboxes for running untrusted, AI-generated code inside agent loops.
+- 📚 **Docs** [Modal Sandboxes](https://modal.com/docs/guide/sandboxes) - Secure sandboxed execution for agent-driven code with resource limits and network controls.
+- 🧰 **Tool** [Daytona](https://www.daytona.io/) - Infrastructure for running AI-generated code in fast, isolated sandboxes.
+
+## State, Memory, And Context Persistence
+
+This section focuses on durable loop state and cross-run context. For context-window design as its own lower layer, see the adjacent Context Engineering lists.
+
+- 📚 **Docs** [Effective Context Engineering for AI Agents](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents) - Anthropic guide to context as managed runtime state rather than a prompt dump.
+- 📝 **Blog** [Agent Harnesses: the Infrastructure Layer Your LLM Agent Actually Needs](https://ninadpathak.com/blog/agent-harnesses/) - Covers execution loops, state, checkpointing, observers, and replayability.
+- 📝 **Blog** [The Agent Loop Is the New OS](https://www.harness.io/blog/agent-loop-new-os) - Frames the agent loop as an OS-like boundary with context as RAM and tools as I/O.
+- 📝 **Blog** [Harness engineering for coding agent users](https://martinfowler.com/articles/harness-engineering.html) - Martin Fowler article on feedforward, feedback, and outer harnesses for coding agents.
+- 📝 **Blog** [Context Engineering](https://simonwillison.net/2025/Jun/27/context-engineering/) - Simon Willison's framing of context engineering, useful for distinguishing context state from loop orchestration.
+- 📝 **Blog** [Agentic Coding in 2026](https://sourcegraph.com/blog/agentic-coding) - Sourcegraph on supplying deterministic, large-codebase context and code intelligence so recurring agent runs reuse durable repository state instead of rediscovering it each time.
+- 📝 **Blog** [Agentic AI State Management with ScyllaDB and LangGraph](https://www.scylladb.com/2026/04/08/agentic-ai-state-management-with-scylladb-and-langgraph/) - Durable agent state with checkpointers, write-ahead logs, and time-travel branching.
+- 🧰 **Tool** [Mem0](https://github.com/mem0ai/mem0) - Open-source memory layer for retaining user, session, and agent state across repeated agent sessions.
+- 🧰 **Tool** [Letta](https://github.com/letta-ai/letta) - Stateful agent framework from the MemGPT line with persistent, self-editing memory across runs.
+- 🧰 **Tool** [Zep](https://github.com/getzep/zep) - Temporal knowledge graph memory that tracks how facts about users and systems change across sessions.
+- 🧰 **Tool** [LangMem](https://github.com/langchain-ai/langmem) - SDK for extracting, consolidating, and retrieving long-term agent memory between loop runs.
+- 🧰 **Tool** [Beads](https://github.com/steveyegge/beads) - Git-plus-SQLite issue and memory store that agents read and write with a `bd` CLI, giving recurring loops durable task state and progress that survives context resets.
+- 📄 **Paper** [ARC: Active and Reflection-driven Context Management for Long-Horizon Agents](https://arxiv.org/abs/2601.12030) - Treats context as a managed runtime artifact, reorganizing the working context when degradation or context rot is detected across a long run.
+
+## Orchestration And Multi-Agent Delegation
+
+- 🧰 **Tool** [AutoGen](https://github.com/microsoft/autogen) - Multi-agent programming framework for conversations, tool use, and orchestration; active development has moved to the Microsoft Agent Framework.
+- 🧰 **Tool** [Microsoft Agent Framework](https://github.com/microsoft/agent-framework) - Microsoft's successor to AutoGen and Semantic Kernel for building and orchestrating multi-agent workflows in Python and .NET.
+- 🧰 **Tool** [LangGraph](https://github.com/langchain-ai/langgraph) - Graph-based framework for controllable agent workflows, persistence, and human-in-the-loop steps.
+- 🧰 **Tool** [CrewAI](https://github.com/crewAIInc/crewAI) - Framework for multi-agent workflows organized around roles, tasks, and crews.
+- 📚 **Docs** [LlamaIndex Workflows](https://developers.llamaindex.ai/python/llamaagents/workflows/) - Event-driven workflow abstraction for agentic applications.
+- 📚 **Docs** [OpenAI Agents SDK handoffs](https://openai.github.io/openai-agents-python/handoffs/) - First-class delegation between specialized agents.
+- 📚 **Docs** [Agent Protocol](https://agentprotocol.ai/) - API protocol for agent interaction, useful for separating loop managers from agent runtimes.
+- 🧰 **Tool** [AgentKit](https://github.com/inngest/agent-kit) - TypeScript toolkit for durable, event-driven agents on workflow infrastructure.
+- 🧰 **Tool** [deepagents](https://github.com/langchain-ai/deepagents) - LangChain project for deeper, longer-running agents with middleware and harness patterns.
+- 📚 **Docs** [Temporal for AI](https://temporal.io/solutions/ai) - Durable execution for long-running agent workflows: crash-proof state, automatic retries, and human-in-the-loop signals.
+- 🧰 **Tool** [Restate](https://restate.dev/) - Durable execution runtime for building resilient, stateful agents and workflows that survive failures mid-loop.
+- 🧰 **Tool** [DBOS](https://www.dbos.dev/) - Lightweight Postgres-backed durable execution library for crash-proof agent workflows, queues, and scheduled triggers.
+- 🧰 **Tool** [Composio Agent Orchestrator](https://github.com/ComposioHQ/agent-orchestrator) - Orchestrates parallel coding agents in isolated worktrees that plan tasks, fix CI failures, respond to reviews, and manage their own PR lifecycle.
+
+## Benchmarks And Evaluation
+
+- 🧪 **Benchmark** [SWE-bench](https://www.swebench.com/) - Benchmark for resolving real GitHub issues through code editing and tests.
+- 📄 **Paper** [SWE-bench: Can Language Models Resolve Real-World GitHub Issues?](https://arxiv.org/abs/2310.06770) - Original SWE-bench paper.
+- 📄 **Paper** [SWE-bench Goes Live](https://arxiv.org/abs/2505.23419) - Dynamic benchmark designed to reduce overfitting to static issue sets.
+- 🧪 **Benchmark** [Terminal-Bench](https://www.tbench.ai/) - Benchmark for agents operating in terminal environments.
+- 🧰 **Tool** [Terminal-Bench repository](https://github.com/harbor-framework/terminal-bench) - Open-source benchmark and harness for hard terminal tasks.
+- 📄 **Paper** [AgentBench](https://arxiv.org/abs/2308.03688) - Multi-environment benchmark for evaluating LLMs as agents.
+- 📄 **Paper** [WebArena](https://arxiv.org/abs/2307.13854) - Realistic web environment for autonomous agents.
+- 📄 **Paper** [OSWorld](https://arxiv.org/abs/2404.07972) - Benchmark for multimodal agents operating full computer environments.
+- 📄 **Paper** [ToolBench](https://arxiv.org/abs/2307.16789) - Tool-use benchmark and dataset for tool-augmented agents.
+- 📄 **Paper** [GAIA](https://arxiv.org/abs/2311.12983) - Benchmark for general AI assistants requiring reasoning, tool use, and multi-step work.
+- 📄 **Paper** [Tau-bench](https://arxiv.org/abs/2406.12045) - Benchmark for tool-agent-user interactions in realistic domains.
+- 📄 **Paper** [VisualWebArena](https://arxiv.org/abs/2401.13649) - Visually grounded web-agent benchmark extending WebArena.
+- 📄 **Paper** [AppWorld](https://arxiv.org/abs/2407.18901) - Benchmark of interactive app tasks with state-based and execution-based evaluation.
+- 📄 **Paper** [Vending-Bench](https://arxiv.org/abs/2502.15840) - Benchmark for long-term coherence of autonomous agents; documents how small errors compound over very long loop horizons.
+- 🧪 **Benchmark** [Vending-Bench leaderboard](https://andonlabs.com/evals/vending-bench) - Live long-horizon coherence results from Andon Labs.
+- 📄 **Paper** [SWE-EVO: Benchmarking Coding Agents in Long-Horizon Software Evolution Scenarios](https://arxiv.org/abs/2512.18470) - Release-note-derived evolution tasks where agents score far below isolated-issue benchmarks, quantifying the long-horizon gap loops must manage.
+- 📄 **Paper** [EvoSkills: Self-Evolving Agent Skills via Co-Evolutionary Verification](https://arxiv.org/abs/2604.01687) - A skill generator and a co-evolving surrogate verifier improve multi-file skill packages over iterations, evaluated on the SkillsBench benchmark of structured skill bundles.
+- 📄 **Paper** [SlopCodeBench: Benchmarking How Coding Agents Degrade Over Long-Horizon Iterative Tasks](https://arxiv.org/abs/2603.24755) - Quantifies structural erosion and verbosity creep across iteration checkpoints in native harnesses like Claude Code and Codex, evidence for why loops need verification and budgets.
+- 📄 **Paper** [LongCLI-Bench: A Preliminary Benchmark for Long-horizon Agentic Programming in Command-Line Interfaces](https://arxiv.org/abs/2602.14337) - Long-horizon CLI tasks where most runs stall below 30% completion, mapping where unattended loops break down.
+
+## Operations Playbooks
+
+- 📝 **Blog** [Agentic Engineering: The Agent Loop](https://junpingyi.com/books/agentic-engineering/agent-loop/) - Minimal mental model for the loop underlying agent operation.
+- 📝 **Blog** [The agent loop: ReAct, plan-and-execute, reflection](https://www.kunwar.page/chapter/067-the-agent-loop-react-plan-and-execute-reflection) - Practical walkthrough of the base loop and common variants.
+- 📝 **Blog** [How to Build an Agent](https://ampcode.com/how-to-build-an-agent) - Thorsten Ball's demystification of the inner agent loop: a model, a loop, and enough tokens.
+- 📝 **Blog** [Agentic Coding Recommendations](https://lucumr.pocoo.org/2025/6/12/agentic-coding/) - Armin Ronacher's field notes on which practices hold up when agents do most of the work.
+- 📝 **Blog** [Coding Agents 101: The Art of Actually Getting Things Done](https://devin.ai/agents101) - Practical delegation guidance from the Devin team on scoping tasks agents can actually finish.
+- 📝 **Blog** [How Anthropic teams use Claude Code](https://claude.com/blog/how-anthropic-teams-use-claude-code) - Cross-team field report of real recurring agent workflows in engineering, security, and data science.
+- 📝 **Blog** [How Boris Uses Claude Code](https://howborisusesclaudecode.com/) - Unofficial but concrete compilation of Boris Cherny's autonomous setups: parallel worktrees, auto mode, `/loop`, `/schedule`, dynamic workflows, and `/goal` completion conditions.
+- 📝 **Blog** [Agent of the Day: Copilot Agent PR Analysis](https://github.github.com/gh-aw/blog/2026-05-26-agent-of-the-day/) - Official walkthrough of a daily scheduled agentic workflow that ingests PR data, analyzes it, and publishes findings to a Discussion, a concrete recurring loop with trigger, intake, analysis, and output.
+
+## Templates And Patterns
+
+Reusable patterns that contributors can turn into future examples, templates, or playbooks.
+
+- 🧾 **Template** [Resource entry template](templates/resource-entry.md) - Format for adding a single resource with evidence quality and category fit.
+- 🧾 **Template** [Loop pattern template](templates/loop-pattern.md) - Template for documenting an operational loop such as PR babysitting, CI repair, or feedback clustering.
+- 🧾 **Template** [Loop contract schema](schemas/loop-contract.schema.json) - Machine-readable schema for portable loop specs.
+- 🧾 **Template** [Loop contract preview script](scripts/preview_loop_contract.py) - Dependency-free demo that validates and renders a loop contract JSON file.
+- 🧾 **Template** [Translation guide](TRANSLATIONS.md) - How to add or maintain a language translation without drifting from the canonical English list.
+- 🧾 **Template** [Pattern library index](patterns/README.md) - Practical loop patterns with triggers, state, verification gates, budgets, and escalation paths.
+
+Additional loop patterns worth documenting include PR babysitting, CI repair, feedback clustering, deploy verification, and docs drift collection.
+
+## Examples And Schema
+
+Concrete examples make the loop contract easier to adapt to real repositories.
+
+- 🔁 **Pattern** [Example loop specs](examples/README.md) - Human-readable walkthroughs for PR babysitting, CI repair, and docs drift collection.
+- 🧾 **Template** [Loop contract library](examples/README.md#contract-library) - Schema-validated loop contracts for every pattern-library loop, from PR babysitting to model routing.
+- 🧾 **Template** [Runnable test-repair loop](examples/runnable/test-repair-loop.sh) - Dependency-light reference loop script with a verification gate, retry budget, durable progress log, repeat-failure detection, and escalation exit.
+- 🧾 **Template** [Runnable loop guide](examples/runnable/README.md) - Maps the script line by line to the Loop Contract and shows how to drive it with Claude Code, Codex CLI, or any agent CLI.
+
+Preview an example locally:
+
+```sh
+python3 scripts/preview_loop_contract.py examples/pr-babysitter-loop.json
+```
+
+## Community Gallery
+
+The gallery is for real-world or realistic loop examples contributed by the community.
+
+**Running a real loop?** Share it, real or anonymized, in the patterns discussion linked under Roadmap And Discussion below. Use the [minimum useful case study](gallery/README.md#minimum-useful-case-study) and [anonymization](gallery/README.md#safe-anonymization-checklist) checklists so others can learn from it safely.
+
+- 🧾 **Template** [Loop gallery guide](gallery/README.md) - Quality bar for contributed loop examples with receipts and lessons learned.
+- 🧾 **Template** [Loop gallery template](gallery/template.md) - Markdown template for sharing a loop's trigger, intake, state, verification, escalation, and safety notes.
+- 🔁 **Pattern** [PR babysitter reference loop](gallery/pr-babysitter-reference.md) - Reference gallery entry for keeping a pull request moving.
+- 🔁 **Pattern** [CI repair reference loop](gallery/ci-repair-reference.md) - Reference gallery entry for turning failing CI into a verified patch or escalation.
+- 🔁 **Pattern** [Docs drift reference loop](gallery/docs-drift-reference.md) - Reference gallery entry for recurring docs/code consistency checks.
+
+## Discovery And Distribution
+
+This repository includes a lightweight GitHub Pages landing page for search and social previews:
+
+- 🧾 **Template** [Landing page](https://chaoyue0307.github.io/awesome-loop-engineering/) - SEO-friendly entry point for the repository.
+- 🧾 **Template** [Landing page source](docs/index.html) - Source for the static landing page.
+- 🧾 **Template** [Sitemap](docs/sitemap.xml) - Crawl hints for the landing page and core repository pages.
+- 🧾 **Template** [Robots file](docs/robots.txt) - Allows indexing and points crawlers to the sitemap.
+
+For launch copy and backlink strategy, use the [distribution checklist](meta/DISTRIBUTION.md).
+
+## Roadmap And Discussion
+
+- 🧾 **Template** [Roadmap](ROADMAP.md) - Near-term work, pattern priorities, gallery goals, and open questions.
+- 🧾 **Template** [Launch article](posts/launch.md) - Shareable explanation of the concept and repository.
+- 🧾 **Template** [Discussion guide](meta/DISCUSSIONS.md) - Suggested discussion categories, starter prompts, and moderation standard.
+- 🔁 **Pattern** [Show your Loop Engineering patterns](https://github.com/ChaoYue0307/awesome-loop-engineering/discussions/2) - Community discussion for real or anonymized loop examples.
+
+## Pattern Library
+
+Practical loop patterns translate the abstract contract into runnable operating models. Each pattern documents the trigger, discover/intake step, agents, workspace, state, verification gates, retry budget, escalation path, and loop instruction.
+
+- 🔁 **Pattern** [PR babysitter](patterns/pr-babysitter.md) - Repeatedly checks review comments, CI, merge conflicts, stale threads, and readiness to merge.
+- 🔁 **Pattern** [CI repair loop](patterns/ci-repair-loop.md) - Reproduces failing checks, patches narrowly, reruns evidence, and escalates when failures are outside scope.
+- 🔁 **Pattern** [Docs drift collector](patterns/docs-drift-collector.md) - Finds mismatches between docs and code, proposes small patches, and verifies examples.
+- 🔁 **Pattern** [Deploy verifier](patterns/deploy-verifier.md) - Watches rollout signals, compares them with release expectations, and stops on anomalies.
+- 🔁 **Pattern** [Feedback clusterer](patterns/feedback-clusterer.md) - Periodically groups GitHub, Linear, Slack, support, or social feedback into actionable themes.
+- 🔁 **Pattern** [Dependency triage loop](patterns/dependency-triage-loop.md) - Classifies dependency updates, applies safe groups, verifies them, and escalates risky upgrades.
+- 🔁 **Pattern** [Evaluation regression loop](patterns/evaluation-regression-loop.md) - Investigates degraded agent evals with baseline traces, targeted reruns, and repair proposals.
+- 🔁 **Pattern** [Security review loop](patterns/security-review-loop.md) - Reviews sensitive diffs with evidence-backed findings, safe permissions, and human approval boundaries.
+- 🔁 **Pattern** [Cost-control loop](patterns/cost-control-loop.md) - Monitors agent workflow spend, identifies waste, proposes scoped savings, and preserves quality gates.
+- 🔁 **Pattern** [Bug hunting loop](patterns/bug-hunting-loop.md) - Discovers, reproduces, minimizes, and reports bugs with concrete evidence.
+- 🔁 **Pattern** [Enterprise approval loop](patterns/enterprise-approval-loop.md) - Drives a permissioned change through required gates and approvers with a full audit trail.
+- 🔁 **Pattern** [Incident response loop](patterns/incident-response-loop.md) - Triages an alert into an owned, evidence-backed incident with a postmortem seed.
+- 🔁 **Pattern** [Data-quality loop](patterns/data-quality-loop.md) - Validates each dataset refresh against quality rules and quarantines bad versions.
+- 🔁 **Pattern** [Release-note loop](patterns/release-note-loop.md) - Drafts release notes from merged commits, issues, and PRs with linked evidence.
+- 🔁 **Pattern** [Model-routing loop](patterns/model-routing-loop.md) - Routes tasks across models on measured quality, latency, privacy, and cost.
+
+## Critiques, Risks, And Limitations
+
+- ⚠️ **Critique** [Most Developers Do Not Need Agent Loops Yet](https://alphasignalai.substack.com/p/most-developers-do-not-need-agent) - Useful caution against adopting loops before the task, signal, and economics justify them.
+- ⚠️ **Critique** [Engineering Agentic Systems for Reliability](https://pruningmypothos.com/systems/engineering-agentic-systems-for-reliability/) - Cautions that agentic systems fail at boundaries when permissions, verification, traceability, and escalation are weak.
+- ⚠️ **Critique** [Self-Correcting Agents: Reflexion, CRITIC, and ReAct Loops Compared](https://callsphere.ai/blog/self-correcting-agents-reflexion-critic-react-loops-compared-2026) - Compares self-correction patterns and their cost/failure tradeoffs.
+- ⚠️ **Critique** [How to Build an AI Agent Harness: A 2026 Complete Guide](https://atlan.com/know/how-to-build-ai-agent-harness/) - Broad guide with useful warnings on data readiness, permissions, context management, and evaluation.
+- ⚠️ **Critique** [Harness Engineering vs Prompt Engineering vs Context Engineering Explained](https://medium.com/@visrow/harness-engineering-vs-prompt-engineering-vs-context-engineering-explained-0423b692c87d) - Adjacent framing that helps avoid confusing loop engineering with the surrounding harness discipline.
+
+## Adjacent Awesome Lists
+
+- 🧭 **List** [Awesome Harness Engineering](https://github.com/ai-boost/awesome-harness-engineering) - Comprehensive list for the agent harness layer that Loop Engineering builds on.
+- 🧭 **List** [Awesome Harness Engineering](https://github.com/walkinglabs/awesome-harness-engineering) - High-signal harness list with strong categories for context, guardrails, specs, evals, runtimes, and benchmarks.
+- 🧭 **List** [Awesome Agent Harness](https://github.com/AutoJunjie/awesome-agent-harness) - Curated tools and resources for environments, constraints, and feedback around coding agents.
+- 🧭 **List** [Awesome Context Engineering](https://github.com/Meirtz/Awesome-Context-Engineering) - Survey-style list for context engineering across LLMs and agents.
+- 🧭 **List** [Awesome Prompt Engineering](https://github.com/promptslab/Awesome-Prompt-Engineering) - Classic adjacent list for prompt techniques and prompting resources.
+- 🧭 **List** [Awesome LLM Agents](https://github.com/kaushikb11/awesome-llm-agents) - General list of LLM agent papers, frameworks, and applications.
+- 🧭 **List** [Awesome AI Agents](https://github.com/e2b-dev/awesome-ai-agents) - Broad AI agent ecosystem map.
+- 🧭 **List** [Awesome CLI Coding Agents](https://github.com/bradAGI/awesome-cli-coding-agents) - Directory of terminal-native coding agents, parallel runners, autonomous loops, and the harnesses that orchestrate them.
+- 🧭 **List** [Awesome Self-Evolving Agents](https://github.com/XMUDeepLIT/Awesome-Self-Evolving-Agents) - Survey-style list of agents that improve themselves over repeated runs, an adjacent angle on long-running loops with memory and verification.
+
+## Contributing
+
+Contributions are welcome. Please read [CONTRIBUTING.md](CONTRIBUTING.md) before opening a pull request.
+
+This repository uses a strict [curation standard](meta/CURATION.md) to keep the list focused, verifiable, and useful for builders. Maintainers can use the [maintenance guide](meta/MAINTENANCE.md) for link checks, identity checks, and periodic refreshes.
+
+For community expectations and support channels, see [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md), [SUPPORT.md](SUPPORT.md), and [SECURITY.md](SECURITY.md).
+
+Fast path for adding a resource:
+
+- Check that it is about AI/coding-agent Loop Engineering or a direct foundation for it.
+- Search the README to avoid duplicates.
+- Pick the most specific category.
+- Add one entry using this format:
+
+```md
+- 📄 **Paper** [Title](https://example.com) - One sentence explaining the resource's contribution to Loop Engineering.
+```
+
+- Open a pull request and explain the category fit, source type, and why builders should care.
+
+Fast path for contributing a loop pattern: start from the loop pattern template or loop contract schema, include trigger, discover/intake, delegation, workspace, context, verification, durable state, budget, escalation, and exit, then open a pattern suggestion issue if you want feedback before writing the full pattern.
+
+Good submissions should answer three questions:
+
+1. Is this about the new AI/coding-agent meaning of Loop Engineering or a direct foundation for it?
+2. Does it help someone design, run, verify, evaluate, or critique recurring agent systems that coordinate prompting, context, harnesses, verification, and state?
+3. Is the source stable, public, and specific enough to be useful?
+
+## Citation
+
+If this repository is useful in your work, please cite it with:
+
+```bibtex
+@misc{chaoyue2026awesome_loop_engineering,
+  author       = {He, Chaoyue},
+  title        = {Awesome Loop Engineering},
+  year         = {2026},
+  howpublished = {\url{https://github.com/ChaoYue0307/awesome-loop-engineering}},
+  note         = {Curated resources for Loop Engineering}
+}
+```
+
+**Reusable blurb** (for blog posts, talks, internal docs, or community posts):
+
+> Loop Engineering is the practice of designing recurring AI-agent and coding-agent systems that discover work, delegate to agents, verify results, persist state, and retry or escalate on a cadence or until a goal is reached. *Awesome Loop Engineering* is a curated, implementation-focused resource collection for this practice: [github.com/ChaoYue0307/awesome-loop-engineering](https://github.com/ChaoYue0307/awesome-loop-engineering)

README.pt-BR.md

@@ -0,0 +1,98 @@
+# Awesome Loop Engineering
+
+<!-- last-synced: 2026-06-11 -->
+
+<p align="center">
+  <img src="assets/awesome-loop-engineering-cover.png" alt="Awesome Loop Engineering cover" width="100%">
+</p>
+
+<p align="center">
+  <a href="README.md">English</a> |
+  <a href="README.zh-CN.md">中文</a> |
+  <a href="README.es.md">Español</a> |
+  <a href="README.fr.md">Français</a> |
+  <a href="README.de.md">Deutsch</a> |
+  <a href="README.ja.md">日本語</a> |
+  <a href="README.ko.md">한국어</a> |
+  <a href="README.pt-BR.md">Português</a> |
+  <a href="TRANSLATIONS.md">Ajudar a traduzir</a>
+</p>
+
+> Uma lista curada e orientada à implementação para **Loop Engineering**: a camada acima de prompt, context e harness engineering para projetar sistemas recorrentes de agentes de IA.
+
+Prompt engineering melhora o que você pede ao modelo. Context engineering melhora o que o modelo consegue ver. Harness engineering melhora ferramentas, permissões, sandboxes e verificações ao redor de uma execução de agente. **Loop Engineering fica acima das três**: projeta sistemas que acionam agentes, supervisionam, verificam resultados, persistem estado e executam novamente.
+
+Um loop descobre trabalho, delega para um ou mais agentes, verifica o resultado, registra estado, decide a próxima ação e executa novamente em uma cadência ou até atingir um objetivo verificável.
+
+Este repositório trata do novo significado de Loop Engineering no contexto de AI agents e coding agents. Ele não trata de event loops de software, teoria de controle, growth loops, automação genérica ou feedback loops não relacionados a IA.
+
+## Modelo Mental
+
+- Prompt engineering pergunta: o que devo dizer ao modelo?
+- Context engineering pergunta: que estado e conhecimento o modelo deve ver?
+- Harness engineering pergunta: quais ferramentas, permissões, testes, sandboxes e feedback devem cercar o agente?
+- Loop engineering pergunta: que sistema recorrente deve descobrir trabalho, delegar para agentes, verificar resultados, persistir estado, decidir próximas ações e rodar de novo?
+
+Prompt, context e harness engineering melhoram uma execução. Loop Engineering torna o trabalho de agentes repetível, observável e governável ao longo do tempo.
+
+## Loop Contract
+
+Um loop útil normalmente precisa deixar estes elementos visíveis:
+
+| Parte             | Pergunta de design                         | Artefato comum                                             |
+| ----------------- | ------------------------------------------ | ---------------------------------------------------------- |
+| Objective         | O que o loop deve otimizar?                | Goal, issue, PRD, runbook                                  |
+| Trigger           | Quando o loop roda?                        | Schedule, webhook, `/loop`, `/goal`, automation            |
+| Discover / Intake | Como o loop encontra trabalho?             | GitHub query, Linear filter, CI failure, feedback stream   |
+| Workspace         | Onde o agente pode agir com segurança?     | Worktree, sandbox, branch, container                       |
+| Context           | Que conhecimento durável deve carregar?    | `AGENTS.md`, `CLAUDE.md`, `SKILL.md`, docs                 |
+| Delegation        | Qual agente faz qual parte?                | Explorer, implementer, reviewer, judge                     |
+| Verification      | O que decide sucesso ou falha?             | Tests, typecheck, lint, evals, trace graders               |
+| State             | O que sobrevive para a próxima execução?   | Progress file, checkpoint, trace, issue comment            |
+| Budget            | Quando deve parar de gastar?               | Max turns, max retries, token budget, time box             |
+| Escalation        | Quando uma pessoa assume?                  | PR, issue, Slack alert, triage inbox                       |
+| Exit              | Como o loop sabe que terminou?             | Acceptance criteria, passing checks, no work found         |
+
+## Modelo de Maturidade
+
+| Nível | Nome                       | Descrição                                                                                |
+| ----- | -------------------------- | ---------------------------------------------------------------------------------------- |
+| 0     | Manual prompting           | Uma pessoa lê o estado e escreve o próximo prompt.                                       |
+| 1     | Scripted retry             | Um script devolve erros ao agente.                                                       |
+| 2     | Scheduled loop             | O agente roda em uma cadência e reporta resultados.                                      |
+| 3     | Stateful loop              | O progresso sobrevive por arquivos, issues, checkpoints ou traces.                       |
+| 4     | Self-verifying loop        | Checks determinísticos ou evaluator agents bloqueiam conclusões erradas.                 |
+| 5     | Multi-agent loop           | Agentes especializados dividem discovery, implementation, review e judgment.             |
+| 6     | Production-supervised loop | Observabilidade, budgets, approvals, rollback e escalonamento humano são centrais.       |
+
+## Primeiras Leituras
+
+A lista completa de recursos fica no README canônico em inglês: [README.md](README.md).
+
+Leituras recomendadas:
+
+- [Loop Engineering](https://addyosmani.com/blog/loop-engineering/) - Define a mudança de prompting manual para sistemas que promptam, verificam e continuam.
+- [Run long horizon tasks with Codex](https://developers.openai.com/blog/run-long-horizon-tasks-with-codex) - Runbook prático para plan-edit-test-observe-repair-document-repeat.
+- [Run prompts on a schedule](https://code.claude.com/docs/en/scheduled-tasks) - Mecânica oficial para `/loop`, scheduled tasks e prompts recorrentes.
+- [Building Effective Agents](https://www.anthropic.com/engineering/building-effective-agents) - Patterns componíveis para workflows e agentes.
+
+## Contribuir
+
+Contribuições são bem-vindas. Leia [CONTRIBUTING.md](CONTRIBUTING.md) antes de abrir um pull request.
+
+Fluxo rápido:
+
+1. Confirme que o recurso trata de Loop Engineering para AI/coding agents ou de uma base direta para isso.
+1. Pesquise no README para evitar duplicatas.
+1. Escolha a categoria mais específica.
+1. Adicione uma entrada neste formato:
+
+```md
+- 📄 **Paper** [Title](https://example.com) - One sentence explaining the resource's contribution to Loop Engineering.
+```
+
+1. Explique no PR a relevância, a categoria, o tipo de recurso e por que ele ajuda builders.
+
+## Traduções
+
+Para manter ou adicionar um idioma, leia [TRANSLATIONS.md](TRANSLATIONS.md). As traduções devem preservar o escopo estreito: não incluir event loops, growth loops ou automação genérica.

README.zh-CN.md

@@ -0,0 +1,105 @@
+# Awesome Loop Engineering
+
+<!-- last-synced: 2026-06-11 -->
+
+<p align="center">
+  <img src="assets/awesome-loop-engineering-cover.png" alt="Awesome Loop Engineering cover" width="100%">
+</p>
+
+<p align="center">
+  <a href="README.md">English</a> |
+  <a href="README.zh-CN.md">中文</a> |
+  <a href="README.es.md">Español</a> |
+  <a href="README.fr.md">Français</a> |
+  <a href="README.de.md">Deutsch</a> |
+  <a href="README.ja.md">日本語</a> |
+  <a href="README.ko.md">한국어</a> |
+  <a href="README.pt-BR.md">Português</a> |
+  <a href="TRANSLATIONS.md">帮助翻译</a>
+</p>
+
+> 面向 **Loop Engineering** 的精选资源列表：它位于 prompt、context 和 harness engineering 之上，关注如何设计可重复运行的 AI-agent 系统。
+
+Prompt engineering 改进你对模型说什么。Context engineering 改进模型能看到什么。Harness engineering 改进单次 agent 运行周围的工具、权限、沙箱和检查。**Loop Engineering 位于三者之上**：人不再逐轮手动提示 agent，而是设计一个循环系统，让它负责提示、监督、验证、更新状态并再次触发 agents。
+
+一个 loop 会发现工作、分派给一个或多个 agents、检查结果、记录状态、决定下一步，并按照节奏或直到满足可验证目标为止持续运行。
+
+本仓库不收录软件事件循环、控制论、增长循环、通用 workflow automation 或非 AI feedback loop。
+
+## 一句话定位
+
+- Prompt engineering 关注：我应该对模型说什么？
+- Context engineering 关注：模型应该看到什么状态和知识？
+- Harness engineering 关注：agent 周围应该有什么工具、权限、测试、沙箱和反馈？
+- Loop engineering 关注：当人不在内循环里时，什么系统负责发现工作、分派给 agents、验证结果、持久化状态、决定下一步并重新运行？
+
+Prompt、context 和 harness engineering 让单次 agent 运行更好。Loop Engineering 让 agent 工作能跨时间重复、观察和治理。
+
+## Loop Contract
+
+一个有效的 loop 通常需要这些部分：
+
+| 部分                | 设计问题           | 常见产物                                                  |
+| ----------------- | -------------- | ----------------------------------------------------- |
+| Objective         | loop 要优化什么？    | goal、issue、PRD、runbook                                |
+| Trigger           | 什么时候运行？        | schedule、webhook、`/loop`、`/goal`、automation           |
+| Discover / Intake | 如何发现工作？        | GitHub query、Linear filter、CI failure、feedback stream |
+| Workspace         | agent 在哪里安全行动？ | worktree、sandbox、branch、container                     |
+| Context           | 哪些知识应该长期存在？    | `AGENTS.md`、`CLAUDE.md`、`SKILL.md`、docs               |
+| Delegation        | 哪个 agent 负责什么？ | explorer、implementer、reviewer、judge                   |
+| Verification      | 什么机制判断通过或失败？   | tests、typecheck、lint、evals、trace graders              |
+| State             | 下一轮需要保留什么？     | progress file、checkpoint、trace、issue comment          |
+| Budget            | 何时停止消耗？        | max turns、max retries、token budget、time box           |
+| Escalation        | 何时交给人？         | PR、issue、Slack alert、triage inbox                     |
+| Exit              | loop 如何知道完成？   | acceptance criteria、passing checks、no work found      |
+
+## 成熟度模型
+
+| 等级  | 名称                         | 描述                                                              |
+| --- | -------------------------- | --------------------------------------------------------------- |
+| 0   | Manual prompting           | 人读取状态并写下一条 prompt。                                              |
+| 1   | Scripted retry             | 脚本把错误反馈给 agent。                                                 |
+| 2   | Scheduled loop             | agent 按固定节奏运行并报告结果。                                             |
+| 3   | Stateful loop              | 通过文件、issue、checkpoint 或 trace 保留进度。                             |
+| 4   | Self-verifying loop        | 用确定性检查或 evaluator agent 阻止错误完成。                                 |
+| 5   | Multi-agent loop           | discovery、implementation、review、judgment 由不同 agents 分工。         |
+| 6   | Production-supervised loop | observability、budget、approval、rollback、human escalation 都是一等公民。 |
+
+## 必读入口
+
+完整资源列表以英文 README 为准：[README.md](README.md)。
+
+建议从这些直接讨论 Loop Engineering 的资料开始：
+
+- [Loop Engineering](https://addyosmani.com/blog/loop-engineering/) - Addy Osmani 对 Loop Engineering 的核心定义和 Codex / Claude Code primitives 对照。
+- [Loop Engineering](https://addyo.substack.com/p/loop-engineering) - 同文 Substack 版本，包含 Peter Steinberger 和 Boris Cherny 的相关引用。
+- [Loop Engineering](https://cobusgreyling.substack.com/p/loop-engineering) - 简明解释从 prompt agents 到 design loops 的转变。
+- [Loop Engineering: The Guide for AI Agents](https://lushbinary.com/blog/loop-engineering-ai-coding-agents-guide/) - 面向实践的 guide，拆解 automations、worktrees、skills、connectors、subagents 和 state。
+- [Codex Loops: What Boris Cherny Gets Right About Managing Agent Work](https://www.developersdigest.tech/blog/codex-loops-boris-cherny-agent-routines) - 关于 PR babysitting、CI repair、deploy verification 和 feedback clustering 的 loop 思路。
+
+## 如何贡献内容
+
+欢迎提交 PR。请先阅读 [CONTRIBUTING.md](CONTRIBUTING.md)。
+
+最快流程：
+
+1. 确认资源属于 AI/coding-agent 语境的 Loop Engineering，或是它的直接基础。
+1. 在 README 中搜索，避免重复。
+1. 选择最具体的分类。
+1. 按这个格式添加一行：
+
+```md
+- 📄 **Paper** [Title](https://example.com) - One sentence explaining the resource's contribution to Loop Engineering.
+```
+
+1. 在 PR 中说明：为什么相关、属于哪个分类、资源类型是什么、为什么对 builders 有用。
+
+## 翻译
+
+如果你想维护新的语言版本，请阅读 [TRANSLATIONS.md](TRANSLATIONS.md)。翻译应该保留概念边界：不要把 event loop、growth loop 或普通 automation 翻译进来。
+
+## 许可证
+
+本仓库中的原创整理文字、注释、模板、模式文档和仓库元数据使用 [CC0-1.0](LICENSE) 发布。
+
+本仓库链接到的第三方论文、博客、文档、工具、benchmark、图片和其他外部资源仍遵循其原作者或发布方各自的许可证和使用条款。本仓库只是索引和链接它们，并不重新授权这些外部内容。

ROADMAP.md

@@ -0,0 +1,49 @@
+# Roadmap
+
+This roadmap keeps Awesome Loop Engineering focused on useful, verifiable work for an emerging practice.
+
+## Near Term
+
+- Collect more direct Loop Engineering sources as the term stabilizes.
+- Add real or anonymized gallery entries from practitioners running recurring agent loops.
+- Grow the runnable loop directory beyond the test-repair reference loop, including scheduled-trigger variants per runtime.
+- Add more translations for the introduction, mental model, Loop Contract, and contribution guide.
+- Continue replacing weak or unstable links with primary sources, official docs, papers, and implementation-heavy write-ups.
+
+## Pattern Library
+
+Completed reference patterns now cover PR babysitting, CI repair, docs drift, deploy verification, feedback clustering, dependency triage, evaluation regression, security review, cost-control, and bug hunting. Every pattern now ships a schema-validated loop contract in `examples/`.
+
+Next pattern-library work should focus on variants backed by operational evidence:
+
+- enterprise approval loops for permissioned agents;
+- incident response loops with pager handoff and postmortem evidence;
+- data-quality loops for repeated dataset or knowledge-base refresh;
+- release-note loops that connect commits, issues, docs, and changelogs;
+- model-routing loops that balance quality, latency, privacy, and cost.
+
+## Gallery
+
+The gallery should grow from reference examples into public or anonymized case studies. Good entries should include:
+
+- the runtime or agent tool used;
+- trigger and intake source;
+- verification gates;
+- durable state artifact;
+- budget and escalation rules;
+- receipts or anonymized evidence;
+- lessons learned after real use.
+
+## Quality And Governance
+
+- Keep CI dependency-light and easy for contributors to run locally.
+- Keep all resource annotations tied to recurring agent systems, not generic AI-agent interest.
+- Keep public claims conservative: this repository is an early curated field guide, not a finished standard.
+- Preserve clean owner-only commit identity for `main`.
+
+## Open Questions
+
+- Which loop primitives become common across Codex, Claude Code, GitHub Agentic Workflows, and custom runtimes?
+- What is the right schema shape for portable loop contracts?
+- Which verification gates are strong enough for unattended or semi-attended loops?
+- How should maintainers evaluate submitted real-world loop examples without exposing private data?

SECURITY.md

@@ -0,0 +1,26 @@
+# Security Policy
+
+This repository is a curated documentation and resource list. It does not ship a production service, package, or runtime. Security concerns can still appear in examples, scripts, links, or contribution material.
+
+## Please Report
+
+- A linked resource that appears malicious or impersonates another project.
+- A script or example that could cause unsafe actions if copied directly.
+- Accidentally committed credentials, tokens, private URLs, or sensitive data.
+- Guidance that could encourage unsafe production autonomy without approvals or escalation.
+
+## How To Report
+
+Open a private security advisory if GitHub offers that option for this repository. If not, open an issue with sensitive details removed and ask for a maintainer response.
+
+Do not post secrets, private customer data, exploit details, or internal URLs in public issues or pull requests.
+
+## Security Review Standard
+
+Loop Engineering examples should be conservative:
+
+- sensitive actions require human approval;
+- production actions should be read-only by default unless explicitly scoped;
+- credentials and secrets must never be included in examples;
+- loops should have retry budgets, exit conditions, and escalation paths;
+- verification should rely on concrete evidence, not only model self-assessment.

SUPPORT.md

@@ -0,0 +1,25 @@
+# Support
+
+This repository is maintained as a public field guide and curated resource list for Loop Engineering.
+
+## Best Channels
+
+- **Resource suggestions**: use the resource suggestion issue template.
+- **Loop patterns**: use the loop pattern suggestion issue template or the pinned community pattern issue.
+- **Corrections**: open a pull request when the fix is clear, or open an issue if it needs discussion.
+- **Translations**: use the translation proposal issue template and follow `TRANSLATIONS.md`.
+- **Security concerns**: follow `SECURITY.md`.
+
+## What Maintainers Can Help With
+
+- deciding whether a resource fits the narrow AI/coding-agent meaning of Loop Engineering;
+- improving annotations, categories, and source quality;
+- reviewing loop pattern contracts for trigger, intake, verification, state, budget, escalation, and exit;
+- fixing broken links or replacing unstable sources.
+
+## What Is Out Of Scope
+
+- product support for third-party agent tools;
+- private consulting on proprietary loops;
+- generic prompt engineering questions with no loop, state, verification, or recurring system angle;
+- unrelated software event loops, growth loops, control theory loops, or generic automation.

TAXONOMY.md

@@ -0,0 +1,56 @@
+# Loop Engineering Taxonomy
+
+This taxonomy gives contributors a shared vocabulary for classifying AI-agent loops.
+
+## By Trigger
+
+- **Scheduled loop**: runs on a cadence such as hourly, daily, weekly, or during a rollout window.
+- **Event-triggered loop**: starts from a webhook, failed check, new comment, issue label, release event, or alert.
+- **Goal-driven loop**: continues until a verifiable goal is met, such as passing tests or resolving all blocking comments.
+- **Manual bootstrap loop**: starts from a human command, then follows a repeatable contract with state, verification, and exit rules.
+
+## By Work Intake
+
+- **Queue loop**: consumes work from issues, PRs, tickets, alerts, feedback streams, or triage inboxes.
+- **Scan loop**: periodically searches a repository, dashboard, logs, docs, or benchmark output for new work.
+- **Reactive loop**: responds to a specific failure signal such as CI, eval regression, deploy anomaly, or user report.
+
+## By Verification
+
+- **Deterministic loop**: uses tests, typechecks, lint, schemas, dashboards, or threshold checks as the main gate.
+- **Evaluator loop**: uses a second model, rubric, reviewer, or judge agent to evaluate output.
+- **Human-supervised loop**: requires human approval before sensitive actions or before completion is accepted.
+- **Receipt-based loop**: records evidence such as commands, logs, trace IDs, screenshots, PR links, or issue comments.
+
+## By State Model
+
+- **Stateless retry loop**: feeds immediate failure evidence back into one session. Useful but fragile.
+- **File-backed loop**: stores progress in `PROGRESS.md`, task files, runbooks, or generated reports.
+- **Issue-backed loop**: stores progress in GitHub, Linear, Jira, Slack, or another system of record.
+- **Checkpointed loop**: persists structured state in a database, workflow engine, trace store, or event log.
+
+## By Agent Topology
+
+- **Single-agent loop**: one agent acts, with deterministic checks or human review.
+- **Maker-checker loop**: one agent changes the artifact and another verifies it.
+- **Manager-worker loop**: an orchestrator decomposes work and assigns specialized agents.
+- **Adversarial loop**: reviewer, critic, or security agents try to falsify the maker's output.
+
+## By Operating Domain
+
+- **Repository loop**: PR babysitting, CI repair, bug hunting, docs drift, dependency triage.
+- **Release loop**: deploy verification, canary monitoring, rollback recommendation, incident handoff.
+- **Feedback loop**: user feedback clustering, issue deduplication, community triage, roadmap signal collection.
+- **Evaluation loop**: recurring benchmark runs, trace review, regression detection, prompt or harness hill-climbing.
+
+## Maturity Path
+
+Most teams should move in this order:
+
+1. Manual bootstrap loop with explicit state.
+1. Scheduled or event-triggered loop with deterministic gates.
+1. Maker-checker loop with durable receipts.
+1. Multi-agent or workflow-backed loop.
+1. Production-supervised loop with observability, approvals, budgets, and rollback rules.
+
+Higher maturity is not automatically better. The right loop is the simplest loop that can safely discover work, delegate, verify, persist state, decide the next action, and stop.

TRANSLATIONS.md

@@ -0,0 +1,52 @@
+# Translations
+
+The canonical list is [README.md](README.md). Translations should help more readers understand Loop Engineering without drifting from the repository's scope.
+
+## Available
+
+- [English](README.md)
+- [中文](README.zh-CN.md)
+- [Español](README.es.md)
+- [Français](README.fr.md)
+- [Deutsch](README.de.md)
+- [日本語](README.ja.md)
+- [한국어](README.ko.md)
+- [Português](README.pt-BR.md)
+
+## Wanted
+
+Maintainers and contributors are welcome for:
+
+- Русский
+- Italiano
+- العربية
+- हिन्दी
+
+## Translation Rules
+
+- Preserve the narrow definition: AI/coding-agent Loop Engineering as the layer above prompt, context, and harness engineering.
+- Do not translate unrelated meanings into scope: event loops, control theory, growth loops, generic automation, or non-AI feedback loops.
+- Keep the English README as the source of truth for the full resource list.
+- Prefer translating the introduction, mental model, Loop Contract, maturity model, and contribution instructions first.
+- If you translate the full resource list, keep URLs unchanged and translate only annotations.
+- Add yourself as a translation maintainer in your PR if you can help keep the file current.
+- Every translation carries a `<!-- last-synced: YYYY-MM-DD -->` marker near the top. When you review a translation against the current English README, bump the date. CI fails when a marker is missing or older than 180 days.
+
+## Suggested File Names
+
+- `README.de.md`
+- `README.es.md`
+- `README.fr.md`
+- `README.ja.md`
+- `README.ko.md`
+- `README.pt-BR.md`
+- `README.ru.md`
+
+## Translation PR Checklist
+
+- [ ] The translation links back to the canonical English README.
+- [ ] The language switcher has been updated in `README.md`.
+- [ ] The `<!-- last-synced: YYYY-MM-DD -->` marker is present and current.
+- [ ] The translation preserves the scope boundary.
+- [ ] Resource URLs are unchanged.
+- [ ] Technical terms are translated consistently or left in English where that is clearer.

assets/README.md

@@ -0,0 +1,10 @@
+# Assets
+
+This directory contains visual assets used by the repository README, GitHub Pages landing page, and social previews.
+
+- `awesome-loop-engineering-cover.png` - Wide social and README cover image. It visualizes the Prompt, Context, Harness, and Loop stack.
+- `loop-engineering-stack.svg` - Lightweight stack diagram showing how Loop Engineering sits above prompt, context, and harness engineering.
+- `loop-contract-cards.svg` - Visual card grid for the Loop Contract: objective, trigger, intake, workspace, context, delegation, verification, state, budget, escalation, and exit.
+- `loop-lifecycle.svg` - One pass of a recurring loop: Intake, Delegate, Act, Verify, Persist, and Decide, where Decide retries, escalates, or exits.
+
+Please keep assets lightweight and directly useful for repository presentation. Avoid adding screenshots or large generated files unless they improve the README or documentation experience.

docs/.nojekyll

@@ -0,0 +1 @@
+

docs/index.html

@@ -0,0 +1,293 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>Awesome Loop Engineering</title>
+    <meta name="description" content="A curated field guide to Loop Engineering: designing recurring AI-agent systems above prompt, context, and harness engineering.">
+    <meta name="robots" content="index,follow">
+    <link rel="canonical" href="https://chaoyue0307.github.io/awesome-loop-engineering/">
+    <meta property="og:type" content="website">
+    <meta property="og:title" content="Awesome Loop Engineering">
+    <meta property="og:description" content="Curated resources, patterns, examples, schema, and field guides for recurring AI-agent systems.">
+    <meta property="og:url" content="https://chaoyue0307.github.io/awesome-loop-engineering/">
+    <meta property="og:image" content="https://raw.githubusercontent.com/ChaoYue0307/awesome-loop-engineering/main/assets/awesome-loop-engineering-cover.png">
+    <meta name="twitter:card" content="summary_large_image">
+    <meta name="twitter:title" content="Awesome Loop Engineering">
+    <meta name="twitter:description" content="A field guide for designing recurring AI-agent systems above prompt, context, and harness engineering.">
+    <meta name="twitter:image" content="https://raw.githubusercontent.com/ChaoYue0307/awesome-loop-engineering/main/assets/awesome-loop-engineering-cover.png">
+    <style>
+      :root {
+        color-scheme: dark;
+        --bg: #0f172a;
+        --panel: #111827;
+        --muted: #cbd5e1;
+        --text: #f8fafc;
+        --accent: #38bdf8;
+        --accent-2: #a78bfa;
+        --border: rgba(148, 163, 184, 0.24);
+      }
+      * {
+        box-sizing: border-box;
+      }
+      body {
+        margin: 0;
+        background:
+          radial-gradient(circle at 10% 0%, rgba(56, 189, 248, 0.22), transparent 26rem),
+          radial-gradient(circle at 90% 10%, rgba(167, 139, 250, 0.2), transparent 28rem),
+          var(--bg);
+        color: var(--text);
+        font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+        line-height: 1.6;
+      }
+      a {
+        color: #7dd3fc;
+        text-decoration: none;
+      }
+      a:hover {
+        text-decoration: underline;
+      }
+      main {
+        width: min(1120px, calc(100% - 32px));
+        margin: 0 auto;
+        padding: 48px 0 72px;
+      }
+      .hero {
+        display: grid;
+        gap: 28px;
+        grid-template-columns: minmax(0, 1.1fr) minmax(280px, 0.9fr);
+        align-items: center;
+      }
+      .eyebrow {
+        color: var(--accent);
+        font-size: 0.82rem;
+        font-weight: 800;
+        letter-spacing: 0.14em;
+        text-transform: uppercase;
+      }
+      h1 {
+        margin: 10px 0 18px;
+        font-size: clamp(2.4rem, 6vw, 5.4rem);
+        line-height: 0.95;
+        letter-spacing: -0.055em;
+      }
+      .lead {
+        max-width: 760px;
+        color: var(--muted);
+        font-size: clamp(1.08rem, 2vw, 1.3rem);
+      }
+      .actions {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 12px;
+        margin-top: 28px;
+      }
+      .button {
+        border: 1px solid var(--border);
+        border-radius: 999px;
+        padding: 11px 18px;
+        background: rgba(15, 23, 42, 0.72);
+        color: var(--text);
+        font-weight: 700;
+      }
+      .button.primary {
+        border-color: transparent;
+        background: linear-gradient(90deg, var(--accent), var(--accent-2));
+        color: #08111f;
+      }
+      .visual {
+        border: 1px solid var(--border);
+        border-radius: 28px;
+        overflow: hidden;
+        background: rgba(17, 24, 39, 0.74);
+        box-shadow: 0 24px 80px rgba(0, 0, 0, 0.28);
+      }
+      .visual img {
+        display: block;
+        width: 100%;
+      }
+      .wide-visual {
+        border: 1px solid var(--border);
+        border-radius: 28px;
+        overflow: hidden;
+        background: rgba(17, 24, 39, 0.72);
+        box-shadow: 0 24px 80px rgba(0, 0, 0, 0.24);
+      }
+      .wide-visual img {
+        display: block;
+        width: 100%;
+      }
+      .section {
+        margin-top: 56px;
+      }
+      .grid {
+        display: grid;
+        gap: 16px;
+        grid-template-columns: repeat(3, minmax(0, 1fr));
+      }
+      .card {
+        min-height: 100%;
+        border: 1px solid var(--border);
+        border-radius: 22px;
+        padding: 22px;
+        background: rgba(17, 24, 39, 0.72);
+      }
+      .card h2,
+      .card h3 {
+        margin: 0 0 10px;
+        line-height: 1.2;
+      }
+      .card p,
+      .card li {
+        color: var(--muted);
+      }
+      .stack {
+        display: grid;
+        gap: 12px;
+      }
+      .layer {
+        border: 1px solid var(--border);
+        border-radius: 18px;
+        padding: 16px 18px;
+        background: rgba(15, 23, 42, 0.76);
+      }
+      .layer strong {
+        color: var(--text);
+      }
+      .definition {
+        border-left: 4px solid var(--accent);
+        padding: 18px 22px;
+        border-radius: 16px;
+        background: rgba(15, 23, 42, 0.76);
+        color: var(--muted);
+      }
+      footer {
+        margin-top: 64px;
+        color: #94a3b8;
+        font-size: 0.95rem;
+      }
+      @media (max-width: 850px) {
+        .hero,
+        .grid {
+          grid-template-columns: 1fr;
+        }
+        main {
+          padding-top: 28px;
+        }
+      }
+    </style>
+    <script type="application/ld+json">
+      {
+        "@context": "https://schema.org",
+        "@type": "CollectionPage",
+        "name": "Awesome Loop Engineering",
+        "url": "https://chaoyue0307.github.io/awesome-loop-engineering/",
+        "description": "A curated field guide to Loop Engineering: designing recurring AI-agent systems above prompt, context, and harness engineering.",
+        "isPartOf": {
+          "@type": "WebSite",
+          "name": "Awesome Loop Engineering",
+          "url": "https://github.com/ChaoYue0307/awesome-loop-engineering"
+        },
+        "about": [
+          "Loop Engineering",
+          "AI agents",
+          "Coding agents",
+          "Agent workflows"
+        ],
+        "author": {
+          "@type": "Person",
+          "name": "Chaoyue He"
+        }
+      }
+    </script>
+  </head>
+  <body>
+    <main>
+      <section class="hero">
+        <div>
+          <div class="eyebrow">Awesome Loop Engineering</div>
+          <h1>Design loops, not just prompts.</h1>
+          <p class="lead">
+            Loop Engineering is the AI and coding-agent practice of designing recurring systems that discover work, delegate it to agents, verify results, persist state, decide next actions, and run again.
+          </p>
+          <div class="actions">
+            <a class="button primary" href="https://github.com/ChaoYue0307/awesome-loop-engineering">Open GitHub Repo</a>
+            <a class="button" href="https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/DEFINITION.md">Read Definition</a>
+            <a class="button" href="https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/examples/README.md">See Examples</a>
+          </div>
+        </div>
+        <div class="visual">
+          <img src="https://raw.githubusercontent.com/ChaoYue0307/awesome-loop-engineering/main/assets/loop-engineering-stack.svg" alt="Loop Engineering stack diagram">
+        </div>
+      </section>
+
+      <section class="section">
+        <div class="definition">
+          <strong>Canonical definition:</strong>
+          Loop Engineering is the AI and coding-agent practice of designing recurring systems that discover work, delegate it to agents, verify results, persist state, decide next actions, and run again on a cadence, event, or until a verifiable goal is reached.
+        </div>
+      </section>
+
+      <section class="section wide-visual" aria-label="Loop Contract visual">
+        <img src="https://raw.githubusercontent.com/ChaoYue0307/awesome-loop-engineering/main/assets/loop-contract-cards.svg" alt="Loop Contract cards">
+      </section>
+
+      <section class="section wide-visual" aria-label="Loop Engineering lifecycle visual">
+        <img src="https://raw.githubusercontent.com/ChaoYue0307/awesome-loop-engineering/main/assets/loop-lifecycle.svg" alt="Loop Engineering lifecycle: Intake, Delegate, Act, Verify, Persist, Decide; Decide retries by feeding evidence back, escalates to a human, or exits when the goal is met">
+      </section>
+
+      <section class="section grid" aria-label="Engineering stack">
+        <div class="card">
+          <h2>The Stack</h2>
+          <div class="stack">
+            <div class="layer"><strong>Prompt Engineering</strong><br>What should I say to the model?</div>
+            <div class="layer"><strong>Context Engineering</strong><br>What state and knowledge should the model see?</div>
+            <div class="layer"><strong>Harness Engineering</strong><br>What tools, permissions, tests, and sandboxes surround one run?</div>
+            <div class="layer"><strong>Loop Engineering</strong><br>What recurring system governs agent work over time?</div>
+          </div>
+        </div>
+        <div class="card">
+          <h2>What The Repo Contains</h2>
+          <ul>
+            <li>Curated papers, blogs, docs, tools, benchmarks, and patterns.</li>
+            <li>Manifesto, taxonomy, comparison guide, and anti-patterns.</li>
+            <li>Validated loop contract schema and example loop specs.</li>
+            <li>Pattern library for PR, CI, docs, deploy, feedback, dependency, eval, security, cost, and bug-hunting loops.</li>
+          </ul>
+        </div>
+        <div class="card">
+          <h2>Contribute</h2>
+          <p>
+            Share resources, corrections, or real loop patterns with trigger, intake, delegation, verification, state, budget, escalation, and receipts.
+          </p>
+          <p><a href="https://github.com/ChaoYue0307/awesome-loop-engineering/issues/1">Join the community pattern thread</a></p>
+        </div>
+      </section>
+
+      <section class="section grid" aria-label="Key links">
+        <div class="card">
+          <h3>Start Here</h3>
+          <p>Use the README for the complete curated map and contribution path.</p>
+          <p><a href="https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md">Read the README</a></p>
+        </div>
+        <div class="card">
+          <h3>Field Guides</h3>
+          <p>Understand the concept, boundaries, taxonomy, anti-patterns, and comparisons.</p>
+          <p><a href="https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/MANIFESTO.md">Read the Manifesto</a></p>
+        </div>
+        <div class="card">
+          <h3>Build A Loop</h3>
+          <p>Start from validated JSON specs or the pattern template.</p>
+          <p><a href="https://github.com/ChaoYue0307/awesome-loop-engineering/tree/main/examples">View examples</a></p>
+        </div>
+      </section>
+
+      <footer>
+        <p>
+          This is an early curated map of an emerging practice, not a final standard.
+          Original repository materials are released under CC0-1.0.
+        </p>
+      </footer>
+    </main>
+  </body>
+</html>

docs/llms.txt

@@ -0,0 +1,20 @@
+# Awesome Loop Engineering
+
+> Curated resources and practical patterns for Loop Engineering: the practice of designing recurring AI-agent and coding-agent systems that discover work, delegate to agents, verify results, persist state, and run again on a cadence or until a verifiable goal is reached.
+
+## Core
+
+- [README](https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md): the curated list with the Loop Contract, design checklist, and maturity model
+- [Canonical definition](https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/DEFINITION.md): short definition, positioning, and minimal loop test
+- [Taxonomy](https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/TAXONOMY.md): classification by trigger, intake, verification, state model, and topology
+- [Anti-patterns](https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/ANTI-PATTERNS.md): common loop failure modes
+
+## Patterns
+
+- [Pattern library](https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/patterns/README.md): operational loop patterns with triggers, gates, budgets, and escalation
+- [Loop contracts](https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/examples/README.md): schema-validated contract JSON for every pattern, plus runnable reference loops
+
+## Optional
+
+- [Landing page](https://chaoyue0307.github.io/awesome-loop-engineering/)
+- [Contributing](https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/CONTRIBUTING.md)

docs/robots.txt

@@ -0,0 +1,4 @@
+User-agent: *
+Allow: /
+
+Sitemap: https://chaoyue0307.github.io/awesome-loop-engineering/sitemap.xml

docs/sitemap.xml

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+  <url>
+    <loc>https://chaoyue0307.github.io/awesome-loop-engineering/</loc>
+    <changefreq>weekly</changefreq>
+    <priority>1.0</priority>
+  </url>
+  <url>
+    <loc>https://github.com/ChaoYue0307/awesome-loop-engineering</loc>
+    <changefreq>weekly</changefreq>
+    <priority>0.9</priority>
+  </url>
+  <url>
+    <loc>https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/DEFINITION.md</loc>
+    <changefreq>monthly</changefreq>
+    <priority>0.8</priority>
+  </url>
+  <url>
+    <loc>https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/MANIFESTO.md</loc>
+    <changefreq>monthly</changefreq>
+    <priority>0.8</priority>
+  </url>
+  <url>
+    <loc>https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/examples/README.md</loc>
+    <changefreq>monthly</changefreq>
+    <priority>0.7</priority>
+  </url>
+</urlset>

examples/README.md

@@ -0,0 +1,90 @@
+# Loop Examples
+
+These examples show how to turn the abstract loop contract into concrete operating specs.
+
+## Contract Library
+
+Every loop in the [pattern library](../patterns/README.md) has a matching contract. Each JSON file follows [`schemas/loop-contract.schema.json`](../schemas/loop-contract.schema.json) and is validated in CI:
+
+- [`pr-babysitter-loop.json`](pr-babysitter-loop.json)
+- [`ci-repair-loop.json`](ci-repair-loop.json)
+- [`docs-drift-loop.json`](docs-drift-loop.json)
+- [`deploy-verifier-loop.json`](deploy-verifier-loop.json)
+- [`feedback-clusterer-loop.json`](feedback-clusterer-loop.json)
+- [`dependency-triage-loop.json`](dependency-triage-loop.json)
+- [`evaluation-regression-loop.json`](evaluation-regression-loop.json)
+- [`security-review-loop.json`](security-review-loop.json)
+- [`cost-control-loop.json`](cost-control-loop.json)
+- [`bug-hunting-loop.json`](bug-hunting-loop.json)
+- [`enterprise-approval-loop.json`](enterprise-approval-loop.json)
+- [`incident-response-loop.json`](incident-response-loop.json)
+- [`data-quality-loop.json`](data-quality-loop.json)
+- [`release-note-loop.json`](release-note-loop.json)
+- [`model-routing-loop.json`](model-routing-loop.json)
+
+Use them as starting points. Adapt triggers, tools, checks, state artifacts, and escalation rules to your repository and runtime.
+
+## Runnable Loops
+
+The [runnable directory](runnable/README.md) contains working loop scripts, starting with a dependency-light test-repair loop you can drive with Claude Code, Codex CLI, or any agent CLI.
+
+## PR Babysitter
+
+Use when a PR needs recurring attention but should not require a human to poll comments, checks, conflicts, and stale review state.
+
+Example loop instruction:
+
+```text
+Every 2 hours during working hours, inspect PR <number>.
+Load review comments, check status, mergeability, linked issues, and project instructions.
+If there is a narrow mechanical blocker, patch it in an isolated worktree and run the smallest relevant checks.
+Record commands, changed files, check URLs, and remaining blockers in a PR comment.
+Stop when the PR is merge-ready, waiting only on human review, blocked, or out of retry budget.
+```
+
+Good gates:
+
+- required checks pass;
+- unresolved comments are answered or resolved;
+- merge conflicts are gone;
+- diff is limited to the stated blocker.
+
+## CI Repair Loop
+
+Use when failing CI should be turned into either a small verified patch or an escalation note.
+
+Example loop instruction:
+
+```text
+When a required CI check fails, inspect the failing check, logs, artifacts, changed files, and recent successful run.
+Identify the exact failing command or closest local equivalent.
+Patch only the smallest log-backed cause, rerun the failing command first, and summarize evidence.
+Escalate instead of changing tests, broad CI config, dependencies, or unrelated files without proof.
+```
+
+Good gates:
+
+- the original failing command passes locally or in rerun CI;
+- the patch is limited to the failure cause;
+- behavior changes include focused tests;
+- the report includes the failing log excerpt and passing output.
+
+## Docs Drift Collector
+
+Use when docs need periodic alignment with code, CLI behavior, schemas, or examples.
+
+Example loop instruction:
+
+```text
+Weekly, scan changed files, public docs, examples, generated API references, CLI help, and docs-related issues.
+Confirm each possible drift item against code, schema, tests, or runtime output before editing.
+Patch only verified mismatches, run docs/link/example checks, and record false positives so future runs do not repeat them.
+Escalate when product behavior, generated docs, credentials, or screenshots need owner judgment.
+```
+
+Good gates:
+
+- examples run or match current output;
+- link checker passes;
+- generated files are not edited manually unless that is the project convention;
+- false positives are recorded as loop state.

examples/bug-hunting-loop.json

@@ -0,0 +1,59 @@
+{
+  "name": "Bug hunting",
+  "objective": "Find, validate, and report likely bugs with reproducible evidence instead of filing speculative agent-generated issues.",
+  "trigger": {
+    "type": "scheduled",
+    "cadence_or_event": "Weekly on modules with recent churn, and when error logs spike or flaky tests cluster."
+  },
+  "intake": {
+    "sources": ["error logs", "flaky tests", "issue labels", "support snippets", "recent diffs", "traces"],
+    "selection_rule": "Start only from concrete signals, search for duplicate issues first, and pursue candidates that reproduce in a safe environment."
+  },
+  "workspace": {
+    "isolation": "Branch, worktree, sandbox, or read-only mode depending on the target.",
+    "allowed_actions": ["run tests and local fixtures", "static search", "non-production reproduction", "file evidence-backed issues or small PRs"],
+    "disallowed_actions": ["production data access", "destructive fuzzing", "speculative mass issue creation", "broad refactors"]
+  },
+  "context": {
+    "required_files": ["module ownership docs", "safe reproduction commands"],
+    "runtime_sources": ["existing bug reports", "prior bug-hunt state and false positives"]
+  },
+  "agents": [
+    {
+      "role": "Scout",
+      "responsibility": "Discover suspicious signals and likely affected code paths."
+    },
+    {
+      "role": "Reproducer",
+      "responsibility": "Attempt minimal reproduction in a safe environment."
+    },
+    {
+      "role": "Minimizer",
+      "responsibility": "Reduce the reproduction to the smallest failing case."
+    },
+    {
+      "role": "Reporter",
+      "responsibility": "File evidence-backed issues, or a small PR with tests when the cause is clear."
+    }
+  ],
+  "verification": {
+    "gates": ["reports include reproducible steps or a clear trace link", "patches include a failing test or deterministic reproduction", "duplicate search is recorded", "expected vs actual behavior is grounded in docs or tests"],
+    "receipts": ["modules checked", "signals inspected", "reproduction commands", "expected and actual behavior", "final disposition"]
+  },
+  "state": {
+    "artifacts": ["bug-hunt log", "false-positive ledger"],
+    "update_rule": "Persist checked areas, reproductions, false positives, and dispositions so future runs do not repeat work."
+  },
+  "budget": {
+    "max_retries": 3,
+    "max_runtime_minutes": 90
+  },
+  "escalation": {
+    "conditions": ["production-only bug", "privacy-sensitive logs", "security-sensitive finding", "possible data loss", "fix needs architectural judgment"],
+    "destination": "Module owner via issue; private channel for security-sensitive findings"
+  },
+  "exit": {
+    "success": "A bug is reproduced and reported with evidence, or a small verified patch is opened.",
+    "stop_without_success": "The signal is classified as non-bug, retries are exhausted, or owner judgment is needed."
+  }
+}

examples/ci-repair-loop.json

@@ -0,0 +1,59 @@
+{
+  "name": "CI repair loop",
+  "objective": "Turn a failing CI signal into a small verified fix or a precise escalation note.",
+  "trigger": {
+    "type": "event",
+    "cadence_or_event": "A required CI check fails on an active pull request."
+  },
+  "intake": {
+    "sources": ["failed check name", "CI logs", "artifacts", "changed files", "recent successful run"],
+    "selection_rule": "Work only on failures with a reproducible command or a clear log-backed cause."
+  },
+  "workspace": {
+    "isolation": "Clean worktree based on the failing commit.",
+    "allowed_actions": ["inspect logs", "run test commands", "apply narrow fixes", "add focused tests"],
+    "disallowed_actions": ["weaken assertions", "delete tests", "broad formatting", "unrequested dependency upgrade"]
+  },
+  "context": {
+    "required_files": ["AGENTS.md", "README.md", "CONTRIBUTING.md"],
+    "runtime_sources": ["CI log URL", "failing command", "test artifacts"]
+  },
+  "agents": [
+    {
+      "role": "Investigator",
+      "responsibility": "Extract the failing command, error, and likely affected files."
+    },
+    {
+      "role": "Implementer",
+      "responsibility": "Make the smallest patch consistent with the failure evidence."
+    },
+    {
+      "role": "Verifier",
+      "responsibility": "Rerun the failing command and adjacent cheap checks."
+    },
+    {
+      "role": "Reporter",
+      "responsibility": "Summarize evidence and residual risk."
+    }
+  ],
+  "verification": {
+    "gates": ["original failing command passes", "patch is limited to the failure cause", "new behavior has a focused test when needed"],
+    "receipts": ["failing log excerpt", "commands run", "passing output", "diff summary"]
+  },
+  "state": {
+    "artifacts": ["CI repair progress note", "PR comment"],
+    "update_rule": "Record failed command, root-cause hypothesis, patch attempts, verification output, and unresolved blockers."
+  },
+  "budget": {
+    "max_retries": 3,
+    "max_runtime_minutes": 90
+  },
+  "escalation": {
+    "conditions": ["missing credentials", "third-party outage", "nondeterministic failure", "fix exceeds scope"],
+    "destination": "PR comment or issue assigned to the owning team"
+  },
+  "exit": {
+    "success": "The target check passes locally or in rerun CI.",
+    "stop_without_success": "Failure is flaky, not reproducible, blocked by environment, or requires owner approval."
+  }
+}

examples/cost-control-loop.json

@@ -0,0 +1,59 @@
+{
+  "name": "Cost control",
+  "objective": "Keep long-running agent workflows within budget by measuring usage, identifying waste, and proposing scoped efficiency improvements.",
+  "trigger": {
+    "type": "scheduled",
+    "cadence_or_event": "Daily or weekly usage review, and when spend, tokens, retries, or runtime exceed thresholds for a workflow."
+  },
+  "intake": {
+    "sources": ["token and model usage", "tool-call counts", "retry volume", "trace IDs", "billing exports", "recent workflow changes"],
+    "selection_rule": "Cluster usage by workflow, task type, model, and retry cause; investigate only clusters that exceed budget policy or baseline."
+  },
+  "workspace": {
+    "isolation": "Read-only access to traces, billing exports, dashboards, and workflow configs.",
+    "allowed_actions": ["analyze usage", "inspect traces", "propose config or prompt changes", "verify against representative tasks"],
+    "disallowed_actions": ["silent quality-reducing changes", "disabling verification gates", "production routing changes"]
+  },
+  "context": {
+    "required_files": ["budget policy", "accepted cost exceptions"],
+    "runtime_sources": ["baseline spend window", "trace samples", "recent prompt and harness changes"]
+  },
+  "agents": [
+    {
+      "role": "Analyst",
+      "responsibility": "Cluster usage by workflow, task type, model, tool, and retry cause."
+    },
+    {
+      "role": "Investigator",
+      "responsibility": "Inspect traces for context bloat, repeated failures, and missing stop conditions."
+    },
+    {
+      "role": "Optimizer",
+      "responsibility": "Propose the smallest change: smaller context, cheaper routing, caching, batching, or early exit."
+    },
+    {
+      "role": "Verifier",
+      "responsibility": "Rerun sample tasks or evals to confirm quality is preserved."
+    }
+  ],
+  "verification": {
+    "gates": ["before/after usage measured on a comparable task mix", "quality gates and evals still pass", "savings estimates include uncertainty and sample size", "verification and escalation remain intact"],
+    "receipts": ["baseline spend", "usage clusters", "trace samples", "before/after metrics", "verification results"]
+  },
+  "state": {
+    "artifacts": ["cost review report", "accepted-exception ledger"],
+    "update_rule": "Record baseline, suspected causes, proposed changes, and verification evidence after each review."
+  },
+  "budget": {
+    "max_retries": 2,
+    "max_runtime_minutes": 60
+  },
+  "escalation": {
+    "conditions": ["quality tradeoff required", "model-routing policy change", "customer impact", "unknown spend source"],
+    "destination": "Workflow owner with before/after evidence and rollout plan"
+  },
+  "exit": {
+    "success": "Spend returns below threshold, or a verified scoped optimization is proposed with evidence.",
+    "stop_without_success": "The cause is explained but the fix requires owner approval, or retries are exhausted."
+  }
+}

examples/data-quality-loop.json

@@ -0,0 +1,59 @@
+{
+  "name": "Data quality",
+  "objective": "Keep a recurring dataset or knowledge base trustworthy by validating each refresh against explicit quality rules before it is published.",
+  "trigger": {
+    "type": "event",
+    "cadence_or_event": "After each dataset or knowledge-base refresh, or nightly; also when the source schema changes or a freshness SLA is breached."
+  },
+  "intake": {
+    "sources": ["new dataset version", "schema and row counts", "prior accepted version", "quality rule definitions"],
+    "selection_rule": "Validate the latest version against the data contract and quality rules; quarantine on any hard-rule failure."
+  },
+  "workspace": {
+    "isolation": "Read access to the dataset, schema, profiling tools, and prior versions; quarantine area separate from production.",
+    "allowed_actions": ["run validation queries", "profile the data", "write a quality report", "quarantine a failing version"],
+    "disallowed_actions": ["edit source data", "publish to production", "relax rules without review"]
+  },
+  "context": {
+    "required_files": ["data contract or schema", "quality-rule definitions", "ownership map"],
+    "runtime_sources": ["load metrics", "profiling output", "diff against the last accepted version"]
+  },
+  "agents": [
+    {
+      "role": "Profiler",
+      "responsibility": "Compute counts, distributions, null rates, and freshness for the new version."
+    },
+    {
+      "role": "Validator",
+      "responsibility": "Check the profile against quality rules and the prior accepted baseline."
+    },
+    {
+      "role": "Investigator",
+      "responsibility": "Classify each failure as a defect, an accepted shift, or a rule bug."
+    },
+    {
+      "role": "Reporter",
+      "responsibility": "Record results, quarantine bad versions, and propose rule fixes."
+    }
+  ],
+  "verification": {
+    "gates": ["hard rules pass before a version is promotable", "distribution shifts beyond threshold are flagged with the delta", "every quarantine cites the failing rule and a sample", "accepted exceptions are recorded"],
+    "receipts": ["dataset version", "profile metrics", "rule results", "quarantine status with samples"]
+  },
+  "state": {
+    "artifacts": ["quality report", "accepted-exception ledger"],
+    "update_rule": "Persist the profile, rule results, and any new accepted exception so recurring shifts are not re-investigated."
+  },
+  "budget": {
+    "max_retries": 2,
+    "max_runtime_minutes": 90
+  },
+  "escalation": {
+    "conditions": ["ambiguous distribution shift", "schema change needing a data-contract update", "repeated upstream failure", "regulated or PII-bearing fields", "a rule that may itself be wrong"],
+    "destination": "Dataset owner via the data-quality channel"
+  },
+  "exit": {
+    "success": "The version is validated against all hard rules and ready for promotion.",
+    "stop_without_success": "The version is quarantined with evidence, or a shift needs owner judgment."
+  }
+}

examples/dependency-triage-loop.json

@@ -0,0 +1,59 @@
+{
+  "name": "Dependency triage",
+  "objective": "Classify dependency updates into safe patches, deferred upgrades, or human-review items with reproducible evidence.",
+  "trigger": {
+    "type": "scheduled",
+    "cadence_or_event": "Weekly, and on Dependabot, Renovate, or advisory-driven update PRs."
+  },
+  "intake": {
+    "sources": ["dependency update PRs", "release notes and changelogs", "security advisories", "lockfile diffs", "package audit output"],
+    "selection_rule": "Group updates by risk: safe patch, minor feature, major migration, security, or blocked; act automatically only on the safe group."
+  },
+  "workspace": {
+    "isolation": "Clean branch or worktree per update group.",
+    "allowed_actions": ["run package manager commands", "run tests, typechecks, and builds", "apply low-risk updates", "comment on PRs"],
+    "disallowed_actions": ["major version migrations", "runtime version changes", "security-policy changes", "broad multi-group upgrades"]
+  },
+  "context": {
+    "required_files": ["compatibility policy", "supported runtime versions"],
+    "runtime_sources": ["recent CI status", "known flaky tests", "prior triage state"]
+  },
+  "agents": [
+    {
+      "role": "Classifier",
+      "responsibility": "Group updates by risk, security relevance, version change, and blast radius."
+    },
+    {
+      "role": "Implementer",
+      "responsibility": "Apply low-risk updates and resolve lockfile conflicts."
+    },
+    {
+      "role": "Verifier",
+      "responsibility": "Run targeted tests, typechecks, builds, and package audits."
+    },
+    {
+      "role": "Reporter",
+      "responsibility": "Record accepted, deferred, and human-review updates with reasons."
+    }
+  ],
+  "verification": {
+    "gates": ["lockfile and manifest are consistent", "relevant tests, typecheck, build, and audit pass", "no skipped migration steps named in changelogs", "diff is limited to the intended group"],
+    "receipts": ["package versions and changelog links", "commands run with output", "deferred reasons", "reviewer questions"]
+  },
+  "state": {
+    "artifacts": ["triage report comment", "processed-update ledger"],
+    "update_rule": "Record processed update IDs, verification evidence, and deferral reasons after each group."
+  },
+  "budget": {
+    "max_retries": 2,
+    "max_runtime_minutes": 60
+  },
+  "escalation": {
+    "conditions": ["major version upgrade", "runtime requirement change", "security advisory with product impact", "licensing concern", "repeated verification failure"],
+    "destination": "Issue assigned to the repository owner with the blocked group and evidence"
+  },
+  "exit": {
+    "success": "Safe updates are verified and merged or review-ready, and risky updates are deferred with reasons.",
+    "stop_without_success": "Verification fails repeatedly or remaining updates all require human review."
+  }
+}