“An LLM agent runs tools in a loop to achieve a goal.”
That is Simon Willison’s definition of an agent, and it stuck because it strips the magic away. Prompt the model, let it call a tool, feed the result back, repeat until the job is done. Everything that feels miraculous about agentic coding is that loop turning quickly.
The craft has followed the definition. Willison calls designing agentic loops a critical new skill. Geoff Huntley’s Ralph technique went viral by running an agent in an infinite shell loop, fresh context every pass, and made the loop folklore. This year the practice even got a name, loop engineering, with a thesis that fits on a sticker: stop prompting your agents and start designing the loops that prompt them.
All of it is right. All of it is also missing people.
Every loop diagram has one human in it
The discourse has mapped exactly where you should sit. Humans in the loop inspect every step, and the arithmetic no longer works: agents generate faster than any individual can review. Humans on the loop step back and design the harness instead, the specs and tests and checks that keep the loop honest while it runs. Humans outside the loop are vibe coding and hoping for the best.
Beneath all three sits the sharpest observation in the whole conversation: in any loop, the bottleneck is the verifier, not the model. Even Huntley, whose technique is the purest form of letting the agent run, is blunt that agents amplify operator skill, and that setting one off and walking away ends badly.
Now look at the cast list. One human, many agents. That picture describes a weekend project. It does not describe work.
Real loops have other people in them
Follow one real feature. The prototype works by Tuesday, and now it needs a customer’s reaction. The plan needs a colleague to pull it apart before the team commits to it. The feature branch sits open until a reviewer has enough context to say yes. Security has questions nobody has collected. Finance wants to know what it costs to run.
Very little of the real world is a solo developer churning through tokens. Real work happens with other people, and every one of those people is a verifier in somebody’s loop.
That is where the trouble starts. Agents collapsed the coding loop from days to minutes, but the loops that run through other people did not move. They still turn at the speed of calendars: the review that lands next Thursday, the workshop in three weeks, the steering committee next quarter. A system is only as fast as its slowest loop, and the slowest loops are now the human ones. The model stopped being the constraint; the context bottleneck took its place.
Humans in the loops, plural
Human-in-the-loop asks a narrow question: where does one person sit in one agent’s loop? The honest question is plural at both ends. Loops nest. The agent’s loop turns inside a branch loop that waits on review. The branch turns inside a feedback loop that waits on customers. The feedback loop turns inside a direction loop that waits on leadership. Every level outward adds people, and every level outward turns more slowly.
So call the real discipline humans-in-the-loops engineering: designing the loops that contain other people with the same seriousness the industry now applies to the loops that contain only a model.
The human loops can be engineered too
What actually made the agent’s loop fast? Context that is always at hand, so no iteration starts cold. Verification that runs the moment there is something to verify. A next step chosen inside the loop, not in a meeting about the loop. Loop engineering is, underneath the tooling, a discipline of removing waits.
Apply it to the loops with people in them and the moves fall out:
- Context that persists and is shared. The agent reads its state from disk on every pass. People deserve the same: one living picture of the problem, so nobody needs catching up before they can contribute.
- Feedback that does not wait for a calendar. If the loop only turns when the right six people are in a room, the loop turns monthly. Let stakeholders and customers answer one-to-one, in their own time, and it turns in hours.
- Disagreement pulled forward. An objection is cheap while the work is a prototype and expensive once it is in production. The loop should go looking for objections, not wait for them to arrive.
- Lock in, then loop. Consensus becomes a stable target for the current build window. New information feeds the next turn instead of whiplashing this one.
This is the job Alis Ideate does. It keeps everyone inside one grounded context repository, runs one-to-one AI-led interviews so colleagues and customers join the loop without another meeting, and synthesises the noise into risks, requirements and build-ready direction. Think of it as a harness for the human loops: the role the agent’s harness plays for the model, played for the people around the work.
Where the speed is now
The industry is right that the future belongs to whoever designs the best loops. It is just undercounting the participants. The loops that decide whether software is worth shipping have customers, reviewers, security teams and leaders in them, and those loops reward engineering just as much as the agent’s does. That is the premise of Extreme Alignment: alignment is an unbroken loop, not a sequential process.
Your agents already loop in seconds. Design for the humans in the loops, and the rest of the organisation can keep up.