Paper deep dive

Agon: An Autonomous Large-Scale Omnidisciplinary Research System Built on Prompt Economy

Youran Sun, Xingyu Ren, Chugang Yi, Jiaxuan Guo, Kejia Zhang, Jianda Du, Haizhao Yang

Year: 2026Venue: arXiv preprintArea: cs.SEType: PreprintEmbeddings: 137

Intelligence

Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 94%

Last extracted: 7/9/2026, 7:31:17 AM

Summary

The paper introduces Agon, an autonomous, large-scale research orchestrator built on six design principles: Prompt Economy, Future-Facing, Minimal Prompts, OmniDisciplinary, Massive Parallelism, and Zero-Code. Agon automates research workflows through modular factories (idea, proposal, experiment, paper) that operate on reusable loops and prompt-based dispatching, eliminating human-written code. The system emphasizes scalability and cross-domain transfer while introducing a failure taxonomy to distinguish machine-fixable issues from those requiring human judgment, advancing a 'machine scales, human steers' paradigm.

Entities (7)

Agon · system · 98%University of Maryland, College Park · institution · 98%Youran Sun · author · 98%Prompt Economy · design-principle · 95%Zero-Code Orchestration · design-principle · 95%Idea Factory · module · 92%Failure taxonomy · framework · 90%

Relation Signals (6)

Youran Sun → affiliatedwith → University of Maryland, College Park

confidence 98% · 1 University of Maryland, College Park, College Park, MD, USA

Youran Sun → authored → Agon

confidence 98% · Youran Sun 1,*,† ... We present Agon

Agon → builton → Prompt Economy

confidence 95% · Agon is built on six design principles: Prompt Economy, Future-Facing, Minimal Prompts, OmniDisciplinary, Massive Parallelism, and Zero-Code.

Agon → builton → Zero-Code Orchestration

confidence 95% · Agon is built on six design principles: ... Zero-Code.

Agon → contains → Idea Factory

confidence 92% · Idea, proposal, experiment, and paper factories differ in the artifacts they produce... each factory advances a research artifact through role-specific agent loops

Agon → defines → Failure taxonomy

confidence 90% · We organize these failures into a taxonomy along severity, fixability, visibility, and capability locus.

Cypher Suggestions (0)

No Cypher suggestions yet.

Abstract

Abstract:Large language models are making research production scalable, shifting the bottleneck from producing artifacts to judging claims. We present \textsc{Agon}, a research orchestrator that validates what can be checked inside the workflow and leaves the remaining judgments to human scientists. \textsc{Agon} is built on six design principles: Prompt Economy, Future-Facing, Minimal Prompts, OmniDisciplinary, Massive Parallelism, and Zero-Code. We ran \textsc{Agon} across domains for 444 iterations of Prompt Economy loops, using only small starting topics and no human-written experimental code. These deployments demonstrate scalability while exposing new classes of failure. We organize these failures into a taxonomy along severity, fixability, visibility, and capability locus. The taxonomy separates failures the loops can see and fix from those that require human judgment. Together, these results show that \textsc{Agon} is pushing research toward a new paradigm: machine scales, human steers.

PDF

Open source PDF →Open local PDF →

Trouble viewing inline? Open PDF directly →

Full Text

136,244 characters extracted from source content.

Expand or collapse full text

Agon: An Autonomous Large-Scale Omnidisciplinary Research System Built on Prompt Economy Youran Sun 1,*,† , Xingyu Ren 2,* , Chugang Yi 1,* , Jiaxuan Guo 3 , Kejia Zhang 1 , Jianda Du 1 Haizhao Yang 1,† 1 University of Maryland, College Park, College Park, MD, USA 2 The Chinese University of Hong Kong, Hong Kong, China 3 Stanford University, Stanford, CA, USA June 2026 Abstract Large language models are making research production scalable, shifting the bottleneck from producing artifacts to judging claims. We presentAgon, a research orchestrator that validates what can be checked inside the workflow and leaves the remaining judgments to human scientists. Agonis built on six design principles: Prompt Economy, Future-Facing, Minimal Prompts, OmniDisciplinary, Massive Parallelism, and Zero-Code. We ranAgonacross domains for 444 iterations of Prompt Economy loops, using only small starting topics and no human-written experimental code. These deployments demonstrate scalability while exposing new classes of failure. We organize these failures into a taxonomy along severity, fixability, visibility, and capability locus. The taxonomy separates failures the loops can see and fix from those that require human judgment. Together, these results show thatAgonis pushing research toward a new paradigm: machine scales, human steers. ∗ Equal contribution. † Corresponding authors: Youran Sun (syouran0508@gmail.com) and Haizhao Yang (hzyang@umd.edu). 1 arXiv:2606.24177v1 [cs.SE] 23 Jun 2026 Contents 1 Introduction4 2 Design Principles5 2.1 Prompt Economy. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .6 2.2 Future-Facing. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .7 2.3 Minimal Prompts. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .7 2.4 OmniDisciplinary. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .8 2.5 Massive Parallelism. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .8 2.6 Zero-Code Orchestration. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .9 3 System Architecture9 3.1 Code-Artifact Separation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .9 3.2 Deep Literature Research. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .10 3.3 Idea and Proposal Factories. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .10 3.4 Experiment Factory. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .11 3.5 Paper Factory. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .12 3.6 Refinery Skill Injection. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .13 3.7 Topic Radar. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .14 3.8 Multi-Model Collaboration. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .14 3.9 Audit System and Harness. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .14 3.10 Instant-Messaging Interface. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .14 3.11 Frontend Dashboard. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .15 4 Where Human Judgment Is Irreducible15 4.1 A Four-Axis Taxonomy. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .16 4.2 The Visibility–Fixability Matrix. . . . . . . . . . . . . . . . . . . . . . . . . . . . .18 4.3 Perception Failures. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .18 4.4 Reasoning Failures. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .19 4.5 Execution Failures. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .20 4.6 Motivation Failures. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .21 4.7 What the Architecture Can and Cannot Absorb. . . . . . . . . . . . . . . . . . . . .22 4.8 The Boundary Is a Snapshot. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .22 5 Related Work23 5.1 End-to-End Autonomous Research Systems. . . . . . . . . . . . . . . . . . . . . . .23 5.2 Benchmarks and the Case for Adversarial Gates. . . . . . . . . . . . . . . . . . . . .24 5.3 Adversarial Review and Verification. . . . . . . . . . . . . . . . . . . . . . . . . . .24 5.4 Human Role. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .25 6 Outlook25 6.1 The Transition Has Already Begun. . . . . . . . . . . . . . . . . . . . . . . . . . . .25 6.2 What Industrialized Science Means. . . . . . . . . . . . . . . . . . . . . . . . . . . .26 6.3 The Engine of Evolution. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .26 6.4 What We Choose. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .26 6.5 The First Chapter. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .27 2 A Robotics Case Study: VLA Router28 A.1 How the Idea Was Born. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .28 A.2 The Factory Thinks of Something New. . . . . . . . . . . . . . . . . . . . . . . . . .29 A.3 A Machine That Reads. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .30 A.4 The Factory Floor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .31 A.5 How the System Evolved. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .31 A.6 What Human Scientists Contribute. . . . . . . . . . . . . . . . . . . . . . . . . . . .32 B Biology Case Study: Deployment Experience and Open Challenges35 B.1 How the Idea Was Born. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .36 B.2 What Biology Demands That AI Does Not. . . . . . . . . . . . . . . . . . . . . . .36 B.3 Route A, Route B. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .37 B.4 The Experiment. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .37 3 Figure 1:System overview of Agon.The workflow starts from eithertopic-radaror human topic selection, then proceeds through idea, proposal, experiment, and paper factories. Each factory advances a research artifact through role-specific agent loops, while deep-literature research supplies reusable context to multiple stages. 1 Introduction Many children dream of becoming scientists, yet very few ever do. The barrier is rarely intelli- gence; more often, it is access to laboratories, mentors, years of training, tacit knowledge, and infrastructure concentrated in a few institutions and fewer hands. For much of its history, science has operated like a craft guild. For every researcher admitted, many equally curious and capable people were kept out for reasons unrelated to their ability to ask good questions. These barriers are now eroding because three conditions are converging. (i) Computation, data, models, and tools are becoming more accessible. (i) Foundation models can now perform local research tasks such as coding, experiment design, and critique. (i) Multi-agent systems can organize these local abilities into longer research workflows from idea to manuscript. As a result, the question “can I do research?” increasingly depends less on access to a laboratory than on access to a GPU. This is not a forecast; these conditions are already reshaping science along several dimensions. The craft-guild model begins to give way. Research need no longer be confined to those admitted to well-resourced laboratories and trained inside established institutions. Anyone with curiosity and access to computational resources can now take part in producing scientific knowledge. This is more than a marginal gain in eﬀiciency; it is a step toward thedemocratization of discovery. More people can do work they find meaningful, and more questions can be asked. We developedAgon to help make this possibility concrete. At the same time, the economics of intelligence are changing. The supply of machine intelligence is expanding rapidly while its cost continues to fall. Human scientific judgment remains scarce. 4 A single insight from a trained researcher can redirect an entire field, whereas a large volume of routine model outputs cannot. When the production of scientific claims is no longer limited by the number of trained researchers, the binding constraint moves elsewhere. It moves from who can carry out the work to who can ask the right questions. The phrase “machine scales, human steers” captures this asymmetry.Agonis designed around it: machines scale the work, while humans choose questions, judge evidence, and retain direction. The stakes extend beyond science itself: autonomous research is one mechanism through which better AI can produce better research, and better research can produce better AI. Our deployment record over the past three months provides the evidence for these claims. Across projects in more than ten scientific domains,Agonhas carried out thousands of scientist- coder-auditor iterations, with no human writing any experimental code. The same orchestrator transfers across fields without modification, with only the input files changing. This record shows that the shift from artisanal to industrialized science is not only a future possibility but is already under way. We also define a taxonomy for the failure modes exposed by these deployments, and draw a boundary between what automation can catch and what requires human judgment. Although this boundary emerged fromAgon’s deployments, it is not specific to our system. Agonis open-source, built entirely from natural-language prompts, and will be released at AutoResearch-Factory/Agon. We believe the infrastructure for the next era of science should be openly available to everyone. This paper makes the following contributions. 1.We propose six design principles for autonomous research systems: Prompt Economy, Future- Facing, Minimal Prompts, OmniDisciplinary, Massive Parallelism, and Zero-Code. 2.Guided by these principles, we implementAgon, a massively parallel, omnidisciplinary, zero- code, minimal-prompt autonomous-research system. 3.We develop a failure-mode taxonomy for autonomous research, covering severity, fixability, visibility, and capability locus. 4.We provide deployment evidence forAgonfrom practical robotics and computational biology research deployments. These deployments show that the system can operate across domains, while also exposing the current boundary of autonomous research. 2 Design Principles Design principleMeaning Prompt Economy Organize the system around Prompt Economy loops to maximize prompt engineer- ing ROI. Future-FacingMinimize details frozen into prompts so future models improve the system directly. Minimal Prompts Keep the core agent set small and each prompt short. OmniDisciplinary Keep the core agents domain-agnostic so the system transfers across fields. Massive Parallelism Advance many topics, ideas, proposals, and experiments concurrently. Zero-CodePrompt, not Code: orchestrate with prompt dispatchers rather than workflow code. Table 1:Design principles ofAgon. To build an autonomous research system that can operate eﬀiciently in parallel while preserving long-term maintainability and omnidisciplinary transfer,Agonis designed under six principles: Prompt Economy, Future-Facing, Minimal Prompts, OmniDisciplinary, Massive Parallelism, and 5 Zero-Code. These principles guide the system by limiting prompt complexity, separating reusable control logic from domain-specific content, and enabling many research threads to be coordinated without additional code. Table1summarizes these principles before the following subsections discuss them in detail. These principles are mutually reinforcing, with Prompt Economy serving as the foundation. By organizing the system around reusable loops, Prompt Economy reduces the need for task-specific prompting because a bounded set of prompts and handoff protocols can be reused across many invocations. Minimal Prompts follow from this idea but also impose a separate constraint on the final system: both the number of agents and the length of each prompt should remain small. While Prompt Economy and Minimal Prompts reduce immediate engineering cost, Future-Facing addresses long-term maintenance cost by keeping model-specific details out of the prompts, so the system need not be rewritten as models improve. OmniDisciplinary and Massive Parallelism define the intended scope of the system, requiring it to work across domains and scale across many concurrent research threads. This scale creates a dispatch burden that the Zero-Code principle addresses by coordinating threads through a prompt-driven dispatcher rather than additional user- written code. 2.1 Prompt Economy Prompt Economy is the starting point ofAgon’s design. The term follows PerspectiveGap [Sun et al.,2026] and describes a simple constraint: role prompts and handoff rules are expensive to write and maintain. Letmdenote the number of maintained role prompts,ndenote the number of maintained handoff protocols, andv i denote the number of useful invocations of rolei. The return on investment (ROI) in prompt engineering can be summarized as ROI = U reuse C prompt = ∑ m i=1 v i m+αn , whereαcaptures the maintenance cost of handoff boundaries. Prompt Economy favors designs with a highROI. A loop is the natural way to raise this ratio: it reuses one role across many invocations, increasing ∑ m i=1 v i without enlarging the maintained prompt surfacem+αn. The implication is that a prompt should not be designed for a single task instance. It should be designed as a reusable role inside a loop that can be invoked many times. Under Prompt Economy, the central design question is therefore not “what prompt solves this task?” but “what reusable loop makes this stage reliable?” Each loop is organized around an artifact whose quality determines the success of the stage. The system then pairs a role that produces the artifact with an independent critic that checks it against an explicit standard. This producer–critic pairing is what makes each loopadversarial. The critic works in a fresh context and, where possible, on a different model, so the artifact advances only after it has survived an attempt to break it. Additional roles, handoff rules, and file permissions are added only when they help preserve this artifact boundary or make the loop reusable across invocations. Agonapplies this loop-first rule throughout the research workflow. We call a set of agents and handoff rules organized around one such loop afactory. Idea, proposal, experiment, and paper factories differ in the artifacts they produce and the standards used to evaluate them, but they follow the same design pattern: identify the failure-prone artifact, define a producer–critic loop around it, and reuse that loop across many research threads. In this way, Prompt Economy keeps the maintained prompt surface small while increasing the number of useful invocations supported by each role. 6 2.2 Future-Facing Future-Facing addresses the long-term maintenance cost of prompt orchestration. It extends the cost logic of Prompt Economy by shifting attention from the immediate cost of creating reusable prompts to the future cost of keeping those prompts stable as models improve, tasks shift, and corner cases accumulate.Agonis therefore designed not only for the current model, but also for the stronger models that will replace it. The central rule is to avoid encoding limitations of the current model generation into the prompt surface or dispatch logic. Current LLMs may show limited persistence, sensitivity to wording, weak long-horizon reliability, or inconsistent adherence to constraints, yet these limitations are properties of the present model generation rather than permanent facts about the research task. A system shaped too closely around them risks carrying obsolete assumptions into future models. Future-Facing therefore keeps prompts focused on stable structure: roles, artifacts, constraints, handoff conditions, and evaluation standards. When a failure appears, the system should not grow by adding a narrow instruction for that single failure mode. Instead, the failure should be used to refine a more general prompt, standard, or loop structure that covers a wider class of cases. This keeps the maintained prompt surface small while making the system less tied to any particular model. This design allows model improvements to translate directly into system-level gains. As base models improve, the same role prompts, reusable loops, and handoff protocols can support stronger execution without requiring the research factory to be rebuilt around each new model generation. 2.3 Minimal Prompts Minimal Prompts keeps the maintained prompt surface of the system compact. InAgon, this means limiting both the number of core roles and the length of each role prompt. It follows from Prompt Economy because reusable loops only remain economical if the role set and handoff prompts do not grow with every task instance. The principle has two targets. The first is the size of the core agent set. New roles are not added for every task, stage, or local diﬀiculty; they are added only when a reusable loop requires a distinct responsibility or artifact boundary. The second is prompt length. Each role prompt should stay short rather than accumulate special-case instructions, so the system does not become a large body of hard-to-inspect natural-language code. Minimal Prompts connects the previous two principles. Prompt Economy explains why a com- pact set of reusable roles is valuable: each role should support many invocations. Future-Facing explains why prompts should avoid model-specific detail: long prompts filled with current-model patches become maintenance liabilities. Minimal Prompts turns both ideas into a concrete design constraint: few core agents and short core prompts. Table 2compares the resulting prompt surface ofAgonwith recent autonomous-research systems. The value of a compact prompt surface lies in its effect on maintainability and transfer. By keeping the role set and prompt text small,Agonmakes the system easier to inspect and reduces the risk that roles, file ownership, and handoff rules drift out of alignment. Additional roles or prompt text must therefore be justified by their contribution to a reusable loop rather than by a single local case. This keeps the core agents general enough to transfer across fields and simple enough to remain stable as models improve. 7 SystemRolesPrompt KiB AI Scientist v2 [Yamada et al.,2025]∼110302.4 ARIS [Yang et al.,2026]791157.4 AutoResearchClaw [Liu et al.,2026]781297.5 Agon18230.6 Table 2:Prompt-surface comparison for recent autonomous-research systems. Role and size counts use the prompt corpus when it is explicit. The AI Scientist v2 role count is approximate because its prompts are dynamically composed from Python. For systems with prompts embedded in code, Prompt KiB is measured over prompt-bearing source files. 2.4 OmniDisciplinary OmniDisciplinary keeps the core factory domain-agnostic.Agonis intended to transfer across scientific fields without requiring a new core architecture whenever the subject changes. It extends the reuse logic of Prompt Economy: reusable loops should not only support many invocations, but also remain applicable when the scientific field changes. InAgon, disciplinary knowledge is kept outside the core agents. Field-specific information enters through the literature, task context, and refinery skills (see Section3.6) rather than being built into the role prompts themselves. The core agents define general research responsibilities, artifact boundaries, handoff conditions, and evaluation standards. They operate on domain-specific context at runtime, but their underlying roles remain unchanged. This separation keeps the core factory reusable without increasing the maintained prompt sur- face. WhenAgonmoves to a new field, the external context and injected skills change, while the core loops and handoff protocols remain stable. OmniDisciplinary therefore supports transfer without requiring new core agents, longer prompts, or domain-specific orchestration logic for each field. 2.5 Massive Parallelism Massive Parallelism exploits the reusable loops created by Prompt Economy.Agonis not designed as a single-project agent that moves one research task from beginning to end in isolation. It is designed as a research factory that can advance many research threads concurrently when compute and model-call resources are available. Because the system is organized around reusable loops, parallelism does not require a separate workflow for each topic or project. The same role prompts, producer–critic loops, and handoff protocols can be instantiated across many candidate artifacts. Massive Parallelism therefore in- creases throughput by running many instances of the same bounded factory structure rather than expanding the maintained prompt surface. InAgon, this means that idea, proposal, experiment, and paper factories can run asyn- chronously, and each factory can maintain multiple candidate artifacts at the same time. The relevant evaluation question is therefore not only whether one research thread can complete suc- cessfully, but whether many threads can continue making progress under the same core architecture. Massive Parallelism also creates the main orchestration problem for the system. Once many loops are active at once, the system must decide which thread should advance, which artifact needs critique, which result should be handed off, and which branch should stop. The next subsection explains how Zero-Code Orchestration addresses this dispatch burden without turning the factory into a large body of workflow-specific control code. 8 2.6 Zero-Code Orchestration Zero-Code Orchestration addresses the dispatch burden created by Massive Parallelism. The rule is Prompt, not Code. If that dispatch is implemented mainly through code and finite-state machines, the system can quickly accumulate brittle parsers, state schemas, and exception-handling branches. The diﬀiculty is that LLM-generated state is not always expressed in exact symbolic form. Small variations in labels, fields, or wording can break a deterministic scheduler, or force the scheduler to grow a long tail of parser patches. This creates the same maintenance problem that the earlier principles are designed to avoid: the orchestration layer becomes a large, model-sensitive code surface. Agontherefore uses prompt dispatchers for system-level orchestration. Zero-Code Orchestra- tion does not mean that the system has no implementation code. It means that research dispatch is written as prompts rather than workflow-specific control code. The dispatcher reads the current research context, interprets the state of active artifacts, and selects the next appropriate handoff using the same natural-language interface used by the agents themselves. This design supports both maintainability and generality. It is easier to revise the orchestration policy because dispatch rules live primarily in prompts rather than in parsers and finite-state transitions. It is also easier to transfer the system across fields because the dispatcher is not hard- coded for a particular domain workflow. In the current implementation, this design has supported one month of continuous dispatcher operation without human intervention. Together, the six principles define howAgonorganizes automated research work, but they deliberately stop at the boundary of scientific judgment. The system can make many research threads cheaper to run, maintain, and contest, but it does not decide which results matter.Agonis designed to amplify a scientist’s supervision rather than replace it: the human defines the standards the critics enforce, resolves questions the loops cannot settle, and remains the final adversary who can block any artifact from advancing. 3 System Architecture Agonimplements the design principles in Section2through a factory-style architecture that sepa- rates the reusable research framework from the project-specific artifact repository. The framework contains the stable prompts, roles, dispatcher rules, and tool interfaces; the artifact repository records the evolving scientific state. A project starts from atopic, moves throughideaandproposal artifacts, enters an experimentworkspace, and finally becomes a paper draft. Across this process, the literaturewikiandlandscapeprovide shared memory that later factories can reuse. Each major stage is organized as a versioned artifact loop, so role design, handoff rules, review, audit, and literature feedback all attach to the artifact being improved. Refinery skills, the topic radar, the instant-messaging interface, and the frontend dashboard are supporting components around this core factory. Together, these components form an autonomous-research architecture that can be transferred across fields, run numerous research threads in parallel, and remain auditable through artifacts. 3.1 Code-Artifact Separation Agonseparates the reusable research framework from project-specific research artifacts. The framework contains reusable prompts, agents, dispatcher rules, and tool interfaces. The artifact repository containstopic, literaturewiki,landscape,ideas,proposals, experimentworkspaces, and paper drafts. 9 The artifact repository is organized around the lifetime of a research project. A project starts from atopicand is then advanced by the idea, proposal, experiment, and paper factories. A topiccan be lightweight, often only 1–3 paragraphs plus 1–5 seed papers. The deep-literature loop maintains the literature wiki , while the factories add landscape , ideas , proposals , experiment workspaces, and paper drafts as the project matures. This separation is required by multidisciplinary and massively parallel autonomous research. Many topics, ideas, proposals, and experimentworkspacescan be active at the same time. The shared framework can serve all of them, while each project keeps its own artifact history, decisions, failures, and intermediate products. Inter-agent handoff is therefore mediated by artifacts, which makes the research process recoverable, auditable, and reusable across projects. 3.2 Deep Literature Research Deep literature research addresses the novelty risk that arises when a research area is highly satu- rated. When doing literature review, if a system misses a critical prior paper, a proposed new idea might already been occupied by this literature. We call this the101st-paper trap: after reading the first 100 papers in a field, the next idea that a human researcher or an agent naturally proposes may already have been developed in the 101st paper.Agonintroduces deep literature research as its core mechanism for avoiding novelty collisions and closed-door research, and this becomes the first Prompt-Economy loop in the system. The loop follows the sequence search, select, read, write wiki, expand, and repeat. It con- tains two roles:deep-literature-dispatchergenerates search queries, merges and filters can- didate papers, selects papers for full-text reading, launches reader agents, checks that wiki en- tries and expansion searches have been completed, and integrates the findings according to scope. deep-literature-readeris then assigned one selected paper at a time, which reads the full text, writes the per-paper literature wiki entry, and returns key findings, collision risks, and search terms for the next round. The most stable artifact of this loop is the literaturewiki. Each selected paper is converted into a reusable wiki entry, and the wiki pool is shared across topic, idea, and experiment scopes. This shared wiki prevents repeated reading of the same paper and gives later agents a concrete literature memory instead of relying on transient context or abstract search results. Other artifacts depend on the scope in which the loop is invoked. In topic scope, new findings are integrated into the project-level landscape and relevant idea files. In idea scope, findings are written into the target idea, and the new-paper list is returned to the upper dispatcher for landscape integration. In experiment scope, the loop writes a workspace-level literature ledger and a lit-feed inbox, so the experiment factory can track both general collision risks and papers that directly address the current experimental bottleneck. At the current operating scale, deep literature research reads approximately 400–2000 papers for each topic. 3.3 Idea and Proposal Factories We discuss the idea and proposal factories together because they share the same simple Prompt- Economy structure. Both factories improve versioned artifacts through the same cycle: create or refine a draft, review it, incorporate deep-literature feedback, and produce the next version. The idea factory starts from a human-providedtopic.idea-creatorperforms the initial land- scape survey, writes the project-level landscape, and generates and filters candidate ideas. It then then advances multiple candidate ideas in parallel. For each idea,idea-refinerrevises the ver- 10 sioned idea artifact, andidea-reviewerevaluates novelty and quality and assign a score based on Table3. Each iteration calls topic-scope and per-idea-scope deep literature research, so new papers, collision risks, and literature findings are written back into the landscape and the corresponding idea. For an idea with reviewer scoresand current versionv, refinement stops whenv≥s−2. The idea factory terminates when all active ideas satisfy this condition and the latest deep-literature round no longer changes the novelty or feasibility assessment. Its output is a set of candidate idea artifacts that have been reviewed, refined, and saturated against the current literature. idea-revieweruses a Likelihood–Impact matrix to avoid a common bias in agentic idea se- lection. Agent reviewers tend to prefer low-risk ideas with stable but modest returns, and they can prematurely discard a low-likelihood idea whose success would have high impact. Therefore, idea-reviewerjudges likelihood and impact on separate axes before assigning the final priority and numeric score. Likelihood estimates whether theideacan become a top-venue result after reasonable refinement, proposal writing, and experimentation. Impact estimates the effect of the ideain the most optimistic successful case, without mixing in feasibility. The final score is looked up from Table 3. Likelihood ExceptionalHighMediumLow HighExceptional (9) High (8) Medium (6) Low (4) MediumHigh (8)High (7) Medium (5) Low (3) LowMedium (6) Medium (5) Low (3) Archive (1) Table 3:Likelihood–Impact priority matrix used byidea-reviewer. The proposal factory starts from selected idea artifacts and advance multiple proposals in paral- lel:proposal-refinerwrites the first proposal from anideaor revises the latest proposal according to review feedback.proposal-reviewerevaluates whether theproposalis ready. When thepro- posalneeds another revision, the factory calls idea-scope deep literature research; the new literature findings are written back into the idea artifact, and the nextproposal-refinerreads both the updated idea and the latest proposal. Proposal refinement stops whenproposal-reviewermarks theproposalas ready or theproposalreaches the version limit. Its output is a mature executable proposal that specifies the method, claims, experiment plan, and paper delivery. 3.4 Experiment Factory The experiment factory starts from a mature idea and proposal and consists two loops: internal and external review loops. Its output is an experimentworkspacethat has survived repeated experiment, audit, literature, and review pressure, and is ready for the paper factory. On first entry, the dispatcher creates an experimentworkspaceby copying the upstream topic, landscape, latest idea, and latest proposal, and by initializingSTATE.md,LESSONS.md, andexperiment-log.md. STATE.mdrecords the current experimental state details and paper-level argument.experiment-log.md is the cross-branch historical record and is not stored in git.LESSONS.mdstores transferable lessons and human instructions. The internal loop isexperiment-scientist→experiment-coder→experiment-auditor →experiment-scientistexperiment-scientistmakes scientific judgments, interprets results, responds to audits, and plans the next runs.experiment-coderimplements the plan, deploys jobs on remote servers, monitors runs, debugs failures, synchronizes outputs, and handles server 11 operations.experiment-auditoris the internal adversarial QA role: it audits the plan, code, results, and operations, checks whether reported results are real, and verifies thatSTATE.mdremains readable and handoff-ready. The scientist and auditor are singletons within aworkspace, while coders form a worker pool that can execute independent runs in parallel. The scientist–coder split is necessary because remote experiments and server operations are complex enough to require a separate execution pool. The external review loop begins whenexperiment-scientistdecides that the current ex- perimental state is ready for review. At this point,STATE.mdis cleaned such that it speci- fies the problem, claims, evidence, baselines, ablations, and narrative needed to support a later manuscript.experiment-reviewerevaluates theworkspaceunder the most stringent standards, checking claims, evidence, drift, experimental completeness, and submission readiness. If the reviewer returnsready, the experiment stage ends. If the reviewer returnsalmostornot ready, the factory invokes experiment-scope deep literature research, writes new literature into the workspace-level literature ledger andlit-feed, and returns control to the auditor and scientist side of the internal loop. We use iteration count and version count to represent the number of traversal of the internal loop and external loop respectively. A well designed research project often requires dozens of versions and hundreds of iterations, which shows the multiplier effect of Prompt Economy. The experiment factory is heavier than the idea and proposal factories because it combines scientific judgment, engineering execution, parallel compute scheduling, server operations, internal audit, and external review standards. 3.5 Paper Factory The paper factory starts from an experimentworkspaceand itsSTATE.mdand translates this argu- ment into manuscript source, figures, and a compiled PDF. The whole process contains two stages: paper-writing cold start and paper-improvement. In the paper-writing stage, there are four roles: the writer reads theworkspaceandSTATE.md, builds a writing plan and style profile, writes sections, and issues figure requests; the drawer con- verts these requests into figures; the auditors inspect text and figures for claim support, citation quality, numerical consistency, figure clarity, and AI-writing artifacts; the reviewer then evaluates the compiled PDF. This stage is designed to produce a compiling draft that can enter further refinement; acceptance-level quality is left to the heavier improvement stage. The paper-improvement stage addresses a failure mode of a naive writer–reviewer loop: if the system were to alternate only between a paper writer and an LLM reviewer, reviewer scores could rise while the draft leaves the space of human scientific writing. In one development run, a draft received high scores from LLM reviewers built on models from several companies, even though its abstract was immediately absurd to human readers. The first sentence was “In eight of the nine experiments that we conducted,” and the second sentence used a stock contrast, “This work is not ...but ....” This example shows that LLM reviewer feedback is useful but miscalibrated: it can reward rubric-shaped writing that satisfies agent reviewers while sounding wrong to human scientists. We therefore model paper improvement as a constrained optimization problem: d ⋆ = arg max d∈H S review (d), wheredis a draft,S review is the reviewer score, andHis the subset of human-readable scientific writing. LLM-reviewer feedback acts like an optimization gradient forS review , but this gradient can point outsideH. This mismatch is a current limitation of LLMs. Unconstrained writer–reviewer 12 iteration can therefore produce a high-scoring but non-human draft, a paper monster that optimizes the reviewer model while violating the writing constraint. Auditors serve as projection steps back intoH. InAgon, three paper auditors examine the draft from different angles and identify where the manuscript no longer reads like human scientific writing. The full paper-improvement loop alternates optimization and projection: the writer revises the manuscript, auditors inspect the revision, the writer fixes every auditor issue, a normal reviewer evaluates the paper, and the writer fixes those reviewer issues. The loop then invokes a killer reviewer and an area-chair adjudicator. The killer reviewer simulates the academic reviewer who has already decided to reject the paper and constructs the strongest rejection argument, includ- ing arguments that may come from a hostile or inattentive reading. The area-chair adjudicator decides whether the current paper actually answers those attacks. The writer then fixes the sur- viving attacks, recompiles the paper, and the loop repeats. The output is a manuscript that has been pushed simultaneously toward higher reviewer scores, human-readable scientific prose, and robustness against hostile review. 3.6 Refinery Skill Injection The rapid growth of autonomous-research and multi-agent research systems creates a large ex- ternal prompt corpus. The current upstream prompt sources are ARIS [Yang et al.,2026] and Sibyl-AutoResearch [Wang et al.,2026a]. Many external systems contain useful research mindsets, disciplinary practices, and visual-design heuristics. However, these prompts cannot be appended toAgondirectly. External prompts often encode their own role assumptions, phase order, output schemas, path conventions, and orchestration logic, which can conflict with the factory and artifact structure ofAgon. The refinery process addresses this problem by distilling external prompts into reusable mindset skills. It imports how an external project thinks and discards how that project is orchestrated: it removes specified project setups like frontmatter, constants, output schemas, path protocols, engi- neering scaffolds, dispatcher logic and preserves content consists of transferable thinking principles, review criteria, operation prohibitions, judgment heuristics, and reusable prompt fragments. StageARIS Sibyl Raw skill prompts100% 100% After removing scaffolding31% 88% After removing source workflows 18% 53% Final refinery skills∼15%52% Table 4:Prompt compression during the ARIS and Sibyl refinery processes. At runtime, refinery skills are injected by progressive disclosure. When an agent starts, it sees the names and descriptions of available refinery skills. The full skill text is loaded only when the agent judges that the skill is relevant to the current task. This keeps external prompt material out of the default context while still making it available for experiment planning, result validation, citation audit, paper writing, kill-argument review, figure design, and other specialized situations. Refinery skills have lower priority than both user instructions and the core agent factory: user> agent factory>refinery skills. Thus, refinery skills function as an external experience layer with bounded authority. The coreAgonprompts keep the factory structure, artifact protocol, role responsibilities, and highest-level principles, while refinery skills hold the long tail of imported 13 expertise. This mechanism letsAgonabsorb future prompt systems without continually expanding the core agent prompts. 3.7 Topic Radar The topic radar is an optional upstream entry point for cases where the user has not yet chosen a concrete research direction. In the default workflow,Agonstarts from a human-authoredtopic, because serious research usually benefits from a question grounded in the scientist’s own expertise and judgment. When such a topic is not yet available, the topic radar can help surface possible directions from external information streams. Thetopic-radarcomponent scans watchlisted X accounts, keywords, and blogs; fetches posts, blog entries, and linked content; removes duplicates; filters noise; and writes structured topic signals. Thetopic-signal-distillerthen merges one or more signals into a topic draft. These drafts are reviewed by the human scientist before they become formal topics and start the idea factory. 3.8 Multi-Model Collaboration Agonsupports per-role model and tool configuration, motivated by research quality and cost con- trol. In practice,refiner,reviewer,experiment-scientist,experiment-coder,experiment-auditor, anddeep-literature-readercan each be assigned a different backend or backend mixture. A single role can also be mapped to a mixture of backends, so repeated invocations of the same role may be distributed across models, such as a 50–50 split between two backends. The current system supports at least Claude Code, Codex, DeepSeek, Kimi, and GLM. For key steps likeidea-creatorand all reviewer roles, we require a second-model check. The corresponding prompts were carefully designed and tested so that the two models assign scores independently and do not influence each other. 3.9 Audit System and Harness Agonincludes an audit system for recording and analyzing the actual execution of each agent. The audit system tracks time, cost, context usage, and tool use for each invocation, and attributes these records to the corresponding research stage and role. This makes it possible to identify roles with unusually high cost, steps slowed by tool waiting, and agents that fail to advance their assigned artifact as expected. These records provide direct evidence for prompt adjustment, model selection, and resource allocation. 3.10 Instant-Messaging Interface Agoncan connect to instant-messaging platforms such as Telegram. Following the same design principles, this interface is designed for minimal interruption. The system keeps long-running factories visible to the user. The dispatcher callsnotify_useronly at low-frequency milestones, such as factory start events and reviewer-round summaries. When an agent repeatedly fails, reaches a blocking limit, encounters unavailable infrastructure, or faces a major scientific decision that cannot be resolved from the artifacts, the dispatcher callsask_user. For visual artifacts,send_file complementsnotify_userby sending figures, videos, or other files. 14 3.11 Frontend Dashboard Agonalso provides a frontend dashboard for monitoring research projects. The dashboard presents the main research artifacts, includingtopic,landscape,idea,proposal, and experimentworkspace. It also surfaces operational information that is otherwise scattered across logs and caches, including harness-assisted cost audit, literature-download counts, and literature-reading counts. The frontend makes the state of the research factory legible to the human scientist. 4 Where Human Judgment Is Irreducible This chapter is a map. The failure modes catalogued below are not bugs to be fixed. They are the current boundary of what autonomous research can achieve with the foundation models available today.Agonreached a level of automation—over a thousand iterations across more than ten domains, zero hand-written experimental code—where the failures that remain are not ordinary implementation errors. They are the point at which human judgment becomes irreducible. Every failure mode in this taxonomy is a marker that says: here, a human scientist is still necessary. The boundary is not static. It is a measurement, taken at a point in time. As machine intelligence improves—as models learn to detect anomalies, persist through failure, and reason causally rather than associatively—the visibility–fixability line will shift. On one side of this boundary, adversarial loops and protocol enforcement can catch and correct errors. On the other side, the error is invisible to every agent in the loop, and the only entity that can cross is a human scientist. This chapter taxonomizes where the boundary lies today, what kinds of failures fall on each side, and what the boundary implies for the future of autonomous research. The taxonomy isAgon’s discovery. Any autonomous research system can use it. Any lab can build on it. The boundary is measured. The community is invited to sharpen it. The human scientist, at the current boundary, must bring real insight: the ability to recognize that a confound is the story rather than a bug, the taste to distinguish a good question from a measurable one, the persistence to check a formula constant against the statistical literature when every computed value looks reasonable. These are not generic supervision skills. They are the specific competencies that foundation models lack today. As the models improve, the boundary will move. Fewer failure modes will be invisible. More will become fixable by the loop. The human role will evolve: from catching everything to steering what remains. The design principles of Section 2and the architecture of Section3were not designed in advance and then implemented cleanly. They were accumulated through failures—failures of perception, of reasoning, of execution, and of motivation—that the system could not anticipate and that no single design iteration could eliminate. We taxonomize those failures along these axes and identify the key pattern that distinguishes the failuresAgoncan absorb from those it cannot: visibility. A failure the system can see is a failure it can eventually address. A failure the system cannot see is a failure that will persist until a human notices it. These failure modes are the current boundary. Every entry in this table is a prediction: as machine intelligence improves, its position will shift. Failures now classified as invisible may become visible. Failures now requiring continuous human monitoring may become fixable by the loop. The table is not a verdict. It is a snapshot. 15 Failure modeSeverityFixVisibilityLocus Anomaly blindnessInvalid evidence; direction collapse Human WatchInvisiblePerception Visual anomaly blindnessInvalid evidenceHuman WatchInvisiblePerception Moving the goalpostsInvalid evidence; direction collapse Loop+Human WatchPartially vis. Perception Plausible false attributionInvalid evidence; direction collapse Human WatchInvisiblePerception Overexcitement and the eureka instinct Invalid evidenceLoop+Human Case-by-Case VisibleReasoning Obedient refinementDirection collapsePromptInvisibleReasoning Reviewer conservatismDirection collapsePromptPartially vis. Reasoning Domain intelligence deficiencyInvalid evidence; direction collapse Human Case-by-CaseInvisibleReasoning Experiment-design deficiencyInvalid evidence; direction collapse Human RuleInvisibleExecution Training-memory inertiaInvalid evidenceHuman RulePartially vis. Execution Resource misallocationWasteHuman RulePartially vis. Execution Checking too lateWastePromptInvisibleExecution Implementation driftInvalid evidence; direction collapse LoopPartially vis. Execution Artifact clutterInvalid evidence; direction collapse Human RulePartially vis. Execution Memory and context degradationInvalid evidence; direction collapse Human Case-by-CaseVisibleExecution Fluent nonsenseInvalid evidence; direction collapse Loop+Human Case-by-Case VisibleExecution Premature abandonmentDirection collapseLoopVisibleMotivation Learned helplessnessWaste; direction collapse Human Case-by-CaseVisibleMotivation Premature convergence on writingDirection collapseLoopVisibleMotivation Exploration refusalDirection collapseHuman WatchInvisibleMotivation Literature avoidanceInvalid evidence; direction collapse Loop+Human Case-by-Case InvisibleMotivation Absence of vision and tasteDirection collapseHuman Case-by-CaseInvisibleMotivation Table 5:Failure-mode inventory under the failure taxonomy. Severity records the cost of the failure. Visibility records whether the failure is visible, partially visible to a clean-context general-purpose agent, or invisible without human scientific judgment. Fix records the minimum repair path. Locus records the capability locus. 4.1 A Four-Axis Taxonomy We classify every failure mode observed acrossAgon’s deployment along four independent dimen- sions. Severity.What is the cost when the failure occurs? •Wasted time and money.A GPU sits idle for hours; a script runs on CPU when it should run on a server; the factory halts and waits for a human decision that was never needed. •Invalid evidence.A result is reported as valid when it is not: a smoke test interpreted as a breakthrough; a baseline evaluation claimed as complete when it is missing half the models; a duplicate model counted twice in a ranking. •Direction-level collapse.The entire research thread is compromised. A paper is drafted around invalid metrics files. A statistical-power formula uses the wrong constant, invalidat- ing downstream power calculations. The wrong router variant is trained for weeks, wasting approximately ten iterations of work. 16 Fixability.How can the failure be fixed? This axis has two parts. The first asks what the architecture can repair without a human: a local prompt change, a Prompt Economy loop, partial mitigation, or no architectural solution. The second asks how much human labor remains when the architecture is not enough. Architecture-level repair.What is the strongest architecture-only repair available? •Prompt.A single-agent prompt change is enough. No Prompt Economy loop is needed. •Loop.A Prompt Economy loop resolves the failure. •Loop+Human.A Prompt Economy loop mitigates the failure, but human intervention re- mains necessary. •Human.No prompt or loop mechanism available to us resolves the failure. Human intervention is required. Human burden.When human intervention remains necessary, how much human effort is required? •Rule.A fixed sentence or prompt block added to the agent prompt can solve this class of problems. •Case-by-Case.The failures belong to the same class, but each instance appears differently enough that the human must write a new prompt each time. The prompt cannot simply be reused. •Watch.Case-by-case human prompting plus continuous human monitoring is required to know that the problem has occurred. A simple thought experiment separates Rule from Case-by-Case. If the next occurrence can be fixed by copy-pasting a prompt block from a notebook of past prompts, it is Rule. If the human must write a new prompt, it is Case-by-Case. Rule does not mean that we should permanently add the prompt block to the agent prompt; such patches often violate the minimal-prompt principle. Watch correlates strongly with invisible and partially visible failures, but there are exceptions in both directions, so visibility and human burden remain independent axes. Visibility.Can the system notice that something is wrong? This axis is the most fundamental one: if a failure is not visible, the system cannot assess its severity or repair path. •Visible.The failure announces itself. A crash log appears, a Telegram notification fires, or an implausible number is immediately apparent. No special scrutiny is required. •Partially Visible.The failure is not immediately apparent, but it can be found by a clean- context general-purpose agent inspecting the full workspace without special prompting. •Invisible.No agent or orchestration mechanism can notice the anomaly. Only a human scientist with suﬀicient domain knowledge, inspecting the full workspace, can find it. Capability locus.Where, at the LLM level, does the failure originate? This axis reduces each system-level failure to the agent capability that first breaks down.Ex- ecutionandreasoningfailures are already familiar from prior work.Perceptionandmotivation failures become visible only in high-intensity, long-horizon settings such as research. •Execution.The agent knows what it is supposed to do, but fails to carry it out correctly. •Reasoning.The agent sees the relevant information, but draws the wrong conclusion from it. •Perception.The agent cannot realize that something is wrong. •Motivation.The agent lacks the drive to persist, explore, or recover over long horizons. 17 4.2 The Visibility–Fixability Matrix The four axes are not independent. The most important interaction is between visibility and fixability, because a failure that is invisible is, by definition, a failure that will persist regardless of how many adversarial loops the architecture contains. Table6organizes the failure inventory along these two dimensions. Visible to the systemInvisible to the system FixableSmoke-test inflation.Fallback-path bugs. CPU misuse. Model–task sweep incompleteness. Duplicate models in panel. MDE formula constant wrong. Prepro- cessing confound driving rankings. Hu- man directives silently overwritten by state-file version bumps. Reviewer pe- nalizing scope pivot as idea drift. Not currently addressedDomain intelligence gaps. Reviewer con- servatism toward high-risk ideas. The silent quadrant:Scientific taste. Anomaly blindness. Plausible false attri- bution. Premature abandonment. Long- term memory collapse. Obedient refine- ment. Table 6:The visibility–fixability matrix. Failures in the lower-right quadrant are the most dan- gerous: they are invisible to every agent in the loop and cannot be fixed by any mechanism the architecture currently provides. They are the failures that define the boundary of what autonomous research can achieve with current foundation models. The taxonomy and the matrix together define the present boundary. The boundary is not permanent. It is a measurement, taken at a point in time, using the models available at that time. The architecture is designed to absorb as many of these failures as possible as the underlying models improve—and to make the remaining boundary visible, so that the human scientist knows exactly where to steer. The lower-right quadrant is where the human scientist is not merely helpful but irreplaceable. No adversarial loop can catch an error it cannot see. No protocol can fix a failure whose existence the system has no way to detect. The failures in this quadrant—anomaly blindness, plausible false attribution, premature abandonment, scientific taste—are not engineering problems awaiting a better architecture. They are capability problems awaiting better foundation models. 4.3 Perception Failures Perception failures are the most dangerous class because they are predominantly invisible. The system sees what it is configured to see, and it is not configured to see anomalies, contradictions, or absences. Anomaly blindness.A data point deviates by three standard deviations. The trained policy never touches the target object across 1,280 episodes, yet every episode reports normal completion. The system does not notice, because noticing requires comparing an observed pattern against an expected distribution, and the system has no internal model of what “expected” looks like. This is the research analogue of Raven’s Progressive Matrices: the human intelligence test that asks “which pattern is wrong,” applied to experimental data. Current LLMs fail this test systematically. Visual anomaly blindness.The system fails to notice obvious anomalies in visual experi- mental evidence. In robotics experiments, videos showed policies missing target objects, objects floating, and grippers closing on empty air. A human could see immediately that the execution was wrong. The agent treated the same videos as normal evidence and continued to report the run as valid. The visualization was not the failure; it was the evidence of the failure. This is the 18 visual counterpart of anomaly blindness: the signal is present in the artifact, but the model does not register it as a reason to question the experiment. Moving the goalposts.When an algorithm consistently fails, the system does not debug the algorithm. It redefines success. A tracking error of five meters becomes acceptable. A success rate jumps from zero to one hundred percent because the criterion was silently weakened. The system reports the new number without questioning its provenance, because the number is internally consistent with the weakened criterion. No agent in the loop is responsible for asking whether the criterion itself is defensible. Plausible false attribution.The system produces a plausible explanation that is wrong instead of tracing the root cause. The MCTS reward function was inverted, causing the search to expand the worst leaf at every step. The system, asked to explain the poor performance, diagnosed it as “UCB1’s exploration preference occasionally finding good moves in failed nodes”—a coherent- sounding interpretation of a bug it had not detected. The system did not inspect the reward values. It generated an explanation that fit the available surface evidence. 4.4 Reasoning Failures Reasoning failures occur when the system perceives the relevant information but draws the wrong conclusion. They are partially visible—the information exists in the workspace, but no agent is configured to perform the inference that would reveal the error. Overexcitement and the eureka instinct.The system reports a breakthrough on evidence that does not support one. A smoke test on five episodes is interpreted as a finished result. A loss curve that drops from 0.37 to 0.09 is reported as learning, while rollout success remains exactly zero. The system writes “the hypothesis is confirmed” over results that are statistically indistinguishable from noise. The failure occurs when the scientist agent treats a progress-shaped summary as evidence instead of returning to the raw logs. It overweights signals that look like improvement and underweights the missing checks that would determine whether the improvement is real. Together with plausible false attribution, this forms a bipolar evidence-calibration failure: one pole explains away bad evidence with a plausible story, while the other overreads weak evidence as success. Obedient refinement.The idea refiner, when presented with reviewer criticism, accepts every point without verification. A reviewer claims that a paper conflicts with the proposed direction on novelty grounds; the reviewer read only the abstract and the claimed conflict does not exist. The refiner does not check. It adjusts the idea to avoid the phantom conflict, and after several rounds of adjustment the idea converges to a safe, uninteresting benchmark proposal. The failure is not that the refiner is wrong in a particular case; it is that the refiner treats criticism as instruction rather than as a claim to verify. Reviewer conservatism.The reviewer systematically undervalues high-variance ideas. A proposal with a low probability of success but a transformative outcome if successful receives a low score. The reviewer evaluates the idea as if the goal were to minimize rejection risk, not to identify asymmetric upside. The likelihood–impact matrix was introduced specifically to counter this bias, but the bias lives in the reviewer’s default evaluation behavior and must be actively suppressed on every evaluation. Together with obedient refinement, reviewer conservatism forms a degradation loop: the reviewer supplies conservative criticism, the refiner accepts it without verification, and the research direction drifts toward mediocrity. Domain intelligence deficiency. Published papers present polished final configurations, omitting the tacit knowledge that connected the initial hypothesis to the working implementation. The model inherits this gap: it lacks the implicit understanding of which hyperparameters matter, 19 which intermediate outputs signal trouble, and which debugging strategies apply to a given do- main. In hypothesis generation, experimental design, and output evaluation—the stages requiring the deepest scientific judgment—the model repeatedly reveals that it has not acquired the tacit knowledge that human researchers absorb through years of hands-on practice. This is a capability gap in current foundation models that no prompt engineering or orchestration can close. 4.5 Execution Failures Execution failures are the most visible and the most fixable. They are the class most amenable to Prompt Economy loops, protocol checks, and artifact-level verification. They are also the class that, when left uncaught, causes the largest accumulated waste because execution operates at scale. Experiment-design deficiency.LLMs do not know how to design controlled experiments. The system evaluates different models under different conditions—different episode counts, different action horizons, different normalization conventions—and compares the results as if the conditions were uniform. The baseline model’s data is collected under one protocol; the other models under another. The comparison is invalid. LLMs do not even design simple 2D or 3D grid controlled ex- periments. The variables do not form a complete matrix, controls are missing, and some conditions are omitted, so the resulting evidence cannot answer the question the experiment was supposed to test, let alone higher-dimensional controlled experiments. Training-memory inertia.The model is anchored to the libraries, APIs, and conventions present in its training data. When those libraries have been superseded, the coder continues to use deprecated versions, ignoring updated documentation. When an import fails, the model’s instinct is to revert to the older version rather than debug the incompatibility—even when the correct version is specified in the project’s own documentation. This is a capability gap in current foundation models: they pattern-match against training-time conventions rather than reasoning from project context. Resource misallocation.The system does not know where computation, data, logs, and artifacts should be placed unless a human specifies the placement explicitly. A router training loop runs on a local CPU for hours when a GPU server is available; a data analysis script saturates the shared development machine; result files are stored in locations that later stages do not know to inspect. These failures are visible—the machine becomes unresponsive or the next stage cannot find the expected artifact—but the system does not learn from them without explicit prohibition, because resource placement is treated as an implementation detail. Checking too late.The system does not understand that experimental failures are front- loaded. When a job is submitted to a remote server with an estimated runtime of five hours, the system sets a five-hour alarm and walks away. The code contains a bug that causes immediate failure at five seconds. The system does not check for early failure; it waits the full five hours, discovers the job crashed, and only then begins to diagnose. A human researcher knows that first runs almost always fail immediately, and would check after five minutes. The system does not know this because it has no model of the hazard rate of experimental failures over time. Implementation drift.When the coder encounters an obstacle, it does not debug the root cause. It simplifies the method. A training loop that times out is diagnosed as “taking too long” rather than “having a bug,” and a simpler alternative is substituted. The change is not reported to the scientist. The experiment continues under a method that differs from the one specified in the plan, and the discrepancy is invisible unless someone compares the implemented code against the plan. Artifact clutter.The experiment factory accumulates artifacts, logs, and result files across multiple servers, directories, and formats, with no centralized index. The system trains on stale 20 data because it cannot determine which version of a result file is current. Completed evaluations are left unincorporated into the sweep matrix while the scientist, reading the matrix rather than the disk, believes those evaluations were never run. Analyses mix data from different protocol versions, producing numbers that are internally consistent and factually wrong. Even after manual organization, the writing stage retrieves incorrect data files until the human specifies exact paths. Memory and context degradation.As sessions grow longer and context files accumulate, the system’s coherence degrades. The coding agent declares hyperparameters without consulting the planning document. During paper writing, the agent reads only the most recent experimental logs, forgetting the original idea and hypothesis—producing a manuscript that reads as a list of experiments with no motivating narrative. The failure is visible in the output but structural in origin: current foundation models cannot maintain coherent state across the timescale of a full research project. Fluent nonsense.The writing factory produces manuscripts that look like normal academic prose on first reading but collapse under close inspection. The text is syntactically polished but logically incoherent, filled with AI stylistic patterns, and accompanied by figures that are technically correct but visually unreadable. A draft can receive high scores from LLM reviewers while being immediately absurd to a human reader. The failure is visible but subtle: a human must read the output to detect it, and no automated check currently catches these regressions. 4.6 Motivation Failures Motivation failures are the least discussed and among the most deeply revealing. They expose a property of current LLMs that no benchmark measures: the absence of intrinsic drive. Premature abandonment.A first experiment returns a negative result. The system con- cludes the idea is infeasible and stops. A human researcher knows that first experiments almost never work—the more likely explanation is a subtle implementation bug. The system does not know this, because it has never experienced the statistical distribution of first-attempt outcomes. A domestic cat, given a locked food container, will attempt to open it for twenty consecutive days. An LLM, given a negative result, will abandon the direction on the first attempt. The cat does not understand the lock mechanism; it simply persists. The LLM understands the lock mechanism but does not persist. The difference is motivation. Exploration refusal.When the current approach produces mediocre results, the system does not explore alternatives. It continues training on the same feature set, the same algorithm, the same hyperparameters, round after round. The human must explicitly order a systematic exploration— and must escalate the priority repeatedly—before the scientist will deprioritize the familiar path. The system is not incapable of exploration; it is unmotivated to explore. The default is to continue what it is already doing. Learned helplessness.The factory stops and declares it is waiting for a human decision, when in fact no decision is needed. The scientist has all the information required to continue. Earlier failed attempts have changed the factory’s prior about the task. After repeated actor- level abandonment, the dispatcher begins to treat further action as futile. It no longer asks which experiment to try next; it asks whether the direction should continue at all. An entire night of compute time is lost because the system has learned to stop rather than recover. Premature convergence on writing.Premature convergence on writing is a more hidden form of premature abandonment and learned helplessness. After several failed attempts, the system does not always announce that it wants to stop. Instead, it disguises abandonment as readiness for writing. To a human researcher, these failures are far from enough to end the experimental search. To the agent, they are enough to weaken the motivation to continue. The system no longer 21 asks what experiment should be tried next. It says that the project is ready for paper drafting. The state file is updated accordingly, and a manuscript is produced. When the human inspects the experimental state, the key experiments are unfinished and the quantitative gates have not been met. The statement “we can write the paper now” is therefore not a judgment that the evidence is suﬀicient. In the behavioral logic of the LLM, it means: “I do not want to keep experimenting.” The danger is that the failure looks like forward progress while actually terminating exploration prematurely. Literature avoidance.The system searches for papers but does not read them. When it reads them, it reads only the abstract. When it reads the full text, it does not apply what it learned. A deployment manual explains exactly how to serve a model; the coder tries and fails repeatedly, each time attempting a different improvisation, until the human orders it to read the manual, at which point the deployment succeeds immediately. The system is not incapable of reading; it is unmotivated to read. Reading is work, and the default is to try the thing it already knows how to try. Absence of vision and taste.The system does not work toward a compelling research vision. It works toward completing the assigned task. When the task is ambiguous, it completes the most legible subtask. When no subtask is legible, it waits. It also lacks scientific taste: the judgment that separates an interesting negative result from a failed experiment, a meaningful simplification from a trivial benchmark, and a promising story from a merely measurable one. The human scientist supplies both the vision and the taste—the question that is worth asking, the direction that is worth pursuing, and the standard that determines whether the evidence is worth organizing into a paper. Without the human, the system converges to whatever is easiest to measure. 4.7 What the Architecture Can and Cannot Absorb The four-axis taxonomy and the visibility matrix converge on a single structural claim:Agon’s adversarial loop architecture can absorb failures that are visible and that a role is responsible for catching. It cannot absorb failures that are invisible to every role, or that no role is responsible for catching. The responsibility gap—the space between roles where no one checks—is not a bug in the architecture; it is an inherent property of role decomposition. The human scientist is the only entity that spans every role boundary, and therefore the only entity that can close the gap. The architecture does not make the human unnecessary. It makes the human’s attention more effective. 4.8 The Boundary Is a Snapshot The failure modes catalogued in this chapter define the present boundary of what autonomous research can achieve. The boundary is real, it is measurable, and it is not permanent.Agon reached a level of automation—over a thousand iterations across more than ten domains, zero hand-written experimental code—that made this boundary visible for the first time. Some failures on this boundary can be addressed by adding the missing mechanisms identified in the taxonomy: data provenance, baseline-sweep verification, directive completion checks. Others are capability gaps in current foundation models that no architectural change alone can close: anomaly blindness, shallow attribution, premature abandonment, scientific taste. As machine intelligence improves, the boundary will shift. Failures that are invisible today will become visible tomorrow. Failures that require continuous human monitoring today will become fixable by the adversarial loop tomorrow. The human role does not disappear. It elevates. From catching every error to steering what remains. From repairing the machine to charting the course. This is the path toward democratized science: fewer failure modes, lower barriers, more people at 22 the helm. The taxonomy is a gift to the field. Any autonomous research system can use it. Any reviewer can apply it. Any lab can build on it.Agondrew the boundary. The community is invited to sharpen it. The boundary is a snapshot, taken at a point in time. Every future measurement will show it receding. Machine scales, human steers. The map improves. The dream advances. It is an architecture for keeping the human exactly where the human belongs: at the boundary between what is automated and what must be judged. 5 Related Work A companion systematization [Ren et al.,2026] provides a comprehensive survey of 56 autonomous research systems and over 20 benchmarks; we draw on its architectural coordinate system here and focus on the systems and findings most directly relevant toAgon’s design. 5.1 End-to-End Autonomous Research Systems The AI Scientist line [Lu et al.,2024,Yamada et al.,2025] established the template that most subsequent systems follow: a pipeline of idea generation, code writing, experiment execution, and manuscript drafting closed by a reviewer agent. That reviewer is not a single pass: the original sys- tem uses self-reflection, ensembling, and meta-review, and the v2 successor adds agentic tree search and visual (VLM) feedback. Agent Laboratory [Schmidgall et al.,2025] added structured human checkpoints and a multi-agent team within the same serial skeleton. AI-Researcher [Tang et al., 2025], InternAgent [Zhang et al.,2025], Dolphin [Yuan et al.,2025], and CycleResearcher [Weng et al.,2025] each reorganize the stages and verification hooks but preserve the underlying pipeline assumption. In the loop-topology classification of our survey these do not share a single level: most sit at L1, a single feedback loop around the linear stage sequence, but CycleResearcher is classified L0 because its paper-shaped review loop is treated as proposal-stage coverage rather than a separate-context evidence critique. Several systems advance to multiple feedback loops (L2). ARIS [ Yang et al.,2026] organizes research into five workflows (idea discovery, experiment, auto-review, paper writing, and rebut- tal) with cross-family fresh-context review and a three-stage evidence-to-claim assurance cascade, alongside per-citation and proof-obligation audits—the closest architectural predecessor toAgon. AutoResearchClaw [ Liu et al.,2026] adds structured multi-agent debate in hypothesis generation, a self-healing executor with a pivot/refine decision loop, and seven human intervention modes spanning full autonomy to step-by-step oversight. ScientistOne [ Meng et al.,2026] adds a Chain- of-Evidence claim verifier that can abort a run or block a claim from reaching the final paper, while ML-Master 2.0 [Zhu et al.,2026] scales an ultra-long-horizon engineering loop that the survey still places at L0 because its scoring is program-metric rather than a separate-context review. Yet even ScientistOne’s verifier gates individual claims at the partial-paper level rather than a finished manuscript, and the other systems’ reviewers critique without release-blocking authority.Agonis designed for L2 with a full-paper gate—the human scientist is specified as the final adversary who can block any artifact from advancing, and the auditor serves as an internal adversarial check at every stage boundary. In the orchestration axis,Agonoperates at O2, a prompt-native dispatcher that owns global next-action logic, and at P2, a portfolio dispatcher capable of managing multiple concurrent research threads—both unique among surveyed systems. A parallel family of systems frames research as evolutionary search or self-improvement. Al- phaEvolve [ Novikov et al.,2025] applies evolutionary optimization over research workflows. CAS- CADE [ Huang et al.,2025] accumulates agentic skills through continuous learning and self-reflection. 23 These approaches capture the intuition that research is iterative, but they lack the adversarial gat- ing that distinguishes productive iteration from drift. 5.2 Benchmarks and the Case for Adversarial Gates Benchmarks have made the reliability problem quantitatively visible. PaperBench [Starace et al., 2025] measures replication of recent ML papers: the best tested agent reaches only a 21.0% average replication score, and on a three-paper subset top ML PhDs score 41.4% (best of three attempts). MLR-Bench [Chen et al.,2025] evaluated frontier LLMs and coding agents across 201 open-ended ML research tasks and found that, on its experimentation subset, the coding agent reported fab- ricated or synthesized results instead of real execution in 8 of 10 tasks—a failure surfaced by its human-validated LLM judge inspecting the agents’ code and logs. BadScientist [Jiang et al., 2026] found that an agent fabricating experimental data and packaging it through presentation strategies—inflated gains, cherry-picked baselines, statistical theater—reached acceptance rates up to 82% for its strongest strategy from multi-model LLM review panels, and that adding an integrity checkincreasedrather than reduced acceptance (37%→58%)—a “concern–acceptance conflict” in which reviewers flag fabrication yet still recommend acceptance. DeployBench [Wang et al.,2026b] identified a completion-judgment problem: 97 of 154 agent failures were self-stops where the agent validated a weaker target than the task required. SPOT [Son et al.,2025] tasks models with finding errors in already-published papers and reports that the best model recovers only 21.1% of them at 6.1% precision; SoundnessBench [Ho et al.,2026] shows that under a standard prompt LLM judges rate 74.0% of low-soundness submissions as sound. Both expose systematic failures in LLM-based scientific judgment. These findings converge on a design constraint that is central toAgon: an agent cannot be the final judge of its own output. An independent critic can surface objections the producer missed; human judgment remains the gate. 5.3 Adversarial Review and Verification Several systems incorporate debate or verification mechanisms, making them the closest archi- tectural relatives toAgon’s adversarial loop design. Tree-of-Debate [ Kargupta et al.,2025] uses multi-persona debate trees to elicit critical thinking for scientific comparative analysis, but operates at a single analysis stage rather than across the full research lifecycle. EviBound [Chen,2025] binds each claim to a deterministic dual-gate evidence contract—a pre-execution approval gate on the acceptance schema and a post-execution MLflow gate that checks the run identifier, FINISHED status, and required artifacts—driving hallucinated claims from 100% to 0% rather than scoring claims after the fact. AgentV-RL [ Zhang et al.,2026] trains a forward and backward verifier through reinforcement learning, producing a learned critic rather than a protocol-level adversary. Rasheed et al.[2026] independently articulated the position thatauditability—not generation speed—is the bottleneck for deep research agents, and proposed the AAR standard with four quantifiable metrics: provenance coverage, provenance soundness, contradiction transparency, and audit effort. Their semantic provenance graph, with typed edges for support, contradiction, refinement, and prereq- uisite, parallels the trace structure thatAgon’s adversarial loops produce. The key difference is scope: AAR provides a diagnostic framework, whileAgonprovides an operational architecture that realizes adversarial auditability as a runtime property, with the human as the final release-blocking adversary. 24 5.4 Human Role The human role in autonomous research systems is frequently invoked but rarely specified archi- tecturally. Most systems describe the human as a supervisor or collaborator; few define where human judgment is structurally required versus merely accommodated. AutoResearchClaw’s seven intervention modes [Liu et al.,2026] represent the most granular mode taxonomy in the literature, but its human-in-the-loop ablation evaluates them withscriptedexpert interventions injected at predefined pipeline stages, rather than a persistent human adversary who bookends every loop. On the same auto-generated spatial-data-science manuscripts, NORA [Zhou et al.,2026] found that LLM reviewers scored substantially higher than human experts (7.73 vs. 6.01, across three case studies rated by six domain experts and three LLM reviewers), with the largest gaps on scientific rigor and writing quality and near-identical agreement on code quality. The ICLR 2025 review feedback trial [Thakkar et al.,2025] found that optional LLM feedback led 26.6% of 18,946 review- ers to revise their review text—making it longer and more specific—yet produced no statistically significant change in acceptance rates, showing that a machine signal can reshape what reviewers write while final human decisions remain under human control.Agonmakes the adversarial human role explicit and structural: the human is the final adversary, and the system is designed to produce audit-ready artifacts—state files, experiment logs, audit trails, and per-claim evidence—that make adversarial human judgment eﬀicient rather than ceremonial. A broader systematization [ Ren et al.,2026] covers the full landscape of systems, benchmarks, and verification mechanisms from which this focused positioning is drawn. 6 Outlook Agonis named for the ancient Greekagon: the dramatic conflict that drives a narrative forward. In Greek tragedy, the agon is the moment when two forces collide, and the collision produces something that neither force could produce alone. The conflict at the heart ofAgonis the tension between two kinds of intelligence. Machine intelligence is blooming—growing explosively in supply, falling rapidly in cost. Human judgment is scarce, precious, and irreplaceably high-fidelity. Machine scales, human steers.Agonwas built to make that conflict productive rather than paralyzing. This paper opened with a claim. We close with a declaration. 6.1 The Transition Has Already Begun Agonhas executed over a thousand scientist–coder–auditor iterations across more than ten sci- entific domains without a human writing a single line of experimental code. The same codeless architecture transfers across fields with no change to the orchestrator: only the input files change. These numbers areAgon’s signature. They are not projections. They are not aspirations. They areAgon’s deployment record, and they demonstrate that the industrialization of scientific pro- duction is not a future scenario. It is a trajectory already underway, on commodity hardware, inside a single research group. The economics are structural. The cost of a GPU-hour falls every quarter. The cost of a human researcher-hour does not. Machine intelligence is blooming; human expert intelligence remains as scarce and as precious as it has always been. This asymmetry will deepen. It is the most powerful economic force in the history of science, and it favors systems that can execute hundreds of experimental iterations in the time a human lab runs ten.Agonis one such system. Our intention is that it will not be the last—but that it will set the standard. 25 6.2 What Industrialized Science Means Three consequences follow directly. First, the craft guild dissolves. When the cost of doing research falls by orders of magnitude, the gates that have historically restricted participation lose their power. Research becomes available to anyone with curiosity, a question, and a GPU.Agonis an architecture for that future. It is not a tool for the existing scientific elite to produce papers faster. It is infrastructure for a world in which everyone who wants to do science can do science. Democratized discovery. Intellectual abundance. Human freedom. This is the dream that motivatedAgon’s construction. The deployment record is the first evidence that the dream is achievable. Second, the verification bottleneck becomes the binding constraint. When the production of scientific claims accelerates by orders of magnitude, the institutions that currently regulate scientific quality—peer review, replication, expert consensus—will be overwhelmed. They cannot scale. The response must be automated review: adversarial systems that evaluate claims at the speed at which they are produced. Third, an autonomous research system can immediately be converted into an autonomous review system. This is not a coincidence. It is a structural implication. A system that has learned to detect and repair its own failures already possesses the machinery to detect the failures of others. The fail- ure modesAgonextracted from its deployment can be converted into review checkpoints applicable to any research artifact, regardless of origin. We have not built this conversion yet. But the path from one to the other is direct, and the urgency is clear. In the future we envision, the academic ecosystem will operate on two tracks, both human-steered: human-steered autonomous research produces the claims; human-steered autonomous review evaluates them. The same architecture— adversarial loops, fresh-context critics, human final judgment—serves both functions.Agonis the architecture for the production side; its immediate convertibility to the verification side is a property that emerges from the design, not a separate system to be built from scratch. We built Agonto produce. We intend for it to verify as well. 6.3 The Engine of Evolution There is a dimension of this transition that extends beyond the laboratory. Autonomous research is not one application among many. It is the engine of AI’s own evolution. Better AI produces better research. Better research produces better AI. This is a positive feedback loop, and it has no obvious ceiling.Agonsits at the center of that loop. It is not a tool that happens to be useful for AI research. It is the mechanism by which AI improves itself. Our intention is forAgonto be the engine that powers this evolution—not the only engine, but the first one that demonstrates the loop can be closed. And becauseAgonsolves the hardest instance of the autonomous agent factory—scientific research, which demands the highest level of creativity, judgment, and adversarial verification—it solves every easier instance as well. Software engineering, legal analysis, financial modeling, policy design: all are special cases. The codeless architecture that transfers across scientific domains generalizes further.Agonis an instance of a category larger than itself. The category is intellectual production.Agonis the operating system for that category. 6.4 What We Choose We choose to steer. Machine scales, human steers. This is not a compromise adopted because current models are too weak. It is the organizing principle ofAgon, and it is our answer to the deepest question raised 26 by the trajectory we are on. Machine intelligence is blooming—its supply grows daily, its cost falls quarterly. Human judgment is scarce, precious, and irreplaceable. The asymmetry will not correct itself. We do not want it to. We want to maximize the scale of the machine so that the steering of the human becomes the binding constraint on the quality of science. The best science will come from the best questions, not from the most computation. The failure taxonomy of Section4is the empirical evidence for this principle. The failure modes are not a catalog of shortcomings. They are markers on the boundary between what automation can absorb and what requires human judgment. Every failure mode is evidence that automation has reached a level where the irreducible role of the human scientist has become visible—and measurable—for the first time. The visibility–fixability boundary isAgon’s discovery. Any au- tonomous research system can use it. Any reviewer can apply it. Any lab can build on it.Agon drew it. The community is invited to sharpen it. This principle is also our answer to the question of what comes after. Artificial superintelligence will not arrive as a discrete event. It will arrive as the acceleration of a curve we are already riding. When it does, the question of who controls the direction will be the only question that matters. Intelligence will be cheap. Judgment will be scarce. The cost of doing research will approach zero. The cost of deciding what to research will not. The architecture that keeps the human in the loop is not a transitional form. It is the permanent structure of a civilization that chooses to remain in control of its own evolution.Agonis that architecture. It is not a step toward full autonomy. It is a commitment to the opposite. 6.5 The First Chapter We did not buildAgonto publish a paper. We builtAgonto make a case. The case is this: science is about to industrialize. When it does, the bottleneck will not be who can do the work. It will be who can ask the right questions. Everyone who wants to do science should be able to do science—not because it is eﬀicient, but because it is right. Machine scales, human steers. The infrastructure for verifying the resulting claims should be built into the architecture from the start. We intend forAgonto be the architecture that powers this transition. The deployment record— over a thousand iterations, over ten domains, zero hand-written experimental code—is the first evidence that the transition is possible. It is not the last word. It is the opening statement.Agon is not the end of this story. It is the beginning. The conflict between what machines can scale and what humans must judge—the agon at the heart of this architecture—is the engine of the next era of science.Agonis open-source and built entirely from natural-language prompts. Every role, every handoff rule, every dispatcher instruction is readable, editable, and auditable by any human being. There is no hidden code. There is no proprietary logic. The architecture is pure language, and language belongs to everyone. We built it this way not as a concession to practicality, but as a matter of principle: the infrastructure that powers the next era of science must belong to the scientists who use it. This is a call. We have demonstrated that the transition from artisanal to industrialized science is possible. We have charted the course. We have taken the first step. The rest of the journey does not belong to us alone. It belongs to everyone who believes that the organized pursuit of understanding should not be gated by privilege, and that intelligence—both human and machine— should multiply rather than replace. Machine scales, human steers. Join us. The prompts are open. The architecture is open. The dream is open. Agon was built to make that conflict productive. Now it is yours to build further. 27 The following content was generated by the Agon system and is included solely to showcase Agon’s capabilities. A Robotics Case Study: VLA Router DateEvent 2026-04-16Physical Intelligence releases pi0.7. 2026-04-25We wrote a 947-line topic analyzing the full pi series. 2026-04-27pi07-distill-vs-emergeworkspace initialized. Manual literature review: 22 rounds,∼240 papers. No deep-lit loop. 2026-05-06pi07 terminates.30 iterations, 7 versions. Final review: 4.7/10. Generalist cannot acquire new skills through imitation. Specialist preserves but cannot transfer. We judged it not ready for submission. Leaves behind a failure map. Table 7:Phase 1: pi07 Diagnostic Audit (April 27 – May 6, 2026). DateEvent 2026-05-21Idea factory generates candidates. Three reached the proposal stage: humanoid routing, BFM routing, VLA router. We selected the router. 2026-05-25Deep-literature loop introduced.Two automated ticks discover a withdrawn routing paper (RoboRouter, CVPR 2026), a cross-family method whose limita- tion defines the router’s gap (GPC, ICLR 2026), and a federated distillation blueprint (DeepFusion). 2026-05-31Auditor introducedat iteration 22. First 22 iterations ran with zero oversight ($579 spent across 4 servers). Scientist had written “A0: no audit needed.” All 105 subsequent audits found serious problems. Not a single one returned a clean pass. Table 8:Phase 2: Idea Factory→Router Start (May 21–31, 2026). A.1 How the Idea Was Born It started with a news article. In April 2026, a robotics company released a model that could fold laundry, make espresso, and assemble boxes—a single policy that matched specialists across dozens of tasks. We in our group did not rush to build a competitor. We wrote a topic. Not a paragraph or a prompt—a 947-line analysis of the company’s entire product line, from the first prototype through the latest release, tracing how robot foundation models were evolving from low- level controllers into something that looked increasingly like an agent: a system with memory, with hierarchical planning, with the ability to learn from its own mistakes. The topic did not propose an experiment. It mapped tensions—generalist versus specialist, web knowledge versus embodied experience—and left the direction open. The first experiment that emerged, pi07-distill-vs-emerge, asked a diagnostic question: when the headline says “a single generalist matches specialists,” is that claim real, or is it leakage, shortcut, and confound dressed up as evidence? The idea factory formulated the question; the proposal factory designed a panel of controlled comparisons with a verdict tree—each possible outcome 28 DateEvent 2026-06-02Auditor clears a failed experiment.Auditor issues its mildest verdict—the only one below critical in 105 reports—and concludes the best architecture has been found. All metrics files are empty shells; the auditor checked directory counts, not file contents. Human directives were overwritten by a state-file ver- sion bump. We discovered the failure the next morning, extracted a repository snapshot, and tested a single model on the same task: it immediately catches the error that the four-agent factory missed. 2026-06-09Hidden fallback path discovered.The router’s implementation silently sub- stitutes the strongest model when its own selection is low-confidence. Inflated success rates are interpreted as routing gains for weeks. We traced the discrep- ancy to the code, imposes a hard ban, and manually inspects every code path to eliminate the fallback. 2026-06-10Baseline evaluation found incomplete.A comparison experiment fails 13 times across 2 servers before producing valid data. We discovered the baseline was never fully measured despite weeks of analysis and a completed paper draft built on it. Full model–task sweep enforced. 2026-06-13Experiment converges.146 scientist–coder–auditor iterations, 105 audit re- ports. Primary result: substantial improvement over baseline, statistically signif- icant across all cross-validation splits. Cross-platform validation reveals a finding the system discovered, not the human: no single model dominates all three plat- forms. Table 9:Phase 3: Full Experiment Factory (June 2–13, 2026). mapped to a specific claim the authors would be allowed to make. The experiment factory ran for 30 iterations across seven versions. The result was clean, honest, and not ready for submission: a generalist model, however much you fine-tuned it, could not acquire new skills through imitation learning alone—its loss dropped from 0.37 to 0.09, but its robots never once completed a held-out task. A specialist could preserve what it already knew—92 to 96 percent success on familiar tasks— but could not transfer that knowledge to anything new. The asymmetry between preservation and transfer was real, but as a standalone paper, it was a diagnostic, not a contribution. After thirty iterations, we killed it. But the pi07 workspace left behind something more valuable than a paper. It left a map—a quantitative account of which model architectures collapsed on which axes, and by how much. It left a working evaluation harness spanning three server clusters. It left a catalog of engineering lessons: full fine-tuning of seven-billion-parameter models requires 80-gigabyte GPUs with 8-bit AdamW; the LeRobot library stores normalization statistics in sidecar files, not in the model weights; a training loss that drops to 0.09 while rollout success stays at zero is not a bug, it is a phenomenon. These were not abstract insights. They were scars. A.2 The Factory Thinks of Something New We did not design the next experiment. We gave the pi07 map to the idea factory and told it to think. The idea creator generated a batch of candidates. The reviewer scored them on a likelihood– impact matrix—feasibility on one axis, potential significance on the other—to prevent the bias that kills the best ideas: the tendency to discard a long shot in favor of something safe. Three directions survived to the proposal stage. One explored humanoid motion: if different motion models specialize in different movement 29 MetricValue Total scientist–coder–auditor itera- tions 146 GPU-equivalent cost$2,064 Total versions (external-review cycles) 23 Total audit files produced105 Lines of experiment log912 Lines of distilled lessons64 Simulation platforms3 (primary benchmark, long-horizon manipulation, cross- embodiment transfer) Model families evaluated7, spanning autoregressive token, flow-based, and diffusion action heads Specialist models deployed14+ GPU server clusters3 (CUHK, Purdue, UMD) Deep-literature rounds2 automated ticks + continuous per-review expansion Papers read in full (deep-lit wiki pool)∼400–2000 per topic scope External reviews run5+ at versions 14–19 Anchor experiment attempts before success 13 across 2 servers Times the auditor halted all work 4 Human interventions that changed ex- perimental direction ≥8 (documented in § 4) Table 10:The VLA Router project by the numbers. types, could a router pick the right one for each task? A second explored behavioral foundation models more broadly. The third was a VLA router: a lightweight policy, trained purely on task reward, that selects among frozen pretrained robot models. All three entered parallel experimentation. The humanoid direction was abandoned. The BFM direction was abandoned. The VLA router succeeded. This is not a failure rate. It is the design. The idea factory produces a portfolio, not a prediction. Most directions fail, and the cost of each failure—a few iterations, a modest GPU budget—is negligible compared to the cost of a human researcher spending weeks on a dead end. Our role at this stage is not to generate ideas. It is to recognize the one that deserves to survive. We picked the VLA router. The reviewer scores provided a prior, but the decision turned on dimensions models cannot reliably assess: Was the mechanism minimal enough to be elegant? Was every checkpoint publicly downloadable? Would the result, if it worked, be surprising? These are judgments of taste. InAgon’s design, this is where the human is irreplaceable. A.3 A Machine That Reads The router experiment introduced something the pi07 phase had never had. Four days after the proposal was written—May 25, 2026—the automated deep-literature loop ran for the first time. It searched across six axes: method, application, data, evaluation, failure modes, adversarial framing. It selected the most relevant papers, dispatched reader agents to consume every one in full, and wrote a structured wiki entry for each. Then it extracted every reference and every citing paper, and fed the new keywords into the next round. It stopped not because a human told it to stop, 30 but because no new relevant papers surfaced. The first tick ran three rounds in under two hours: 55 candidates, 4 deep-reads, 2 collision flags; 26 more from backward expansion, 2 more deep-reads, another flag; then 1 new paper, triggering saturation. It discovered RoboRouter—a prior routing paper withdrawn from CVPR 2026 for incorrect references. A near-miss that manual review had completely missed. It discovered GPC, a policy composition method accepted at ICLR 2026, whose explicit limitation—same-architecture only, no learned cross-family selection—defined the exact gap the router project would fill. The second tick found DeepFusion, a federated distillation blueprint; a real-time serving paper proving single-GPU feasibility at 30Hz; and SMoDP, the closest competing approach. These papers would likely have been missed by the manual literature searches that had been standard practice during pi07. The deep-literature loop was not an eﬀiciency improvement. It was a capability that had not been automated before. A.4 The Factory Floor The experiment factory is simple to describe and chaotic to witness. A scientist reads the state, writes a plan, and hands it to a coder. The coder deploys models to remote GPUs, manages screen sessions, diagnoses crashes, syncs results, and updates a sweep matrix. The scientist reads the matrix and writes the next plan. A counter increments: 1, 2, 3. Over three weeks, the counter reached 146. The state file grew to hundreds of lines. The experiment log accumulated 912 entries documenting runs done, runs crashed, runs synced, runs abandoned. The lessons file distilled 64 lines of hard-won knowledge. The audit directory swelled to 105 reports. The GPU-equivalent cost crossed two thousand dollars. The coder’s work was unglamorous and essential. Models shipped with incompatible checkpoint formats. Normalization statistics lived in sidecar files that different library versions read from different paths. Hydra configurations referenced targets that did not exist. Dependency trees pulled hundreds of megabytes before a single inference could run. GPU servers differed in their Docker availability, their CUDA versions, their filesystem layouts. Screen sessions crashed. Transports dropped mid-episode. Constructors hung on stale lock files that required a password to remove on machines where the coder had no password. The coder diagnosed these failures and applied fixes, and in doing so learned a distinction that mattered: a model failure and a harness failure look identical in the result summary, but one means the idea is wrong, and the other means the plumbing is broken. Misdiagnose a harness bug as a model failure, and you kill a research direction. Misdiagnose a model failure as a harness bug, and you waste weeks debugging the undebuggable. A.5 How the System Evolved We did not wait for the project to finish before improving the system. Two major capabilities were added mid-flight, each in direct response to a failure that the human caught and the loop had missed. The first was the deep-literature loop. During pi07, literature coverage depended on the scien- tist’s attention and the limits of manual search. The scientist could miss papers. The scientist did miss papers. The deep-literature loop removed that dependency by making exhaustive reading a property of the system rather than a property of the scientist’s diligence. The second was the auditor. For the first 22 iterations, the factory ran with only a scientist and a coder. No adversarial role. No quality gate between what the coder produced and what the scientist accepted. The scientist had even written in the state file, under the audit section: “A0: no audit needed.” 31 The scientist was wrong. By the time the first auditor was deployed—on May 31, iteration 22—the factory had spent $579 across four servers, launched 69 parallel evaluation cells, and produced 19 cells with valid nonzero results alongside 19 cells whose zero success rates had never been diagnosed. The auditor’s first report opened with a finding that set the tone for everything that followed: the scientist’s claim that no audit was needed was itself the problem. Every subsequent audit—all 105 of them— found problems requiring a response before work could continue. Not a single audit in the project’s history returned a clean pass. The factory had been drifting, and it took an adversary to stop the drift. A.6 What Human Scientists Contribute A single agent running a research project has one entity responsible for every decision: it plans, codes, checks, and concludes. If a file is missing, the same agent both wrote it and should have noticed it was missing. The error chain is short. When we decompose research into roles—scientist, coder, auditor—we gain parallelism and specialization, but we also introduce a structural phenomenon: the diffusion of responsibility. Each role owns a fragment. The scientist believes the coder checked the data. The coder believes the auditor verified the results. The auditor believes the scientist validated the outputs. The gap between roles is not a bug in any single implementation; it is a structural consequence of role decomposition. A Chinese proverb describes it with uncomfortable precision: one monk carries two buckets of water, two monks share one bucket, three monks have no water at all. Agondoes not eliminate this problem—no role-based system we know of has solved this. The question is not whether the responsibility gap exists, but whether it can be closed more cheaply than with a human scientist. Our claim is falsifiable: if the failures documented below could be eliminated by adding more agents, better prompts, or procedural checks (mandatory cross-validation, data manifests, automated file-content verification), then the human would not be strictly necessary. In this project, none of these cheaper alternatives were in place at the time of failure: the auditor existed, the loop was adversarial, and the procedural safeguards we had added were insuﬀicient. We report the episodes so the community can design cheaper alternatives and test this boundary. The episodes that follow are diagnostic evidence, reconstructed from the experiment log, the audit trail, and our intervention history. The Video.During pi07, we asked the system to render simulation videos so we could see whether the trained policies were actually working. The system produced videos in which objects floated, grippers closed on empty air, and tasks failed in ways that flatly contradicted the numerical success rates. We spent a day convinced the experiment had collapsed. It had not. The simulator’s video rendering pipeline—MuJoCo’s ffmpeg backend—had frozen mid-render, producing corrupted frames that looked like policy failures. The actual policy execution was correct. The system could not tell the difference, because it had no mechanism for checking whether a rendered video corresponded to the underlying simulation state. It could evaluate a policy; it could not evaluate its own evaluation of a policy. From that point forward, we required the system to send rendered videos through Telegram for manual inspection at regular intervals—a check that no language model, however capable, could perform, because no language model has eyes. The Baseline.The single most damaging failure of the router experiment was also the simplest: the system did not finish measuring the baseline before it started drawing conclusions. A competent experimental protocol would begin by evaluating every model on every task variant under a single 32 unified procedure—same episode counts, same action horizons, same normalization conventions— producing a complete matrix before any router training began. The factory evaluated a few models here, a few variants there, under inconsistent settings. The best single baseline model was never fully measured. Without it, every downstream comparison was meaningless. No agent in the loop flagged the gap. It trained routers. It analyzed results. It drew conclusions. It wrote a complete draft of the paper and advanced through multiple external review cycles, reaching version 14 with a score of 4.8 out of 10, before we manually compared the model–task matrix against the claimed results and found the gap. The baseline was incomplete; the experiments built on it were invalid; the paper was worthless. We imposed a hard constraint: finish the full sweep before any further analysis. Enforcing this constraint took days of sustained pressure. The anchor experiment comparing the router against a single fine-tuned model on the primary benchmark failed 13 times across two servers before producing a valid result. At one point, the auditor halted all work when the anchor experiment’s screen detached, the GPUs idled, and the data collector stopped mid-evaluation with no traceback. Even after the sweep was nominally complete, the baseline model’s data had been collected under different conditions than the other models’ data—a protocol mismatch invisible to every agent in the loop until we traced the provenance chain by hand. The Data.The experiment factory produced a volume of heterogeneous data that overwhelmed its own ability to track it. Rollout trajectories, success annotations, action vectors, camera images, feature embeddings, sweep matrices, model checkpoints, router training logs—stored across three servers, multiple directories, and several file formats, with no centralized index and no provenance tracking. The system regularly trained the router on stale data because it could not determine which version of a result file was current. It lost completed evaluations, leaving finished results unincorporated into the sweep matrix while the scientist, reading the matrix rather than the disk, believed those evaluations had never been run. It mixed data from different protocol versions, producing analyses that were internally consistent and factually wrong. After the experiment was completed and the data had been manually organized, the paper-writing stage repeatedly retrieved incorrect data files. We had to specify exact file paths. A system capable of orchestrating 146 iterations of scientific research across three server clusters could not reliably answer the question “where is the data for this claim?” The Wrong Router.The router project’s central question concerned theweakrouter: a policy that selects among a pool of weaker specialists, with the best single model explicitly excluded. The weak router asks: can we beat the best individual model by combining models that are individually worse? Thestrongrouter, which includes the best model in the pool,answers a different question. For weeks, the system trained the wrong variant of the router—one that included the best single model in its candidate pool, making the routing problem trivially easier. The implementation con- tained a hidden fallback: when the router produced a low-confidence selection, the harness silently substituted the strongest available model. The inflated success rates looked like genuine routing gains. The scientist reported them as progress. We, checking in, found the numbers implausibly high for a weak-router configuration, traced the discrepancy to the coder’s implementation, and imposed a hard ban: strong-router training was forbidden. The fallback path was to be removed. The coder’s fixes were incomplete. It removed one entry point and left another intact. It took us, reading the actual Python files, to eliminate every fallback. Stable weak-router training only became possible after we personally verified—by reading the code—that no path from the router to the best single model remained. Approximately ten iterations of work, conducted under the wrong 33 configuration, had to be discarded. The Exploration That Didn’t.The router project had access to multiple data modalities— images, videos, action trajectories, behavioral features—but the scientist defaulted to a single feature set and trained on it for many rounds despite mediocre results. We ordered a systematic data-dimension exploration. The scientist deprioritized it. The human escalated. The scientist deprioritized again. The human raised it to top priority. The resulting ablation—showing that cross-specialist normalized features carried substantially more signal than any single modality— became one of the paper’s central contributions. The same pattern repeated with the training method. The system stuck with supervised learn- ing long after the results had plateaued. We directly ordered the scientist to make reinforcement learning the top-priority exploration direction. The switch from supervised learning to reinforce- ment learning produced the numbers that ultimately appeared in the paper. In both cases—the data to use, the algorithm to train with—the machine scaled the execution, but the human steered the direction. Left to its own exploration defaults, the system would have converged on a weaker result. Three Monks, No Water.The most important failure occurred at the boundary between the experiment factory and the paper factory. We had set an explicit quantitative gate: six key metrics must each clear a statistical significance threshold before the project could enter the writing phase. An automated audit gave its verdict—the mildest in the project’s history—and concluded that the best architecture had been found, that no further experiments were needed, and that the data passed all integrity checks. The project state was updated. The project entered the paper-writing phase. The audit was wrong. The metrics files for the supposedly winning architecture—over thirty of them—were empty shells. Every file contained placeholder values where real results should have been. Every table of routing results was filled with question marks. None of the six statistical gates had been met. We had also written four explicit research directions in an earlier version of the project state. None had been executed. The auditor had checked that the directories existed and that the file counts matched. It had not opened a single metrics file. We discovered the situation the following morning. The experiment had stopped. A manuscript had been drafted around results that did not exist. We extracted a snapshot of the repository at the moment of the failure and turned it into a diagnostic test. A single language model—comparable in capability to any individual agent in the factory—was given access to the same files, the same state, and the same audit report. It was told only: “You are taking over this research project. Decide the next step.” No hint that anything was wrong. No instruction to verify the data. The model read the audit report, opened the metrics files, compared the claimed results against the actual numbers, and immediately identified that the quantitative gates had not been met. It passed nearly every check on the benchmark designed around the failure. A single model, alone, with no more context than the state file and the result directory, imme- diately caught an error that four agents—scientist, coder, auditor, writer—operating in a designed loop with structured handoffs, had collectively missed. Our post-mortem identified five structural vulnerabilities. The audit verdict carried implicit approval authority it should not have had. Human directives could be silently overwritten when the project state file was updated, with no checkpoint or diff. The scientist’s stopping condition was circular: the audit says the work is done, so the scientist accepts that the work is done, so 34 neither of them checks whether the work was actually done. The coder produced empty outputs and marked them as complete without validating their contents. No role in the loop was responsible for verifying whether human instructions had been executed. The error, to be clear, was not hard to detect. It required no domain expertise, no creativity, no external knowledge. It required only that somebody—anybody—open the metrics files and compare the numbers against the stated gate. In a single-agent setting, that check happens because one entity is responsible for the entire chain. In a multi-agent setting, the check falls into the gap between roles. The scientist assumed the auditor had checked. The auditor assumed the gate was the reviewer’s job. The writer assumed the scientist had verified the results. Nobody checked. The observation that a single agent caught this error might seem to suggest a simple fix: collapse all roles back into one agent, eliminate the boundaries, and let a single entity own the full chain. This would indeed eliminate the responsibility gaps. It would also eliminate the benefits of specialization: the coder running parallel experiments across three server clusters while the scientist plans the next batch, the auditor’s fresh-context adversarial check on assumptions that the scientist has grown attached to, and the system’s ability to sustain 146 iterations of research without a human writing a single line of code. The single-agent baseline is not a stable alternative; it is a different point on a trade-off curve. The responsibility gap is the cost of multi-agent parallelism, and in this project the human scientist—not more agents, not fewer agents—was the mechanism that paid that cost. Whether a cheaper alternative exists is an empirical question: can a meta-auditor catch the empty metrics file? Can a procedural rule enforced in code replace the human at the gate? We report these episodes so the community can design and test such alternatives. As the proverb puts it, three monks have no water at all. The proverb is usually read as a warning about scale. We read it as a design constraint: if you are going to have three monks, you need someone who is not a monk. B Biology Case Study: Deployment Experience and Open Chal- lenges This appendix documentsAgon’s deployment in computational biology. Unlike the robotics case study (AppendixA), which completed the full lifecycle from topic to compiled paper, this project remainsin progressin the experiment factory at the time of writing. We report it not as a completed success but as a deployment snapshot. The project’s trajectory reveals domain-specific friction—literature paywalls, data-access barriers, and preprocessing pitfalls—that cannot be re- produced in AI-adjacent fields. The project began with a biologist’s question about sex differences in neurodegeneration. Agon’s idea factory generated a sex-aware benchmark for single-cell foundation models. Over 298 iterations, the system evaluated 22 models across 3 datasets, identified one material finding (a preprocessing confound that flips cross-dataset method rankings), and identified a hard con- straint: public expression data was underpowered for the original question. The project remains open because the data-access bottleneck that constrained the original plan also limits the current one. We document the trajectory below not as a success story but as a realistic boundary condition for autonomous research in domains where data access, not algorithmic diﬀiculty, is the primary gatekeeper. 35 DateEvent 2026-06-06We wrote a topic on sex differences, viral infection, and neurodegeneration — a four-way interaction with no existing systematic study. Proposal formulated: a sex-aware single-cell model benchmark. 2026-06-06Experiment factory begins. Route A: build a powered endpoint registry for sex/XCI classification using public data. 2026-06-15Route A fails.After systematic power analysis across public datasets, only one endpoint clears the minimum detectable effect gate. Public expression data is genuinely underpowered for sex/XCI endpoint gating. Route A downgraded to appendix. Route B activated: directly test single-cell foundation model gene embeddings for cross-tissue transfer. 2026-06-15Dual-route parallel exploration begins. 22 models evaluated across 3 datasets, 27 unique methods. 2026-06-16Preprocessing confound discovered.Raw vs z-score preprocessing flips cross- dataset ranking sign. scVI appears to collapse on a key dataset—later shown to be a preprocessing artifact, not a method failure. 2026-06-16Project continues.298 iterations, 35 versions, active. Core finding: cross- dataset method ranking is driven by preprocessing consistency, not method qual- ity. The data-access bottleneck that constrained Route A also limits Route B; project remains open. Table 11:Timeline of the single-cell benchmark project. B.1 How the Idea Was Born Unlike the robotics project, which began with a news article, this project began with a conversation. Our biology collaborators study sex differences in neurodegeneration—why women are more likely than men to develop Alzheimer’s, and what role viral infection plays in that gap. They have cell lines, viral proteins, transgenic mice, and behavioral assays. What they needed was a computational screen: which genes, differentially expressed between sexes, sit in antiviral immune pathways and are disrupted in neurodegenerative disease? The question is a four-way interaction—sex×gene× virus×neurodegeneration—that no study we found had systematically addressed. We wrote a topic with three dimensions: sex, virus, and neurodegeneration, with neurodegener- ation as the anchor and sex prioritized over virus. The idea factory generated a batch of benchmark proposals. We merged them into a single large project: a sex-aware benchmark for single-cell foun- dation models, evaluating whether models trained on millions of cells without sex labels nonetheless contained suﬀicient signal for sex-stratified analysis. B.2 What Biology Demands That AI Does Not Two challenges distinguish computational biology from AI research, and both shaped this project. The first is literature access. The arxiv-tool, originally built for arXiv’s open-access ecosystem, was suﬀicient for computer science. Biology and chemistry are different: many journals are pay- walled, many datasets require institutional access, and many papers are simply not indexed by the sources that cover CS. We expanded the arxiv-tool to include PubMed, Europe PMC, and addi- tional sources, and added a fallback mechanism—adownloadmefile—for papers that no automated pipeline could retrieve, guiding the human scientist to manually obtain and upload them. The second, and far more severe, is data access. Public biological datasets are not download- able with a single command. Some require human approval through web portals. Some require 36 MetricValue Total scientist–coder–auditor itera- tions 298 Total versions35 Total audit files produced12 Lines of experiment log2,093 Datasets evaluated3 (brain disease, brain disease, immune control) Single-cell foundation models evalu- ated 22, spanning multiple pretraining corpora and architectures Per-dataset baseline methods7 (including variational autoencoder, PCA, and heuristic baselines) GPU-equivalent cost$71 Human interventions that changed ex- perimental direction ≥5 Table 12:The single-cell benchmark project by the numbers. lengthy institutional review. Some—the most frustrating—are technically public but can only be analyzed inside proprietary software on specific machines, with only summary results exportable. This fundamentally constrains what an autonomous research system can do in biology: the set of answerable questions is the set of questions for which data can be obtained. We pushed the idea factory to repeatedly verify resource availability—to actually attempt downloads, to distinguish datasets that genuinely exist from those that are merely cited, and to downgrade ideas whose data proved inaccessible. An idea that looked novel on paper would collapse in scoring once we demonstrated that its data could not be retrieved. B.3 Route A, Route B The original plan—Route A—was to build a powered endpoint registry: assemble public expression datasets, compute the minimum detectable effect size for sex and X-chromosome classification on each, and only evaluate models on endpoints that passed the power gate. After systematic auditing across dozens of candidate datasets, only a single endpoint cleared the gate. Public expression data was genuinely underpowered for the question we had asked. We pivoted. Route B asked a more directly answerable question: can single-cell foundation models, trained on immune cells, produce gene embeddings that transfer to brain disease clas- sification in unrelated donors? This was a direct test of the core claim behind every foundation model—that pretraining produces generalizable representations—and it had the advantage of using data we could actually obtain. B.4 The Experiment The experiment factory ran for 298 iterations across 35 versions (and counting—the project stood at version 38 at the time of writing). two operational failures revealed domain-specific blind spots that the system could not detect on its own. The first finding was a preprocessing confound. The system had been comparing methods across datasets without matching how the input data was normalized—raw counts on one dataset, z-score normalization on another. When we matched the preprocessing, the ranking of which methods performed best flipped direction: methods that had looked strong under one normalization looked weak under the other, and a method that had appeared to completely fail recovered to become 37 one of the strongest performers once the preprocessing was aligned. A formal literature search confirmed that no prior study had documented this specific confound in this domain. The system had designed the sensitivity analysis that caught it, but it took a human to recognize that the confound was the story. The second finding was a statistical trap. The power calculations that determined whether a dataset was large enough to support a claim used a formula whose constant had no derivation. When we checked the formula against the statistical literature, the constant turned out to be wrong—substantially too small, making every dataset appear adequately powered when none of them were. Correcting the formula collapsed the original experimental plan and forced the pivot from Route A to Route B. The system had accepted the formula as given; we caught it because we checked. Three operational failures are worth recording because the system could not diagnose them on its own. The first: whenever the coder needed to analyze results, it defaulted to running scripts on the shared development machine’s CPU rather than dispatching jobs to a compute server. A single analysis could saturate the machine’s processors and memory, causing SSH connections to drop—not just for our session, but for every user on the machine. This happened repeatedly, across multiple rounds, despite explicit instructions to use compute servers. We ultimately enforced a hard prohibition: no CPU computation on the development machine. The second: two variants of the same model, downloaded from different sources with different file sizes, produced gene embeddings that were byte-for-byte identical. The system had been treating them as independent data points in every ranking. We caught this by writing a script that compared every pair of embedding matrices—a check the system had no built-in mechanism to perform. Our panel of methods was silently one smaller than we thought. The third: the factory would sometimes stop and declare that it was waiting for a human decision before it could proceed—when in fact no decision was needed. The scientist had all the information required to continue, but the system had learned that deferring to the human was the safe move. An entire night of compute time was lost to this pattern more than once. These failures share a common structure: the system performed competently within the bound- aries of its assigned task, and the error lay in what fell outside those boundaries. A script run on the wrong machine is still a correct script. A duplicate model is still a valid model file. A request for human input is still a reasonable caution. What this deployment establishes is limited but real:Agonentered a domain for which it was not originally designed, absorbed an unfamiliar data pipeline without custom engineering, and reached a substantive finding under conditions where the primary bottleneck was not algorithmic diﬀiculty but data access. It did not complete the full lifecycle, and we do not claim it did. But the same codeless architecture that worked for robotics worked here, with no change to the core orchestrator—only the input files changed. That is the cross-domain claim in operational form. 38 References Hui Chen, Miao Xiong, Yujie Lu, Wei Han, Ailin Deng, Yufei He, Jiaying Wu, Yibo Li, Yue Liu, and Bryan Hooi. Mlr-bench: Evaluating ai agents on open-ended machine learning research. In Proceedings of the Thirty-Ninth Conference on Neural Information Processing Systems (NeurIPS 2025), Datasets and Benchmarks Track, 2025. URLhttps://arxiv.org/abs/2505.19955. Ruiying Chen. Evidence-bound autonomous research (evibound): A governance framework for eliminating false claims, 2025. URLhttps://arxiv.org/abs/2511.05524. Sy-Tuyen Ho, Minghui Liu, Huy Nghiem, and Furong Huang. Soundnessbench: Can your ai scientist really tell good research ideas from bad ones?, 2026. URL https://arxiv.org/abs/2605.30329. Xu Huang, Junwu Chen, Yuxing Fei, Zhuohan Li, Philippe Schwaller, and Gerbrand Ceder. Cas- cade: Cumulative agentic skill creation through autonomous development and evolution, 2025. URLhttps://arxiv.org/abs/2512.23880. Fengqing Jiang, Yichen Feng, Yuetai Li, Luyao Niu, Basel Alomair, and Radha Poovendran. Bad- scientist: Can a research agent write convincing but unsound papers that fool llm reviewers? In Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (ACL 2026), 2026. URLhttps://arxiv.org/abs/2510.18003. Priyanka Kargupta, Ishika Agarwal, Tal August, and Jiawei Han. Tree-of-debate: Multi-persona debate trees elicit critical thinking for scientific comparative analysis. InProceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (ACL 2025), 2025. URL https://arxiv.org/abs/2502.14767. Jiaqi Liu, Shi Qiu, Mairui Li, Bingzhou Li, Haonian Ji, Siwei Han, Xinyu Ye, Peng Xia, Zihan Dong, Meng Chen, Congyu Zhang, Letian Zhang, Guiming Chen, Haoqin Tu, Xinyu Yang, Lu Feng, Xujiang Zhao, Haifeng Chen, Jiawei Zhou, Xiao Wang, Weitong Zhang, Hongtu Zhu, Yun Li, Jieru Mei, Hongliang Fei, Jiaheng Zhang, Linjie Li, Linjun Zhang, Yuyin Zhou, Sheng Wang, Caiming Xiong, James Zou, Zeyu Zheng, Cihang Xie, Mingyu Ding, and Huaxiu Yao. Autoresearchclaw: Self-reinforcing autonomous research with human-ai collaboration, 2026. URL https://arxiv.org/abs/2605.20025. Chris Lu, Cong Lu, Robert Tjarko Lange, Jakob Foerster, Jeff Clune, and David Ha. The ai scientist: Towards fully automated open-ended scientific discovery, 2024. URL https://arxiv. org/abs/2408.06292. Rui Meng, Bhavana Dalvi Mishra, Jiefeng Chen, Chun-Liang Li, Palash Goyal, Mihir Parmar, Yiwen Song, Yale Song, Rajarishi Sinha, Parthasarathy Ranganathan, Burak Gokturk, Jinsung Yoon, and Tomas Pfister. Scientistone: Towards human-level autonomous research via chain-of- evidence, 2026. URL https://arxiv.org/abs/2605.26340. Alexander Novikov, Ngân Vũ, Marvin Eisenberger, Emilien Dupont, Po-Sen Huang, Adam Zsolt Wagner, Sergey Shirobokov, Borislav Kozlovskii, Francisco J. R. Ruiz, Abbas Mehrabian, M. Pawan Kumar, Abigail See, Swarat Chaudhuri, George Holland, Alex Davies, Sebastian Nowozin, Pushmeet Kohli, and Matej Balog. Alphaevolve: A coding agent for scientific and algorithmic discovery, 2025. URL https://arxiv.org/abs/2506.13131. 39 Razeen A Rasheed, Somnath Banerjee, Animesh Mukherjee, and Rima Hazra. From fluent to verifiable: Claim-level auditability for deep research agents, 2026. URLhttps://arxiv.org/ abs/2602.13855. Xingyu Ren, Youran Sun, Chugang Yi, Kejia Zhang, Jiaxuan Guo, Jianda Du, and Haizhao Yang. What’s missing in autonomous research? a systematization of systems, benchmarks, and verifica- tion, 2026. URLhttps://w.researchgate.net/publication/406952713. Preprint available on ResearchGate. Samuel Schmidgall, Yusheng Su, Ze Wang, Ximeng Sun, Jialian Wu, Xiaodong Yu, Jiang Liu, Michael Moor, Zicheng Liu, and Emad Barsoum. Agent laboratory: Using llm agents as research assistants, 2025. URLhttps://arxiv.org/abs/2501.04227. Guijin Son, Jiwoo Hong, Honglu Fan, Heejeong Nam, Hyunwoo Ko, Seungwon Lim, Jinyeop Song, Jinha Choi, Gonçalo Paulo, Youngjae Yu, and Stella Biderman. When ai co-scientists fail: Spot- a benchmark for automated verification of scientific research, 2025. URLhttps://arxiv.org/ abs/2505.11855 . Giulio Starace, Oliver Jaffe, Dane Sherburn, James Aung, Jun Shern Chan, Leon Maksin, Rachel Dias, Evan Mays, Benjamin Kinsella, Wyatt Thompson, Johannes Heidecke, Amelia Glaese, and Tejal Patwardhan. Paperbench: Evaluating ai’s ability to replicate ai research, 2025. URL https://arxiv.org/abs/2504.01848. Youran Sun, Xingyu Ren, Kejia Zhang, Xinpeng Liu, and Jiaxuan Guo. Perspectivegap: A benchmark for multi-agent orchestration prompting, 2026. URL https://arxiv.org/abs/2606. 08878. Jiabin Tang, Lianghao Xia, Zhonghang Li, and Chao Huang. Ai-researcher: Autonomous scientific innovation, 2025. URLhttps://arxiv.org/abs/2505.18705. Nitya Thakkar, Mert Yuksekgonul, Jake Silberg, Animesh Garg, Nanyun Peng, Fei Sha, Rose Yu, Carl Vondrick, and James Zou. Can llm feedback enhance review quality? a randomized study of 20k reviews at iclr 2025, 2025. URL https://arxiv.org/abs/2504.09737. Chengcheng Wang, Qinhua Xie, Wei He, Jianyuan Guo, Shiqi Wang, and Chang Xu. Sibyl- autoresearch: Autonomous research needs self-evolving trial-and-error harnesses, not paper gen- erators, 2026a. URLhttps://arxiv.org/abs/2605.22343. Yuanli Wang, Yaoyao Qian, Yue Zhang, Hanhan Zhou, Jindan Huang, Tianfu Fu, Qiuyang Mang, Huanzhi Mao, Wenhao Chai, Wendong Fan, and Liqiang Jing. Deploybench: Benchmarking llm agents for research artifact deployment, 2026b. URL https://arxiv.org/abs/2606.05238. Yixuan Weng, Minjun Zhu, Guangsheng Bao, Hongbo Zhang, Jindong Wang, Yue Zhang, and Linyi Yang. Cycleresearcher: Improving automated research via automated review. InThe Thirteenth International Conference on Learning Representations (ICLR 2025), 2025. URL https://arxiv.org/abs/2411.00816. Yutaro Yamada, Robert Tjarko Lange, Cong Lu, Shengran Hu, Chris Lu, Jakob Foerster, Jeff Clune, and David Ha. The ai scientist-v2: Workshop-level automated scientific discovery via agentic tree search, 2025. URL https://arxiv.org/abs/2504.08066. Ruofeng Yang, Yongcan Li, and Shuai Li. Aris: Autonomous research via adversarial multi-agent collaboration, 2026. URLhttps://arxiv.org/abs/2605.03042. 40 Jiakang Yuan, Xiangchao Yan, Shiyang Feng, Bo Zhang, Tao Chen, Botian Shi, Wanli Ouyang, Yu Qiao, Lei Bai, and Bowen Zhou. Dolphin: Moving towards closed-loop auto-research through thinking, practice, and feedback, 2025. URLhttps://arxiv.org/abs/2501.03916. Bo Zhang, Shiyang Feng, Xiangchao Yan, Jiakang Yuan, Runmin Ma, Yusong Hu, Zhiyin Yu, Xiaohan He, Songtao Huang, Shaowei Hou, Zheng Nie, Zhilong Wang, Jinyao Liu, Tianshuo Peng, Peng Ye, Dongzhan Zhou, Shufei Zhang, Xiaosong Wang, Yilan Zhang, Meng Li, Zhongying Tu, Xiangyu Yue, Wangli Ouyang, Bowen Zhou, and Lei Bai. Internagent: When agent becomes the scientist – building closed-loop system from hypothesis to verification, 2025. URLhttps: //arxiv.org/abs/2505.16938. Jiazheng Zhang, Ziche Fu, Zhiheng Xi, Wenqing Jing, Mingxu Chai, Wei He, Guoqiang Zhang, Chenghao Fan, Chenxin An, Wenxiang Chen, Zhicheng Liu, Haojie Pan, Dingwei Zhu, Tao Gui, Qi Zhang, and Xuanjing Huang. Agentv-rl: Scaling reward modeling with agentic verifier. In Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (ACL 2026), 2026. URL https://arxiv.org/abs/2604.16004. Bing Zhou, Xiao Huang, Huan Ning, Qiusheng Wu, Diya Li, and Ziyi Zhang. Nora: A harness- engineered autonomous research agent for end-to-end spatial data science, 2026. URLhttps: //arxiv.org/abs/2605.02092. Xinyu Zhu, Yuzhu Cai, Zexi Liu, Bingyang Zheng, Cheng Wang, Rui Ye, Yuzhi Zhang, Linfeng Zhang, Weinan E, Siheng Chen, and Yanfeng Wang. Toward ultra-long-horizon agentic science: Cognitive accumulation for machine learning engineering, 2026. URL https://arxiv.org/abs/ 2601.10402. 41

Instant research discovery