Close the loop. Improve it, never expand it.

A company becomes a business when it closes the loop. Loop engineering is something musicians, directors and game designers have done for centuries. Now it’s how you build a company, and it’s the most fun I’ve had building one.

Groundhog Day

In Groundhog Day, Phil Connors wakes up at 6:00 a.m. to the same song on the radio in the same small town on the same February 2nd. Every morning his day resets. The only thing that carries over is what he remembers.

He remembers every attempt. He learns the town, the people, the piano, and what goes wrong at every hour. Every lap, he gets a little better. The day only lets him go once he lives it perfectly. That’s the eval (evaluation) and nobody ever told him the solution, he just had to keep trying to find out.

A self-populating breakdown

Our February 2nd is a morning at a dental practice. It starts the same way every day: a schedule full of patients, before each one sits in the chair, someone at the front desk works out what their insurance will pay; The yearly maximum, the deductible, how often cleanings are covered, how much of a crown.

We call that answer a breakdown, and it has exactly 110 fields. We run that morning as a loop. Everything we know goes into one long text, the tape: what the insurance company reports, their plan benefits and the practice’s records.

• A model reads the tape and fills in the fields.
• A validator checks the result against the spec and sends back every violation.
• The model goes again until it passes.

Like Phil, the model does not know what the test is. It just keeps trying until it gets it right. Then the next patient’s tape loads.

None of this is an intelligent agent. It's a closed loop. I used to think the model was the clever part. It isn't. Almost everything I've ever seen work, in AI, and in business, is a closed loop.

All of the good is a closed loop

Beethoven's Fifth symphony starts with four notes, short-short-short-long. This motif is repeated throughout the symphony, until it resolves at the end. It's the looping that makes the resolution feel satisfying.

The purest example of a looped system is a video game. A game repeats dozens of times per second, a loop of taking input, updating the state, and rendering the frame. The player must also master the loop: in Tetris, rotate, drop, clear. In Dark Souls, die, learn, repeat. That's all you need to understand to make progress; everything else is gloss.

A verifiable business loop

In its iconic visualisation, Amazon uses the image of a flywheel. This is usually cited to the 2001 meeting with Jim Collins, when Amazon stock was trading in the single digits. The flywheel runs: lower prices attract more customers -> more customers attract more sellers -> more sellers offer greater variety, as well as reduced per-unit costs -> the lower costs justify lower prices.

A loop becomes valuable because it closes. If a dollar in can return more than a dollar out, you're not predicting the result anymore, you've proved it. You can now scale capital into the system.

That's also what clients and investors trust when they believe in a company: not the pitch, but the closed loop.

Startup companies can engineer the outer loop

A modern company, like any company, has a closed loop. It has many more nodes than the original flywheel: find, win, sell, deliver, support, renew. In most companies, the outer loop is a process that human operators execute. Meanwhile, engineering and product teams work on the inner loop, the product itself. Sales, marketing, and operations handle the outer loop.

Now startups can re-imagine this structure, and build the outer loop with software. Agents can run the nodes that used to need a person. Employees can then focus on the inner loop, in the form of product and craft. This is the part I'm most excited about, because the inner loop is the work people actually started a company to do.

Here's the spicy version; I think the next wave of great companies will have an outer loop that is completely AI driven. It will not be fully autonomous, but it will be engineered, measured and improved like any other system. This is not how most companies work today. But I think this is the direction we're headed.

RISC won by being smaller

By making the outer loop software, the question becomes, how do we build software like this? Chips solved this question forty years ago.

Back in the late 1970s, processors were getting bigger. They were adding more and more complex instructions that did a lot in one step. But at Berkeley, David Patterson and his team decided to go the opposite direction. They built a simple processor in 1982, RISC-I. It had a small, fixed set of simple instructions that ran fast. And it ran faster than a traditional design despite using only 44,000 transistors, compared to the 100,000 transistors used in the traditional design.

Patterson won the 2017 Turing Award for his work, and the chip inside your phone, and every Apple laptop since the M1, is a RISC chip. They proved that a small, fixed core can be optimized to run fast and run right. But a complex, growing core cannot.

I think AI tooling is in its CISC era right now. Every week a new framework adds a new part: another memory layer, another planner, another router. I'd bet on the ones that do less.

An agent harness is a tape

When we talk about an agent harness, we mean the program that wraps around the model so it can run in a loop. In it, we can list a lot of components: the model, a system prompt, the input, tools, output format, memory, feedback, etc. But in reality, based on what we've seen, it's only three;

• The LLM model (inference). Either self-hosted (and maybe even trained) or paid for through an API.
• The tape (txt file). The plain text that the model reads from top to bottom. Its first few lines are the instructions, a couple sentences long, and the rest is the input.
• The spec (schema). What the correct output looks like. We write it in a way that the code can check it and enforce/normalize it.

Feedback and memory are not separate components. They're output from the model that we check with the spec and write back onto the tape. So, one rule to make three components into a loop.

This is basically what Alan Turing drew in 1936. A machine that reads one cell of a tape, writes, and moves on. And he showed that this small fixed machine is capable of computing anything that is computable, provided the tape is configured correctly.

Improve, don't expand

Here's one rule for how to improve a harness: improve these three components, don't expand them. Improve the tape, improve the instructions, improve the spec. Improve the instructions by making them cleaner, shorter, more true. Improve the spec by making it stricter and improving the feedback loop so it's more precise. If something goes wrong, we fix it by updating one of those three things.

We don't expand the diagram by adding a fourth box. That's the hardest rule to keep, because a fourth box always feels like progress on the day you add it.

When we look at working harnesses, this is what we see. Mario Zechner's pi uses a model with four tools (read, write, edit and bash) and a system prompt under a thousand tokens. The viral personal assistant OpenClaw uses pi underneath.

What makes a good tape

Creating a good tape is detective work; an unglamorous process which ultimately determines the success of the loop. It's the part nobody puts in a demo. You can't read anything with a great model if it isn't on the tape.

How to make work more fun

I'd genuinely like to hear what your company is stuck doing, because I think we can make your job more fun and exciting.