Everyone kept saying “loop.” It took me four days to notice they meant four different things.
Notes from AI Engineer World Fair 2026 on software factories, loop engineering, and the argument underneath all of it that I'm still chewing on.
I went to the AI Engineer World's Fair the last week of June expecting to hear about models. New benchmarks, bigger context windows, the usual arms race. That's not what I got. Walk any hallway at Moscone West, sit in almost any talk on the software factories track, and one word followed you around all week: loop.
By the second day it started to bug me, because people clearly weren't talking about the same thing. A founder on stage would say “the loop is the product” and mean one thing. Ten minutes later, in the next room, someone would say “just wrap it in a loop” and mean something completely different. Same word. Underneath it, four or five ideas that don't really have much to do with each other.
I'm not the first person to notice. Aparna Dhinakaran and Laurie Voss (seldo) from ArizeAI wrote the piece that finally made it click for me, “What the hell is a loop, anyway?” They counted four distinct architectures hiding behind the one word. I'm going to borrow their map, because it's the clearest one out there, and add what it actually felt like in the room, plus where I landed on the argument sitting underneath all of it.
One disclaimer before I start naming names. I don't write production code for a living. I work on the business side of this industry and I go to things like this to keep learning. So read this as a curious outsider's notes, written to understand the thing, not to grade anyone's homework.
The four loops, bottom to top
The execution loop — the agent’s own act-observe cycle
The task loop — restart until the spec passes (the ralph loop)
The product loop — the software factory
The system loop — the loop that improves the loop
The oversight loop — the one that stays human
The word doing all the work
A few weeks before the conference, “loop” went from a niche term to the word everyone reached for.
Addy Osmani, who leads a good chunk of Chrome’s developer experience, published an essay calling it Loop Engineering. His line stuck with me: “You shouldn’t be prompting coding agents anymore. You should be designing loops that prompt your agents.” Around the same time swyx put out “Loopcraft”, which became his keynote at the Fair. Boris Cherny from Anthropic said on stage that he doesn’t really prompt Claude anymore. He writes loops, and the loops do the work.
So by the time the doors opened, you couldn’t sit through a session without hearing it. The trouble is the word had quietly split into at least four meanings, and once I could tell those four apart, a lot of the week made more sense.
The four loops, plus the one that stays human. Framing after Aparna Dhinakaran & seldo.
Loop 1: the execution loop (the one you already picture)
This is the loop most people mean when they say “agent.” Call a tool, read what came back, decide the next move, repeat until there’s nothing left to do. Addy calls it the inner loop. It’s the agent running its own act-and-observe cycle with you out of the middle.
It’s real and it works, but it has a known flaw. The agent decides when it’s done, and it’s often wrong about that. It will declare victory on a task that isn’t actually finished. The fix people landed on is almost dumb in how simple it is. You wrap that loop in another loop that doesn’t just believe the agent when it says it’s done.
Loop 2: the task loop (restart until it’s actually right)
That wrapper got a name first. Geoffrey Huntley’s “everything is a ralph loop”, which got name-checked from the main stage when Keycard’s Allie Howe opened the software factories track by citing it.
The Ralph loop is blunt. You restart a coding agent against the same spec, over and over, with a fresh context window every single time, doing exactly one task per run. It looks wasteful, and re-feeding the whole spec every single time really does feel like setting money on fire. But that’s sort of the point. A clean context each time avoids the slow rot that creeps into a long agent session, where the model gradually loses the plot and starts making things up.
What ends this loop isn’t the agent’s opinion. It’s the tests passing and the spec being satisfied. You write the spec, you judge done-ness. And, as Huntley put it, you also watch the loop. You spot the failure patterns and fix them so they stop recurring. He compared the role to a train engineer whose whole job is keeping the thing on the rails.
Loop 3: the product loop, also known as the software factory
This was the loud one. A whole track was named after it.
Tereza Tížková from Factory defined a software factory as “the whole lifecycle of developing software with autonomy.” Not one task. The entire thing: triage, spec, build, review, test, ship, watch it in production, go again. Warp’s Zach Lloyd made the case that software engineering starts to look like factory engineering, where your real job is building the thing that builds the product.
One honest caveat about my own notes here. Some of the specific numbers people cited around this (Warp raising its auto-merge rate over time, Anthropic saying a large share of one team’s code now comes from its own internal agent) I’m repeating from Aparna and seldo’s writeup, not from a slide I checked myself. I’m flagging that because I’m trying to keep the difference straight in my own head between what I heard and what I’ve actually verified. These are early days, and the teams putting real numbers on stage are doing the harder, braver thing: trying this in the open and telling us how it’s going.
The important shift is the exit condition. The first two loops finish. A factory doesn’t. It runs on the codebase and its backlog, continuously, and the signals that tell it what to do next come from outside the code: new issues, production logs, user complaints, review outcomes. Your role stops being “do the task” and becomes “decide which parts run themselves, and where a human steps back in.”
Loop 4: the system loop (the loop that improves the loop)
The last one took me the longest to get my head around. Roland Gavrilescu from Introspection calls it autoresearch, and his framing was the cleanest thing I heard all week: the inner loop does the user-facing work, and the outer loop studies and improves the inner one. It tunes the prompts, the harness, the model choice, even the evals. His one-liner:
The loop is the product.
The reference everyone reached for was Andrej Karpathy’s autoresearch experiment from earlier this year, a small Python loop that edited a training script, ran a short job, read the result, and kept the change only if the metric improved. No one in the seat overnight. It works. It also, in every serious version I heard described, still had a human making the final call before anything shipped.
That last bit, the human still signing off before anything ships, is where the actual disagreement starts.
The loop nobody put on a slide
Stack those four, and there’s a fifth ring sitting on top that mostly went unnamed. swyx’s own diagram literally labeled the top ring “???? loop.” It’s where goals get set, budgets get allocated, and work gets killed. Its exit condition, on his slide, was “none.”
I think it has a name. Call it the oversight loop. It’s the one ring where a human belongs, and it’s what every sharp disagreement at the Fair was secretly about.
Autonomy levels after Addy Osmani. The point: you set the dial once per loop.
Two main ways to see it
By the last day the energy had shifted from show-and-tell to something I found more interesting: two thoughtful groups of people who genuinely disagree, and both of whom make sense.
One view says turn the dial up. Pick your checkpoints on purpose, earn trust, and let the system take on more of the lifecycle over time. Roland’s version had a hedge I liked: build toward the factory, don’t assume you can stand one up fully autonomous on day one. He called the middle state an orchestra, a system that still keeps a human conductor.
The other view says the dial has a stop, and you should respect it. Geoffrey Litt from Notion gave the line I keep coming back to: “understanding is the new bottleneck.” His worry isn’t that the tools are bad. It’s that if you hand off the understanding along with the work, you give away the part that made you useful in the first place. Dex Horthy from HumanLayer, who was careful to say he isn’t anti-loop (he pointed out that Kubernetes is built on control loops), thinks the excitement has run a little ahead of the engineering, and that the grounded move is to step down an abstraction level rather than up.
What struck me is that nobody up there was being naive. Both sides had shipped real things and were mostly describing what they’d already learned the hard way. And the moment that stuck with me most, again through Aparna’s reporting, was hearing that even the teams furthest down this road say the human review step has become their bottleneck. The one job we kept for ourselves turned into the thing slowing everything else down. I didn’t take that as a dunk on anyone. It sounded more like a field being honest about where it actually is, which you don’t hear at conferences as often as you’d want.
Where I landed: it’s a dial, not a camp
What I actually walked out with, and the reason I stopped feeling like I had to pick a side, was pretty simple. Autonomy isn’t a yes or no. It’s a dial, and there’s a separate one on every loop.
Addy’s essay spells this out with levels, L0 through L5, borrowed straight from how we talk about self-driving cars. L0 is autocomplete. L5 is “the system runs itself and only surfaces the exceptions.” Most real setups live somewhere in the middle, and the honest answer for any given team is “it depends which loop you mean.”
You can run a fully autonomous execution loop (let the agent bang on the tests all it wants) inside a heavily supervised product loop (nothing ships to a customer without a person reading it). You can hand the system loop to the machines and still keep goal-setting entirely human. Once I saw it that way, the argument bothered me a lot less. Both sides sounded right to me because they were answering the question for different loops, without really saying so.
For someone like me, who spends way more time on strategy than on syntax, that shift was the whole value of the trip. The question I found more useful wasn’t “will this all get automated.” It was “for this specific loop, where’s the dial, and what would actually tell me I set it wrong?” That second half is the part I haven’t seen anyone fully answer, and it’s the part I keep thinking about. A loop with no real finish line doesn’t stop on its own. It just runs until someone outside it pulls the plug.
The oversight loop is the one that stays yours. Goals, budgets, and the call to stop work that’s going nowhere. Everything below it is a dial you get to set. I don’t think that’s a clever compromise between the two views. I think it’s the design space both of them were already working in, and I only got to see it because so many people were generous enough to show their work out loud.
So, which loop are you building?
That’s the question I’d leave you with, because “we’re using AI to write code” now means four or five completely different things depending on which loop you’re pointing at.
If you want the real map, read Aparna Dhinakaran and seldo’s “What the hell is a loop, anyway?” It organized my whole week. Addy Osmani’s Loop Engineering and his autonomy levels are worth it for the dial framing. swyx’s Loopcraft, the Latent Space interview with Roland Gavrilescu on autoresearch, Geoffrey Huntley’s ralph loop, and Geoffrey Litt’s “understanding is the new bottleneck” fill in the rest.
I’m still chewing on all of it. If you were there and saw it differently, or if you’re running one of these loops for real and the day-to-day is messier than the keynote made it sound, I’d genuinely like to hear it. Which loop are you building?
Credits & further reading
Aparna Dhinakaran (Arize) and Laurie Voss / seldo — “What the hell is a loop, anyway?” The recap that supplied the four-loop map.
Addy Osmani (Google Chrome) — “Loop Engineering” and “Agentic Autonomy Levels” (the L0–L5 dial).
swyx / Latent Space — “Loopcraft: The Art of Stacking Loops” and the AIEWF daily dispatch.
Roland Gavrilescu / Introspection — on autoresearch (via Latent Space).
Geoffrey Huntley — “everything is a ralph loop.”
Geoffrey Litt (Notion) — “Understanding is the new bottleneck.”
Dex Horthy (HumanLayer) — on keeping humans in the design loop.