01What Is Loop Engineering and How It Works

Loop engineering is the practice of designing AI systems that run automatically through repeated cycles of acting and checking, without needing you to write prompts for every step. Instead of you typing a prompt, waiting, reading the answer, and typing again, you write a loop that prompts the AI for you. The loop acts, checks its own work, and repeats until the goal is met.

This idea is spreading fast. Peter Steinberger, founder of OpenClaw, says loop engineering is everywhere. Jensen Huang at NVIDIA's GTC keynote described agents as loops, not better prompt boxes.

Google engineer Addy Osmani published an essay called 'Loop Engineering and an Anatomy.' Even Boris Cheney from Anthropic (creator of Claude Code) says, 'I don't prompt Claude anymore. I have loops that are running.'

The core loop is: observe, reason, plan, act, verify, repeat. The model acts as the brain, the harness as the body, and tools run in a runtime. The agent understands intent, observes context, reasons, plans, calls tools, and manages memory.

The loop keeps going until the output passes the judge's check.

02Why Loops Beat Prompts: You Are Not the Bottleneck

With prompting, you are the loop. You type a prompt, wait, read the answer, spot mistakes, type again, and start over if something goes wrong. Nothing moves unless you sit there.

Your output is capped by your attention and energy.

With looping, you write the loop once and it runs. You define what done looks like. An agent acts, builds, writes, searches.

An independent judge checks the work against your goal. If it's not done, it loops around again on its own. It can run while you sleep, and you wake up to finished work.

Think about where your time goes. Prompting needs you the whole time. A loop needs you for about a minute.

You set it up, then you're free while it runs and checks itself. This is the difference between being the engine and being the architect.

Real proof: 80% of production code at Anthropic is now written by Claude. That only became possible when engineers stopped reviewing every answer and started building loops that verify the work automatically.

03The Two Halves of Every Loop: Doer and Judge

The secret to loop engineering is that every loop has two halves: a doer and a judge. The doer is an agent that does the work, like building a page or writing code. The judge is a separate model that grades the work against your goal.

The judge doesn't need to be smarter than the doer—just independent.

Why independent? Because the agent that wrote the code can't be the one that grades it. If the doer judges its own work, it will always say 'looks good to me.' That defeats the purpose.

So you always have a separate judge.

Here's the simple flow:

  • The doer acts and produces something.
  • The judge checks it against a clear goal.
  • If it fails, the loop repeats with the feedback.
  • If it passes, it ships—no human in the middle.

You set the gates. Your only job is up front: define what done looks like. The loop holds the line to that standard.

This works for apps, games, websites, tools, even blog posts.

04How to Set Up Loop Engineering in the Agent OS

Getting started with loop engineering is simpler than it sounds. In this episode, Julian demonstrates the agent operating system inside the AI Profit Boardroom. It comes with four pre-built loop systems: fusion loops, agent Kanban, Fusion boardroom, and Sakana Fugu.

Here's how to set up your first loop:

  1. Open the agent operating system dashboard.
  2. Go to the Loop section.
  3. Define what done looks like. For example, 'build a beautifully optimized SEO blog.' You can give a starting point or leave it blank.
  4. Select the builder API (the model that does the work).
  5. Set the number of rounds the loop can self-iterate.
  6. Choose a judge model—did you know it can be a totally different model? You can use a frontier model to check the work while cheaper or free models do the work.
  7. Let the loop run. It will repeat until the judge passes it.

If you're non-technical, don't worry. Julian says it's simpler because the system runs without you. Members like Rick set it up in 30 minutes, and Jose built it on day one.

05Four Loop Systems to Use: Fusion, Kanban, and More

The agent operating system includes four loop systems you can pick based on the job. Each has the same doer/judge skeleton but different strengths.

  • Fusion loops: A builder creates, a judge checks, and the loop repeats until the gate passes. You define the goal, choose a builder, set the number of rounds, and select a judge.
  • Agent Kanban: A planner, builder, and reviewer work on a task board. The task gets triaged. A judge profile (like a content quality checker) scores the work and gives a verdict. If it fails, the task goes back into doing until it passes.
  • Fusion boardroom: Five different models come up with answers. A judge fuses all the answers together into one best result. The idea is multiple minds are better than one.
  • Sakana Fugu: A new Japanese model that aims for Fable 5-level intelligence. A council of models deliberates in parallel, searches the web, and a judge weighs it all into one verdict. It's cheaper than Fusion.

All these run inside one dashboard with shared memory and context.

06Real Examples: Fully AI-Generated Blog and Videos

Julian shows real results from loop engineering. One example: a blog post and video were fully done by AI agents. He just gave the goal, and the system went off running.

A builder, an editor, and a judge—all separate profiles inside Hermes—worked together in a loop until the job was done.

Another example: building a full world using Fusion. Fusion is an API where multiple models work on the same answer, and a judge checks the work. You type what you want, ask your boardroom (a panel of agents), and the system critiques and fuses the answers to make sure they're good.

The results show that loop engineering isn't theory—it's already how top teams ship code. With 80% of Anthropic's production code written by Claude, loops are the standard.

The community has 186 pages of wins and reviews. Members share screenshots and testimonials of their own successes, proving that non-technical people can get results too.

07Tips, Limits, and Mistakes to Avoid in Loops

Loop engineering has a few important catches. The biggest mistake is letting the doer judge its own work. Always use a separate judge.

The agent that did the work will always say it's fine. You need an independent model to grade it.

Another tip: define what done looks like clearly before the loop starts. If your goal is vague, the judge will pass or fail randomly. Be specific like 'build an SEO-optimized blog.'

You can set the number of rounds. This controls how many times the loop can iterate. It prevents infinite loops.

You also choose which models act and which judge—you can use a cheaper model for the work and a frontier model for checking, which saves money.

Sakana Fugu is cheaper than Fusion but still gives collective intelligence. Use it when cost matters. Use Fusion boardroom when you want multiple minds fused into one.

Remember: the loop runs without you, but you set the gates. If the judge is weak, your output will be weak. So invest time up front in choosing a good judge.

08Who Should Use Loop Engineering and Why It Matters

Loop engineering is for anyone who creates things with AI—blog posts, videos, code, apps, websites, or tools. If you've been prompting back and forth with Claude or ChatGPT, you are the bottleneck. This system moves you from babysitting to designing.

It matters because it scales. One loop or a hundred loops takes the same effort from you. Once you define the goal and set the judge, you can run many loops at once.

Repetitive work stops being your problem. The people who win next year, Julian says, won't have the cleverest prompts—they'll have loops running while they do something else.

Non-technical people can do it. Julian says if he can build it and many members can, you can too. The agent OS includes a setup walkthrough, four coaching calls a week, daily tutorials, a 30-day roadmap, and 3,700 members in the community.

You get shared memory, so agents improve over time.

The future isn't a better prompt; it's a better loop. Start designing loops today instead of managing prompts.