Reimagining Research Papers as Interactive and Reliable AI Agents

A research paper has long been the standard unit of scientific communication, but it is also a passive one. A reader who wants to use a published method must usually locate the repository, install the environment, infer the expected inputs and outputs, and rewrite the author's workflow for a new dataset. Paper2Agent tries to close that gap. It does not simply ask a language model to read a paper. It turns the paper's code, data, supplementary material and workflows into tested tools exposed through a remote Model Context Protocol server, allowing a general-purpose agent to execute and combine the research through natural language.

The important shift is not summarization. It is making a paper's contribution callable, testable and composable with other research artefacts.

Published in Nature, the Stanford-led study demonstrates the framework on AlphaGenome, Scanpy and TISSUE, then connects three paper agents to investigate a psoriasis-associated locus. It also states a crucial limitation: reliable execution is not the same as reliable open-ended scientific judgment. Humans remain responsible for selecting research directions, interpreting evidence and deciding whether a conclusion is justified.

Why a paper should become an executable object

Computational science already produces papers, repositories and datasets in enormous quantities, but these assets rarely form a smooth path to use. Even a public repository may lack a reproducible environment. A tutorial may no longer match a new input format, dependency version or parameter scale. For biologists and other domain scientists who are not software maintainers, the barrier can be more consequential than access to the paper itself.

AlphaGenome illustrates the problem. It predicts how genetic variants affect gene expression, splicing and chromatin state, but using it still requires users to install software, create client objects, manage API keys, construct variant inputs and understand the semantics of different output modalities. Paper2Agent hides those details behind validated tools so that a scientist can ask a research question directly, such as how a variant affects chromatin accessibility in muscle cells, without first becoming an expert in the repository's software architecture.

This is broader than retrieval-augmented generation over manuscript text. In an ordinary RAG system, the answer boundary is still largely textual. Paper2Agent exposes the manuscript, supplementary tables, datasets, executable examples and analysis functions as structured resources and callable tools. The model can plan a sequence of actions, invoke functions, inspect output files, generate figures and revise its strategy after observing an error. The paper becomes an artefact with explicit inputs and outputs that can reproduce an experiment or be applied to a new question.

It also goes beyond containerized artefacts and earlier paper-to-code efforts. Binder and CodeOcean preserve environments, while code generation can reduce manual implementation work, but users still need to understand how the software is organized. Paper2Agent adds an agent interface, structured resources and workflow prompts, making natural language a stable entry point into the underlying scientific capability.

The six-stage conversion pipeline

The implementation uses Claude Code's agent SDK. A central orchestrator coordinates specialized sub-agents, each with a defined role, permitted tools and expected output schema. Results move between stages through structured JSON reports and file conventions, and tutorials can be processed in parallel within a stage. The pipeline has six steps.

1. Locate and retrieve the codebase

The orchestrator first infers the associated repository from the manuscript, references or supplementary material. If automatic detection fails, produces multiple candidates or the user wants a particular repository, the URL can be supplied directly. The system then downloads the code, configuration files and necessary supplementary data, and records the project language.

2. Build an isolated environment

An environment manager analyses dependency specifications, installation instructions and runtime constraints. It creates an isolated workspace, handles version conflicts and system dependencies, and produces a test configuration that later stages can reuse.

3. Discover useful tutorials

A tutorial scanner reviews examples, notebooks and documentation, separates executable material from general prose, and produces a classified index. Tutorials are valuable evidence about intended inputs, outputs and parameter semantics, but they are not an absolute prerequisite. The authors later test a repository after all executable tutorials have been removed.

4. Execute and audit each tutorial

A tutorial executor runs selected examples end to end with their reference data. It captures inputs, outputs, figures, runtime constraints and implicit assumptions. Success requires more than a process that did not crash: the system preserves authoritative numerical and visual outputs for later comparison. Failed runs enter a diagnosis and repair loop.

5. Extract tools, test and refine

A tool extractor and implementer converts generalizable analysis steps into standalone Python functions. Hard-coded paths, thresholds and column names are parameterized; inputs and outputs are file based; and each function receives an MCP tool decorator. A second agent creates tests from the tutorial's own example data. A test passes when the expected files exist, floating-point outputs match within 3% and generated figures match their references at a perceptual-hash Hamming distance below 20.

Each function gets at most six generate-test-diagnose-repair attempts. If it still fails, the MCP decorator is removed and the function is excluded from the final server. This is why tool count is not the objective. The server should expose only capabilities that have a demonstrated path to reproducible execution.

6. Assemble and deploy the MCP server

Validated modules are assembled into one MCP server with a manifest, version information and basic security defaults. Every tool retains a traceable link to the original code. The server can be hosted remotely, including on Hugging Face Spaces, and connected to any compatible agent framework.

Each server has three components. Tools execute scientific functions. Resources expose manuscript text, code, datasets, supplementary tables and figures. Prompts encode multi-step workflows in the correct order. Resources provide context, tools perform execution and prompts make the composition of tools repeatable. For a single-cell workflow, for example, the prompt can require data inspection, quality control, normalization, feature selection, dimensionality reduction, graph construction and clustering in sequence.

AlphaGenome: validating 22 tools

Paper2Agent generated 22 AlphaGenome tools without human intervention, and all passed automated validation. The conversion took about 45 minutes and cost about US$14 on a personal laptop. The tools covered single- and batch-variant scoring across functional assays, sequence prediction, tissue ontology exploration and a visualization suite. score_variant_effect(), for example, predicts consequences across expression, splicing and chromatin accessibility; visualize_variant_effects() produces modality-specific charts.

The interfaces are not hard-coded to one tutorial. Users can change sequence context, cell or tissue type, output modalities and the tracks shown. Each tool also points back to its source implementation so that a result can be audited.

Benchmark design

During evaluation, the generated agent had no access to the manuscript or raw repository, only its MCP tool definitions and the question. Two domain experts graded answers against predefined rubrics, with 96.7% inter-rater agreement. The baselines were Claude Code with direct access to the repository, called Claude + Repo, and the general biomedical agent Biomni. Each method was run five times.

AlphaGenome benchmark	Paper2Agent	Claude + Repo	Biomni
15 tutorial-derived questions	98.7 ± 1.3%	82.7 ± 3.4%	37.3 ± 4.0%
15 novel questions	100.0 ± 0.0%	78.7 ± 4.4%	56.0 ± 3.4%
30 open-ended researcher questions	82.7 ± 2.4%	56.7 ± 2.3%	72.2 ± 2.2%

The paper agent also reduced median runtime by 1.9 times relative to Claude + Repo and 3.1 times relative to Biomni on tutorial-derived queries. On novel queries, the reductions were 2.9 and 3.8 times. The authors report that the gains survived prompt paraphrasing and remained when the Claude + Repo baseline was upgraded to Claude Opus 4.6.

A disagreement is more informative than a perfect score

The researchers asked the agent to reinterpret the LDL-cholesterol-associated variant chr1:109274968:G>T. It planned the analysis, scored the variant, filtered tissues, generated modality-specific visualizations and assembled a report. It prioritized SORT1, while the original paper emphasized CELSR2 and PSRC1.

The agent favored SORT1 because it had a liver expression-effect quantile score of 0.99983 and because sortilin is directly involved in LDL and very-low-density lipoprotein secretion. A GTEx query confirmed that the variant is a significant liver expression quantitative trait locus for SORT1, with P = 1.1 × 10−65. The issue remains difficult, however: CELSR2 and PSRC1 each had an AlphaGenome quantile score of 0.99998 and were also significant in GTEx liver, with P = 4.7 × 10−46 and 8.5 × 10−50.

Complex loci can affect several nearby genes, so a single model ranking cannot settle causality by itself. The useful capability is re-analysis: a researcher can revisit a published interpretation from one prompt without rebuilding an entire pipeline. Paper2Agent provides an auditable way to test a hypothesis; it does not declare the final biological answer.

Scanpy: preserving the order of an analysis

Scanpy is widely used for large-scale single-cell transcriptomics. Paper2Agent focused on its common preprocessing and clustering workflow and generated seven validated tools in about 45 minutes and US$13 on a personal laptop. quality_control() calculates and visualizes quality metrics, filters cells and genes, and detects doublets.

The hard part of single-cell analysis is often not an individual function call but the order and parameterization of the whole workflow. Users need to know when to filter, how to normalize, how many variable features to retain and which graph and clustering settings to use. Paper2Agent encodes the sequence as an MCP prompt: inspect the data, then perform quality control, normalization, feature selection, dimensionality reduction, graph construction, clustering and annotation. The prompt is inferred from the paper and repository rather than added as a separate hand-written tutorial.

The agent was tested on four public single-cell datasets that were not part of the Scanpy codebase. It required only the dataset path and then reproduced human researchers' post-quality-control cell and gene counts, top differential marker genes and matched parameter choices. The authors also applied it to seven diverse datasets and observed adaptive parameter selection. A separate TISSUE case extended the framework to spatial transcriptomics with uncertainty estimation.

This case exposes an important design requirement for research agents. Wrapping functions as tools is insufficient if the agent does not know which sequence is scientifically valid. The workflow prompt is not decorative documentation. It is part of the executable research asset because it constrains how tools are composed.

Large-scale evaluation: what a 74% success rate means

To test natural variation in research software, the team did not pre-filter repositories for documentation quality or maintenance. It sampled 100 computational biology papers retrospectively from bioRxiv, beginning in December 2025 and moving backward. It also evaluated 26 data- and discovery-focused papers and 10 non-biology computational papers from AI, statistics, econometrics, game theory and astrophysics. All were processed end to end without manual cleanup, code changes or intervention.

Paper collection	Scale	Main result	Failure or limitation
Computational biology	100 papers	74 agentified; 593 of 599 tools validated; 91.2 ± 1.6% on 300 tutorial questions	Missing executable code, data or model artefacts; environment failures; non-generalizable scripts
Data and discovery	26 papers	89.0 ± 3.1% on 100 synthesis questions using the resource layer alone	No executable tool layer; integration is limited to text, tables and supplementary material
Non-biology computation	10 papers, 42 tasks	98.1 ± 0.8% across five independent runs	Limited coverage and not representative of every discipline or programming paradigm

Among the 100 computational biology papers, 74 were successfully agentified. On 300 tutorial-derived questions, accuracy was 91.2%, compared with 80.3% for direct Sonnet 4 repository access and 86.3% for an upgraded Sonnet 4.6 baseline. The reported cost was US$0.20 per query versus US$0.38, and latency fell from 4.3 to 1.6 minutes.

For 26 data and discovery papers, even the structured resource layer without executable tools reached 89.0%, above the 82.0% browser-use baseline. That route was reported to be 34 times cheaper and 15 times faster. On 42 execution tasks from 10 non-biology papers, the system reached 98.1%. The results show that an executable tool layer is valuable but not the only useful endpoint: careful resource organization and workflow prompts can substantially improve how papers are used.

Injected faults, out-of-scope questions and ablations

The authors introduced four classes of defects into three repositories: missing dependencies, broken file paths, typographical errors and deprecated API calls. AlphaGenome covered notebook-based Python, POP-TOOLS covered command-line Python and mlearner covered command-line R. The 12 adversarial configurations were created before Paper2Agent ran and were not disclosed to it. The execute-diagnose-repair loop still recovered functional MCP servers.

In a permuted paper-question benchmark, where questions were paired with unrelated papers, the system reported a 100% correct rejection rate. Ablations showed that multi-agent decomposition and parallel execution affected performance, and that removing the independent test verifier reduced tool correctness. Tool count and callability are therefore not substitutes for validation.

The 74% success rate should not be presented as complete reproducibility. The system explicitly failed on missing code, unavailable data or model files, broken environments and scripts that only worked for one author-specific case. These failures matter. Paper2Agent turns a vague reproducibility claim into an observable diagnostic result. The difficulty of converting a paper into an agent can itself reveal whether its research artefacts are complete enough to reuse.

Three paper agents collaborate on a psoriasis target

The discovery case does not rely on one agent producing an answer from a prediction. It connects three independent paper assets. The AlphaGenome agent predicts variant effects. An MPRA-coupled single-cell CRISPR interference agent provides gene-expression changes after perturbing a cis-regulatory element. A CD4⁺ T-cell Perturb-seq agent provides transcriptome-wide knockdown signatures.

For the psoriasis-associated variant rs887314, AlphaGenome ranked GPR137 as the top affected gene in CD4⁺ T cells, with an RNA-seq quantile score of 0.997. Under human supervision, the co-scientist inspected the other two papers and their supplementary data, then proposed ten validation strategies. The human researcher selected signature-correlation analysis. It asks whether the downstream expression changes caused by perturbing the regulatory element match the changes caused by knocking down each candidate gene.

The team compared the five top-ranked candidates with available knockdown data across Rest, Stim8hr and Stim48hr conditions. Only GPR137 showed significant concordance under stimulation:

• Stim8hr: Spearman r = 0.613, P = 3.79 × 10−3.
• Stim48hr: Spearman r = 0.630, P = 4.71 × 10−3.
• Both stimulated conditions passed Benjamini-Hochberg correction with FDR below 0.05.
• Rest was not significant: r = 0.29, P = 0.21.

BAD and the three other top-ranked candidates showed no significant correlation under any condition. The authors therefore interpret GPR137 as a probable activation-dependent causal gene. The pattern agrees with the source Perturb-seq study's finding that regulators vary across stimulation states and with the established role of activated CD4⁺ T cells in psoriasis.

The proposed validation strategy is itself notable. The source papers did not directly correlate CRE-perturbation signatures with gene-knockdown signatures. The agent proposed that cross-screen, cross-modality comparison after reading both papers, and the human selected it for execution. This is a concrete example of human-on-the-loop collaboration: the AI retrieves, combines and executes evidence, while the human decides what analysis is worth doing and whether the result supports a scientific claim.

A supplementary ADHD case follows the same pattern. After connecting an AlphaGenome method agent to an ADHD genome-wide association dataset, the system prioritized rs1626703 among 209 candidate variants. It generated the computational hypothesis that the variant may alter MPHOSPH9 splicing and increase expression in glutamatergic neurons. The paper explicitly treats that mechanism as requiring experimental validation, not as an established discovery.

What changes and what does not

The immediate value of Paper2Agent is that it packages the software work between understanding a paper and using it. A researcher can initiate an executable analysis in natural language. Source links make individual tools auditable. Workflow prompts preserve correct sequencing. Multiple MCP servers can be attached to one agent, enabling cross-paper composition without asking every reader to learn each author's code style.

The framework also suggests a new way to assess research software. If code, data and examples determine whether a paper can be made agent-ready, then successful agentification can act as a practical stress test for openness. The authors therefore imagine an “agent availability” statement alongside data and code availability: how a contribution has been embodied as an interactive agent, who maintains it and which tasks it supports.

Reproducing a workflow shows that an agent faithfully executed the authors' method. It does not prove that the method answers the right scientific question or that an open-ended interpretation is uniquely correct.

The paper is explicit about this boundary. Open-ended research tasks can have multiple defensible answers. A benchmark that scores agreement with one reference answer primarily measures faithful execution, not the validity of every analytical path. Humans still select directions, judge evidence, resolve conflicting mechanistic explanations and take responsibility for conclusions.

Executable research agents also introduce security, intellectual-property and attribution questions. Remote servers need constrained permissions. Users need to understand which files and network operations a tool can access. Authors and maintainers need to define responsibility when a tool generates a consequential result. Dependencies change over time, so paper agents and their validation tests need ongoing maintenance alongside repositories and example notebooks. Paper2Agent does not erase that work; it moves it from an individual reader's one-time burden into shared, auditable research infrastructure.

Practical lessons for scientific agent builders

The first lesson is to validate tools before giving them to an agent. If a function is unstable on a new dataset, a stronger model may only produce a polished-looking failure faster. Paper2Agent requires concrete output files, sets a 3% numerical tolerance and a perceptual-hash threshold below 20, then removes functions that cannot pass repeated tests. This is closer to disciplined research-software engineering than to simply enlarging model context.

The second lesson is that a workflow is part of the knowledge. A list of functions may tell an agent what each tool does without telling it which sequence is scientifically valid. The Scanpy case shows that method order, inspection steps and expected outputs should be encoded as prompts rather than left for every user to restate.

The third lesson is to preserve a path back to the evidence. A source-code link for each tool, combined with manuscript, table and dataset resources, makes results auditable. The valuable part of cross-paper collaboration is not models chatting with one another. It is connecting traceable methods and datasets from different papers to a specific scientific task.

The fourth lesson is to treat failures as first-class findings. Only 74 of 100 computational biology papers became agents successfully. That number is as important as the high scores on parts of the benchmark. It locates the bottleneck in code completeness, data availability and environment reproducibility, not merely in whether the interface accepts natural language.

From reading the paper to invoking it

Paper2Agent proposes a new form of scientific dissemination. A paper is no longer only the endpoint of a narrative. It can also be an execution surface with tools, resources, workflow prompts and validation records. The framework links method papers to data papers, enabling AlphaGenome predictions to be compared with MPRA and Perturb-seq evidence, and producing a GPR137 hypothesis that human researchers can audit.

Its value comes from not overstating automation. It lets agents execute repeatable analysis without handing them scientific authority. It pursues natural-language usability while making tool validation a precondition. It supports cross-paper discovery while preserving provenance and requiring experimental confirmation. For teams building scientific agents, research-data platforms or executable-paper systems, the combination that matters is not a slogan about a universal research assistant. It is research that remains callable, traceable, allowed to fail and open to audit.

Source and licensing

Original article: Jiacheng Miao, Joe R. Davis, Yaohui Zhang, Jonathan K. Pritchard and James Zou, “Reimagining research papers as interactive and reliable AI agents,” Nature 658, 1272–1280 (2026). DOI: 10.1038/s41586-026-11044-y.

Source: https://www.nature.com/articles/s41586-026-11044-y. This article is an in-depth adaptation based on the paper's main text, Methods, figure captions and supplementary-information descriptions. Images are reproduced from the open-access article under CC BY-NC-ND 4.0; copyright remains with the authors and publisher.