Evolving Minds: How LLMs Teach Themselves Through Adversarial Cooperation

Training data is the quiet tax on modern AI. Someone has to write the examples, verify the answers, clean the failures, and pretend the spreadsheet is a strategy. Reinforcement learning makes that tax even more visible: if a model is supposed to improve through feedback, then the organisation must either provide ground-truth answers, hire evaluators, or build verifiers that can tell success from nonsense.

That works tolerably well in domains with hard checks. Code can be executed. Maths can be verified. Games have win conditions. But business reasoning, policy analysis, planning, general knowledge, and messy internal workflows are not Go boards. They do not always come with a neat environment that says “correct” or “wrong” after every move.

The paper behind Multi-Agent Evolve, or MAE, attacks that bottleneck directly.¹ Its proposal is simple enough to sound dangerous: take one language model, split it into three roles, and let those roles train one another. One copy proposes questions. Another solves them. A third judges both. Then the shared backbone is updated through reinforcement learning.

The trick is not that the model “teaches itself”. That phrase is too easy, and therefore suspicious. The trick is that the authors impose enough structure on self-teaching to stop it from becoming a synthetic nonsense factory. The useful idea is not autonomy in the abstract. The useful idea is adversarial cooperation under supervision-by-design.

The model is not one student; it is a small classroom with strict rules

MAE instantiates three agents from the same Qwen2.5-3B-Instruct backbone: a Proposer, a Solver, and a Judge. They are not three separately trained models with independent memories and personalities. They are role-specialised behaviours emerging from one shared model that is updated synchronously.

The Proposer generates tasks. It is rewarded for producing questions that are clear, solvable, and difficult enough to challenge the Solver. The Solver answers those questions. It is rewarded for producing correct, structured answers. The Judge evaluates both the question and the answer using prompt-defined rubrics and parseable score tags.

That produces a loop:

Proposer creates a task
        ↓
Solver attempts the task
        ↓
Judge scores question quality and answer quality
        ↓
Rewards update the shared model
        ↓
The next round becomes slightly different

The important detail is that the Proposer is not rewarded simply for defeating the Solver. If it were, the obvious strategy would be to generate impossible, ambiguous, or malformed tasks. Congratulations: we have reinvented office politics, but with GPUs.

Instead, the Proposer receives a mixture of rewards. It gets a quality reward from the Judge, a difficulty reward based on how hard the Solver finds the task, and a format reward for putting the generated question in the required tags. The Solver receives a Judge score and a format reward. The Judge itself is pushed to produce extractable scores in the required format.

This is the paper’s core mechanism. The system does not replace human design with pure emergence. It replaces some human labelling with a constrained internal market for questions, answers, and evaluations.

This is why a mechanism-first reading matters. A result-first summary would say MAE improves benchmarks without labelled answers. True, but thin. The real contribution is the architecture of constraint: roles, rubrics, format checks, quality filters, and synchronized updates. The paper is less a manifesto for self-improving intelligence than a manual for making self-play slightly less reckless.

The Judge is not a referee from heaven

The Judge is the most powerful and most fragile part of the system. It provides the reward signal for both generated questions and generated answers. For answers, the Judge uses a strict rubric: factual, logical, or calculation errors should fall into the low score band; incomplete but broadly relevant answers occupy the middle; only correct and complete answers earn top scores. For questions, the Judge assesses solvability, clarity, coherence, and whether the prompt is actually answerable.

This design is what lets MAE move beyond domains with external verifiers. A Python interpreter can judge code execution. A game engine can judge a win. But for general reasoning tasks, the paper uses the model-as-judge paradigm to create a domain-agnostic reward signal.

That move is powerful, but it is not magic. During training, MAE avoids labelled ground-truth answers and external verifiers. During evaluation, however, most non-coding benchmark outputs are judged by a strong external LLM, nvidia/llama-3.1-nemotron-70b-instruct, against benchmark ground truth. Coding is evaluated using EvalPlus. That distinction matters.

The training loop is self-rewarding. The experimental evaluation is not a vibes-only parade. It still uses benchmark answers and a stronger judge for measurement. This is good experimental hygiene. It also means the paper should not be read as proof that internal self-judgement alone guarantees real-world truth.

The evidence is a benchmark gain, not a declaration of machine childhood

The authors test MAE on Qwen2.5-3B-Instruct across mathematics, coding, commonsense reasoning, reading comprehension, general knowledge, truthfulness, and held-out reasoning benchmarks. The headline result is that the best MAE variant, “half reference”, reaches an overall average of 59.87, compared with 55.33 for the base model and 53.87 for supervised fine-tuning on the seed dataset.

That is a 4.54-point gain over the base model on the paper’s overall average. It is not a universal 4.54% improvement in all capabilities, and it is not proof that the model has discovered a general route to autonomous intelligence. It is a respectable benchmark improvement under a specific training and evaluation setup.

The experimental settings are worth separating because they answer different questions.

The SFT comparison deserves care. The paper reports that supervised fine-tuning on the small seed dataset, using ground-truth answers, underperforms both the base model and MAE variants. That is interesting, but not a death sentence for SFT. It likely says that a small, broad, heterogeneous set of 967 examples is a poor fit for conventional fine-tuning, especially when the target is broad benchmark performance. MAE uses the seed questions differently: not as a fixed answer key, but as a starting distribution for generating more tasks.

That is the business-relevant interpretation. The paper does not show that labels are obsolete. It shows that when labels are scarce, task generation and self-evaluation may extract more useful training signal from unlabeled question seeds than naïve supervised fine-tuning.

The “half reference” result is a curriculum lesson hiding inside an RL paper

The best MAE configuration alternates between two behaviours: sometimes the Proposer modifies a reference question, and sometimes it creates a question from scratch. This is the most commercially interesting result in the paper because it resembles how practical training systems often need to behave.

A purely reference-driven system risks staying too close to known examples. A purely exploratory system risks wandering into junk. MAE half reference lands between anchoring and exploration. It uses seed questions to preserve distributional relevance while still allowing the model to invent new challenges.

That is curriculum design, not just data augmentation.

The paper’s training-curve analysis supports this reading. The authors observe that useful learning depends on “desirable difficulty”: questions should be hard enough to stretch the Solver, but not so broken that the Judge rejects them or the Solver receives useless feedback. The valid question pool grows during training, while low-quality questions are filtered out. The Proposer gradually learns to generate tasks around the Solver’s frontier.

For business teams, this is the difference between synthetic data as volume and synthetic data as diagnosis. Volume says: create more examples. Diagnosis says: create examples that expose the model’s current weakness without leaving the domain of answerable work. The latter is rarer, more useful, and harder to automate. Naturally, it is also the part everyone will put on a slide and then forget to engineer.

The ablations show that the boring safeguards are doing real work

The paper’s ablation study is where the “self-improving model” story becomes less cinematic and more credible. The authors remove parts of the system and measure what happens under the half-reference setting.

Removing Solver training drops the overall average from 59.87 to 57.79. Removing Proposer training gives 57.90. Removing Judge training gives 57.24. These are not catastrophic failures, but they are consistent losses. The conclusion is not that any single role is magical. It is that the loop works because the roles adapt together.

The more revealing ablation concerns question quality filtering. MAE only adds generated questions to the valid dataset when the Judge rates their quality above a threshold. The paper uses 0.7 on a 0-to-1 scale. Remove that filter, and the overall average falls to 56.15, a 3.72-point drop from the full half-reference system.

That is the paper’s most practical warning. Difficulty alone is hackable. If the Proposer is rewarded when the Solver fails, it can win by writing impossible questions. Quality filtering prevents that by requiring the Judge to approve clarity and solvability before a generated question becomes training material.

Format rewards sound even less glamorous, but they matter because the loop is automated. If the Proposer fails to put the question inside the required tags, or the Judge emits multiple scores instead of one extractable score, the training pipeline becomes brittle. The paper finds that removing format reward causes only a small overall drop, from 59.87 to 59.44, partly because quality filtering also catches some malformed outputs. Still, the implementation lesson is obvious: autonomous loops need parseability, not poetry.

This is where the paper becomes useful for enterprise AI. Most companies do not fail because they lack clever prompts. They fail because their data-generation loops quietly accumulate garbage. MAE’s safeguards are not decorative. They are the difference between self-training and self-pollution.

The business value is cheaper training signal, not label-free omniscience

The business pathway from MAE is straightforward, but narrower than the hype version.

What the paper directly shows: on one 3B open model, under the authors’ training setup, a Proposer-Solver-Judge loop can improve broad benchmark performance without using ground-truth answers during training. It performs best when seeded with unlabeled reference questions and allowed to mix reference-based generation with free exploration.

What Cognaptus infers: this architecture points toward cheaper internal training and evaluation workflows for domains where labelled answers are expensive, incomplete, or slow to obtain. A company could use role-separated agents to generate domain-specific tasks, attempt solutions, judge clarity and correctness, and filter candidate examples before human review. Human experts would then audit the highest-value cases rather than authoring every example from scratch.

What remains uncertain: whether the same method works on larger or more specialised models, whether the Judge remains reliable in high-stakes domains, whether generated tasks reflect real operational distributions, and whether benchmark gains translate into measurable productivity, reduced error rates, or lower annotation cost.

The most plausible near-term business use is not fully autonomous model improvement. It is assisted curriculum generation. For example:

• A legal AI team could generate contract-analysis questions from existing clause patterns, then route only high-quality cases to human reviewers.
• A finance AI team could create reasoning tasks around disclosures, ratios, and scenario assumptions, while filtering out ambiguous or unverifiable prompts.
• A customer-service automation team could generate edge-case tickets, evaluate draft answers, and identify where the model fails under unusual constraints.
• An internal knowledge assistant team could use generated questions to test whether the model handles multi-hop reasoning across company documents.

In all of these cases, MAE-like systems would not remove human oversight. They would change where human oversight is applied. Instead of writing every training item, experts would inspect the loop, audit Judge behaviour, approve task pools, and validate downstream performance.

That is less dramatic than “AI teaches itself”. It is also much more likely to survive procurement.

The boundary is the Judge, the seed distribution, and the world outside the benchmark

MAE’s limitations are not generic “more research is needed” boilerplate. They affect how the result should be used.

First, the evidence is based on Qwen2.5-3B-Instruct. Scaling may help, as the authors suggest, because stronger models may propose better questions and judge more reliably. But scaling may also amplify self-consistency errors. A larger model can be more persuasive while still being wrong. Delightful.

Second, the training loop depends heavily on engineered prompts, rubrics, tags, thresholds, and role instructions. The paper’s appendix is not decorative; it is part of the method. This matters because enterprises often underestimate the maintenance cost of these control surfaces. If the rubrics are weak, the Judge becomes weak. If the tags break, the pipeline breaks. If the seed questions are misaligned, the generated curriculum drifts.

Third, the evaluation procedure itself relies on a strong LLM judge for most benchmarks. That is a practical choice, but it means some measured performance depends on another model’s evaluation behaviour. For internal business use, this would need calibration against human expert review, especially where correctness is consequential.

Fourth, the seed dataset is broad and modest: 967 unlabeled questions across 14 datasets in the reference-based settings, plus a minimal 16-question model-generated seed for the zero setting. The result says something about broad reasoning benchmarks. It does not automatically transfer to regulated finance, medical advice, legal interpretation, safety-critical operations, or company-specific process execution.

Finally, MAE trains on generated tasks. Generated tasks can expose weaknesses, but they can also form a private synthetic universe where the model improves at the game it invented. Quality filtering reduces that risk; it does not abolish it. The world remains annoyingly external.

The paper’s real lesson: autonomy needs architecture

Multi-Agent Evolve is valuable because it refuses a false choice. It does not rely entirely on human-labelled datasets, but it also does not ask us to believe in unconstrained self-improvement. It builds a structured loop where proposing, solving, and judging are separated, rewarded, and filtered.

The result is not a machine that wakes up and educates itself. It is a training architecture that converts unlabeled questions, role-specific incentives, and model-based evaluation into usable reinforcement learning signal. The benchmark gains are meaningful because they come with ablations showing why the loop does not immediately collapse into malformed prompts and fake difficulty.

For businesses, the takeaway is equally specific. The future value of agentic AI will not come only from agents executing workflows. It may also come from agents manufacturing better tests of those workflows: harder questions, sharper failure cases, cleaner evaluation pools, and cheaper diagnostic data. But the organisations that benefit will be the ones that treat self-training as an engineered control system, not a motivational poster.

The model can propose. The model can solve. The model can judge. The adult supervision is still in the architecture.

Cognaptus: Automate the Present, Incubate the Future.