Skip to main content

When Is a Loop Ready to Run Without You?

Updated 6 min readMarkdown
When Is a Loop Ready to Run Without You?

Boris Cherny at Anthropic said something that landed hard: "I don't prompt Claude anymore. I have loops running. They're the ones prompting Claude and figuring out what to do."

The term loop engineering took off from there. Stop being the person who prompts the agent. Design the system that does it instead. You define a goal and a stopping condition. The loop iterates.

Most developers today are still in the seat, prompting the agent, reviewing each step, deciding what comes next. Loop engineering is about moving that work into the system. Since then, the conversation has been mostly about how to design loops well. That's the right question to start with.

But the more important question hasn't been answered: once you have loops running, how do you know when to get out of the seat?

The question loop engineering doesn't answer

The most common answer is location. Inner loop: agents running locally, developer present, ad hoc work. Outer loop: agents in the cloud, triggered from Slack or Jira or GitHub, running autonomously. OpenHands framed it this way last December.

It's a useful distinction. It doesn't hold up.

Their own CVE remediation example shows the seam. The loop runs in the cloud — outer loop by definition — but the developer still reviews the PR before it merges. A loop running locally in the IDE can be fully autonomous once the developer kicks it off. Location and autonomy don't cleanly map. Location is the wrong variable.

Addy Osmani takes a different approach. He defines a loop by what it needs to run: automations for scheduling, worktrees for isolation, skills for project knowledge, connectors for tooling, sub-agents for verification. That's the infrastructure anatomy of a loop. It's the right answer if your question is "how do I build one?"

But that's not the question you're sitting with. Your question is: how much can I trust this loop? When is it ready to run without someone watching?

Neither framing gives you an answer. One tells you where your loop runs. The other tells you what it's made of. Neither tells you when to let it go.

That requires a definition based on properties, not primitives.

A loop has five properties — the last one is what determines whether it can be trusted:

  1. Skills — an ordered sequence of skills that execute within the loop

  2. Trigger — what starts it: a manual invocation or an event like a ticket assigned, a CI failure, a schedule

  3. Memory — the loop reads persistent context before running and writes learnings back when it completes

  4. Goal state — the condition the validator checks against; what "done" looks like for this loop

  5. Validator — an automated check that verifies output against the goal state, built into the loop

In Addy's infrastructure model, verification is an implementation choice — a sub-agent you may or may not wire up. In this definition, the validator is intrinsic. It has to be, because the validator is what earns trust. Without it baked in, deciding when a loop is ready to run on its own is just a gut call.

Here's what five loops look like in practice, sequenced across a full software delivery cycle. Each loop has its own validator. The Validate loop is a dedicated quality-checking phase — not the only place validators run.

Core engineering loops: Spec, Plan, Dev, Validate, Release

Core engineering loops across the full delivery cycle. Each has a validator.

The validator is what makes confidence measurable. Not location. Confidence. Specifically, how much confidence you have in this loop for this class of task.

Foreground loop — the developer is present and reviewing. The loop hasn't proven itself for this task type in this context yet. The validator hasn't built up a track record here. The developer holds a gate between each step, verifying output before the loop advances.

Background loop — the developer has established confidence in this loop for this class of task. The validator has passed consistently enough to earn it. The loop runs, produces an artifact (a PR, a fix, a release), and the developer reviews the output, not the process.

The same loop can be foreground or background depending on context. A Dev Loop running for the first time on a new codebase needs foreground attention. The loop hasn't proven itself in this stack, with this team's loop design, against this test suite. The same Dev Loop, after running consistently and passing validators across enough tasks in this context, can move to the background. The task type didn't change. The loop's track record in this specific context did.

You don't decide to trust the loop. The validator earns it.

Loops don't start trusted

The inner/outer model asks: where does this run? That's an infrastructure question.

Foreground/background asks: how much do I trust this loop for this task? That's an engineering judgment.

It describes a progression teams actually go through. Every new loop starts in the foreground. You watch every step, review every output, tighten the verification gates. As the loop proves itself on a class of tasks, confidence accumulates. You let it run further before checking in. Eventually, for well-scoped, repeatable task types, it runs in the background, and you review the artifact.

The goal is to graduate loops from foreground to background. Not automation for its own sake. Graduation established through a track record.

Loops that haven't established a track record stay in the foreground. That's where your judgment belongs. Loops that have proven themselves move to the background, freeing you for the work that actually needs you.

What comes after loop engineering

Everyone right now is asking how to design better loops.

The missing discipline is loop confidence — how you build trust in a loop so work can graduate from foreground to background. Loop design tells you what to build. Loop confidence tells you when to let go.

The measure of a mature AI-native engineering team isn't how much they've automated. It's how much they've earned the right to let go.


We're iterating towards autonomous engineering at DeepModel. We just open sourced our orchestrator: dmx. Take a look.

No comments yet. Be the first to comment.