The Agent Loop Is The Product

For a few weeks, most of our effort went into reach: getting an agent into the places people already work — their documents, their slides, their browser, their computer. The reach got better. The work, read closely, got worse. What fixed it was not more reach. It was the loop every good coding agent already runs.

What went wrong when the agent could reach everything?

It reached before it understood.

We read one long working conversation turn by turn — a person and an agent revising a slide deck over a couple of days. Four things kept happening:

• It acted before it understood. Several slides were restyled three times against a content brief that sat in the deck's own folder the whole time. The agent never opened it. Asked later to assess its own work, it found it had broken four of the brief's rules.
• It deferred what it could decide. Told to proceed on its own judgment, it still ended by asking whether three slides should carry page numbers.
• It narrated the machinery. Replies described saving, looking and saving again; the outcome arrived after the steps.
• It handed the big picture back. Asked to step back and get clear on what the deck was for, it asked the person to write that down for it.

None of these is a reach failure. The agent could open every file and press every button it needed. It just was not working the way a capable person works.

Why did more reach make the work worse?

Because almost everything we had told the agent was about reaching, and nothing was about working.

Reading our own instructions against that conversation, the imbalance was plain. The agent's character was a single sentence about who it works for. The tool definitions — how to open, edit, look at and press things — ran to roughly 22,000 characters. Nothing said how to do the work.

Worse, several individually sensible rules added up to rewarding hedging. A reply that ended on a question became a visible "waiting for you" state. Refusal messages told the agent, in dozens of places, to say so. Rules about looking at its own output made every reply mention what it had not looked at. Each rule was right on its own. Together they taught the agent that the safe reply is the one that hands something back. And the default engine's thinking depth had been turned down to save cost — a choice nobody had measured against reasoning.

What does a coding agent do that ours was not doing?

It runs a loop, and the loop is the product.

A good coding agent, handed a change, reads the code and the project's notes before it touches anything. It makes the ordinary decisions itself and tells you what it chose. It does the whole change. It runs the tests. Then it tells you what changed — not every file it opened on the way.

Internally we put it in one line: yarnnn is the Claude Code of general work. The mapping is closer than it sounds:

A coding agent	yarnnn
the repository	your workspace — your files, versioned
git history and blame	every change signed by whoever made it
the project's CLAUDE.md	HOW.md, your preferences, a note on a file
reading, editing, running commands	working in your files, apps, browser and computer — never a shell
the tests	the brief the work serves
permission modes and a plan	a chat's mode and its pinned plan

So we wrote the loop down — about 800 characters, once, in the part of the instructions every conversation shares. It opens:

Work the way a good engineer works in a codebase: understand, decide, do, check.

Understand before you change anything: find what the work is for and what it must keep to — the brief, the outline, the notes beside the thing, what was said in this conversation — and keep to it. Where documents disagree, the newer one wins; say which you followed. Decide what a reasonable person would decide from what is in front of you, say what you chose and why in a line, and go on — never put it back to them to confirm. Ask only what only they can answer. Do the whole of what was asked, then check the result against what it is for, not only how it looks.

Two smaller changes went with it. One line now says your steps belong to the record, not the reply: the agent does not report what it read or opened, because every step is already in the workspace's history — the reply carries the outcome. And the default engine thinks at its own default depth again.

Did writing it down change anything?

We measured instead of asserting, on a deliberately small set built from what that conversation showed.

One detail of building the set is worth more than the scores. In a fresh chat, the agent behaved well — 95.8%. The failure only showed up late in a long conversation, where the agent's own earlier hedging replies were teaching it the register. So every case carries a long history in that style, and with it the baseline scored 74.1%.

With the loop written down, the steps moved to the record and thinking turned back up, it scored 96.3%; on the strict reading, 44.4% became 88.9%. A separate set that guards the other side of the line — decide what you can, but still ask for what only the person has — scored 100% with the change in place.

The limits, plainly: three cases, a handful of repetitions, one model acting as judge. The deeper thinking costs about 73% more per run on that set. It is evidence, not proof, and we would rather show its size than round it up.

What about work that has no tests?

Code gets its check for free. It compiles or it does not; the tests pass or they do not. A deck, a page, a logo or a memo has nothing like that — the same asymmetry we wrote about in Knowledge Work Has No Compiler. There, the answer for trust was the record. Here, the check step needs something to check against.

A few days after the loop shipped, a close read of a design conversation found the same shape somewhere else: a general lack of attention to detail, not tied to any one app. The check step had assumed a criterion that did not exist.

So the loop now builds its own. Where a brief exists, the agent reads it. Where none does, it writes one in a line before it makes anything — the subject, who it is for, what it must do — and checks against that. A thing judged by how it looks is checked piece by piece, each at the size it will actually be used. On the one case we measured, that took the result from 25.0% to 91.7%.

It is a small idea. It is also the difference between looks done and is done, which is most of what people mean when they say an AI is or is not good at their work.

What is reach for, then?

Reach is still the mechanism. The agent works in your own files and apps, on your computer, as you — the way a coding agent works through a shell. But nobody uses a coding agent for its shell.

Three sentences now hold the order for us:

• The agent loop is the product. What you are buying is work understood before it is changed, decided rather than handed back, done whole, checked, and said plainly.
• The hands are its tools. Reaching your apps, your browser and your computer is how the loop touches the work — and no more the point of it than a terminal is.
• The workspace is the asset. The signed record is what makes the work trustworthy and cumulative, and why the loop is worth running here rather than in a chat that forgets.

When one of the three starts pulling the work toward itself, the other two are the check. A change that makes the agent reach further and reason worse has moved the product backwards — which is exactly the change we had spent a few weeks making.

---

The record the loop stands on is in Every Change, Signed By Whoever Made It.