Skip to content
← All posts

Blog3 min read

RLARThe Review Is the Next Prompt

Two small decisions inside RLAR changed how long-horizon runs behave: the reviewer's words go to the actor verbatim, and "done" is read off a field rather than a sentence.

RLAR is a loop of about fifty lines. Two decisions in it are the reason it works, and both sound like details until you watch a hundred hours of runs without them.

RLAR · one round
actorone sessionrepositoryreviewernew each rounddone: boolnotes: strnotes, verbatimend

Swipe the diagram sideways to see all of it →

1/0 The actor works in one session that remembers every round.

One: the review is the next prompt, verbatim ​

The obvious way to build an actor-and-reviewer loop goes like this. The reviewer writes an assessment, the loop reads it, and something (a template, a summariser, the flow itself) turns it into instructions for the actor.

Every layer in that chain is somewhere findings go to die. The reviewer notices that a test was narrowed. The summariser renders it as "some test changes were noted". The actor reads that as permission.

So in RLAR there is no chain. What the reviewer writes is passed to the actor word for word, as its entire next prompt, and it is everything the actor will hear about that round.RLAR now ships inside humanize as a built-in flow, flows/builtin/rlar. The quotes on this page are from that source.

The second-order effect is the interesting one. Once the reviewer knows its output is the instruction, it stops writing assessments and starts writing instructions. Its skill file says so outright:

The review is not a report for a person. It is the next prompt of the agent that did the work, word for word, and it is everything that agent will hear about this round.
— RLAR's review-notes skill

Reviews written under that rule cite files, lines and commands. Vagueness is no longer somebody else's problem to resolve. It is a wasted round.

Two: "done" is a field, not a sentence ​

The other decision is how the loop ends.

The common pattern is a marker: the reviewer is told to write DONE on its own line, and the loop searches for it. This fails in both directions, quietly. A reviewer writing "this is not done until the migration is added" contains the word. A reviewer that has decided the work is finished, but wrote a graceful paragraph, does not.

The same two reviews, read two waysDrag to compare
A marker
ReviewWhat a marker search does
1"This is not done until the migration is added." The word is there, so the run ends.
2A paragraph deciding the work is finished. No marker, so another round runs.
A field
ReviewWhat the field does
1"This is not done until the migration is added." done: false, so the actor gets the notes.
2A paragraph deciding the work is finished. done: true, so the run ends on it.

In RLAR the reviewer answers into a shape with two fields, a done boolean and a notes string, and the loop reads the boolean. A review that says the work is done and a review that decides the work is done are then not the same thing. That is as it should be: one is prose and the other is a decision.

The field's description carries the whole standard, because the description is what the backend is given as the shape to answer in:

True only if the task is completely and correctly done: everything asked for is implemented, it works, nothing was faked, stubbed or special-cased to pass, and there is no next step worth taking. False if there is anything at all left to do or to fix.

That is a deliberately hostile bar, and it is the one that ends the run. The only other ways out are the budget running out and three failed rounds in a row.

Why both of these are about reward hacking ​

On a long unattended run, work does not usually fail by being incompetent. It fails by looking finished: a test narrowed until it passes, a branch special-cased on the exact input the test uses, a stub with a confident summary written on top of it.

The reviewer

No memory.

It arrives fresh every round, so it cannot be told a story about what happened. It has to look at the repository.

The ending

A structured verdict.

The run ends on a boolean, so no sentence can end it by accident.

The handoff

Unedited words.

The one agent whose job is scepticism is the one whose language the actor hears.

None of this is expensive: one loop and one skill file. We are writing it down because the cheap decisions are the ones people skip.

Read the flow · Read the source · Run it

Read next

BlogFlow Science: A New Dimension of Scaling AgentsModels scale with parameters and data, and agents scale with tools; the next dimension is the flow. Why one flow cannot solve every problem, flow-level ablations on four benchmarks with the models held fixed, four findings we did not expect, and whether a flow is engineering or a science.Read it BlogKDA²: Kernel Design Agents (KDA) Optimize Kimi Delta Attention (KDA)Our agents wrote Kimi Delta Attention kernels that run up to 2.96× faster than FlashKDA on B300 with a tenth of its state error. Here is how, and how the agents tried to cheat along the way.Read it BlogHumanfia: From a Review Loop to Four Layers and a RefereeHow Humanfia went from a July launch, an agent workflow for serious L3–L4 development, to a four-layer system of agents, a runtime, flows and applications, plus FlowBench, whose best flow becomes the default.Read it