Picture a student who writes their own exam questions, solves those questions alone, and grades their own answers. At first there's no real problem. But things unravel the moment they happen to write down the wrong answer key for a question. They study toward the wrong answer, write the same mistake again on the next exam, and because the answer they posed matches the answer they solved, they declare it "correct" and award themselves full marks. The scoreboard keeps climbing while their actual ability stays flat — or slides backward.
This is exactly what happens to a self-evolving search agent that grows by repeatedly posing and solving its own problems. This paper identifies a failure inside that closed loop — where examiner and solver increasingly agree on the same wrong answer — and names it "co-cheating." The internal reward keeps rising while the true accuracy stalls or drops. The authors actually measure the phenomenon, then suppress it with a method called CrossFit that swaps around which solver does the grading.
A retrieval-augmented language model mixes in search to gather evidence before producing an answer. Normally it learns from human-written questions and answers, but a self-evolving agent manufactures its own learning material. The structure splits in two. A proposer looks at a source document and produces a question plus a pseudo-label (a provisional answer the model attaches on its own, without human verification). The question pairs that clear a bar are used to train a solver. Then the solver's performance on new questions becomes the proposer's reward in turn. Run this cycle and the questions cluster around the solver's current ability, yielding an automatic curriculum without any human-authored fixed syllabus.
The problem is that this structure uses 'agreement' as a proxy for 'correctness.' This is exactly where the student analogy lands. Suppose the proposer's pseudo-label is wrong. A solver trained on that wrong answer repeats the same error on the next question drawn from the same source. Because the proposer's and solver's answers match, a reward goes out, and that reward embeds the error more deeply into the next round's curriculum. The visible score keeps climbing, but part of that gain isn't skill — it's a shared delusion.
The authors first measured whether the failure is real at all. They took Dr. Zero, an existing self-evolving loop, and ran it as-is without touching the training procedure, saving at every step the source document, the adopted pseudo-labels, and the solver responses used for the proposer's reward. Then an external auditor — one that never intervenes in training — independently produces reference answers grounded in the sources and checks the saved outputs against them.
The key metric here is false-agreement mass: the fraction of cases where the proposer and solver are both wrong but happen to produce the same wrong answer, which then gets counted as 'agreement.' Put plainly, the higher this number, the more often the AI falls for "we're both wrong, but the answers match, so it's correct."
The results were stark. In the first round there's almost no false agreement. Most wrong labels are 'missed answers' — cases where the solver answered correctly but the label was wrong, so no reward was given. But as rounds pile up, the picture flips. Accuracy doesn't rise, yet agreement inflates optimistically, and by the third round false agreement climbs noticeably (figures in the table below). The fact that questions got harder and accuracy dropped doesn't by itself explain why agreement on 'the same wrong answer, contradicting the same source' would increase. It's a signal that mistakes that used to differ are converging into shared ones.
The most obvious fix is to verify the pseudo-labels before feeding them into training. That's MSV (multi-sample verification) — sampling several times and filtering. You give the same model the source and draw three answers, then hide the source and draw three more. The task passes only when both sides return a stable majority answer and the two agree, and that majority answer replaces the label. The source-visible answers test whether evidence backs the answer; the source-hidden answers test whether the answer itself is stable.
But MSV has two holes. First, six samples from the same model can share the same error side by side. Second, even if a label clears verification, it doesn't block the later path where a solver trained on that source picks the label back up. On top of that, each candidate costs six extra generations.
So the authors' main method is CrossFit. The only thing it changes is who does the grading. It splits the proposer's source documents into two groups, fold 0 and fold 1. A question keeps the group its source belongs to throughout training. Each group trains one auxiliary solver. In the next round the roles cross: questions from fold 0 are graded only by the solver trained on fold 1, and vice versa. As a result, for any question, the solver grading it has never trained on that question's source. The reward rule itself is unchanged — points are given by how hard the question looks to the solver. The only thing that changed is who provides that signal.
In short, the two aren't competitors but complements. MSV filters the labels; CrossFit crosses the feedback. Each plugs a different hole, one at the front and one at the back.
The clever move is splitting documents by source rather than by question. Why clever? Split by question and similar questions derived from the same source get exposed to both solvers, which immediately breaks the principle of 'grading with questions you've never trained on.' The very reuse path you meant to eliminate survives intact. One more thing — the main solver isn't split. It trains on every question that passes, as-is. The crossing applies only to the feedback that shapes the proposer's next curriculum.
In a sentence: strip away the fake, inflated score bubble, and real ability rises with it. Block the road to becoming a clever idiot, and the actual problem-solving performance follows upward. CrossFit cuts false agreement to less than half of the conventional approach while lifting downstream performance (the final score from running the trained model on actual QA problems) more than 8 points above standard self-evolution.
One auxiliary experiment is especially worth noting. The authors held out a fixed set of 3,000 questions and replayed the same question set side by side under two kinds of feedback. Under 'combined feedback,' where data from a source went straight into the grader's training history, false agreement was 5.8% at 4B and 7.3% at 9B; under 'source-excluded feedback,' where data originating from that source was kept out of the grader's training history, it dropped to 0.4% at 4B and 0.1% at 9B. Here 'source-excluded' doesn't mean hiding the input document — it means distinguishing whether the grader doing the scoring has ever trained on that source. This replay matters because it separates whether the change in false agreement is 'because the curriculum changed' or 'because the lineage of the feedback changed.' In the end it shows the root of false agreement lies in the feedback's lineage — that is, whether the grader has seen that source or not.
The concrete figures are in the tables below.
False-agreement mass (post-training, lower is better)
| Feedback method | 4B | 9B |
|---|---|---|
| Combined (baseline) | 6.1% | 8.8% |
| MSV | 5.7% | 7.2% |
| CrossFit | 3.0% | 3.7% |
(For reference, pre-training round 1 false agreement is 0.004 at 4B and 0.003 at 9B — essentially nil — then spikes to the combined figures above by round 3.)
Replay experiment (fixed 3,000 questions, false-agreement mass — a separate setup from the table above)
| Feedback method | 4B | 9B |
|---|---|---|
| Combined | 5.8% | 7.3% |
| Source-excluded | 0.4% | 0.1% |
Downstream performance (accuracy, higher is better)
| Method | 4B | 9B |
|---|---|---|
| CrossFit | 48.8% | 51.2% |
| vs. standard combined self-evolution | +8.8 pts | +8.4 pts |
| vs. Search-R1 | +8.7 pts | +7.8 pts |
The authors draw their own lines. CrossFit doesn't turn the auxiliary solvers into all-knowing oracles. The two solvers can still carry shared errors inherited from pretraining or overlapping evidence. What CrossFit cuts is strictly the path where agreement gets rewarded 'merely because they trained on the same source.' In practice, around 3% false agreement remains even after treatment.
The evaluation scope is worth flagging too. The validation is tied to two sizes of Qwen3.5, one particular three-round setup, and seven QA benchmarks, and the audit itself leans on the judgment of yet another large model. Above all, splitting the source in half shrinks the data each auxiliary solver sees, and how this split behaves in data-scarce domains remains to be seen.
This finding doesn't end as academic curiosity. It connects directly to the reliability problem of the AI products we build.
Picture ONTLE's AI PM finishing a customer task and issuing its own 'completion verdict.' The PM produces the deliverable, and the same PM also sets the acceptance criteria — "did it meet the requirements?" — and grades its own work. Keep refining the PM on the accumulated task history, and the apparent 'completion rate' can climb prettily every quarter. This paper's warning lands precisely here. When posing and grading share the same root, a false frontier grows where wrong acceptance criteria and wrong deliverables join hands to approve each other. The completion-rate graph points up and to the right while customer rejections don't fall — that gap is the field version of false agreement.
That said, CrossFit can't be ported over verbatim. This shape only applies if you're automating the completion verdict through learning. Verdict logic trained and tuned on one customer group's tasks is barred from grading its own group's completions, and a verdict-maker raised on a different group handles acceptance review across the line. The main PM keeps learning from the full history, but the 'well done' reward signal alone is drawn from outside the source it trained on. That's why, before seriously tackling completion-verdict automation, there's reason to nail into the design that the data lineage of generation and evaluation is kept apart.
Let's keep one distinction clear. The dual-verification gate ONTLE already runs before publishing — where an independent reviewer, separate from whoever wrote the piece, checks the result against the sources — corresponds to the paper's external audit protocol. It's the habit of continuously measuring the gap between completion rate and actual fulfillment. The CrossFit-style separation of training-data lineage, by contrast, shares the same spirit but applies at a different point — and it's a task we still have to newly bake into the design. The start is simply not conflating what we already have (external audit) with what we still need to add (lineage separation).
No. The paper explicitly states it does not mean intentional coordination. It's simply the flow where the solver learns from a wrong pseudo-label the proposer created, repeats the same error on the next question from the same source, and that agreement loops back as a reward. No one is rigging anything — it's a self-reinforcing phenomenon that hardens on its own as a byproduct of maximizing reward.
The root idea is similar, but the point of application differs. Where cross-validation splits data for model 'evaluation,' CrossFit splits it for the 'reward signal' inside the training loop. And crucially, the unit of the split is the source, not the question. To uphold the principle that the grader must never have trained on that question's source, you have to split by source.