TL;DR
Agent loops need a proof system
Agent loops work when the agent has structured input, a measurable goal, a repeatable check, and a human review surface.
The useful shift is not "the model runs longer." It is "the system knows what outcome it is chasing and how to prove progress." Claire Vo shows the goal loop: define the outcome, verification, constraints, boundaries, iteration policy, and stopping rule. Felix Rieseberg shows the team loop: collect feedback, structure it, batch fixes into one branch, review the rendered app, and let learnings compound.
Attribution and thanks: this piece builds on Claire Vo's How I AI walkthrough of Codex goals and Felix Rieseberg's Every/Fable 5 walkthrough of Kora v2. Thank you to both for making these operating patterns visible.
The loop replaces babysitting
Most AI work is still babysitting. Ask for one thing, read the answer, tell it what to do next, and repeat until you run out of patience.
Claire Vo names the giveaway: if you keep typing "what's next?", you are the loop. Codex goals change the contract. You describe the outcome and the evidence that proves it is done. The harness then works, checks, decides the next step, and keeps going until it can report completion.
A harness is the working shell around the model: repo access, logs, tests, browser, tools, permissions, and rules. The model does the work. The harness gives it a ruler. The operator question is simple: "What should be true when the work is done?"
Better input beats a longer run
Felix Rieseberg's Kora v2 workflow shows the same idea at team scale. The loop starts in Slack, where people drop notes, screenshots, videos, and RiffRack recordings into an alpha channel.
RiffRack records clicks, spoken notes, network requests, and errors from a React app. The agent gets evidence, not vibes.
Felix describes the scheduled routine plainly: it "just reads everything and structures it." It reads Slack, classifies feedback, checks what is already done, downloads recordings, and creates a pull request with structured state in YAML and markdown. The output is not a chat reply. It is a branch with memory.
Batch it or drown in review
The obvious agent workflow is one issue, one branch, one pull request. That breaks once the agent gets productive.
Felix describes a batch with roughly 17 feedback items. Seventeen pull requests would create seventeen review surfaces. His move is one branch, notes where judgment is needed, and one review.
This is not free. One bad fix can contaminate the batch. You need tests, CI, and a human looking at the actual product, not just the diff.
Give it a responsibility
The best agent loop is not a bigger prompt. It is a clearer responsibility.
The 2026 AI Engineer World's Fair recap named this split a control layer: work divides into an inner loop the agent runs autonomously and an outer loop where you set direction and evals. As Peter Steinberger frames it, the agent runs the inner execution loop while you make the decisions in the outer one — responsibility is you keeping the outer loop while the agent absorbs the inner.
Claire's strongest coding example points Codex at Sentry error traces, where many teams collect production errors. The job is to classify each error category, find the root cause, fix it, replay historical examples, and keep going until the error class is gone.
The same shape works outside code: clean thousands of emails, leave judgment calls for the human, or clean up old task-tracker work so only future work remains.
The exit condition is where responsibility becomes real. Matt Shumer's rule for the current models sharpens it: don't hand the agent an adjective like "high quality" — it stops at its own idea of good enough, which is lower than yours. Give it a bar it can check itself against, make that bar hard, and loop.
The whole point of the loop is that Fable never gets to decide it's finished. There's always a next gap.
Matt Shumer
The heartbeat is the on-ramp
Loops stay abstract until one runs on your own inbox. Nick Baumann, an engineer on OpenAI's developer-experience team, describes the cheapest loop to start with: a monitor that checks Gmail and his finances twice a day and pings him when something needs attention — a package alert, an odd charge. No goal spec, no code, just a schedule and a connected account. For a non-engineer, that is the first real "agentic" moment.
Where it compounds past that is a quieter capability: in ChatGPT and Codex, a thread can create, message, and fork other threads, and read its own memory — self-prompting at the thread level. Baumann flags it as the most under-discovered feature; most people never find it. Start with a heartbeat, then graduate to threads that spawn threads. (He is an OpenAI employee demoing OpenAI tools, so read it as capability, not evaluation.)
The minimum viable loop
Start with one feedback channel. Give feedback a consistent format. Run a daily or twice-weekly sweep. Put the state in a file. Batch the safe fixes. Review the rendered artifact.
The minimum pieces are simple: input, state, goal, verification, review, and memory.
The model matters. But the loop is what you can copy.
Where it breaks
Agent loops fail when the finish line is vague. "Make customers happy" is not a loop. "Refactor this code" is not enough either.
Use this pattern when you have a durable objective, an evidence-based finish line, and several rounds of investigation ahead.
They also fail when the input is poor, the review surface is too large, or teams confuse internal alpha workflows with production safety. Felix's overnight merge story happened inside an internal alpha product, with CI and morning human review. Useful evidence. Not a permission slip.
