Friday evening, just before seven. The review queue holds hundreds of open question-answer pairs, each waiting for a human verdict: is the captured answer good enough to learn from? I spent an hour in it and admitted to myself: this is extremely hard to decide, even for a developer. Not because the cases are hard. Because there are too many, and each one needs a clear head. Two days later a council runs at night in which two small local models argue over every case, and a large model is only woken when they cannot agree. Here is how the two days went. Without claiming what it all means. With a question at the end that I have no answer to.
Friday, the trigger
The first idea was the usual one: more discipline. Half an hour of review queue every morning. I know myself. That lasts two weeks. The second idea was division of labour: the platform should weigh where the human eye is worth most, delegate the contested cases to a nightly council, and the human confirms recommendations in the morning instead of reading raw material. That sounds like a big rebuild. It was a Friday evening and a Saturday.
The council: two argue, one arbitrates
For each case two roles debate, both on small local models. An advocate defends the captured answer. An examiner attacks it. At most four contributions per role, hard time and token caps, loop detection. If they agree, the case is closed, cost zero, because local. If they remain at odds, only then does the referee wake up: the large cloud model, with a night budget of two dollars and a cost line on every ruling.
Escalation is a deliberate, paid exception. Not a silent automatism. That mattered more to me than any intelligence in the system: that in the morning I see at a glance how many cases were settled locally, how many took the expensive route, and what that cost.
The stage: you watch how it was decided
Because nobody is watching at night, every deliberation is kept as a transcript, and during the day you can replay it as a film. Sleeping figures with zzz, exactly one is thinking right now, the thoughts visibly fly into the contribution. That sounds playful. It is trust work. You see how a decision came about, who said what, and what it cost. I wrote in October that nothing at our place may happen in silence. This is the continuation: what happens at night must be watchable by day.
Saturday morning, the mishap
First real transcript, first look. The two models said literally the same thing. And the case still ended as "stuck". Loop detection had fired before agreement detection saw the match. The system mistook consensus for stubbornness.
I looked at the screen for a while, because it was so stupid and so logical at once. Of course a repetition looks like a loop. Of course repetition is also what agreement is. The fix was a lesson in ordering: check for agreement first, then for a loop. And one in interface discipline: since then every contribution ends with a structured position line, agreement or disagreement, one sentence of reasoning, machine-readable. No more guessing at phrasings. Every case now has exactly three honest endings: agreed, free. Ruling, a few cents. Waiting, budget spent, next night.
Saturday evening, the finale
A night run that survives deployments, cleans up after itself after crashes, picks its cases up again when the budget postponed them. And in the morning a review queue that no longer asks: do you want to read six hundred pairs? But: here are the roughly ten where your verdict counts, the rest is prepared, with reasoning, with cost line, with film.
Seven findings, seven laws
In between lay what makes every workshop day at our place: findings, numbered, each nailed down with a named test. Most found on the live system, not in the lab. The seven that left a law behind:
The masked error. A view showed a friendly empty state for hours, "no run yet". In truth the server call was failing on a missing permission, and the interface dressed that up as "nothing here". We diagnosed the wrong house. Law: an empty state is only allowed when the server honestly says "200, but empty". Every error gets its own card with cause and retry button. And the fastest move stays banal: browser console and network tab first. Status code and response in a minute, instead of hours of speculation.
Consensus is not a loop. Whoever detects loops must first check whether the parties already agree. Otherwise the system punishes agreement. Ordering is design.
Jobs must survive deployments. A night run killed by a rollout blocked every following run as a "running" corpse. Cure in three layers: heartbeat on the job, cleanup at startup, before all automatic starters, and cleanup on every tick. Because rollouts like to boot twice in quick succession, and the second zombie slips past the first cleaner.
The assumed database. A repair query looked for a flag the real documents never carried. Zero hits, zero effect, tests green. The same lesson for the third time, I wrote it down in October already: tests run against delivered real sample documents, never against the developer's idea of them.
Choreography is part of the design. An animated mockup specifies not only looks but behaviour: who sleeps, who thinks, where the effects fly. If only the looks are ported and the sequence reinvented, suddenly everything animates at once. Law: the mockup's sequence logic is ported as code, deviations must be justified, secured with state-machine tests: time steps in, states out. Structure tests prove presence, never behaviour.
Links navigate, buttons act. A blue text may never start a batch on the side. The answer to cumbersome paths is an explicit button with a server preview, the same calculation that executes afterwards.
Counter equals list. If the header says "0" and the list below shows hundreds, two paths are calculating. One server-side truth for counter and list. Client-side post-filters that discard delivered data are forbidden.
The numbers, honestly
| What | Value |
|---|---|
| Night budget for the referee | 2 dollars cap, overridable |
| Cost of most cases | 0, because decided locally |
| Debate duration per case | seconds to a few minutes |
| Findings in two days | double digits, each with a named test |
| Review queue in the morning | instead of hundreds: the roughly ten where the verdict counts |
These are our numbers from two days, not a measurement series. Whether the council's recommendations are good, we do not know after two nights. Measuring that is the next step, and it leads straight to the question that has occupied me since Saturday evening.
The question: may the platform judge its own material?
What the council does at night is, honestly named: models judging data that models are meant to learn from. The question-answer pairs are training material. The council decides which of them are good enough. And in the end, so the plan, a small decider model of our own is to learn from the referee cases, so that the roles migrate step by step from the cloud back home. The referee is working on its own replacement.
That is elegant. It is also exactly the pattern research warns about: systems trained on material that systems selected or generated. I do not want to talk that away. So both sides, as well as I know them.
What speaks for it
First, it demonstrably works when done right. Small models trained to a large extent on carefully generated data have shown over the past two years that data quality can beat data quantity. Second, debate as a checking procedure is not a gut feeling of ours: a 2024 study shows that a weaker judge reaches more truthful verdicts when two stronger parties argue in front of it than when it judges alone. That is exactly our setup, except that with us the judge is the expensive one and the debaters are the cheap ones. Third, and for me this is the strongest argument: the alternative is not "a human checks everything". The alternative is "nobody checks", because no human gets through hundreds of pairs a week. A checked proposal with reasoning that a human confirms is better than an unchecked pile nobody looks at.
What speaks against it
First, model collapse. A paper in Nature in 2024 showed that models trained over generations on model-generated data flatten out: the edges of the distribution disappear first, the rare, the unusual, then the rest. That is exactly our loop if we are not careful. Second, self-preference: models as judges recognise and favour texts that resemble their own. Two roles on similar models can agree because they share the same blind spot, not because the answer is good. Our Saturday mishap was harmless. The dangerous version would be: they agree, both are wrong, and nobody escalates. Third, the feedback into training: if the decider model learns from referee rulings, it learns the referee's preferences, not the truth. What the referee systematically overlooks becomes the rule.
What we do because we do not know
I do not claim that our council reaches good verdicts. I do not know. But I can say what we built in so that we find out, and so that the damage stays small if it does not.
The strongest signal is the human's disagreement. Every referee case produces a record: input, debate, ruling, and whether the human decided differently in the morning. That deviation is what we want to learn from. Not the agreement. If the human never disagrees, that is not a success but a reason to raise the sample.
Add, never replace. The pairs released by the council are added to the ones checked by humans, marked with their origin. They never replace them. That is the one sentence from the research that translates directly into a rule.
Two models, not one twice. Advocate and examiner run on different small models, so that agreement does not merely mean the same blind spot agreed twice. That does not rule out self-preference. It makes it less likely.
Sampling against the council. A fixed share of the "agreed, free" cases still goes to the human, without them seeing what the council said. Only when the deviation stays small there do we trust the rest.
The replacement referee has to prove itself. The small decider model may run alongside and lay its rulings next to the large model's. It takes over only when, over weeks, it agrees with the human more often than the large model does. Not when it is cheaper.
What remains
Two workshop days. A council that argues at night and delivers recommendations in the morning. Seven laws, one of them from a mishap I will not forget soon. And a question that stays: we taught the platform to judge its own learning material, and research says that exactly this can go wrong. I believe it works if the human keeps the last word, real data is never replaced, and disagreement is the signal, not agreement. But I only believe it. We have not measured it yet. That comes, and I will write it here, whichever way it turns out.
Two small models argue, a large one arbitrates, a human decides. Two dollars a night, mostly zero. On the first morning the system mistook agreement for stubbornness, and that was the most useful bug of the week. Whether the council reaches good verdicts, I do not know. I know how we will find out, and that the human who disagrees in the morning is the most important thing we have.
Sources
Model collapse. Shumailov et al., AI models collapse when trained on recursively generated data, Nature, July 2024. Counter-position: Gerstgrasser et al., Is Model Collapse Inevitable? Breaking the Curse of Recursion by Accumulating Real and Synthetic Data, 2024: replacing leads to flattening, adding does not. Further: Collapse or Thrive?, 2024.
Models as judges favour themselves. Panickssery, Bowman, Feng, LLM Evaluators Recognize and Favor Their Own Generations, 2024.
Debate as a checking procedure. Khan et al., Debating with More Persuasive LLMs Leads to More Truthful Answers, ICML 2024. Original idea: Irving, Christiano, Amodei, AI safety via debate, 2018.
Own articles. A day in the workshop (no silence, no invented fixtures, raw data sacred), The bottleneck is the review, 169 files.
Status and caveat. 8 November 2026. The episodes are real and anonymised: no customers, projects, model or server names. The numbers are ours from two days, not a measurement series. The research is cited, not recalculated. Whether our council reaches good verdicts is open; the measurement follows, and its result will be added here, either way.
Written by me. The thoughts, the values, the learnings, the mistakes: all mine. Grammar and spelling are corrected by a twin model of my own, trained on my texts. Sometimes that turns into a mix. Of course I read everything again, but nobody is infallible. Whatever stays in is mine too.