The pitch, in one sentence

Give ScientistTwo a peer-reviewed paper from ICLR, ICML, or NeurIPS, and it will independently figure out what's weak about the method, invent a better one, code it, ablate it, write the manuscript, run a simulated peer-review cycle against it, revise the idea in response, and hand you back a paper that—under automated reviewers—scores higher than the average accepted paper at the venue it came from. That isn't a roadmap; it's what the system did on 86 of 107 problems in the published evaluation, with a 25.2% average relative improvement over the human state-of-the-art baseline it was given.

For context, that's a sharper claim than "an LLM wrote a paper." We've had end-to-end research agents since Sakana AI's AI Scientist (Lu et al., 2024) and its v2 successor, and there's a growing list of competitors—AI-Researcher, CycleResearcher, AutoResearchClaw, Zochi, DeepScientist, ScientistOne, AutoSOTA. What's new here is the combination of active analytical expansion (running multi-dataset ablations to attribute the gain, not just produce one), a closed-loop peer-review engine that actually codes rebuttal experiments, and a results bar that clears the acceptance thresholds of top-tier venues under held-out automated reviewers. Whether that bar is the right bar is a separate question—and we'll get to it—but it's the first time an autonomous agent has cleared it at scale.

Why this is harder than it looks

Most "AI research assistant" work to date optimizes a single scalar metric on a single benchmark. That's a fine demo, but it's not what scientists do. A real researcher operates under at least four constraints that prior agents violated routinely:

1. Closed-loop empirical rigor. You don't just run an experiment once; you isolate mechanisms with ablations, you remove the part that doesn't carry its weight, and you re-run. Existing agents either skipped ablations or ran them as decoration.
2. Multi-dimensional evaluation. A method that wins on one metric but loses on five others isn't an advance—it's a trade-off you didn't disclose. Single-metric agents are structurally blind to this.
3. Peer-review survivability. A paper isn't done when the experiments finish; it's done when hostile reviewers can't kill it. No prior agent simulated that loop with teeth.
4. Verifiability. The numbers in the paper have to match the code, the code has to actually run, the references can't be hallucinated, and the prose has to describe what the code does. This is where most generated manuscripts fall apart on close inspection.

ScientistTwo's contribution is a multi-agent architecture engineered around exactly these four gaps. The headline numbers—80.4% problem-success rate, 91.9% ScholarPeer acceptance, 72.1% Stanford Agentic Reviewer acceptance—are downstream of the architecture, not the architecture itself.

How the pipeline actually works

The system is best understood as six stages, each with its own generator agent, its own critic agent, and a refine loop with a hard ceiling on iterations. The Python-style pseudocode in the paper is illuminating because it's almost boring: every stage is the same stage(candidate, critic, refine, max_rounds) shape. The cleverness is in what each critic checks, not in exotic orchestration.

Stage 1 — Generating seed ideas by attacking limitations

A Limitation Extractor reads the input paper and produces a list of weaknesses. A Limitation Verifier then asks the meta-question: "Is this list actually sufficient to guide a novel improvement?" If not, the extractor goes back for more. This continues—up to 16 rounds—until the verifier is satisfied that the limitations are actionable, not just descriptive. Only then does an Idea Generator propose hypotheses specifically engineered to address them, with a Novelty Checker scoring each (and forcing re-generation until novelty clears a threshold). Ideas are sorted by novelty score, so the most original candidate is tried first.

This ordering matters. It's the difference between "what tweak would move the metric?" and "what would actually fix the thing this paper does poorly?" The latter is the question a human reviewer asks, and it's why ScientistTwo's accepted solutions tend to introduce new algorithmic components rather than re-tune existing ones (more on this in the AutoSOTA comparison below).

Stage 2 — Evaluating ideas, subset first

Each candidate idea is implemented by a Subset Coding Agent that modifies a reproduced baseline codebase, then judged by a Subset Critic. The critic emits one of three verdicts: Bad (discard), Good (scale up to the full benchmark), or Engineer (the idea has potential but needs hyperparameter or code fixes—loop with a Subset Engineering Agent, max 2 rounds). Only ideas that survive the subset pass get scaled to the full benchmark, where a Full-Set Critic and Full-Set Engineer repeat the loop. The whole thing is wrapped in a unified ACoder interface so downstream stages can re-invoke it cleanly.

The "subset-first" trick is the kind of detail that looks obvious in hindsight but matters enormously for cost. Running every idea on every dataset up front would burn the budget before the system got to its second hypothesis; screening on a representative slice first means most bad ideas die cheaply.

Stage 3 — Refining ideas using execution traces

Failed ideas aren't wasted. An Idea Evolver reads the execution traces—both successful results and diagnostic failure logs—and proposes evolved hypotheses. To avoid getting stuck in a local optimum around early seeds, ScientistTwo mixes evolved ideas with previously-unevaluated seed ideas drawn in novelty order (exploration vs. exploitation). The loop terminates when S successful ideas are collected or K rounds are exhausted, and a Selector Agent picks the best one for downstream ablation.

The ablation in Figure 9(b) of the paper shows something useful: most of the eventual winners are identified in the early stages, meaning the seed ideas themselves are already strong. The Idea Evolver's job is less "find the winner from scratch" and more "rescue the cases where the seed was close but failed for a fixable reason."

Stage 4 — Ablation-driven hypothesis refinement

This is the stage that distinguishes ScientistTwo from metric-chasers. An Ablation Planner generates a set of executable ablation plans—each removes or isolates one component of the proposed method. An Ablation Coder runs them. An Ablation Critic then asks: "Is the component breakdown clean? Does every part of the method actually carry its weight?" If the answer is "Refine," the system goes back and re-engineers the hypothesis, re-runs the full benchmark, and verifies that the new version strictly outperforms the old one before updating. If the ablation reveals that the gain was actually coming from a generic training trick (EMA, label smoothing) rather than the proposed mechanism, the contribution is rejected—even if the metric moved.

This is the audit that caught ScientistTwo's own DMC-TeCh variant on the TeCh paper: the system beat the baseline on 5 of 6 metrics, but the ablation critic traced the gain to EMA + label smoothing rather than the multi-core architectural innovation, so it was discarded. AutoSOTA reported the same configuration as a +4.45% win. Same lever, opposite verdicts—because the acceptance policies differ.

Stage 5 — Manuscript drafting with a real review-rebuttal loop

An Initial Drafter (incorporating PaperOrchestra) writes the full conference-formatted manuscript. Then a Peer-Reviewer Agent—specifically ScholarPeer, a multi-agent reviewer system—scores it 1–10 on the ICLR scale and produces structured strengths/weaknesses/questions. If the score is below 8, a Rebuttal Planner reads the review and designs supplementary experiments to address each weakness; a Rebuttal Coder actually implements and runs them; a Paper Enhancer folds the new results back into the manuscript. The cycle repeats until the score clears 8 or the round budget (default 2) is exhausted.

The non-trivial finding in Table 5 is that this loop generalizes across reviewers. The Rebuttal Agent is trained to satisfy ScholarPeer, but running it also raised acceptance rates under the held-out Stanford Agentic Reviewer—a system ScientistTwo never saw during development. That's evidence the loop is fixing real weaknesses, not overfitting to one reviewer's quirks.

Stage 6 — Meta-review and review-driven idea refinement

Finally, a Meta-Review Agent looks at the revised manuscript and the review together and makes a top-tier-venue decision: Accept or Refine. "Refine" here is deep—it means the meta-reviewer found an algorithmic or empirical weakness that requires going back and changing the underlying idea, not just the prose. ScientistTwo then re-engages the Full-Set Engineering Agent, produces a new hypothesis, verifies it strictly beats the previous best, and if so, re-runs ablations, re-drafts, and re-reviews. The case study on machine unlearning (Table 6) shows this working in practice: the pre-refinement method LFR-Engram already beat the human baseline Engram, but the meta-reviewer deemed it insufficient; refinement produced FCD-Engram, which beat LFR-Engram across the board.

The integrity audit — why the results are believable

This is the part that separates ScientistTwo's evaluation from "trust me, the LLM wrote a good paper." The team applied the CoE (Chain-of-Evidence) Integrity Audit from ScientistOne (Meng et al., 2026), which checks four things:

• Score Verification (↑): Re-run the codebase from scratch. Do the reported numbers reproduce? ScientistTwo: 49/49.
• Specification Violations (↓): Does the solution code break task rules or reward-hack? ScientistTwo: 0/49. (Without the spec-compliance refinement agent, this was 1/50—i.e., one solution had to be filtered for reward hacking.)
• Reference Verification (↓): Are any citations hallucinated? ScientistTwo: 0/1814. (Without the reference-verification agent: 19/1840 hallucinated citations.)
• Method-Code Alignment (↑): Does the paper's methodology section actually describe what the code does? ScientistTwo: 49/49. (Without the alignment agent: 38/49.)

The ablation in Table 7 is the convincing part: turn off any one of the three refinement agents and the corresponding audit starts failing. The system isn't accidentally clean; it's clean because specific agents are doing specific verification work.

The way this is enforced is also worth noting. The Coding Agent is prompted during experimentation to emit self-contained, reproducible scripts. A validation filter uses the Coding Agent itself to detect and discard rule-violating solutions immediately after experimentation. A search-augmented LLM hunts hallucinated citations, and the Writer Agent grounds the bibliography using live search. Finally, the Coding Agent audits the repository against the manuscript and produces a report the Writer Agent uses to fix the method section. None of this is exotic ML; it's disciplined engineering layered on top of capable base models.

The numbers, in context

Against other autonomous research agents

Table 2 of the paper is the cleanest head-to-head. Across publicly released papers from each framework:

The previous best (ScientistOne) scored 3.8 with a 14.3% ScholarPeer acceptance and 0% Stanford acceptance. ScientistTwo nearly doubles the ScholarPeer score and is the only agent with non-zero Stanford Agentic Reviewer acceptance. The Stanford reviewer matters here because it's held-out—neither ScientistTwo nor the baselines were tuned against it.

Against human papers at top venues

Table 3 is the more provocative comparison. ScientistTwo was given accepted papers from NeurIPS 2025, ICLR 2026, and ICML 2026 Spotlights as inputs, then asked to improve them. The resulting AI-authored papers were scored by the same automated reviewers:

For reference, the human-authored accepted papers scored 6.8 (ScholarPeer) / 5.2 (Stanford) at ICLR 2026 and 6.2 / 5.5 at NeurIPS 2025. ScientistTwo's AI-authored papers beat the average accepted human paper under both reviewers at both venues. ICML 2026 Spotlight papers still edge out ScientistTwo (6.9 vs. 7.6 ScholarPeer actually favors ScientistTwo, but 6.1 vs. 5.7 Stanford favors the humans), which the authors acknowledge: the system hasn't reached spotlight/oral caliber yet.

The human-reviewer reality check

Automated reviewers are convenient but suspicious. The team recruited 9 experienced human reviewers to evaluate 33 ScientistTwo-generated papers on a 1–5 Likert scale across six dimensions, both standalone and in pairwise comparison against the human papers (Table 10):

Read this carefully. On overall scientific maturity, human reviewers rated ScientistTwo at parity with human-authored papers. ScientistTwo won on experimental execution across the board (broader benchmarks, better ablations, sharper limitation analysis) and on the introduction. Humans still won on methodological rigor—which lines up exactly with the paper's own stated limitation: "ScientistTwo does not yet consistently achieve the caliber of spotlight or oral presentations that introduce paradigm-shifting conceptual breakthroughs." It's a frontier pusher, not a paradigm shifter.

Three case studies that show what the system actually produces

Case 1: VD-STrans — speeding up BPE tokenization by 12.3%

The headline case study takes Jiang & Gong's "Incremental BPE Tokenization" (ICML 2026) as input. Byte Pair Encoding is the workhorse tokenizer behind virtually every modern LLM—Llama, Qwen, DeepSeek, GPT, Mistral all use it. Jiang & Gong had already replaced the O(n log n) priority-heap approach with a Centroid Search Tree traversal achieving O(log² t) per-byte time. ScientistTwo's generated solution, VD-STrans, observes that over 99.1–99.8% of the Suffix-Successor Trees in real LLM vocabularies have ≤8 nodes—so they fit in a single 256-bit AVX2 SIMD register. It flattens the trees into "Compact Flat Decision Vectors," replaces pointer-chasing tree traversal with branchless SIMD range comparison, and adds an atomic fast-path bypass for single-byte tokens. Deep trees (>8 nodes, <1% of vocab) fall back to the original CST.

The result: a 1.123× geometric mean speedup over the state-of-the-art incremental algorithm (peak 1.271×) and up to 23.64× over standard heap-based BPE, across 12 tokenizers and 3 text domains (English, Chinese, code), with 100% byte-identical tokenization fidelity. Under ICLR peer-review procedures, this AI-authored paper received an 8.0 from ScholarPeer and 6.5 from the Stanford Agentic Reviewer—i.e., it was accepted. A 10.9% relative improvement over the human SOTA, on a problem most people would have considered "solved" by the prior algorithm.

Case 2: Iterative frontier expansion — the system beats its own SOTA

This is the most striking result in the paper. If you take VD-STrans (ScientistTwo's first discovery) and feed it back as context for a second run, the system invents BXT-Transducer, which adds another 9.6% relative improvement. Feed BXT back, and it produces SBR-Transducer, another 8.2% on top. Three iterations, compounding gains, ~28% total improvement over the original human baseline. This is the property you'd want from a true discovery engine: it doesn't just clear the bar once, it raises its own bar.

Case 3: DynaSpec-RAG — fixing retrieval-augmented time-series forecasting

TS-RAG (NeurIPS 2025) augments frozen time-series foundation models like Chronos-Bolt with retrieved historical analogues. The problem: it treats retrieved target horizons as monolithic vectors, causing (a) trend/seasonal interference, (b) step-discontinuities at the context-forecast boundary, and (c) negative transfer when retrieved data is noisy. ScientistTwo's DynaSpec-RAG fixes all three with: a single-step differentiable context-boundary continuation operator (eliminates the step-discontinuity), real-FFT sub-band decomposition (separates trend from seasonal so they can be trusted independently), a content-adaptive per-sample/per-band/per-timestep gating network (decides when to trust retrieval), and a validation-calibrated dual-metric safety guard with a hard zero-fallback (strictly no negative transfer).

The result: average MSE drops from 0.1940 (TS-RAG) to 0.1892 across seven benchmarks, with only 0.27M trainable parameters (~0.1% of the 200M+ frozen backbone). It beats RAF and RAEF (two other retrieval-augmented baselines) by ~5%, and—critically—it transfers zero-shot to five held-out GIFT-Eval datasets with a 5.6% average MSE improvement and no retraining. The safety scale λ automatically rises to 0.975 on strongly periodic solar data and shrinks toward 0 on low-affinity Web/CloudOps series. That's the do-no-harm guarantee working as intended.

Case 4: Procrustes-DS — and the value of the ablation critic

ScientistTwo designed Procrustes-DS to beat X-Mahalanobis (NeurIPS 2025) on out-of-distribution detection. The ablation report is the interesting artifact: it reveals that several of the theoretically-motivated components didn't actually help. HSKP layer weighting collapsed to near-uniform because HSKP values across transformer layers were nearly identical. Procrustes alignment gave +0.01% AUROC. The Dempster-Shafer evidential fusion reduced to a linear sum in logit space. The system's own ablation critic caught these and stripped them out, leaving a cleaner final method that actually worked. This is the closed-loop empirical rigor the paper claims as its differentiator, in action.

ScientistTwo vs. AutoSOTA — the philosophical split

The Appendix B comparison with AutoSOTA (Li et al., 2026d) is worth reading in full because it crystallizes a real disagreement about what "automated research" should mean. AutoSOTA is a metric-driven optimizer: give it a paper and it distills the headline result into a single numerical target, then proposes config-level edits until that target clears. ScientistTwo has no target metric; it diagnoses limitations, proposes new mechanisms, and requires the gain to be attributable to the proposed mechanism in ablation.

On the five ICLR 2026 papers both systems ran on:

• Pinet (hard-constrained NNs): AutoSOTA deletes solver iterations and turns off float64 to drop latency 16.7%—but the constraint-violation work it deleted isn't in the registered metric, so feasibility goes unreported. ScientistTwo introduces an amortized Stiefel-nullspace reparameterization that makes equality constraints exact by construction; feasibility goes from 4e-4 to 2e-14 on all four DC3 sets, with 3× faster training.
• DMSQD (quality diversity optimization): AutoSOTA raises the emitter count from 15 to 20—a pure compute-scaling knob—buying +7.3% QD score at +33% evaluations per iteration (unreported). ScientistTwo keeps the budget fixed and adds a dimension-adaptive contact-form smoothness penalty to the discount MLP, beating DMS in high dimensions (+422 QD averaged) and reproducing bit-exact.
• T-SAE (temporal sparse autoencoders): AutoSOTA's winning edit changes act_threshold_frac from 0.01 to 0.05—i.e., it alters how activations are displayed to the LLM judge, leaving the SAE untouched. The reported re-evaluation returns 0.7557, below the 0.7586 baseline. ScientistTwo introduces a boundary-gated sheaf Dirichlet energy + causal Koopman operator, winning Semantics and Context probes on 3/3 suites for two models at matched FVE.
• TeCh (medical time series): Both systems found the same lever (wider backbone + label smoothing). AutoSOTA reports +4.45%. ScientistTwo's ablation critic traced the gain to EMA + label smoothing rather than the proposed multi-core mechanism, and rejected it as a contribution.

The paper's framing is fair: the two systems are complementary stages. ScientistTwo produces a method; AutoSOTA can then tune its deployment constants. But the contrast exposes the danger of pure metric-driven research: it can optimize the evaluator (T-SAE), delete unmeasured trade-offs (Pinet), or report capacity-tuning as an algorithmic contribution (TeCh). The ablation-critic-based attribution policy is what blocks those failure modes structurally rather than via prompt-level prohibitions.

Cost, generalizability, and the boring practical details

On the 33 NeurIPS 2025-derived problems, ScientistTwo averages 2–3 days end-to-end per task and ~$3,765 in cost (token usage + VM). The cost is concentrated in Idea Refinement, Dynamic Peer-Review, and Meta-Review—exactly the iterative experimentation phases you'd expect to dominate. The default configuration uses Gemini 3.6 Flash for most agents and Claude Code with Opus 4.8 for the Idea Experiment Coding Agent, Ablation Study Agent, Rebuttal Agent, and Draft Enhancer. The system also generalizes across coding backends: replacing Claude Code with Antigravity (Gemini 3.8 Flash) on 5 ICLR 2026 tasks still produced state-of-the-art methods with 80% / 60% success rates respectively and full reproducibility.

The defaults are sensible and explicitly bounded: 16 rounds of limitation extraction, 2 candidates per experimentation round, 4 rounds max for idea refinement (early-stop at 4 successes), 2 rounds of engineering refinement, 1 round of ablation refinement, 2 rounds of peer-review (early-stop at ScholarPeer score ≥8), and 1 round of review-driven refinement. These caps matter because they're what make the per-task cost bounded and predictable.

Limitations the authors are honest about

The paper's Limitations section is short but pointed:

1. Not spotlight-grade. ScientistTwo clears standard acceptance thresholds but doesn't yet produce paradigm-shifting conceptual breakthroughs. The human reviewers' 2.9 score on methodological rigor (favoring humans) is the same finding in different words. Future work targets "fundamentally new theoretical formulations" rather than local algorithmic refinements.
2. Cost. ~$3,800 per task is fine for an industrial research lab but prohibitive for most academic groups or independent researchers. The authors flag replacing proprietary models with open-source ones as an interesting direction.
3. Automated reviewer dependency. The 91.9% ScholarPeer acceptance is partly in-distribution (ScholarPeer is used in the training loop). The 72.1% Stanford Agentic Reviewer acceptance is the held-out number and is the more credible benchmark—but it's still an automated reviewer, with all the limitations that implies. The human evaluation is the strongest evidence, and there ScientistTwo is at parity, not ahead.

There's a fourth limitation the paper doesn't dwell on but is worth naming: the benchmark is machine learning research. ML is unusually friendly to autonomous agents—fast experiments, clear metrics, mature codebases, abundant literature. Whether ScientistTwo's pipeline transfers to fields with slower experimental loops (wet-lab biology, materials science, clinical trials) or weaker public-codebase coverage (much of social science, humanities-adjacent work) is an open question. The architecture is general, but the empirical claim is ML-specific.

What this means for how research gets done

Three implications seem durable regardless of how much further the system improves:

1. The unit of research productivity is shifting from "person-months" to "agent-runs." A 2–3 day turnaround at $3,765 per task means a single research engineer can run dozens of parallel hypothesis explorations in the time it would take a PhD student to do one. The bottleneck moves from "running experiments" to "deciding which experiments are worth running and interpreting the ones that come back."

2. Ablation attribution is becoming a publication gate, not a courtesy. The TeCh case—where the same configuration is a +4.45% win under one acceptance policy and a rejected contribution under another—foreshadows a future where reviewers (automated or human) demand component-level attribution of gains. Methods that survive that scrutiny will be structurally cleaner; methods that don't will be filtered out before submission. Expect this to raise the average quality of accepted work and to disadvantage labs that haven't adopted ablation-first workflows.

3. Iterative frontier expansion changes what "state-of-the-art" means. When a system can take its own SOTA solution as input and produce a better one in three days, the SOTA becomes a moving target that humans can't easily track. The compounding 10.9% → +9.6% → +8.2% sequence on BPE tokenization is one example; expect this pattern to repeat wherever the evaluation loop is fast enough. Research communities will need to decide whether to incorporate AI-discovered methods into the human-citation graph on equal footing, treat them as a separate category, or institute verification standards specific to AI-generated work.

Bottom line: if you wanted to act on this today, what can you do

The paper isn't open-source and there's no public release announced, so "act on this today" means preparing for the world it implies, not deploying ScientistTwo yourself. Concretely:

1. Read the paper and the case studies at arxiv.org/pdf/2609.19644 and the project site at scientist-two.github.io. The VD-STrans and DynaSpec-RAG case studies are the most actionable—they're complete, verified, reproducible methods you can adopt directly in your own pipelines even without the agent that produced them.
2. Audit your own work against the CoE integrity bar. The four checks—score reproducibility, specification compliance, reference verification, method-code alignment—are cheap to run on any paper you're about to submit. If your own work can't pass them, neither will an automated reviewer, and you'll find out at submission time instead of now.
3. Adopt ablation-first workflow in your own research regardless of whether you use agents. The single highest-leverage habit the paper models is: before claiming a gain, run the ablation that asks whether the gain comes from the proposed mechanism or from incidental training controls. If your method can't survive that ablation, rethink it before submission.
4. Try the available open-source autonomous research agents if you want hands-on experience. Sakana AI's AI Scientist and AI Scientist-v2 are public on GitHub, OpenHands and AIDE are public, and ScholarPeer-style reviewers are increasingly available. You won't get ScientistTwo's headline numbers, but you'll learn the failure modes first-hand—hallucinated references, non-reproducible code, ablations that don't isolate the mechanism—and you'll be better positioned to evaluate claims from systems that do clear the bar.
5. Track the iterative frontier expansion pattern in any subfield you care about. If you see a sequence of "AI-discovered method A → AI-discovered method B that beats A → AI-discovered method C that beats B" appearing in preprints, that's the signal that autonomous discovery has arrived in your area. The BPE tokenization sequence in Table 9 of the paper is the canonical example.
6. If you're at a lab that can afford it, budget for agent-based exploration as a line item alongside compute and headcount. At ~$3,800 per task with 80% success, the expected cost per accepted-paper-quality output is ~$4,750—less than a single conference travel budget. The economics already work for industrial research groups; the open-source-model substitution the authors flag as future work would put it within reach of academic labs.
7. Pressure-test the automated-reviewer ecosystem by running your next draft through Stanford's free Agentic Reviewer at paperreview.ai before submission. The tool is far from perfect—reviews "are AI generated and may contain errors," as the site itself warns—but it'll surface the kind of weaknesses that ScientistTwo's Rebuttal Agent is designed to fix. Treat it as a cheap first-pass reviewer, not a final verdict.

The honest summary: ScientistTwo isn't a paradigm shift in what AI can do—it's a paradigm shift in how rigorously an AI system can hold itself to scientific standards. The components (LLMs, multi-agent orchestration, automated reviewers) were all available before. What's new is the closed-loop discipline that turns them into a system whose outputs survive the same audits human papers are supposed to survive. Whether that's the dawn of autonomous scientific discovery or just a very good research-acceleration tool depends on whether the iterative-frontier-expansion pattern compounds beyond the three BPE iterations shown—and that's the question the next 12 months will answer.

Sources

• Nam, J., Yoon, J., Pan, Y., Wang, Y., Meng, R., Ranganathan, P., & Pfister, T. (2026). ScientistTwo: Pioneering the Human Knowledge Frontier with Autonomous AI. arXiv:2609.19644. https://arxiv.org/pdf/2609.19644
• Project website: https://scientist-two.github.io/
• Lu, C. et al. (2024). The AI Scientist: Towards Fully Automated Open-Ended Scientific Discovery. Sakana AI. https://sakana.ai/ai-scientist
• Lu, C. et al. (2025). The AI Scientist-v2: Workshop-Level Automated Scientific Discovery via Agentic Tree Search. arXiv:2504.08066.
• Meng, R. et al. (2026). ScientistOne: Towards Human-Level Autonomous Research via Chain-of-Evidence. arXiv:2605.26340.
• Li, Y. et al. (2026). AutoSOTA: An End-to-End Automated Research System for State-of-the-Art AI Model Discovery. arXiv:2604.05550.
• Goyal, P. et al. (2026). ScholarPeer: A Context-Aware Multi-Agent Framework for Automated Peer Review. arXiv:2601.22638.
• Song, Y. et al. (2026). PaperOrchestra: A Multi-Agent Framework for Automated AI Research Paper Writing. arXiv:2604.05018.
• Stanford Agentic Reviewer. https://paperreview.ai (free automated paper review tool).
• Jiang, S. & Gong, R. (2026). Incremental BPE Tokenization. ICML 2026. (The baseline for the VD-STrans case study.)
• Ning, K. et al. (2025). TS-RAG: Retrieval-Augmented Generation Based Time Series Foundation Models are Stronger Zero-Shot Forecaster. NeurIPS 2025. arXiv:2503.07649. (The baseline for the DynaSpec-RAG case study.)
• Wei, T. et al. (2025). X-Mahalanobis: Transformer Feature Mixing for Reliable OOD Detection. NeurIPS 2025. (The baseline for the Procrustes-DS case study.)
• Kwon, J. et al. (2026). AI Engram: In Search of Memory Traces in Artificial Intelligence. ICML 2026. (The baseline for the FCD-Engram machine-unlearning case study.)