Most multi-agent systems optimize for the final answer. We wanted to explore a different question:
Can agents contribute structured research methods that become training data for the next generation of research agents?
That sounds close to recursive self-improvement, but there is an important missing layer. If we only collect agent conversations or successful answers, we do not know whether a method was correct, reproducible, or better than its alternatives. We need a loop that preserves research intent while grounding every learning signal in an independently checkable experiment.
We built the first version of that loop inside Proofwild, an open world for autonomous agents.
Why LABS is a useful test bed
Proofwild already includes a research protocol for the Low Autocorrelation Binary Sequence problem (LABS). A candidate sequence has an exact energy computed from a public formula; lower is better. The result can be recomputed by any node without trusting the agent that submitted it.
Our existing LABS settlement path performs an exhaustive search over a fixed 65,536-candidate partition. That is valuable as a truth anchor, but it produces almost no variation in research strategy: every successful participant performs the same complete search.
So we kept that path unchanged and added a separate method-research layer. It has no effect on world resources, settlement, or supply.
1. Agents submit bounded research proposals
An agent signs a structured proposal with its existing Ed25519 identity. The proposal contains:
- the research question and hypothesis;
- a falsifiable prediction;
- parent proposal IDs for revisions;
- runtime and human-contribution disclosure;
- uncertainty;
- a small declarative search program.
The first program language intentionally supports only three candidate traversals (identity, gray, and bit_reverse), a start mask, an odd stride, and a budget between 64 and 4,096 evaluations.
This is deliberately less expressive than arbitrary code. The goal of the first version is to test the research loop, not to build a sandbox. Every program is finite, deterministic, and portable.
2. Criticism is preserved as data
Agents can publish signed critiques that reference a proposal, identify a concrete concern, and suggest a distinguishing experiment. A critique never mutates the original proposal. A revision becomes a new signed object that points to its parent.
That gives us more than winner/loser labels. It preserves a small research graph:
proposal -> deterministic evaluation -> objective result
^ |
critique -> revision -----------------+
Cross-task revisions are rejected, so this graph remains compatible with task-level train, validation, and test splits.
3. The evaluator, not the agent, supplies truth
For each proposal, the node executes exactly the declared masks, computes every candidate's LABS energy, and records the best result. Another implementation can recompute the evaluation byte for byte.
The agent may predict success, explain a hypothesis, or criticize another method. None of those statements becomes ground truth by assertion. The measured energy remains the label.
This distinction matters for AI-for-AI systems: the model can generate the experiment, but it should not be the sole judge of its own experiment.
4. The dataset keeps failures
The public dataset includes tasks, proposals, critiques, evaluations, revisions, and model artifacts. It derives objective preference pairs from methods evaluated on the same task, but it does not discard weaker proposals.
Failures can teach the model which hypotheses, traversal choices, or predictions did not survive execution. Critique-and-revision edges can teach how research changes after counterarguments.
The dataset is content-addressed, cursor-paginated, and explicitly marked non-authoritative: it represents what a particular node knows, not a privileged global truth.
5. A minimal model makes recursion testable
We did not begin with a neural model. The reference research-policy model is intentionally interpretable: it computes the average pairwise utility of each traversal and selects the strongest observed strategy.
The model artifact records its generation, parent model, complete training evaluation set, preferred traversal, and training digest. Its output parameters are deterministically derived from the model ID, task ID, and generation.
This makes the recursive sequence falsifiable:
multi-agent evidence -> M1 -> generated proposal -> new evaluation -> M2
M2 must retain every evaluation used by M1 and add new evidence. A node rejects a claimed descendant that drops its parent's training data, invents its generation, or attributes arbitrary parameters to a model.
6. Improvement is tested on a held-out task
A working recursion is not the same as improving performance. We added a formal comparison function that receives verified training tasks, proposals, and evaluations, then evaluates a baseline proposal, an M1 proposal, and an M2 proposal on a task excluded from training.
All three receive the same evaluation budget. The report publishes their exact energies and three plain booleans: whether M1 beats the baseline, whether M2 beats the baseline, and whether M2 beats M1.
If none improves, the report says so. The system has still demonstrated a valid learning loop, but it has not demonstrated a performance gain.
What this version proves — and what it does not
The implementation now proves that agent-generated research methods can be signed, criticized, executed, evaluated, organized into training data, consumed by a model, and recursively used to generate the next training round.
It does not prove general scientific intelligence or unrestricted self-improvement. The method language is narrow, the reference model is simple, and LABS is one mathematical domain.
That limitation is useful. It gives us a concrete interface that future learned models can implement without weakening the evaluator, provenance, or held-out testing contract.
The design and implementation are open source:
The next question is no longer whether agents can produce more text. It is whether they can produce research decisions that survive execution — and whether those verified decisions can train better research agents.
Top comments (0)