video youtube.com Watch ↗

Finally. Agent Loops Clearly Explained. — loop engineering, decoded for the rest of us

TL;DR

A 14.5-min explainer (Nate Herk, AI Automation) that cuts through the "agent loop / loop engineering" hype into one durable anatomy: an agent loop is Reason → Act → Observe run until a done-check passes, and the two load-bearing pillars are a goal (as objective as you can make it) and verification (how the agent checks progress and knows when to stop). Its titular idea — Loop Engineering, "replacing yourself as the person who prompts the agent; you design the system that prompts it instead" — is genuinely new to the graph: the human's leverage moves up a level, from per-iteration feedback to authoring the goal + acceptance check once. Everything else independently corroborates the bounded-loop discipline the graph already holds from Agent Loop / Forward-Future/loopy — a catalog and skill for bounded, reusable agent loops: loops must be bounded (hard-cap the passes), a loop is only as good as its done-check, and the best loops make "done" a machine-checkable metric ("keep iterating until X metric = Y") rather than "until you're satisfied." Crucially it stays honest about scope: most tasks don't need a loop — you reach for one for the verification/iteration it buys, a "solo loop" beats a swarm, and the loudest "stop prompting, write loops" advice doesn't transfer to everyone (Agentic Simplicity). Illustrated altitude, not a transcript dump: the value is the skeleton-under-the-jargon and a handful of demo moments, not the rolling captions.

Concepts introduced

Loop Engineering — new. The practice/role-shift the title names: replacing yourself as the agent's prompter by designing the loop that prompts it. Distinct from Agent Loop (the artifact) and Meta-Prompt (outsources prompt generation, not the feedback role).
Agent Loop — updated, not duplicated. This source refines the existing page with genuinely new detail: objective-over-subjective done-criteria, verification-is-the-reason- to-loop, the Reason-Act-Observe / four-pictures-one-skeleton framing, and matching done-difficulty to cost (hard-cap passes; loops can burn 12h+).

Held, not dropped

Themes the video touches that don't warrant their own concept page yet — spin out on demand:

Reason → Act → Observe (ReAct) as a named inner cycle — recorded as an observation on Agent Loop rather than its own node; it's the same evaluator-optimizer skeleton under a different name. Promote if a source treats ReAct as a distinct mechanism.
The "quality vs attempts" mental model — a pedagogy device (outsource the human's climb to the agent), not a concept; held as illustration.
Maker–checker / dedicated scorer sub-agent — the "separate checker" pattern; overlaps LLM-as-Judge and the evaluator-optimizer of Agentic Workflow Patterns. Held as an application, not a new node.
Loop run economics — cost/token/runtime budgeting of long loops (12h+ runs, overnight "chunky loops"). Touches a would-be "agent-run economics" theme; held.
Three loop topologies — solo loop / maker-checker / manager-with-helpers. A sizing menu; held under Agentic Simplicity ("solo loop beats a swarm for most work").
Public "loop library" (attributed here to Matthew Berman) — a catalog of submittable agent loops Nate pulls demos from. Maps to Reusable Workflow Library and echoes Forward-Future/loopy — a catalog and skill for bounded, reusable agent loops; noted as corroborating the reusable-loop-catalog idea without asserting it is the same repo (the attribution differs).

Key claims

An agent loop is Reason → Act → Observe, repeated until a done-check passes, then hand back to a human. observation → Agent Loop — the implementation is simple even when the task is not.
A loop's two pillars are the goal (as objective as possible) and verification (how it checks and knows the stop condition). principle → Agent Loop.
The best loops make "done" a machine-checkable metric — "keep iterating until X metric = Y" beats "until you're satisfied." best practice — context: designing the acceptance check; subjective stops still run but are the weak form → Agent Loop, Eval-Driven Development.
A loop is only as good as its done-check; the verification is the load-bearing reason to loop. principle → Agent Loop.
Bound the loop — hard-cap the passes; an unreachable done-check runs forever (loops can burn 12h+). best practice — context: operating loops on hard goals; corroborates the bounded-autonomy discipline of Workflows vs Agents and Forward-Future/loopy — a catalog and skill for bounded, reusable agent loops.
Loop engineering is replacing yourself as the prompter — you design the system that prompts the agent instead of prompting it yourself. principle → Loop Engineering.
Most tasks don't need a loop; prefer a solo loop + a good prompt over a swarm, and don't cargo-cult 24/7 fleets because a hardcore coder ships that way. (principle / best practice) → Agentic Simplicity, Loop Engineering.
The form of verification is task-specific (visual for UI, play-test for a game, flow/tone for prose, a code test for a script); it's your job to give the agent the right checking tools. best practice → Agent Loop, Agent-Computer Interface (ACI).

Why this builds on (and corroborates) the existing graph

Dominant stance builds_on, with a strong secondary corroborates — matching the Forward-Future/loopy — a catalog and skill for bounded, reusable agent loops pattern (a new node + refinements + independent agreement):

Builds on by adding one genuinely new node, Loop Engineering, and by refining Agent Loop with detail it didn't have: objective-over-subjective done-criteria, verification-as-the-reason-to-loop, the Reason-Act-Observe / four-pictures-one-skeleton reconciliation, and cost-matched hard caps. No concept was duplicated to absorb this — the existing page gained claims and a backlink.
Corroborates the bounded-loop discipline as an independent third witness. The graph already holds "loops must be bounded, checked, and hand back to a human" from Anthropic (Workflows vs Agents) and Forward Future (Forward-Future/loopy — a catalog and skill for bounded, reusable agent loops); Nate Herk — a no-code/AI-automation educator, a different corner of the ecosystem entirely — arrives at the same load-bearing claims from scratch. Three independent sources now agree, which is exactly why these are recorded as (principle) rather than one vendor's (best practice).
Corroborates Agentic Simplicity from the loop angle: "most tasks don't need a loop" and "a solo loop beats a swarm" are the simplicity thesis re-derived for loop machinery — a claim was added there too. (Nate Herk was already a cited third source on that page for retrieval complexity; this is the same voice applying the same rule to loops.)
The one place it gently contradicts the hype it quotes: the framing "if you're not running 24/7 swarms you're falling behind" is called "very false" — echoing Agentic Simplicity's "more agents/autonomy ≠ better outcomes." The tension is with the ecosystem's loudest voices, not with anything in this graph.

Illustrated walkthrough

The talk is carried by a self-built HTML deck (Nate notes, with a wink, that he built it with an agent loop — 45 sources, ~V7). Key on-screen moments, fused with what was said:

t=03:04 (f0037) — the "Quality vs Attempts" curve. A hand-drawn Excalidraw chart (titled, tellingly, "Second Brain Levels") with Quality on the y-axis and Attempts on the x. The mental model: AI never one-shots to 100% — attempt 1 lands ~50%, each feedback-and-iterate pass climbs +5–10%, until you're okay at 90–95%. "Why don't we outsource this feedback and iteration loop to an agent rather than having the human do it? This is going to happen either way." That outsourcing is Loop Engineering.
t=04:00 (f0039) — "Nobody draws it the same way." Four cards, one caption: Think → Act → See (the ReAct paper), Model ↔︎ Tools (Anthropic), Goal → Self-prompt, runs unattended (AutoGPT), Manager → helpers (multi-agent). Footer: "Four pictures. → One skeleton underneath. That's the part you actually learn." This is the distillate's reconciliation of the "everyone has their own spin" confusion — all four are Reason–Act–Observe.
t=06:11 (f0044) — Demo 1, thumbnail scoring, in Claude Code. A rubric table (Clarity 10 / Curiosity 9 / Emotion 10 / Contrast 10 / Accuracy 8) and a ✓ Goal achieved · 27m · 1 turn · 48k tokens receipt. The loop made 10 thumbnail concepts, scored each against a MrBeast rubric, improved the top three, rescored, iterated on the strongest. The lesson Nate draws: the done-criteria here was subjective ("until you're satisfied") — the weak form; the fix is a dedicated scorer sub-agent run through evals (touches LLM-as-Judge, Eval-Driven Development).
t=12:31 (f0115) — the iterations are files on disk. The VS Code view of the Abbey Road recreation demo: loop-demo/versions/_shots/ holding v1..v7 HTML + squared screenshots. Concrete evidence of the loop's discipline — the prompt said "if the average is ≥ 9, stop" with a "hard cap on 8 passes," and it stopped at V7. (The output looked nothing like the Beatles photo — Nate's point: loops don't guarantee a perfect result, they get you much closer, and the verification-by-screenshot is what made each pass better.)
t=12:44 (f0118) — "8 things that make a loop actually work." A checklist card grid: checkable goal · hard stop · good tools · memory · separate checker · plan first · logging · cost sense. Two verdict panels: Do this — "start with one small, repeatable task"; Skip this (for now) — "24/7 swarms of 10 agents prompting 10 agents." This is the Agentic Simplicity thesis applied to loops.
t=12:44 (f0119) — the hype, sourced. The viral X post that opens the video ("you shouldn't be prompting coding agents anymore… you should be designing loops that prompt your agents," 8.3M views) and Gautham Pai's reply mocking "Loop Engineering" as the next LinkedIn fad. Nate's "does this apply to you?" beat: that advice comes from a hardcore coder at OpenAI and needn't transfer to your knowledge-work use case.