Skip to content

Loop Engineering — Reading List

A curated, slim collection of the best reading on loop engineering — articles, essays, and reference implementations. Content is selected for depth and longevity, not recency. Weaker pieces are removed when better ones arrive; the list stays short by design.

Each entry records why it earned a place — a reference for future curation decisions.


Why Loops: The Case for the Shift

Articles that establish why the shift from prompting to loop design matters. These belong in every practitioner's reading queue before anything else.


Loop Engineering — Addy Osmani

Added: 2026-06-24 · Published: Jun 2026

Why here: The founding document of loop engineering as a named discipline. Osmani opens by quoting Peter Steinberger — "You shouldn't be prompting coding agents anymore. You should be designing loops that prompt your agents" — and Boris Cherny — "My job is to write loops" — then states the discipline's founding line: "Loop engineering is replacing yourself as the person who prompts the agent."

Summary: Frames loop engineering as sitting "one floor above the harness" and maps five building blocks plus a sixth (memory) — Automations, Worktrees, Skills, Plugins/connectors, and Sub-agents — across the Codex app and Claude Code (the same six blocks docs/03 documents for Claude Code alone). Closes with three risks that get sharper, not easier, as loops improve: verification staying on the human, "comprehension debt" from shipping code you didn't read, and "cognitive surrender" — the pull to stop having an opinion once the loop runs itself.


The Anthropic leader who built Claude Code now writes loops — The New Stack

Added: 2026-06-24 · Published: Jun 2026

Why here: Secondary coverage, not primary — checked directly (Sep 2026): this piece reports the "my job is to write loops" line via an embedded third-party tweet (@Av1dlive) describing a video clip, not from an interview conducted for the piece itself. The primary source is Cherny's own on-stage remarks at Acquired Unplugged, presented by WorkOS (~11:45, Jun 2026). Kept here for its framing of where the discipline is headed, not as the quote's origin.

Summary: News explainer on the loop-engineering trend — not an interview — reporting Boris Cherny's public shift from prompting to writing loops (via a third-party tweet) alongside Peter Steinberger's and Addy Osmani's related posts that named the pattern. Describes how Anthropic internally structures agent workflows, why the terminal is just the first surface ("Claude Everywhere"), and how the role of a software engineer changes when implementation is no longer the bottleneck.


Loop Engineering: Designing the Execution Harness Around an LLM — @roanbrasil

Added: 2026-06-24 · Published: Jun 2026

Why here: The best quantified argument for loops over single-turn prompting. The 0.9^10 = 35% compound probability example is the sharpest demonstration that reliability requires a correction loop, not a better model.

Summary: Proves mathematically why single-turn invocations fail for complex tasks: 10 sequential decisions each at 90% accuracy yields only 35% end-to-end success. Argues the performance ceiling of any LLM system is set by the loop quality, not the model. "A mediocre model inside a well-engineered loop outperforms a frontier model invoked once." Frames the historical progression: 2022 (f(prompt)→answer) → 2023 (LangChain agent loops) → 2024–2026 (stabilised harness architecture).


The Coming Loop — Armin Ronacher

Added: 2026-06-24 · Published: Jun 2026

Why here: The necessary counterpoint. Flask's creator identifies two failure modes that optimists miss — amplification effect and cognitive dependency — and defines the domains where loops genuinely work. Reading only pro-loop material produces brittle practitioners; this article prevents that.

Summary: Names the amplification effect (each loop iteration adds defensive complexity, making systems less understandable while appearing more robust) and cognitive dependency (codebases become unmaintainable without permanent AI participation). Argues loop-generated code exhibits weaker invariants and unnecessary complexity. Also defines where loops legitimately excel: code porting, performance benchmarking, security scanning, research exploration, and disposable outputs. Essential reading before deploying loops in production systems.


Harness Engineering and Loop Engineering: The Fundamentals Are What Matter — Gautham Pai (jnaapti)

Added: 2026-10-19 · Published: 2026-10-18

Why here: A calmer second counterpoint than the "is it over?" posts: it neither sells the label nor dismisses the practice, and it separates the loop that does the work from the loop that improves how the work is done. Read in full on 2026-10-19.

Summary: Defines an agent execution loop (act, observe, repeat until done, needs help or a limit) and a self-improvement loop (evaluate, find a weakness, propose a change, test, keep or discard), and argues both need tools, context, state, permissions and checks whatever the work is called. Includes a Google Trends capture (2026-10-18) where "loop engineering" interest spikes around June, then declines, read by the author as attention, not usefulness. Transferable rule: an agent that proposes changes to its own workflow needs a baseline comparison, test cases and a rollback, because "Producing a revised workflow is not evidence that the workflow improved."


Getting Started: Practical How-Tos

Tutorials, walkthroughs, and frameworks for writing your first loops.


AI Loop Engineering: Build Autonomous Agents with Claude Code /goal + Routines — Sabrina Ramonov

Added: 2026-06-24 · Published: Jun 2026

Why here: The most direct step-by-step tutorial for loop engineering with Claude Code specifically. Introduces three of the most-cited concepts in the community: DOER/CHECKER, the AI Leverage Formula, and the stopping-condition test. Practical, opinionated, and reproducible.

Summary: Covers the DOER/CHECKER pattern ("No grading its own homework" — one agent does the work, a different one checks it), the AI Leverage Formula (AI Leverage = Your Skill × Your Clarity), and the stopping condition prerequisite: "If you can't say what done looks like, you don't have a loop. You have a wish." Demonstrates building an autonomous loop using /goal and Routines, with concrete examples of bounded vs. unbounded tasks.


Agentic Loops: From ReAct to Loop Engineering (2026 Guide) — Data Science Dojo

Added: 2026-06-24 · Published: 2026

Why here: Best taxonomy of loop evolution for practitioners who need historical context. The Inner/Outer Dual Loop pattern is uniquely well-explained here and not documented as clearly elsewhere.

Summary: Four-generation taxonomy: AutoGPT-era (2023) → ReAct (2022–2023) → OODA/Dual Loop (2024) → Ralph/goal loops (2025–2026). The Inner/Outer Dual Loop: an outer loop monitors the inner loop and resets strategy when it fails repeatedly, preventing the agent from grinding indefinitely on a blocked sub-goal. Includes cost benchmarks: ~4× tokens for single-agent loops, ~15× for multi-agent, vs. standard chat.


How I AI: How to write AI agent loops in Claude Code and Codex — Claire Vo / Lenny's Newsletter

Added: 2026-06-24 · Published: Jun 2026

Why here: Introduces job-description framing — the most intuitive technique for writing loop prompts that practitioners with a product background can apply immediately without deep engineering knowledge.

Summary: Covers heartbeat/cron/hook/goal loop types with live demos. The key contribution is job-description framing: write loop prompts as employee onboarding documents (frequency, output deliverables, escalation contacts, performance standard) rather than technical specifications. The framing captures intent and judgment boundaries — exactly what an autonomous loop needs to act without constant supervision.


Three Key Loops for Building Great Software — Andrew Ng (The Batch)

Added: 2026-06-26 · Published: 2026-06-26

Why here: The clearest mental model for where the human fits once loops run the implementation, from one of the field's most authoritative voices. The three-nested- feedback-loops framing (and the "context advantage" that keeps humans necessary) is not articulated this cleanly anywhere else in the list.

Summary: Frames AI-powered product development as three interconnected feedback loops at different cadences: the agentic coding loop (agents build and test a new version every few minutes), the developer feedback loop (humans review at intervals of tens of minutes to hours), and the external feedback loop (user data over days). The better the inner loop closes itself, the longer agents "work productively without human intervention" — but the human loop persists because humans hold a context advantage: they understand user needs better than current AI. The engineer's role becomes holding the context the agent lacks and steering at the cadence the agent cannot self-correct.


My thoughts on Fable — Ben's Bites

Added: 2026-07-08 · Published: Jul 2026

Why here: The most practitioner-legible catalog of the loop-type decision the KB documents formally elsewhere (docs/24). Written as a personal search for an ideal "thinking harness" rather than a reference doc, it's a useful on-ramp for readers who want the intuition before the taxonomy.

Summary: Ben searches for a creative "thinking harness" that fits how he actually works, and in doing so catalogs the loop types now available in Claude Code — turn-based prompts, /goal, /loop, /schedule, and proactive routines — evaluating each against his own workflow rather than in the abstract. Useful as a worked example of applying the Goals vs. Loops decision framework to a real, non-engineering task.


Loop Engineering, beyond prompt, context, and harness engineering — Guillaume Laforge & Wietse Venema (Google Cloud)

Added: 2026-10-19 · Published: 2026-10-06 (deck posted; talk given at Devoxx)

Why here: The most complete public slide set on the term: five-layer definitions (prompt, context, harness, loop, graph), a six-part loop anatomy, worked maker/checker shapes and six named failure modes in one place. A practitioner synthesis, not research: its primitives are Osmani's (slide 19 cites his essay), so read it after the founding documents above. The PDF's text layer (68 pages) was read in full; slide images were only spot-checked and no demo was run.

Summary: Billed as a "3-hour deep dive". Anatomy: trigger, contract/goal, action/maker, verifier/checker, state/memory, stopping gate. Demo loops: maker/checker, planner/maker/checker, red/green/refactor, maker/dreamer with persistent memory; case studies are Huntley's Ralph loop and Karpathy's autoresearch. Failure modes: runaway token burn, unverified autonomy, uncheckable goals, impossible goals, complexity ceiling, context saturation. Graph engineering is the deterministic network routing between loops, as in docs/21; its trigger/exit quadrant is in docs/20.


Harness Design & Architecture

Deep-dive articles on the engineering of the harness — the scaffolding around the agent.


Harness Design for Long-Running Application Development — Anthropic Engineering (Prithvi Rajasekaran)

Added: 2026-06-24 · Published: Mar 2026

Why here: The authoritative first-party reference on harness design. Real cost data, the three-agent architecture, and the "load-bearing vs. optional" principle are not available elsewhere at this level of detail and credibility.

Summary: Documents Anthropic's own harness evolution from a two-part (initializer + coding agent) to a three-agent system (Planner + Generator + QA/Evaluator). Introduces sprint contracts (generator and evaluator negotiate a set of testable criteria before each build phase — one sprint alone had 27), the load-bearing vs. optional principle (re-baseline complexity with each model release), and real cost benchmarks: solo agent $9/20min (broken) vs. full harness $200/6h (working). Key finding: Claude Sonnet 4.5 required context resets; Opus 4.5 largely eliminated the need.


How Claude Mythos found a 15-year-old bug in Mozilla Firefox — Brian Grinstead / Lenny's Newsletter

Added: 2026-06-24 · Published: Jun 2026

Why here: The best published case study of a production security harness. Concrete, verified, with outcome data (423 fixes) and the engineer's direct attribution split between model and harness. Most articles describe patterns; this one shows a working harness at scale.

Summary: Describes a modular security harness built on top of Claude for Mozilla Firefox: LLM scoring to prioritize files by bug likelihood before allocating agents, a mandatory score→fix→verify pipeline where each stage cannot be skipped, and a dedicated verifier subagent separate from the bug-finder. Result: 423 security fixes in one month. Grinstead attributes ~50% of results to the harness architecture and ~50% to model capability — the harness is not incidental.


Harness engineering: leveraging Codex in an agent-first world — OpenAI

Added: 2026-09-09 · Published: Feb 2026

Why here: OpenAI's own primary-source definition and case study — the only entry in this group not from Anthropic, a third-party book, or a practitioner blog. Replaces Martin Dilger's "Loop Engineering — or why you should never argue with an agent" (a single-author LinkedIn post with no quantified backing, still cited directly in docs/17 for its Context Pollution content) with a dedicated first-party account carrying real production numbers.

Summary: Five months, 0 lines of human-written code, ~1M LOC, ~1,500 merged PRs across 3→7 engineers (3.5 PRs/engineer/day, throughput increasing as the team grew). AGENTS.md is deliberately kept to ~100 lines as a "table of contents" pointing into a structured docs/ system-of-record rather than a monolithic instruction file. A recurring cleanup that once cost a dedicated 20%-of-week "AI slop" day was replaced by codifying "golden principles" into linters and a scheduled Codex-driven cleanup pass. (Direct fetch 403s — captured via Wayback.)


Harness Books — AgentWay (wquguru)

Added: 2026-06-24 · Published: Jun 2026

Why here: The most rigorous theoretical treatment of harness design published to date. Introduces the "unstable components" axiom as a foundational stance, ledger closure (every tool_use must pair with tool_result), input governance pipeline, and the runtime republic vs. constitutional control plane distinction — concepts not covered at this depth elsewhere.

Summary: A collection of essays arguing the model is an unreliable runtime component requiring containment, not a collaborator requiring instructions. Key contributions: ledger closure for interrupted tool calls, five-step input governance pipeline (prefetch/snip/microcompact/collapse/autocompact), reactive compact with circuit breaker (reserve 20K output tokens, early-warning at 13K remaining, halt after 3 consecutive failures), synthesis as the non-delegable orchestration bottleneck, and the runtime republic (Claude Code) vs. constitutional control plane (Codex) framing. Essential reading once you have working harnesses and want to make them production-grade.


Building Effective Agents — Anthropic

Added: 2026-06-26 · Published: Dec 2024

Why here: The canonical first-party reference for agent workflow architecture. The five patterns defined here — evaluator-optimizer especially — are the vocabulary the entire field now uses, regardless of whether practitioners trace it back to this document. Pre-dates "loop engineering" as a named discipline but is the foundational design reference every serious practitioner converges on.

Summary: Defines five composable patterns for multi-step agent systems: prompt chaining (sequential processing where each call processes the previous output), routing (a classifier directs each input to a specialised sub-pipeline), parallelization (independent sub-tasks fan out in parallel, outputs aggregated), orchestrator-workers (coordinator breaks the task down; specialist agents execute sub-tasks), and evaluator-optimizer (generator and evaluator alternate until the evaluator's criteria are met — the canonical maker/checker loop). Includes guidance on when not to use agentic frameworks and how to design for reliability in each pattern.


Self-Improving Harnesses

Research on harnesses that optimize themselves — the harness as an evolvable artifact with measurable, benchmarked returns, not a fixed human-authored wrapper.


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

Added: 2026-07-02 · Published: Apr 2026

Why here: The strongest evidence to date that a harness can improve itself and beat a human-designed baseline — and the only source that isolates which harness components carry the gains (ablation), which no other entry in the KB does.

Summary: Automates harness evolution on three observability pillars: component observability (each editable element is file-level, explicit, reversible), experience observability (raw trajectories → a layered evidence corpus), and decision observability (every edit ships a self-declared prediction later verified against the next round's outcomes — a falsifiable maker/checker contract applied to the harness's own changes). Results: Terminal-Bench 2 Pass@1 69.7%→77.0% over 10 iterations, beating the human-designed Codex-CLI baseline (71.9%); top SWE-bench-verified aggregate with 12% fewer tokens than the seed harness; cross-family transfer +5.1 to +10.1pp. Ablation: gains come from tools, middleware, and memory — not system prompts.


Self-Harness: Harnesses That Improve Themselves — arXiv 2606.09498 (v1, Jun 2026)

Added: 2026-07-02 · Published: Jun 2026

Why here: The cleanest statement of the self-improvement loop — a three-stage procedure an agent can run on its own traces with no stronger external model or human engineer — and the first to report per-model gains from turning weaknesses into executable harness edits.

Summary: A three-stage loop: (1) Weakness Mining extracts model-specific failure patterns from execution traces; (2) Harness Proposal generates targeted, minimal harness edits addressing them; (3) Proposal Validation regression-tests each candidate before acceptance. Key claim: it converts model-specific weaknesses into concrete, executable harness changes rather than generic prompt instructions. Terminal-Bench-2.0 gains with the model held fixed: MiniMax M2.5 40.5%→61.9%, Qwen3.5-35B-A3B 23.8%→38.1%, GLM-5 42.9%→57.1% (up to +21.4pp absolute). (Figures are from v1, live at capture; v2/v3, Aug 2026, broadened this to 3 benchmarks / 9 model-benchmark pairs and reframed the headline result as a relative gain of up to 132%.)


Don't Train the Model, Evolve the Harness — Hugging Face (Joel Niklaus)

Added: 2026-07-04 · Published: Jul 2026

Why here: The sharpest cost evidence in this group — the other two entries report accuracy gains with the model held fixed; this one reports a 7x cost reduction at matched accuracy, and isolates harness quality as the sole variable across a 3.5%–80.1% score range with model and tasks both held constant.

Summary: A proposer/accept-reject loop rewrites only the harness code around a frozen model, evaluated on a legal-agent benchmark. The evolved harness matches Sonnet 4.6's score at roughly 7x lower inference cost; holding model and tasks fixed, score varies from 3.5% to 80.1% depending solely on harness quality. Reinforces the KB's central thesis — the harness, not the model, is the leverage point — with a cost multiplier attached rather than only an accuracy delta.


HarnessX: A Composable, Adaptive, and Evolvable Agent Harness Foundry — arXiv 2606.14249

Added: 2026-07-06 · Published: Jun 2026

Why here: The only entry in this group that frames harness components as a substitution algebra (any typed primitive can be swapped for an equivalent) rather than an ad-hoc set of editable parts — a structural contribution the other two entries don't make, and the paper most directly cited elsewhere in this KB (docs/24).

Summary: Frames runtime components — prompts, tools, memory, control flow — as typed harness primitives over a substitution algebra, with an evolution engine (AEGIS) that refines them from execution traces. Reports +14.5% average gains across five benchmarks (ALFWorld, GAIA, WebShop, and two others), up to +44.0%. Distinct from Self-Harness (weakness-mining loop) and AHE (observability pillars) by contributing the typing and substitution formalism underneath both.


metaharness — ruvnet

Added: 2026-07-07 · Published: Jul 2026

Why here: The only entry in this group that specifies how to avoid the overfitting risk SEAGym warns about, rather than just reporting benchmark gains. Its Darwin Mode enforces strict train/eval disjointness between the traces that generate a mutation and the held-out benchmark that gates it — a methodological detail none of the arXiv papers in this group make explicit.

Summary: A factory-model harness generator (branded CLI, MCP server, governance policy, witness-signed release provenance) with a self-evolution mode, Darwin (@metaharness/darwin), that mutates its own config, sandbox-tests each candidate, and keeps only mutations that measurably improve a held-out benchmark (SWE-bench Lite, LiveCodeBench) strictly disjoint from the mutation-generating traces. A companion model router learns the cheapest-sufficient model per task from fleet-wide eval logs, and a Cost-Pareto leaderboard requires Wilson 95% confidence intervals on submissions — statistical rigor not seen elsewhere in this reading list.


Goal Engineering & Stopping Conditions

The stopping condition is where most loops fail. These articles address it directly.


Goal Engineering — Cobus Greyling

Added: 2026-06-24 · Published: Jun 2026

Why here: Introduces a formal vocabulary that the broader community lacks: the Goals vs. Loops distinction and the four Goal Primitives. Fills the gap between "define a good stopping condition" (advice) and the specific mechanism (GOAL.md, Verifier, Budget) for achieving it. Written specifically about xAI's Grok Build CLI /goal feature — the article never mentions Claude — but the vocabulary itself is tool-agnostic and maps directly onto a Claude Code loop.

Summary: Draws a decision boundary: if the work is recurring → Loop; if it has a deterministic completion state → Goal. Defines four Goal Primitives: (1) Objective (bounded, verifiable statement), (2) Verifier (independent validation — tests, CI, subagent), (3) State (GOAL.md file persisting across context resets), (4) Budget (turn/token caps). GOAL.md is the key practical contribution: a lightweight file agents write and read between iterations to survive context resets without losing progress or re-doing completed work.


Loops in Production

Articles documenting real deployed systems using loop engineering.


Introducing Claude Tag — Anthropic

Added: 2026-06-24 · Published: Jun 2026

Why here: The first deployed product that makes loop engineering visible to non-engineers. Claude Tag is loop engineering manifested as a team tool — ambient, self-scheduling, org-aware. It concretises Karpathy's "third LLM paradigm" and Cherny's "Claude Everywhere" thesis in a form you can demo to a stakeholder.

Summary: Claude Tag is a new way for teams to work with Claude, launched on Slack — Anthropic frames it as "the beginning of an evolution of Claude Code," not Claude Code itself. Architecture: channel-scoped instances with isolated memory and tool access, ambient context built from channel history, self-scheduling (plans follow-ups autonomously over hours or days). Governance: token caps per org/channel, audit logging, role-based memory separation. Signal: 65% of Anthropic's product team code is created using their internal version. "The beginning of an evolution of Claude Code: it makes the model even more proactive, and it works better with a full team."


No Figma. No Jira. No docs. How Gusto built a new product line with Claude Code — Eddie Kim (Gusto CTO) / Lenny's Newsletter

Added: 2026-06-30 · Published: Jun 2026

Why here: The clearest case study of process replacement under loop engineering, with hard outcome data. Where the Firefox study shows a security harness at scale, this shows a whole product org restructured around loops — and names a concrete, reusable practice (the "trash-can method") that the other production entries do not.

Summary: A five-person Gusto team shipped a tier-one AI product in ten weeks by treating Claude Code as a primary team member and discarding the usual process artifacts (Figma, Jira, spec docs). The headline practice is the trash-can method: Claude-generated PRs become disposable product proposals — most are closed/discarded, making failed experiments cheap and letting non-engineers ship features that developers later refine. Bug-fixing runs an eval-first loop (write a reproducing eval/test, fix, re-run as the stopping condition, gate on human review before commit). The lesson is organizational: the bottleneck moved from implementation to deciding which disposable proposal is worth keeping.


How the Claude Code team does code review — Addy Osmani, Morgan Westlee Lunt, Qing Wang / Anthropic

Added: 2026-10-19 · Published: Oct 2026

Why here: The only first-party account in this group of a verifier loop that is itself improved by a loop: a layered review process for agent-written code with quantified convergence data and a stated gap. It shows how a stop condition (a round cap) is chosen from observed failure rather than guessed, and it names what Anthropic says does not exist yet.

Summary: Layered verification for agent-written code: pre-PR verification by a fresh-context subagent, parallel bug-hunting agents with voting verifiers, risk-tiered human approval, merge queue, flags and rollback. The reviewer has its own improvement loop (a daily eval built from past incidents). A 3-round cap exists because an agent author and an agent reviewer "can keep each other busy indefinitely" — one PR ran past 50 overnight rounds — and mean reviews-to-pass fell from 2.08 to 1.32. The post says circuit breakers that tighten approval when revert or incident rates move do not exist yet. Figures are Anthropic's own. See docs/04 for the full treatment.


Redesigning source control at Anthropic — Anthropic Engineering

Added: 2026-10-19 · Published: Oct 2026

Why here: The first primary account of the bottleneck moving past review: at agent merge volume the constraint is source control, builds and CI. It replaces the "Astra / OpenClaw portability" entry, which documented a personal-agent migration rather than a loop in production, and which this group no longer needs.

Summary: Merges to Anthropic's monorepo grew from about 2,500/day (May 2026) to over 30,000/day (September). The post argues the bottleneck is "all of the developer infrastructure built for human scale: source control, builds, and CI", and describes Scion, an in-house agent-scale version control system built with Claude and migrated to in five months, on the premise that nearly all clients are always-online agents and that a conventional merge queue and CI break down when thousands of changes land during a test run. Page dated Oct 13, updated Oct 15. See docs/26 for the deep-read.


Loop Engineering — Halldor Fannar (Sr. Director, NVIDIA)

Added: 2026-09-28 · Published: Jul 2026

Why here: The only entry in this group that is a named engineer's own account of a real production loop, end to end, with the specific mechanics that made it resumable — not a platform-migration story or a vendor blog post. Positions Loop Engineering explicitly as a subdiscipline of Harness Engineering, matching this KB's own four-discipline consolidation (docs/21).

Summary: A repeatable production loop fixing Rust clippy lints and proposing them as GitLab MRs, running on an NVIDIA DGX Spark sandbox. Concrete mechanics: a state.json checkpoint/resume so an interrupted run picks up where it left off, worktree restoration per run, and a CI regression gate before any MR is proposed. Reports 27 merges to a lint-free codebase — a modest, real, verifiable result rather than a scale claim.


Reference Implementations

Open-source projects demonstrating complete loop engineering implementations. Curated for depth of design and breadth of patterns covered — not for popularity.


goal-engineering — Cobus Greyling

Added: 2026-06-25 · Published: Jun 2026

Why here: The only reference implementation that provides both a GOAL.md schema and a readiness scoring tool (G0–G3). Fills the gap between the "write a good stopping condition" principle and a reproducible implementation pattern with six canonical goal templates. Built and documented as the canonical reference for xAI's Grok Build CLI /goal feature (quick-start commands use --tool grok), not Claude Code — the GOAL.md schema and G0–G3 readiness scoring tool are portable, but the repo itself is Grok-specific.

Summary: Six canonical goal patterns (Tests Green, Migrate Module, Implement Feature, Fix Bug, Refactor Safely, Coverage Target) each with a typed GOAL.md template, done conditions, and natural verifier. Includes a G0–G3 readiness scoring tool (run before launching a goal to verify objective clarity, verifier independence, state file presence, and budget definition) and a goal-cost estimator that predicts token spend from objective scope.


fleet-engineering — Cobus Greyling

Added: 2026-06-25 · Published: Jun 2026

Why here: The only published reference implementation for fleet-level governance. The six production patterns are not documented at this level of operational detail elsewhere — including F0–F3 maturity gates, Claw vs. Assistant identity choice, and fleet-budget.md as a first-class artefact.

Summary: Six production fleet patterns: Team Registry, Shared Inbox HITL, Hierarchical Delegation, Fleet Budget Guard, Cross-Agent Audit, and Agent Clone & Fork. The Fleet Budget Guard pattern caps per-agent token/API spend, pausing that agent's scheduler and requiring inbox approval before the cap can be raised — not raw ceilings with automatic rollback. Agent Clone & Fork defines a three-tier permission model (can run / can clone / can edit) for spreading a proven agent across teams without permission chaos, tracking every fork's provenance back to its canonical source.


session-orchestrator — Kanevry

Added: 2026-06-24 · Published: Jun 2026

Why here: The most complete reference implementation combining patterns from across the whole field: five-wave execution model, confidence-scored inter-wave gates, STATE.md wave crash recovery, governed cross-session learning, scope-verified parallelism via Pre-Edit hooks, and explicit hook exit code safety contract. Ideal to study before building a production orchestrator from scratch.

Summary: Implements a five-wave sequential architecture (Discovery → Impl-Core → Impl-Polish → Quality → Finalization) where Wave 4 is a dedicated simplification pass run before test authoring — preventing tests from cementing suboptimal AI-generated code. Inter-wave quality gates are confidence-scored (≥80% threshold). STATE.md tracks wave-level execution so crashes resume from the last completed wave rather than from the start. The /evolve + /reconcile commands enable governed cross-session pattern extraction where no rule auto-applies without human review.


loop-contract-skill — hdkhosravian

Added: 2026-09-05 · Published: Aug 2026

Why here: Replaces loop-kernel, whose three-exit-code stopping-condition contribution is now fully absorbed into docs/27 with direct citation, making the standalone entry redundant. This repo states the KB's own thesis as a repo tagline — "an agent is bounded by its verifier, not its model" — and adds two things loop-kernel didn't: an oracle/ledger pattern that mechanically refuses unverified claims, and generalization beyond code to data and research work.

Summary: Frozen scope, red-before-work executable oracles (the check must fail before the fix is attempted, proving it tests something real), per-item proofs, and a gate script (fold_ledger.py) that refuses to accept a claim the ledger cannot verify. DONE vs. KNOWN modes extend the same verifier-bounded discipline from code changes to data and research deliverables, where "done" and "known" are different, both-needed completion states.


vibe-dev-plugin — andrewcigan

Added: 2026-09-07 · Published: Sep 2026

Why here: The only reference implementation in this group that makes verifier independence a tool-permission fact rather than a prompt instruction — the verifier role is denied Write/Edit at the harness level, so it structurally cannot fix what it finds. Adds a concrete, portable model-tiering-per-stage pattern (docs/24) this group didn't otherwise cover with a runnable example.

Summary: Per-stage model tiering assigns a higher-cost tier to planning, critique, and verification while a cheaper tier handles bulk implementation. The verifier stage is write-denied by tool permission, not by convention, closing the same self-grading gap docs/04 documents from the harness-config side. Completion is defined as "proven by a real run" — screenshots, execution traces, or mutation-testing evidence, not a passing typecheck.


LoopX — Ruiteng Huang

Added: 2026-07-08 · Published: Jul 2026

Why here: The only reference implementation that treats BUDGET as a per-turn admission decision (deliver/ask/wait/self-repair/stay-quiet) rather than a single end-of-run ceiling, and pairs it with durable objectives and evidence logs that survive agent restarts — gaps none of the other four entries in this group address. Replaces Strive_Engineering, whose provenance-bound-claims contribution is now fully absorbed into docs/04 with direct citations, making the standalone reading-list entry redundant.

Summary: A local control plane for long-running, restart-prone agent workflows across Codex/Claude Code/Cursor. Tracks durable objectives, a quota-aware should-run gate with five decision states, claimed_by todo ownership, append-only evidence logs, and verifiable handoffs that preserve scope across sessions. Explicitly scopes itself as not an autonomous production controller — dangerous permissions, publishing, and production writes stay with the human operator. 90 stars, 2,525 commits as of this entry's Added date (2026-07-08) — the repo has since grown fast (5,680 stars / 5,627 commits as of 2026-09-07); check current figures before citing them. Comprehensive architecture/quota-allocation/interaction-pattern docs.