Skip to content
Bud's Wiki

Paper2Agent: Reimagining Research Papers As Interactive and Reliable AI Agents

TL;DR

Section titled “TL;DR”

Paper2Agent is an automated multi-agent framework (Stanford; Miao, Davis, Zhang, Pritchard, Zou) that converts a research paper into an interactive MCP server by analyzing both the paper and its codebase, generating executable tools from the methods, and iteratively running tests until outputs match the reference. The resulting paper MCP plugs into any MCP-compatible chat agent (Claude Code in the case studies) so a user can invoke the paper’s methods via natural language on new data. Three case studies — AlphaGenome (genomics), TISSUE (spatial transcriptomics), Scanpy (single-cell) — report 100% accuracy against both tutorial queries and novel curated queries, with the AlphaGenome agent independently re-prioritizing SORT1 over the paper’s CELSR2/PSRC1 call at an LDL GWAS locus using in-model evidence. For a Luma researcher the interesting bits are the pipeline shape (environment agent + extraction agent + testing agent all driven by Claude Code, ~45 min to ~3 hours per paper on a laptop) and the explicit framing of “ease of agentification” as a reproducibility metric for the surrounding scientific community.

Key claims

Section titled “Key claims”
  • Three-agent compilation pipeline — environment agent configures dependencies, extraction agent translates core methods into MCP tools, testing agent runs automated checks until outputs match reference results — produces a validated MCP Python file deployable to a remote host (e.g. Hugging Face Spaces) [§2 Overview of Paper2Agent].
  • MCP server exposes three component types: Tools (executable functions wrapping the paper’s methods, each with a traceable link back to the original GitHub source), Resources (manuscript text, codebase, datasets, figures stored in standardized formats), and Prompts (concise multi-step workflow templates inferred from paper + codebase, not manually curated) [§2 Overview of Paper2Agent].
  • Validation protocol: on 15 curated AlphaGenome tutorial queries plus a held-out set of novel queries (new variant positions, allelic substitutions, tissue/cell-type contexts not in the paper or codebase), the AlphaGenome agent reaches 100% exact-match on numerical outputs, verified by manual execution of the original code [§2 AlphaGenome Agent].
  • Tools are “locked” after validation to mitigate code-hallucination risk and reduce randomness in LLM code generation — reproducibility is enforced at the MCP-tool level rather than relying on the chat agent to regenerate code at inference [§2 Overview of Paper2Agent].
  • Scale datapoints on a personal laptop: AlphaGenome yielded 22 MCP tools in ~3 hours; Scanpy preprocessing-and-clustering slice yielded 7 tools in ~45 minutes — one-time cost producing reusable artifacts [§2 AlphaGenome Agent; §2 Scanpy Agent].
  • MCP Prompts encode the ordered workflow (QC → normalize → feature-select → dimensionality-reduce → graph → cluster → annotate for Scanpy) so the agent executes multi-step pipelines from a single data path without the user having to specify ordering [§2 Scanpy Agent, Figure 4B].
  • At the chr1:109274968 LDL locus, the AlphaGenome agent nominates SORT1 as the top causal gene (quantile score 0.99982 in liver, mechanistic match via sortilin’s role in LDL/VLDL secretion), diverging from the original paper’s CELSR2/PSRC1 call — a demonstration of agent-driven re-evaluation of published conclusions, with the authors’ own manual GTEx lookup noting that all three genes have significant liver eQTL support [§2 AlphaGenome Agent, Figure 2D].
  • Position argument: the ease of converting a paper into a functioning agent can serve as a reproducibility and rigor metric for the surrounding scientific community — if a codebase is incomplete, undocumented, or broken, Paper2Agent cannot reliably agentify it [§3 Discussion].

Method

Section titled “Method”

The system is implemented on top of Claude Code and operates in a workflow Claude orchestrates as the coding backbone. Given a paper + its codebase, Paper2MCP (i) spawns an environment agent that provisions the necessary software environment; (ii) spawns an extraction agent that walks the codebase and the paper’s method sections to translate the key contributions into MCP tools with pre-configured runtime, well-annotated inputs/outputs, and GitHub source traceback; (iii) spawns a testing agent that runs the generated tools on example data from the paper’s own tutorials and iteratively refines code + environment until outputs match the reference numerical values and figures. The validated bundle is packaged as a Python MCP server file and can be deployed remotely (Hugging Face Spaces is the example host).

A chat-agent layer then wraps each MCP server as a context provider — the paper’s methods become natural-language-callable tools. Multiple paper MCPs can connect to one chat agent, so a user can combine methods across papers (the AlphaGenome + GWAS-dataset MCP combination in Figure 5 is the showcase: a co-scientist agent integrates an AlphaGenome method MCP with an ADHD GWAS data MCP and autonomously nominates rs1626703 as a likely causal variant altering MPHOSPH9 splicing in glutamatergic neurons).

Case studies differ in scope: AlphaGenome agentifies the whole method surface (22 tools: single/batch variant scoring, sequence-level prediction, tissue ontology exploration, visualization suite); TISSUE agentifies the full pipeline + a Zenodo-API-backed MCP Resource registry of ST datasets; Scanpy intentionally agentifies only the preprocessing-and-clustering slice (7 tools) to demonstrate partial-method agentification plus workflow-level MCP Prompts.

Results

Section titled “Results”
  • AlphaGenome agent: 100% accuracy on 15 curated tutorial queries, 100% on a held-out novel-query set (new variant positions, allelic substitutions, tissue/cell-type contexts outside the paper and codebase) — verified against manual execution of the original AlphaGenome code [§2].
  • TISSUE agent: for a prediction-interval construction on gene Acta2 given Spatial_count.txt + Locations.txt + scRNA_count.txt, the agent autonomously runs the full TISSUE pipeline and produces outputs matching the human-executed baseline [§2, Figure 3C].
  • Scanpy agent: applied to three held-out 10x Genomics single-cell datasets (not in the Scanpy codebase); MCP-Prompt-driven end-to-end preprocessing and clustering produces outputs matching human-researcher results [§2, Figure 4C].
  • Autonomous collaboration demo: combined AlphaGenome method MCP + ADHD GWAS data MCP; the agent autonomously generates testable hypotheses, filters 209 candidate variants, nominates rs1626703, and uses AlphaGenome to demonstrate altered splicing of MPHOSPH9 with increased expression in glutamatergic neurons as a plausible ADHD mechanism [Figure 5].
  • Compilation cost: AlphaGenome agentified in ~3 hours on a personal laptop (22 tools); Scanpy preprocessing-and-clustering slice in ~45 minutes (7 tools) [§2].

Why it’s interesting

Section titled “Why it’s interesting”

The direct connection on the wiki is to Tool-Use Agents and AI-for-AI Research: Paper2Agent is a concrete instance of the “compile a scientific artifact into a tool-callable surface” pattern that DimOS — The Agentive Operating System for Physical Space (v0.0.13) and Previewing the Model Hardware Standard develop for physical robots, now applied to the research-method surface. It also sits one abstraction level above AIDE²: First Evidence of Recursive Self-Improvement AIDE² and AREX: Towards a Recursively Self-Improving Agent for Deep Research AREX — those systems do research; Paper2Agent compiles existing research into tools that the next layer of agents can call, which is the missing substrate for the research-agent → prior-literature plumbing the AI-for-AI-research cluster has otherwise ignored. The reliability discipline (lock validated tools, embed GitHub source links, test against reference values) is the lightest-weight filed version of the “validated compaction / shippability gate” pattern that Agentic Context Management: Solving Agent Memory and Cost by Treating Them as Lifecycle and Architecture Problems names on the digital side and Zetta ζ: An Efficient Closed-Loop Embodied Harness for Self-Evolving Physical Intelligence applies to embodied harness evolution.

See also

Section titled “See also”