We've Always Lived in Loops. AI Agents Are Just Catching Up.
Loop engineering, a step towads a more powerful and truly autonomous agentic systems
Helping startup founders build their products, drive their growth @ WeBuidl
Look at your day honestly and it's not a list of tasks. It's a loop. Wake up, check phone, assess what changed overnight, act, wait, check again. Open Slack, scan for anything that needs you, respond, close it, come back in twenty minutes. Even the "deep work" hours are a loop: write, run it, see what broke, fix it, run it again. We don't experience life as a sequence with a start and an end. We experience it as a cycle we keep re-entering, each time with slightly more context than the last.
Professional work is even more obviously this. A support engineer's whole job is watch-the-queue, triage, resolve, watch again. A trader's whole job is watch-the-price, evaluate against a thesis, act or wait, watch again. A sales rep's pipeline is a loop with a memory — you don't cold-call the same lead the same way twice, because the last call changed what you know. None of this is new. What's new is that we finally have a name for building the same pattern into software, and for a few years, most of us building AI agents didn't have it.
The loop I built before it had a name
A while back I was building an agentic system for analysis and trading in capital markets — something that could read a thesis, watch a name, and act on it without me babysitting every tick. The naive version was obvious and useless: poll the price every few minutes and ask a model "anything interesting here?" That burns tokens and produces noise, not judgment.
What actually worked was inverting it. Instead of the agent watching the market, I had the system set a price alert with the reasoning attached — not just "notify me at $142," but the actual context: why that level mattered, what thesis it would confirm or break, what to check when it fired. The alert sat dormant, cheap, doing nothing. When price crossed the line, that stored context triggered the agent, and the agent woke up already knowing why it was awake. It didn't have to re-derive the situation from scratch — it picked up the loop mid-cycle, with memory.
At the time there was no term for this. I wasn't "designing a loop," I was just trying to stop paying for an agent to stare at a chart. A decent amount of the actual work was mechanical — weighting which price zones mattered more than others, deciding what counted as a "trigger" worth waking the agent for versus noise to ignore, a fair bit of scoring logic sitting quietly behind what looked like a simple alert.
Then, this June, it got a name
On June 7, 2026, Peter Steinberger — the developer behind OpenClaw — posted that developers should stop prompting coding agents by hand and instead design the loops that prompt those agents, a post that reportedly hit around 6.5 million views within days. Boris Cherny, who leads Claude Code at Anthropic, had already been saying something similar on stage, describing his own job as writing loops that prompt Claude rather than prompting it directly. Days later, Google's Addy Osmani turned the idea into something teachable, and the term "loop engineering" stuck.
The definition that emerged matches what I'd stumbled into without knowing it: a loop is an agent that acts, observes what actually happened — a test result, an error, a market move — and adjusts, repeating until the work is accepted or blocked, rather than a human re-prompting it at every step. The best writeups converge on the same non-negotiables: a specific goal with a testable stopping condition, tools the agent can actually use, context management so it doesn't drown in its own history, and explicit exits so it doesn't run forever. My price-alert-with-context setup was, unknowingly, a crude version of exactly that: goal (react to this level), trigger (price crosses it), memory (the thesis attached to the alert), stop condition (the trade decision itself).
Why this is the real unlock for autonomy
Prompting is you doing the thinking, one exchange at a time. A loop is you doing the thinking once, well, and then trusting the system to re-apply it every time the world changes. That's a small mechanical shift with a large consequence — it's the difference between an assistant you operate and a system that operates itself inside boundaries you set. Every genuinely autonomous agent I've seen actually hold up under real conditions was a loop with good judgment baked into its stopping conditions, not a bigger model with a longer prompt.
The dream isn't agents that respond faster. It's systems that keep watching, keep deciding, keep remembering why — long after you've stopped thinking about the problem yourself.
