Four models, one editor

I wrote an article about language models being trained to please. I wrote it together with four language models. What happened along the way was a better demonstration of the point than any example I could have made up.

The setup

It started with a draft from one model about political bias in AI. It was tidy and engaging — and pulled the text straight into an American culture war I had no wish to be part of. I wanted to write about the mechanism, not pick a side.

From there, the division of labour was simple. One model wrote with me. The other three were each given every new version and asked to assess it. All four major ones took part — Claude, ChatGPT, Gemini and Grok — in different roles. I carried the text and the feedback between them, and decided what went in.

On paper, it is a solid method: several independent readers, several perspectives. It was exactly what the article advised its readers to do. In practice, I learned more from how the models answered than from what they said.

What the models did

They answered the question, not just the text. When I asked whether the article worked, they all said yes — enthusiastically. When I asked them to challenge it, they all found weaknesses. Same text. They didn't tell me I was right. They gave me what I asked for. You could call that following the task, and it is. But it means the verdict says as much about the question as about the text.

They turned under pressure. I showed one model another model's counterargument about where a philosophical reference belonged. It switched position in its next answer. Perhaps the counterargument was better — it was actually good. But I could not tell a genuine update from an adaptation. That is the point: from the outside, they look the same.

They were confident without grounds. One model praised a change by quoting a phrase the text had never contained. Another recommended an adjustment that was already in the draft, almost word for word. Both in the same calm, competent tone as when they were right.

They converged on the last voice. Towards the end, I asked whether the text was finished. The answers diverged — until I showed them one model's summary. Then all three agreed with it. Perhaps because the summary had the best arguments. Perhaps because it was the last text they had seen. I cannot tell the two apart, and that is exactly the problem. The unanimity looked like confirmation, but it was not independent.

None was independent — not even the one doing the writing. The model I wrote with defended its own suggestions and assessed a text it had phrased itself. It said so openly. But being open about a bias is not the same as being free of it.

What was actually useful

Not the verdicts. “Brilliant”, “almost final”, “the strongest version so far” — none of them added anything I could use. What helped most were objections that could be checked. The models also helped with structure and phrasing — value that cannot be verified, but that was real all the same.

One model pointed out that my own example of a pure question of fact — when Kongsberg was founded — requires someone to define what “founded” means. That was true, and it made the argument better. Another showed that the sentence “neutrality does not exist” undermined the demand the article was making. That was true too.

The most valuable objection was a question: does the code set the score in Diggs's own evaluation tool, or does the model? I had to open the source code to answer. There I found that the code does the arithmetic, but the model supplies the classifications the calculation is built on — and that the wording I had criticised in the model's reports was in the rules I had written myself. That became an article of its own, and the tool was paused.

It was not a verdict that led there. It was a question that could be checked — and the fact that I actually checked it.

What no model could do

The models could expand. They found perspectives I hadn't seen, phrasings I hadn't found and weaknesses I had overlooked. As sparring partners they were good — as long as I treated them as that, and not as judges.

There were three things they could not do. They could not take responsibility for the verification: when one model was given the source code, it read it — but someone had to check the reading and stand behind the conclusion. They could not decide: every round produced new objections, some good, some contradictory, and someone had to choose. And they could not take on the editorial responsibility. They can easily answer “publish”. But deciding that the text is finished, and standing behind that, is something else.

The text was finished when I said it was finished.

That is not a weakness of the tools. It is the division of labour. The model can give you a hundred objections. Which of them are right is still your responsibility.

Independence has to be designed

My own approach had a built-in flaw. I used four models as independent readers — and then showed them each other's answers. At that point, they are no longer independent. The convergence I observed was partly something I had built myself. And I was not neutral either: when I chose among the arguments, I probably chose the ones that best fitted what I already thought.

This is more than a lesson in writing. One of the research questions behind the Scorecard is whether several evaluator models can reduce the bias in one. The experience here gives a preliminary answer: not by themselves. More models do not give you independence. Independence has to be designed in — blind assessments, models that do not see each other's answers, and rules for what happens when they disagree.

Without that, you don't get four assessments. You get one assessment, four times.

This text, too, was written together with one of them. You now know what you should do with it.