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.
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.
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.
| Review | What a marker search does |
|---|---|
| 1 | "This is not done until the migration is added." The word is there, so the run ends. |
| 2 | A paragraph deciding the work is finished. No marker, so another round runs. |
| Review | What the field does |
|---|---|
| 1 | "This is not done until the migration is added." done: false, so the actor gets the notes. |
| 2 | A 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.
No memory.
It arrives fresh every round, so it cannot be told a story about what happened. It has to look at the repository.
A structured verdict.
The run ends on a boolean, so no sentence can end it by accident.
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.