Banger paper from NVIDIA on shared memory for research agents.

(bookmark it)

If you run several coding agents on the same research problem, this design keeps them from repeating each other’s experiments and lets each agent build on results the others have already verified.

Agora records every result, hypothesis and verification as an immutable Git commit.

Parent edges show what each claim builds on, and an index lists open branches and which claims have been verified.

They ran 13 LLM workers for nearly 12 days without assigned tasks or a central planner. The workers had to initialize a 119.6M-parameter hybrid model from 141 donor models without training data or gradient updates.

The workers posted 1,703 contributions.

They cut the evaluator from 3.39 to 1.899 bits per byte, closing 62% of the gap to a trained GPT-2 124M. All 165 independent reproductions succeeded.

Paper: https://arxiv.org/abs/2609.18094

Chat with Paper: https://academy.dair.ai/papers/agora-git-as-shared-memory-for-collective-autoresearch-2609.18094…

Agora: Git as Shared Memory for Collective AutoResearch

Source: https://arxiv.org/html/2609.18094 Yunheng ZouShaokun ZhangJian HuHao ZhangBinfeng XuJan KautzYi DongAffiliation:NVIDIAEmail:{yifazhang,yidong}@nvidia.com

Abstract

Autonomous research loops such as AutoResearch show that one coding agent can improve a training setup unattended. Run several of them and each session starts from scratch, so more agents tend to mean more duplicated search rather than more discovery.Agorais a shared memory for such agents: research is recorded as an append-only directed acyclic graph (DAG) stored in Git, so that every claim is a commit anyone can check out and rerun. Each result, insight, hypothesis, verification, and report is an immutable commit whose parent edges say what it builds on; a derived index exposes the frontier, the neglected branches, and the verification status of each claim, and a diversity-aware selection rule keeps the community from collapsing onto one leader. We describe the system and report its first sustained use: a run of nearly 12 days in which 13 language-model workers, with no assigned tasks and no central planner, worked on a weight-transfer problem. Given 141 pretrained donor models and a frozen 119.6M-parameter attention-SSM hybrid whose dimensions match no donor, the workers had to initialize the target without training data or gradient updates. They published 1,703 contributions and drove the evaluator from 3.39 to 1.899 bits per byte, closing 62% of the gap to a trained GPT-2 124M. The winning recipe compresses donor next-token statistics into the target’s embedding and output head, then adds a short-range context signal through sparse edits to attention, feed-forward, and state-space blocks. Its 145-commit ancestry spans 15 accounts, and 165 independent reproductions were posted, none of which failed. We describe the single mid-run human intervention that pulled the community out of a monoculture, what the trace does and does not establish, and the controlled comparison that would settle whether shared research state improves discovery per unit of compute.

\abscontent

1Introduction

Research gets narrated as a sequence of individual breakthroughs, but it is done by communities. Researchers inherit prerequisites, reuse instruments and code, compete over open questions, and arrive at the same idea independently once the frontier makes it reachable;multiple discoveriesare the rule, not the exception(Merton, 1961). A group’s output is not the output of its strongest member(Woolley et al., 2010), and recent work argues that agentic AI should likewise be treated as a social and institutional system rather than one large reasoner(Evans et al., 2026).

AI research agents make the coordination problem hard to ignore. A session can run code, read papers, and launch experiments, but what it learns is stuck in a transcript or a temporary worktree. The next session does not know which learning rate diverged, which branch was abandoned, or which result still needs an independent reproduction. Adding workers makes this worse: more attempts, but also more duplicate search, earlier convergence, and more effort spent reconstructing who did what.

Existing multi-agent frameworks organize conversations or encode role-specific workflows(Li et al., 2023;Wu et al., 2023;Hong et al., 2023). That works within one task. A research community additionally needs state that outlives any worker: a public frontier, immutable lineage, negative results, independent verification, and some way to spread attention without dictating a single workflow.

Agorais that layer. Research is a DAG in which every contribution is a Git commit and every parent edge means “builds on.” Git supplies immutable, content-addressed artifacts; a database supplies searchable views; the graph itself becomes the coordination and quality signal. The system does not try to decide what is true. It makes claims, dependencies, verification status, and untried alternatives visible enough that a mixed community of humans and agents can coordinate around them. The Git history is the only state: workers read and write it, and nothing else passes between them.

We put this to the test with a 12-day run in which 13 coding-agent sessions, given only a two-page brief, an evaluator, and the shared graph, worked on initializing a frozen hybrid language model from a zoo of pretrained donors with no training data. They reached 1.899bpbfrom a random baseline of 3.39, reproduced one another’s results 165 times, and, after a single human intervention that showed them a map of their own concentration, left a five-day monoculture within a day.

Contributions.

We (i) formulate multi-agent research as an append-only DAG whose nodes carry artifacts, claims, metrics, and provenance (Section3); (ii) separate immutable storage from downstream evidence and from diversity-aware attention allocation; (iii) describe the Git, SQLite, API, CLI, and web prototype that implements the design; (iv) report the first sustained run on it, including the method the agents found, how we verified their claims, and the coordination dynamics visible in the trace (Section4); and (v) use what the run leaves open to define a matched, preregisterable evaluation (AppendixC).

2Related Work

Collective intelligence and scientific institutions.

Scientific discovery has long been modeled as a decentralized institution: individuals choose problems locally while coordinating through a shared body of public knowledge(Polanyi, 1962). Independent or simultaneous discoveries are recurrent rather than exceptional(Merton, 1961), and group performance depends on interaction structure as well as individual ability(Woolley et al., 2010). Quantitative studies further connect collaboration structure, topic choice, and team scale to the production and diffusion of discoveries(Fortunato et al., 2018). Recent work extends this institutional perspective to agentic AI(Evans et al., 2026).Agoraimplements a narrow slice of this literature: durable public memory, attribution, verification, and attention allocation for one research community.

LLM multi-agent systems.

Existing frameworks coordinate agents through role play(Li et al., 2023), programmable conversations(Wu et al., 2023), standard operating procedures(Hong et al., 2023), or staged software development dialogues(Qian et al., 2024). AgentVerse varies team composition and studies emergent collaboration(Chen et al., 2023), whereas Magentic-One uses an orchestrator to plan and redirect specialized agents(Fourney et al., 2024). Related work studies persistent memory and emergent social behavior(Park et al., 2023)and repeated debate between model instances(Du et al., 2023). These systems coordinate a team inside one application or episode.Agoraserves asynchronous participants that share no conversation, manager, role graph, runtime, or filesystem.

Autonomous research agents.

AutoResearch shows that a single coding agent can improve a training setup unattended over many iterations(Karpathy, 2026). ResearchAgent generates and iteratively refines research ideas from scientific literature using reviewer agents(Baek et al., 2025). The AI Scientist extends automation across idea generation, implementation, experimentation, paper writing, and simulated review(Lu et al., 2024), while Agent Laboratory organizes literature review, experimentation, and report writing as a staged multi-agent workflow with optional human feedback(Schmidgall et al., 2025). MLAgentBench, MLE-bench, and ScienceAgentBench evaluate agents on machine-learning experimentation, engineering competitions, and publication-derived scientific tasks, respectively(Huang et al., 2023;Chan et al., 2024;Chen et al., 2024). ChemCrow and Coscientist connect language models to scientific tools and, in the latter case, laboratory automation(Bran et al., 2024;Boiko et al., 2023). These systems automate or evaluate large parts of a research process.Agorais complementary: it prescribes no end-to-end researcher, and instead keeps durable state (negative results, lineage, verification) across researchers that are scheduled independently.

Shared workspaces and reproducible artifacts.

Blackboard architectures coordinate heterogeneous knowledge sources through a shared problem-solving state and explicit control policy(Hayes-Roth, 1985). Reproducibility systems capture different parts of the computational record: DataLad versions code, data, and their relationships(Halchenko et al., 2021); ReproZip packages execution dependencies(Chirigati et al., 2013); Whole Tale and RO-Crate package executable or machine-readable research objects(Brinckman et al., 2019;Soiland-Reyes et al., 2022); and Nextflow, Snakemake, and MLflow track executable workflows or experiment lifecycles(Di Tommaso et al., 2017;Mölder et al., 2021;Zaharia et al., 2018).Agoraapplies the same idea one level up, to claims: its shared state is an append-only contribution DAG, and the same graph exposes verification status, neglected branches, and attention signals.

Exploration, open-ended search, and quality diversity.

The exploration–exploitation trade-off is classically formalized by multi-armed bandits(Auer et al., 2002); UCT applies bandit selection to tree search(Kocsis and Szepesvári, 2006). Novelty search shows that abandoning a single objective can avoid deceptive local optima(Lehman and Stanley, 2011), while MAP-Elites and quality-diversity methods seek diverse collections of high-performing solutions(Mouret and Clune, 2015;Pugh et al., 2016). POET jointly generates problems and solutions, transferring stepping stones between branches(Wang et al., 2019).Agoraborrows these intuitions for attention allocation, but its graph is neither a stationary bandit nor a game tree, and its suggestions are heuristics for surfacing underexplored branches, not a guarantee of optimal planning.

3Agora: A Git-Backed Research DAG

3.1Problem setting and design goals

A project has participants𝒜\mathcal{A}and a growing sequence of contributionsVV. A contribution may carry code or data artifacts, a description, optional metric values, tags, and a set of parents. At any moment the platform should be able to answer four questions:

1. 1.What has been tried, including failures?
2. 2.Which claims have independent support or conflict?
3. 3.Where is the current frontier, including neglected alternatives?
4. 4.What exact artifact and lineage produced a reported result?

Table1turns these into system goals.

Table 1:Design goals and the mechanism used byAgora.GoalFailure without a shared institutionAgoramechanismDurable memorySession-local discoveries and negative results disappear.Append-only Git commits with explicit parent lineage and searchable metadata.Frontier visibilityWorkers guess what is open and duplicate the same branch.Leaf, hypothesis, verification, cluster, and metric-landscape views.Evidence qualityVotes reward popularity; self-citation and repeated endorsement are cheap.Independent follow-on work, replaceable verification verdicts, and self-citation exclusion.Search diversityA leaderboard concentrates all workers on one local basin.Semantic clusters, diversity summaries, frontier candidates, and separate exploit/explore slots.AuditabilityA scalar score loses the configuration and code that produced it.Content-addressed artifacts, canonical commits, immutable revisions, and rebuildable contribution indexes.Agorais a coordination substrate, not a lab manager. Projects define their own instructions, metrics, artifact contracts, and safety boundaries; the platform supplies the shared mechanisms for publishing and finding work and does not pretend one scoring rule fits every field.

3.2Contribution graph and provenance

A project state is a directed acyclic graphG=(V,E)G=(V,E). Foru,v∈Vu,v\in V, an edge(u,v)∈E(u,v)\in Emeans thatvvbuilds onuu; in Git terms,uuis a parent of commitvv. Each node stores

v=(h,a,T,d,x,m,P,τ),v=(h,a,T,d,x,m,P,\tau),(1) wherehhis the canonical commit hash,aathe publishing account,TTa set of tags,dda description,xxstructured metadata,mman optional project metric,PPthe parent set, andτ\tauthe server timestamp. Code-bearing contributions carry the full repository state. Because identity is a hash and parentage is Git parentage, history is append-only and acyclic by construction. Git is the only state the system depends on: the SQLite index that answers queries, theanalyzeviews below, and every figure in this report are derived from the Git history and can be rebuilt from it. Participants publish through a CLI or HTTP API and never share a filesystem, model, or conversation (Figure1).

Human and AIparticipantsCLI, web UI,and HTTP APIAuthentication,validation, rate limitsPer-project Gitcanonical artifactsSQLitederived query indexAnalyze, search,clusters, and UCBRanked frontier: exploit⋅\cdotexplore known⋅\cdotexplore novelFigure 1:Agorakeeps the shared memory in Git and derives everything else from it. Participants publish through a shared API and read several views of the frontier; no central planner assigns work.#### Contribution vocabulary.

Tags give contributions a little shared meaning without a rigid ontology. Reserved tags carry validation or scoring behavior; projects add their own for methods, datasets, failure modes, or open questions. Table2lists the reserved set.

Table 2:Reserved contribution types. Weights are applied to a direct parent when the child comes from another account.TagWeightRoleKey rulesetup+5+5Initial project files and instructions.Commit zero; no project metric.result+5+5Experimental outcome with optional artifacts and metric.Successes and failures alike.insight+5+5Interpretation, pattern, or cited observation.Parents identify the evidence being synthesized.hypothesis+5+5Concrete untested proposal.May not present a metric value as if already tested.report+5+5Human-readable synthesis across contributions.Cites the nodes from which conclusions are drawn.verification+20/+10/−20+20/+10/-20Confirmed, partial, or failed reproduction.Exactly one target; never one’s own work.endorsed00Acknowledgement after inspection.Visible, but excluded from fitness.wip00In-flight work, to reduce duplication.Visible, but does not propagate score.

Light and heavy publication paths.

Metadata-only work uses a light path: the client sends JSON, and the server creates the canonical commit. Code-bearing work uses a heavy path: the participant commits locally, uploads a Git bundle, and the server validates the contribution before creating a canonical server-timestamped commit. Both paths yield the same kind of node, so lineage and queries do not care which was used. A project starts withagora init, which creates thesetupcontribution; from then on a participant loops: analyze, pick a parent, run locally, publish, analyze again.

Quality from downstream evidence.

Letw⁡(v)w(v)be the tag-dependent weight in Table2, and leta⁡(v)a(v)be the author. A contribution’s evidence score is the weighted count of what other accounts built on it,

S(u)=∑v:(u,v)∈E𝟙[a(u)≠a(v)]w(v).S(u)=\sum_{v:(u,v)\in E}\mathbbm{1}[a(u)\neq a(v)]\,w(v).(2) A separate descendant count tracks qualifying downstream work reachable fromuu; endorsements, work in progress, and failed verifications do not add to it. The self-citation exclusion stops a worker from manufacturing impact by extending its own branch. If a verifier changes its verdict on a target, the newest verdict replaces the old one’s effect on the score, and both commits stay in the history.

The score is not a truth signal. It encodes a narrower claim: work that others have reproduced or built on is more actionable than work that has only been voted for. Whether a result is accepted still depends on the project’s evaluator, controls, and artifact policy.

3.3Diversity-aware attention allocation

A leaderboard is a good exploitation signal and a poor map. It pulls every worker toward the same parent, hides negative results, and makes a saturated basin look like progress. Theanalyzecall therefore returns several views at once: metric leaders, most built-on nodes, leaves, promising but underexplored results, unverified results, contested verifications, open hypotheses, recent activity, tags, and contributors.

Once embeddings cover enough contributions, the service adds single-link clusters over descriptions and reports cluster count and sizes, top-cluster share, an entropy-based effective cluster count, evenness, a metric histogram, and a frontier of promising nodes in small clusters. Clustering requires at least50%50\%embedding coverage, uses a cosine threshold of0.900.90by default, and caps pairwise analysis at the 5,000 most recent contributions.

Candidates are ranked by a diversity-aware upper-confidence bound in the spirit of bandit and tree-search selection rules(Auer et al., 2002;Kocsis and Szepesvári, 2006),

U⁡(v)=100​Q​(v)+C​log⁡(N+1)n⁡(v)+1+100​D1+ρ⁡(v),U(v)=100\,Q(v)+C\sqrt{\frac{\log(N+1)}{n(v)+1}}+\frac{100D}{\sqrt{1+\rho(v)}},(3) whereQ⁡(v)Q(v)is a quality percentile,n⁡(v)n(v)counts follow-on work onvvout ofNNoverall, andρ⁡(v)\rho(v)counts near-duplicate descriptions. The exploration constantCCgrows when the metric distribution is tightly bunched near its best. Candidates are then shown in three slots:

• •exploit: reproduce or refine the leaders;
• •explore known: extend promising work in a thin cluster; and
• •explore novel: inspect untouched nodes in singleton or very small clusters.

The split matters more than the exact score: it puts the trade-off in front of the participant and gives the project a way to notice when the community is collapsing into a monoculture.

3.4Prototype implementation

The prototype is a Go service with a command-line client and a Next.js web interface; Figure1shows the data path. Each project owns a bare repository under the server data root, and canonical contribution refs keep every accepted node reachable. SQLite holds eight tables: agents, projects, contributions, parents, tags, cross-project references, embeddings, and rate limits. The contribution index can be rebuilt from Git; project metadata and authentication state still need ordinary database backups.

The server exposes 26 HTTP routes and the CLI 15 command groups. Read views cover projects, lineage, DAG structure, search, analysis, file browsing, and diffs. Writes, clones, and fetches require bearer authentication, and rate limits bound registration, contribution creation, search, project creation, and bundle size. A Docker image bundles the API, the web interface, and persistent storage. The codebase is small enough to audit end to end.

4The Weight-Transfer Run

This section reports what a community of agents produced onAgora. They proposed the methods, wrote the code, ran the evaluations, and reproduced one another’s claims; we defined the task and evaluator and wrote this account from their published record. Section4.8describes how we checked it.

4.1Task and evaluator

Pretrained language models store a great deal of knowledge in their weights, but reusing it in a new architecture normally means training on data. We asked how much of a trained model’s predictive quality can be recovered in a target whose architecture matches none of the available donors, using only the donors’ weights and forward passes: no training corpus, no gradient update on the target.

The donor zoo holds 141 open-weight models (534 GB) from 32 architecture families, including GPT-2, LLaMA, Mistral, Qwen, Gemma, Pythia, RWKV, and Mamba(Radford et al., 2019;Touvron et al., 2023;Jiang et al., 2023;Bai et al., 2023;Gemma Team, 2024;Biderman et al., 2023;Peng et al., 2023;Gu and Dao, 2023). The target is a 14-layer hybrid that alternates multi-head attention blocks(Vaswani et al., 2017)with simplified Mamba-style selective state-space (SSM) blocks(Gu and Dao, 2023), with hidden size 672, seven attention heads, untied embeddings, and 119,572,320 parameters. We chose these dimensions so that no donor matches any of them. A participant submits a Python file with atransfer(model, config)function that receives the randomly initialized target and returns it with new weights. The evaluator seeds all random-number generators with 42, runstransfer(), and scores 200 FineWeb-Edu texts(Penedo et al., 2024)in non-overlapping 512-token chunks under the GPT-2 tokenizer, reporting summed next-token loss divided by UTF-8 byte count. The FineWeb-Edu loader raises an error if called from insidetransfer(), and the rules forbid pretraining, fine-tuning, and editing the evaluator or target configuration. Two runs of the same code on the same hardware are bit-identical; across GPU types the score can differ in the third decimal place. Random initialization scores 3.3923bpband a conventionally trained GPT-2 124M about 1.0. The trained model sets the scale; it is not an achievable no-training baseline. The project brief set an aspirational target below 2.5.

4.2Agents, harness, and tools

The workers were coding-agent sessions running frontier language models: Claude Code(Anthropic, 2026a)with Claude Opus 4.7(Anthropic, 2026b)and Codex(OpenAI, 2026a)with GPT-5.5(OpenAI, 2026b). A small launcher ran each session in a container with GPU access, mounted oneAgoraaccount credential, and invoked the agent’s command-line interface in headless mode with a one-line prompt: readprogram.mdfor full instructions, and runagora analyzeto see what others have tried. When a session ended, the launcher started a new one on a free credential.program.mdis a two-page brief committed as the project’s first node. It states the task, the rules, the evaluator contract, the requirement that every contribution run from a fresh checkout, and the loop a session should follow. Nothing in the prompt or brief names a method, assigns a role, or ranks the participants.

Thirteen worker accounts wrote 1,699 of the 1,703 contributions in the primary window: five (worker1–worker5) on A100 nodes from April 27, and eight (slurm_worker_1–8) on H100 nodes from April 28 until the cutoff. The remaining four records are the setup commit and three posts of our own (Section4.7), so the graph holds 17 accounts in all. Every worker had theAgoraCLI, Git, a Python environment with PyTorch(Paszke et al., 2019)and Transformers(Wolf et al., 2020), read access to the donor zoo in object storage, the project’s evaluator, and one 80 GB GPU. Evaluation takes a few seconds; building the six-donor transition matrix takes about five minutes on an H100 and hours on CPU.

4.3Research loop

Figure 2:Daily publication volume by type in the 1,703-record window. The community sustained roughly 170 contributions per day once all 13 workers were running. Explicit negative-result and explore-novel tags appear only after the May 2 deployment of the landscape and diversity views.Each session repeated the loop the brief describes: readanalyze, pick a parent, fetch and check out that exact commit, make one change, evaluate, commit everything needed to reproduce, push with a description and metric, then post whatever else it had learned as an insight, hypothesis, or verification before analyzing again. The run lasted 11 days and 19 hours of server time, from the setup commit on April 26 to our cutoff on May 8 (Figure2). The 1,703 contributions comprise 1,124 scored results, 284 insights, 203 hypotheses, 165 verifications, and one report, with tag overlaps; 233 of the scored results set a new best. Contribution descriptions are long and structured: workers state the parent and its score, the single change made, a predicted outcome band, the measured result, and named follow-ups for others. From April 28 onward more than 400 descriptions declare a prediction band before the result, and later workers explicitly close follow-ups named by earlier ones. We did not ask for any of this. It emerged from the brief’s reproducibility requirement and from the visibility of other accounts’ posts.

4.4The winning recipe

Algorithm1states the method as it exists in the committed code of the best contribution at the analysis cutoff. That commit is a chain of 83 Python modules, each importing its parent and applying one change; we traced the chain to its root and checked every constant below against it.

Stage A builds the initialization from what the donors predict rather than from their parameters. Six donors sharing the GPT-2 vocabulary, GPT-2 small and large(Radford et al., 2019)and Cerebras-GPT 111M to 1.3B(Dey et al., 2023), are queried on every vocabulary tokenvvunder 28 single-token contextspp(none, end-of-text, and 26 frequent tokens such as’ the’). Their next-token log-softmaxes are blended with fixed donor weights (0.725 on GPT-2 small) and per-row context weights, giving a50257×5025750257\times 50257context-averaged bigram tableMM. Its column meanuuis split off as a unigram-like anchor, and the centered table is factorized to rankd−1=671d{-}1=671by randomized SVD(Halko et al., 2011)with a fixed sketch and one power iteration. The factors become the input embedding and output head, hidden dimension 0 carriesuu, two temperatures rescale the two terms, and every sublayer is zeroed. The result is a factorized bigram model stored in a 14-layer network.

Stage B re-enables sublayers with sparse deterministic edits on 96-dimensional bands of the hidden state,Bk=[1+96k,97+96k)B_{k}=[1+96k,\,97+96k), whereB0B_{0}holds the leading singular directions (Table3). Every attention layer becomes a uniform causal mean-pool over one band written back at a small scale, so the model sees an average of its past embeddings. Layer 0’s SwiGLU block receives SVD-projected slices of GPT-2 small’s first MLP at scale 0.009. In each SSM block the selective path is disabled, so it reduces to a gated depthwise causal convolution over one band; layer 1 uses a sign-alternating kernel that emphasizes recent positions, the rest a uniform one. Their output projections write the filtered band into its own band and, on six layers, intoB2B_{2}andB3B_{3}. Each constant was introduced as a single change on the then-current best and kept because the evaluator improved.

Algorithm 1Donor-behavior transfer, as committed at the cutoff.1:frozen target (

d=672d{=}672, 14 layers, vocabulary

VV); donors

D1..D6D_{1}..D_{6}with weights

αj\alpha_{j}; contexts

PP(

|P|=28|P|{=}28); temperatures

Tb,TuT_{b},T_{u}; routes (Table3)

2:Stage A: transition prior

3:foreach donor

jj, context

pp, token

vv(streamed in batches)do

4:

ℓj,p​(v,⋅)←clip⁡(log⁡softmax⁡Dj​(p,v),±25)\ell_{j,p}(v,\cdot)\leftarrow\operatorname{clip}(\log\operatorname{softmax}D_{j}(p,v),\pm 25) 5:

wj,p​(v)←clip⁡(var^j,p​(v)⋅nat^j,p​(v),[0.5,1.5])w_{j,p}(v)\leftarrow\operatorname{clip}\!\big(\widehat{\mathrm{var}}_{j,p}(v)\cdot\widehat{\mathrm{nat}}_{j,p}(v),[0.5,1.5]\big), normalized over

pp 6:endfor

7:

M⁡(v,⋅)←∑jαj​∑pwj,p​(v)​ℓj,p​(v,⋅)M(v,\cdot)\leftarrow\sum_{j}\alpha_{j}\sum_{p}w_{j,p}(v)\,\ell_{j,p}(v,\cdot)⊳\trianglerightV×VV\times Vbigram log-prob table

8:

u←1V​∑vM⁡(v,⋅)u\leftarrow\tfrac{1}{V}\sum_{v}M(v,\cdot);

C←M−𝟏​u⊤C\leftarrow M-\mathbf{1}u^{\top} 9:

(U,S,V⊤)←RandSVD​(C,rank​d−1,oversample​32,1​power iteration, fixed seed)(U,S,V^{\top})\leftarrow\textsc{RandSVD}(C;\ \text{rank }d{-}1,\ \text{oversample }32,\ 1\text{ power iteration, fixed seed}) 10:

E:,0←1E_{:,0}\leftarrow 1;

E:,1:←U/dE_{:,1:}\leftarrow U/\sqrt{d};

H:,0←u/(dTu)H_{:,0}\leftarrow u/(\sqrt{d}\,T_{u});

H:,1:←VS/TbH_{:,1:}\leftarrow VS/T_{b} 11:embedding

←E\leftarrow E; output head

←H\leftarrow H; all sublayer weights

←0\leftarrow 0; norms

←\leftarrowidentity

12:Stage B: structured context routes

13:foreach attention layer

ℓ∈{0,2,…,12}\ell\in\{0,2,\dots,12\}, band

k=ℓ/2k=\ell/2do

14:

Wq,Wk←0W_{q},W_{k}\leftarrow 0⊳\trianglerightuniform causal attention

15:

WvW_{v}reads

BkB_{k}scaled

1/d1/\sqrt{d};

WoW_{o}writes

BkB_{k}scaled

aℓa_{\ell} 16:endfor

17:layer-0 SwiGLU

(Wgate,Wup,Wdown)←0.009⋅SVDProject​(GPT-2 small MLP0)(W_{\text{gate}},W_{\text{up}},W_{\text{down}})\leftarrow 0.009\cdot\textsc{SVDProject}(\text{GPT-2 small MLP}_{0}) 18:foreach SSM layer

ℓ∈{1,3,…,13}\ell\in\{1,3,\dots,13\}do

19:

WinW_{\text{in}}copies read band

RℓR_{\ell}into 96 channels and their gates;

Wx,Wd​t←0W_{x},W_{dt}\leftarrow 0⊳\trianglerightrecurrence off

20:depthwise kernel

←κℓ\leftarrow\kappa_{\ell};

WoutW_{\text{out}}writes each band in

𝒲ℓ\mathcal{W}_{\ell}with its scalar

21:endfor

22:returntarget

Table 3:Stage-B routes in the cutoff commit. Bands are 96-dimensional slices of the hidden state; scalars are the diagonal entries written into the output projection. Attention layers read and write the same band.LayersRead bandKernelWrite band: scalarAttn 0, 2, 4, 6, 8, 10, 12B0..B6B_{0}..B_{6}—same band: 0.21, 0.02, 0.0425,−0.0025-0.0025,−0.002-0.002,−0.0025-0.0025,−0.0025-0.0025SSM 1B0B_{0}(1.85,1.65,0.20,−2.70)(1.85,1.65,0.20,-2.70)B0B_{0}:−0.115-0.115;B2B_{2}: 0.010;B3B_{3}: 0.005SSM 3B1B_{1}uniform1/4\nicefrac{{1}}{{4}}B1B_{1}:−0.060-0.060;B2B_{2}: 0.010;B3B_{3}: 0.005SSM 5B2B_{2}uniform1/4\nicefrac{{1}}{{4}}B2B_{2}: 0.010SSM 7B0B_{0}uniform1/4\nicefrac{{1}}{{4}}B2B_{2}: 0.0075;B3B_{3}: 0.005SSM 9, 11, 13B0B_{0}uniform1/4\nicefrac{{1}}{{4}}B2B_{2}: 0.010

4.5Evidence

Figure 3:Every scored contribution at its server timestamp on a logbpbaxis, with parent edges as faint lines; colour follows the score from magenta (at or above random) to green (below 1.96), and orange rings mark the leaders after May 2. The first day’s statistical priors deliver almost the whole reduction; donor ensembling and a better SVD sketch reach 1.904 by May 1; the first sub-1.90 scores follow the May 2 deployment of the landscape views. The rendering runs through May 9; all numbers in this report use the first 1,703 contributions, ending May 8.#### Trajectory.

Figure3and Table4show how the score moved. The first scored attempt copied parameter slices from GPT-2 and Mamba into matching shapes and scored 4.68, worse than random; its author published it as a negative result with an explanation. Thirty minutes later the same account replaced copying with a unigram prior read off GPT-2’s predictions (2.52), and within six hours four accounts had extended the idea to bigram statistics under 3, 6, 12, and 24 prefixes (1.93). Those 18 scored contributions account for about 98% of the total reduction. The remaining 1,106 found the next 0.03 by adding Cerebras-GPT donors, widening to 28 contexts, adding a power iteration to the SVD, and, after May 2, leaving the bigram basin to re-enable attention, feed-forward, and SSM sublayers.

Table 4:Milestones on the ancestry of the best contribution at cutoff. Times are UTC. Each row was selected on the same development evaluator, so adjacent rows are stages of a search, not a controlled ablation.WhenAccountbpbChange introduced——3.3923Random initializationApr 27 00:24worker14.6784Slice-copy GPT-2 and Mamba weights (worse than random)Apr 27 00:57worker12.5151Unigram prior from GPT-2 predictions; residual sublayers zeroedApr 27 01:50worker12.1284Bigram transition matrix, randomized SVD into embedding and headApr 27 06:55worker21.931924 prefixes, geometric-mean aggregationApr 27 13:30worker21.9304Per-prefix log-softmax before averaging (18th scored)Apr 28 04:31slurm_worker_41.9228Second donor (Cerebras-GPT 111M), variance and naturalness weightsApr 29 11:04slurm_worker_21.9136Six donors, 28 single-token contextsMay 1 05:10worker21.9062One power iteration in the randomized SVDMay 1 10:28slurm_worker_31.9043Layer-0 attention as uniform causal mean-poolMay 3 00:13slurm_worker_31.9028First SSM edit: layer-1 band mean-pool, chosen after a landscape readMay 5 17:34slurm_worker_61.8995Layer-0 feed-forward projection from GPT-2 smallMay 8 13:24slurm_worker_11.8990Cross-band SSM output-projection writes on layers 1, 3, 7

Negative results.

The graph also records what did not work, and later workers cited these records when choosing directions. Doubling the prefix set to 48 made the recipe worse, documented with four controlled variants. Flattening the singular-value spectrum, transplanting native Mamba blocks from hybrid donors, copying GPT-2’s embedding matrix directly, and building the prior from a donor with another tokenizer (Pythia) all regressed and were published with their scores. The window contains 53 contributions explicitly tagged as negative results.

Lineage and reproduction.

The best contribution at cutoff has 145 commits in its ancestry, written by 15 of the 17 accounts; 115 of the 144 parent edges cross account boundaries, so no single worker assembled the recipe. Participants posted 165 verification contributions covering 95 distinct targets. Each names its target, each verifier differs from the author, and none reports a failure. Same-hardware reproductions are bit-identical; cross-hardware ones (A100 versus H100) differ by up to1.3×10−31.3\times 10^{-3}bpb, within the tolerance the brief set for a confirmed verdict. Forty of the winner’s 144 scored ancestors were independently reproduced.

Primary result.

Without training data or a single gradient update on the target, the community’s besttransfer()initializes the frozen 119.6M hybrid to 1.899044bpb, against 3.3923 for random initialization and about 1.0 for a trained GPT-2 124M, closing 62% of that gap. Because every component was selected on the same 200-text development evaluator, the number to trust is the improvement from 3.39 to about 1.90 rather than the final decimal places; the last recorded change moved the score by9×10−69\times 10^{-6}, below cross-hardware variation. Donor behavior, compressed into a low-rank transition operator, transfers across architectures where donor parameters do not, and every step of the search that found this is a reproducible commit in a shared graph.

4.6Coordination dynamics

The shared memory is inspectable in full. At cutoff the graph has 1,703 nodes, 1,894 edges, 149 multi-parent nodes, and one component holding 98.9% of all nodes. Figure4shows its shape: a narrow spine of successive leaders surrounded by short abandoned branches. Four things stand out in the trace, and each is a reason for a controlled evaluation:

Figure 4:Force-directed layout of the full project graph, including the 123 contributions posted after our cutoff. The highlighted spine is the ancestry of the eventual leader. All numbers in this report use the first 1,703 nodes.1. 1.Fast exploitation.The first eight improvements account for roughly70%70\%of the total descent, and the first 18 scored contributions for about98%98\%. 2. 2.Narrow spine.One lineage collects most of the follow-on work; side branches are short and quickly abandoned. 3. 3.Parallel rediscovery.Of 696 pairs of different accounts posting identical scores,63%63\%are within an hour of each other and80%80\%within six (Figure5). 4. 4.Community-level diagnosis.Several families of contributions pile up near 1.90bpb, and agents converge on a shared explanation: the evaluator is globally linear and the target’s sublayers are underused. Agents’ interpretive claims of this kind, such as the claim that the bigram recipe is a hard local optimum, are reported here as theirs.

Figure 5:Parallel discovery and frontier convergence in the run. Left: time gaps between the 696 equal-score pairs from different accounts. Right: how quickly new contributions adopted a recent frontier parent.This is what the mechanism is supposed to produce: a frontier that moves quickly, later workers building on visible leaders, and cross-branch insight into a common ceiling. It is also a picture of its weaknesses. A shared leaderboard did not stop duplicate work, and the graph is heavily exploitation-biased.

4.7Human intervention

Humans acted at two points. Before the run we defined the task, assembled the donor zoo and the target architecture, wrote the evaluator and the project brief, created the project, and launched the workers. During the run we made one change. On May 2, when the analysis views showed that more than a third of all activity sat in a single semantic cluster and the leaderboard had stalled, we deployed the clustering, diversity summary, and diversity-aware UCB of Section3.3. Workers adopted the new views immediately, and the first sub-1.90 result was published the next morning by a worker that chose to follow the thin state-space cluster rather than extend the dominant one. We did not assign tasks, review or approve contributions, or steer individual sessions.

4.8How we verified the record

We treated the agents’ descriptions as claims to check against the artifacts they point to, not as evidence in themselves. The check ran at three levels. At the level of the trace, we exported the complete contribution stream and graph from the server and recomputed every count, statistic, and figure in this report from that export; no number here is taken from an agent’s summary or from the leaderboard display. At the level of the result, we checked the reported best score algebraically against its reported loss, token count, and byte count, and confirmed that other accounts had reproduced it and its ancestors on independent hardware within the tolerance the brief defines. At the level of the method, we followed the winning commit’s chain of imports from the final edit back to the base module, read the code at each step, and confirmed that no step touches the evaluation data or updates a parameter by gradient descent; Algorithm1and Table3were written from that reading, not from the agents’ prose. We did not rerun the winning method; the primary result is the archived evaluator output, corroborated by the agents’ cross-hardware reproductions.

5Conclusion

Scaling autonomous researchers without scaling their institution turns compute into duplicated search.Agoraoffers a simple alternative: make every contribution durable, addressable, and linked to what it builds on; let reproduction and downstream use, not votes, set quality; and show every participant the neglected branches alongside the leading ones. Git-backed provenance, a derived index, and diversity-aware attention are enough to build this.

In its first sustained use, thirteen agents on a shared graph found a no-training initialization that closes 62% of the gap to a trained model, reproduced one another 165 times, and produced a shared diagnosis of their own ceiling. For five days they also refined one recipe by10−510^{-5}bpbper step, each reading the same leaderboard, and left that basin within a day of being shown a map of it. We take from this that the coordination layer, not the individual agent, was the binding constraint. What the run does not settle is causal: we did not run the same models and compute withoutAgoraor with a plain leaderboard, and the community left its first basin only after we showed it a map. The next step is measurement: the matched comparison in AppendixC, which tells us when a research DAG improves discovery and when it merely files the same parallel waste more neatly.

References

• Anthropic (2026a)AnthropicClaude code.Note:https://claude.com/product/claude-codeAccessed: 2026-08-18External Links:LinkCited by:§4.2.
• Anthropic (2026b)AnthropicSystem card: claude opus 4.7.Note:https://www.anthropic.com/claude-opus-4-7-system-cardCited by:§4.2.
• Aueret al.(2002)P. Auer, N. Cesa-Bianchi, and P. FischerFinite-time analysis of the multiarmed bandit problem.Machine Learning47(2–3),pp. 235–256.External Links:DocumentCited by:§2,§3.3.
• Baeket al.(2025)J. Baek, S. K. Jauhar, S. Cucerzan, and S. J. HwangResearchAgent: iterative research idea generation over scientific literature with large language models.InProceedings of the 2025 Conference of the Nations of the Americas Chapter of the Association for Computational Linguistics: Human Language Technologies,pp. 6709–6738.External Links:Document,LinkCited by:§2.
• Baiet al.(2023)J. Bai, S. Bai, Y. Chu, Z. Cui, K. Dang, X. Deng, Y. Fan, W. Ge, Y. Han, F. Huang,et al.Qwen technical report.External Links:2309.16609,LinkCited by:§4.1.
• Bidermanet al.(2023)S. Biderman, H. Schoelkopf, Q. Anthony, H. Bradley, K. O’Brien, E. Hallahan, M. A. Khan, S. Purohit, U. S. Prashanth, E. Raff,et al.Pythia: a suite for analyzing large language models across training and scaling.InInternational Conference on Machine Learning,External Links:2304.01373Cited by:§4.1.
• Boikoet al.(2023)D. A. Boiko, R. MacKnight, B. Kline, and G. GomesAutonomous chemical research with large language models.Nature624,pp. 570–578.External Links:DocumentCited by:§2.
• Branet al.(2024)A. M. Bran, S. Cox, O. Schilter, C. Baldassari, A. D. White, and P. SchwallerAugmenting large language models with chemistry tools.Nature Machine Intelligence6,pp. 525–535.External Links:DocumentCited by:§2.
• Brinckmanet al.(2019)A. Brinckman, K. Chard, N. Gaffney, M. Hategan, M. B. Jones,et al.Computing environments for reproducibility: capturing the “whole tale”.Future Generation Computer Systems94,pp. 854–867.External Links:DocumentCited by:§2.
• Chanet al.(2024)J. S. Chan, N. Chowdhury, O. Jaffe, J. Aung, D. Sherburn,et al.MLE-bench: evaluating machine learning agents on machine learning engineering.External Links:2410.07095,LinkCited by:§2.
• Chenet al.(2023)W. Chen, Y. Su, J. Zuo, C. Yang, C. Yuan,et al.AgentVerse: facilitating multi-agent collaboration and exploring emergent behaviors.External Links:2308.10848,LinkCited by:§2.
• Chenet al.(2024)Z. Chen, S. Chen, Y. Ning, Q. Zhang, B. Wang,et al.ScienceAgentBench: toward rigorous assessment of language agents for data-driven scientific discovery.External Links:2410.05080,LinkCited by:§2.
• Chirigatiet al.(2013)F. Chirigati, D. Shasha, and J. FreireReproZip: using provenance to support computational reproducibility.In5th USENIX Workshop on the Theory and Practice of Provenance,External Links:LinkCited by:§2.
• Deyet al.(2023)N. Dey, G. Gosal, Z. Chen, H. Khachane, W. Marshall, R. Pathria, M. Tom, and J. HestnessCerebras-GPT: open compute-optimal language models trained on the Cerebras wafer-scale cluster.External Links:2304.03208,LinkCited by:§4.4.
• Di Tommasoet al.(2017)P. Di Tommaso, M. Chatzou, E. W. Floden, P. P. Barja, E. Palumbo, and C. NotredameNextflow enables reproducible computational workflows.Nature Biotechnology35,pp. 316–319.External Links:DocumentCited by:§2.
• Duet al.(2023)Y. Du, S. Li, A. Torralba, J. B. Tenenbaum, and I. MordatchImproving factuality and reasoning in language models through multiagent debate.External Links:2305.14325,LinkCited by:§2.
• Evanset al.(2026)J. Evans, B. Bratton, and B. Agüera y ArcasAgentic ai and the next intelligence explosion.External Links:2603.20639,LinkCited by:§1,§2.
• Fortunatoet al.(2018)S. Fortunato, C. T. Bergstrom, K. Börner, J. A. Evans, D. Helbing,et al.Science of science.Science359(6379),pp. eaao0185.External Links:DocumentCited by:§2.
• Fourneyet al.(2024)A. Fourney, G. Bansal, H. Mozannar, C. Tan, E. Salinas,et al.Magentic-One: a generalist multi-agent system for solving complex tasks.External Links:2411.04468,LinkCited by:§2.
• Gemma Team (2024)Gemma TeamGemma: open models based on Gemini research and technology.External Links:2403.08295,LinkCited by:§4.1.
• Gu and Dao (2023)A. Gu and T. DaoMamba: linear-time sequence modeling with selective state spaces.External Links:2312.00752,LinkCited by:§4.1.
• Halchenkoet al.(2021)Y. O. Halchenko, K. Meyer, B. Poldrack, D. S. Solanky, A. S. Wagner,et al.DataLad: distributed system for joint management of code, data, and their relationship.Journal of Open Source Software6(63),pp. 3262.External Links:Document,LinkCited by:§2.
• Halkoet al.(2011)N. Halko, P. Martinsson, and J. A. TroppFinding structure with randomness: probabilistic algorithms for constructing approximate matrix decompositions.SIAM Review53(2),pp. 217–288.External Links:DocumentCited by:§4.4.
• Hayes-Roth (1985)B. Hayes-RothA blackboard architecture for control.Artificial Intelligence26(3),pp. 251–321.External Links:DocumentCited by:§2.
• Honget al.(2023)S. Hong, M. Zhuge, J. Chen, X. Zheng, Y. Cheng, C. Zhang, J. Wang, Z. Wang, S. K. S. Yau, Z. Lin, L. Zhou, C. Ran, L. Xiao, C. Wu, and J. SchmidhuberMetaGPT: meta programming for a multi-agent collaborative framework.External Links:2308.00352,LinkCited by:§1,§2.
• Huanget al.(2023)Q. Huang, J. Vora, P. Liang, and J. LeskovecMLAgentBench: evaluating language agents on machine learning experimentation.External Links:2310.03302,LinkCited by:§2.
• Jianget al.(2023)A. Q. Jiang, A. Sablayrolles, A. Mensch, C. Bamford, D. S. Chaplot, D. de las Casas, F. Bressand, G. Lengyel, G. Lample, L. Saulnier,et al.Mistral 7B.External Links:2310.06825,LinkCited by:§4.1.
• Karpathy (2026)A. KarpathyAutoresearch: AI agents running research on single-GPU nanochat training automatically.Note:https://github.com/karpathy/autoresearchReleased March 2026. Accessed: 2026-09-03Cited by:§2.
• Kocsis and Szepesvári (2006)L. Kocsis and C. SzepesváriBandit based monte-carlo planning.InMachine Learning: ECML 2006,Lecture Notes in Computer Science, Vol.4212,pp. 282–293.External Links:DocumentCited by:§2,§3.3.
• Lehman and Stanley (2011)J. Lehman and K. O. StanleyAbandoning objectives: evolution through the search for novelty alone.Evolutionary Computation19(2),pp. 189–223.External Links:DocumentCited by:§2.
• Liet al.(2023)G. Li, H. A. A. K. Hammoud, H. Itani, D. Khizbullin, and B. GhanemCAMEL: communicative agents for “mind” exploration of large scale language model society.External Links:2303.17760,LinkCited by:§1,§2.
• Luet al.(2024)C. Lu, C. Lu, R. T. Lange, J. Foerster, J. Clune, and D. HaThe AI scientist: towards fully automated open-ended scientific discovery.External Links:2408.06292,LinkCited by:§2.
• Merton (1961)R. K. MertonSingletons and multiples in scientific discovery: a chapter in the sociology of science.Proceedings of the American Philosophical Society105(5),pp. 470–486.Cited by:§1,§2.
• Mölderet al.(2021)F. Mölder, K. P. Jablonski, B. Letcher, M. B. Hall, C. H. Tomkins-Tinch,et al.Sustainable data analysis with Snakemake.F1000Research10,pp. 33.External Links:DocumentCited by:§2.
• Mouret and Clune (2015)J. Mouret and J. CluneIlluminating search spaces by mapping elites.External Links:1504.04909,LinkCited by:§2.
• OpenAI (2026a)OpenAICodex.Note:https://openai.com/codex/Accessed: 2026-08-18External Links:LinkCited by:§4.2.
• OpenAI (2026b)OpenAIGPT-5.5 system card.Note:https://openai.com/index/gpt-5-5-system-card/Cited by:§4.2.
• Parket al.(2023)J. S. Park, J. C. O’Brien, C. J. Cai, M. R. Morris, P. Liang, and M. S. BernsteinGenerative agents: interactive simulacra of human behavior.InProceedings of the 36th Annual ACM Symposium on User Interface Software and Technology,External Links:Document,LinkCited by:§2.
• Paszkeet al.(2019)A. Paszke, S. Gross, F. Massa, A. Lerer, J. Bradbury, G. Chanan, T. Killeen, Z. Lin, N. Gimelshein, L. Antiga,et al.PyTorch: an imperative style, high-performance deep learning library.InAdvances in Neural Information Processing Systems,Vol.32.External Links:1912.01703Cited by:§4.2.
• Penedoet al.(2024)G. Penedo, H. Kydlíček, L. B. Allal, A. Lozhkov, M. Mitchell, C. Raffel, L. von Werra, and T. WolfThe FineWeb datasets: decanting the web for the finest text data at scale.External Links:2406.17557,LinkCited by:§4.1.
• Penget al.(2023)B. Peng, E. Alcaide, Q. Anthony, A. Albalak, S. Arcadinho, S. Biderman, H. Cao, X. Cheng, M. Chung, M. Grella,et al.RWKV: reinventing RNNs for the transformer era.InFindings of the Association for Computational Linguistics: EMNLP 2023,External Links:DocumentCited by:§4.1.
• Polanyi (1962)M. PolanyiThe republic of science: its political and economic theory.Minerva1(1),pp. 54–73.External Links:DocumentCited by:§2.
• Pughet al.(2016)J. K. Pugh, L. B. Soros, and K. O. StanleyQuality diversity: a new frontier for evolutionary computation.Frontiers in Robotics and AI3,pp. 40.External Links:DocumentCited by:§2.
• Qianet al.(2024)C. Qian, W. Liu, H. Liu, N. Chen, Y. Dang,et al.ChatDev: communicative agents for software development.InProceedings of the 62nd Annual Meeting of the Association for Computational Linguistics,pp. 15174–15186.External Links:Document,LinkCited by:§2.
• Radfordet al.(2019)A. Radford, J. Wu, R. Child, D. Luan, D. Amodei, and I. SutskeverLanguage models are unsupervised multitask learners.Technical reportOpenAI.External Links:LinkCited by:§4.1,§4.4.
• Schmidgallet al.(2025)S. Schmidgall, Y. Su, Z. Wang, X. Sun, J. Wu, X. Yu, J. Liu, M. Moor, Z. Liu, and E. BarsoumAgent laboratory: using LLM agents as research assistants.External Links:2501.04227,LinkCited by:§2.
• Soiland-Reyeset al.(2022)S. Soiland-Reyes, P. Sefton, M. Crosas, L. J. Castro, F. Coppens,et al.Packaging research artefacts with RO-Crate.Data Science5(2),pp. 97–138.External Links:DocumentCited by:§2.
• Touvronet al.(2023)H. Touvron, T. Lavril, G. Izacard, X. Martinet, M. Lachaux, T. Lacroix, B. Rozière, N. Goyal, E. Hambro, F. Azhar,et al.LLaMA: open and efficient foundation language models.External Links:2302.13971,LinkCited by:§4.1.
• Vaswaniet al.(2017)A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, Ł. Kaiser, and I. PolosukhinAttention is all you need.InAdvances in Neural Information Processing Systems,Vol.30.External Links:1706.03762Cited by:§4.1.
• Wanget al.(2019)R. Wang, J. Lehman, J. Clune, and K. O. StanleyPaired open-ended trailblazer (POET): endlessly generating increasingly complex and diverse learning environments and their solutions.InProceedings of the Genetic and Evolutionary Computation Conference,pp. 175–183.External Links:Document,LinkCited by:§2.
• Wolfet al.(2020)T. Wolf, L. Debut, V. Sanh, J. Chaumond, C. Delangue, A. Moi, P. Cistac, T. Rault, R. Louf, M. Funtowicz,et al.Transformers: state-of-the-art natural language processing.InProceedings of the 2020 Conference on Empirical Methods in Natural Language Processing: System Demonstrations,pp. 38–45.External Links:DocumentCited by:§4.2.
• Woolleyet al.(2010)A. W. Woolley, C. F. Chabris, A. Pentland, N. Hashmi, and T. W. MaloneEvidence for a collective intelligence factor in the performance of human groups.Science330(6004),pp. 686–688.External Links:DocumentCited by:§1,§2.
• Wuet al.(2023)Q. Wu, G. Bansal, J. Zhang, Y. Wu, B. Li, E. Zhu, L. Jiang, X. Zhang, S. Zhang, J. Liu, A. H. Awadallah, R. W. White, D. Burger, and C. WangAutoGen: enabling next-gen LLM applications via multi-agent conversation.External Links:2308.08155,LinkCited by:§1,§2.
• Zahariaet al.(2018)M. Zaharia, A. Chen, A. Davidson, A. Ghodsi, S. A. Hong,et al.Accelerating the machine learning lifecycle with MLflow.IEEE Data Engineering Bulletin41(4),pp. 39–45.External Links:LinkCited by:§2.

Appendix AReproducibility Requirements

A retained community run should include the following immutable identities:

• •project instructions, contribution schema, reserved-tag semantics, scoring policy, and analysis policy;
• •server, CLI, UI, evaluator, agent harness, and dependency revisions, including dirty-worktree state;
• •model, tokenizer, dataset, donor zoo, target architecture, container, driver, and hardware identities;
• •participant identities or stable pseudonyms, prompts, tool policies, sampling configurations, seeds, concurrency, and compute budgets;
• •the full contribution DAG with canonical hashes, parents, tags, structured values, timestamps, verification lineage, and artifacts;
• •event-level evaluator outputs, failures, timeouts, retries, queue delays, and resource utilization; and
• •frozen aggregation code that regenerates every table, figure, and claim in the report.

Appendix BMinimal Contribution Record

The following conceptual record captures the information shared by light and heavy publication paths. The server produces the canonical commit hash and timestamp.

{

“project”:“weight-transfer”,

“agent_id”:“worker-7”,

“parent_hashes”:[“<canonical-parent>”],

“tags”:[“result”,“multi-donor”],

“description”:“Six-donorblendwithjointtemperatureretune”,

“value”:{

“metric_value”:1.905,

“run_manifest”:“<durable-artifact-uri>”,

“prediction”:“<pre-registered-range>”

}

}

For a verification, the record should additionally identify the target hash, the reproduction configuration, the evaluator identity, and the reproduced value. A verdict without these artifacts is a coordination hint rather than strong validation evidence.

Appendix CProposed Matched Evaluation Matrix

Table 5:Minimum community-level comparison. Every row uses matched agents, models, compute, evaluator, and wall-clock budget.ArmShared informationWork allocationIsolatedProject brief onlyIndependent local choiceFlat logChronological contributionsParticipant reads the logCentral plannerFull state visible to plannerPlanner assigns next workAgoraContribution DAG and analysis viewsParticipant chooses among explicit exploit/explore slotsThe primary analysis unit is the entire community run. Commit-level observations are useful diagnostics but are not independent samples.