Paper2Agent: Stanford Framework Converts Published Papers Into Callable MCP Agents

A Stanford research team has published a framework in Nature that converts a scientific paper's code, data, and methods into a callable AI agent — automating what has historically taken a researcher days to set up by hand. The system, Paper2Agent, wraps a paper's full outputs into an MCP (Model Context Protocol) server, which any compatible agent can then invoke through natural language. Applied to 100 computational biology papers, it successfully agentified 74 of them, and the one it built from the AlphaGenome genomics model scored near-perfectly on genetics queries while running at nearly twice the speed of a raw repository approach.

The practical implication arrives in the same breath as the technical one: if papers ship as callable MCP endpoints, scientific knowledge stops being something researchers download and configure, and starts being something they query. Stanford's James Zou, a co-author of the paper, said the technology "can help us to reimagine what knowledge looks like in the future." The paper was received by Nature in October 2025, accepted in August 2026, and published on September 16, 2026.

Read more: Anthropic Confirms Wet Lab as Claude Moves Into Physical Drug Research

From PDF to Callable API: The Six-Step Pipeline That Wraps a Paper

Paper2Agent is not a retrieval system that reads papers and answers questions about them. That category of tool already exists and is well represented by retrieval-augmented generation approaches. What Paper2Agent does is substantively different: it executes the paper's code, captures the outputs, wraps the resulting functions as validated tools, and deploys them on a remote server any agent can call.

The construction process runs through six stages without human intervention. The orchestrator first locates and downloads the paper's associated code repository — either automatically identified from the manuscript text or specified directly. A specialized environment agent then builds an isolated virtual environment, installing dependencies and resolving conflicts. A tutorial scanner identifies reference materials and example notebooks within the codebase. A tutorial executor runs those examples end-to-end, capturing the numerical outputs and figures they produce as ground-truth references.

The most technically significant step is the fifth: tool extraction and validation. A tool extractor agent converts each executed tutorial into standalone Python functions, replacing hard-coded file paths and dataset-specific constants with generalizable parameters, and decorating each function as an MCP tool. A test verifier then runs automated checks against the ground-truth outputs from step four. A function passes only if expected files are generated, numerical results fall within a 3% floating-point tolerance of the reference, and figures match reference visualizations using a perceptual hash check with a Hamming distance below 20. Any function that fails after six repair attempts has its MCP decorator removed and is excluded from the final server — the paper's own answer becomes the quality gate.

The result is a structured MCP server with three component types. MCP Tools are the validated executable functions. MCP Resources hold static assets: the manuscript text, raw codebase, supplementary tables, and datasets in machine-readable formats. MCP Prompts encode multi-step workflows inferred from the paper itself, so that complex analyses — like a single-cell preprocessing and clustering pipeline — can be invoked with a single natural-language instruction rather than requiring the user to specify the correct order of operations.

The team built Paper2Agent using Claude Code as the orchestrator and sub-agent framework, with Claude Sonnet 4 as the underlying language model for all construction and evaluation. Finished servers are deployed on Hugging Face Spaces, making them remotely accessible without requiring users to install any local dependencies. The full framework is available at the Paper2Agent GitHub repository.

Why This Is Different From Pointing Claude at a Repository

The paper's primary benchmark makes the architectural difference concrete. On 30 genomics queries derived from the AlphaGenome paper, the Paper2Agent-built agent scored 82.7 ± 2.4% on open-ended researcher-style questions — compared with 56.7 ± 2.3% for Claude Code with direct access to the same repository. On the simpler tutorial-derived queries, the gap was 98.7% for Paper2Agent versus 82.7% for Claude pointed at the raw code.

The Biomni comparison, also run by the authors, shows an even starker gap: 37.3% for Biomni on tutorial queries and 56.0% on novel ones, against Paper2Agent's 98.7% and 100%. Biomni is a general-purpose biomedical agent developed by academic researchers that draws from dozens of curated databases rather than wrapping a specific paper's executable code. The comparison should not be read as a condemnation of Biomni — the tasks were designed for AlphaGenome's specific outputs — but it illustrates that a paper-specific agent with locked, validated tools substantially outperforms a generalist agent on tasks that require running the paper's actual methods on new inputs.

Two grading caveats apply. All benchmarks were run and scored by the authors themselves, using two human domain experts at a reported 96.7% inter-rater agreement for the AlphaGenome evaluation. No independent group has reproduced any of the reported accuracy figures. The open-ended questions were scored by expert rubric, but the paper itself acknowledges that multiple defensible answers may exist for complex biological interpretation tasks, meaning accuracy numbers for those queries should be read as faithful-execution measures rather than correctness guarantees.

The cost and latency results are more straightforward to interpret. Paper2Agent queries cost a reported $0.20 at median, against $0.38 for Claude pointed directly at the repository using Sonnet 4 — a reduction the authors attribute to the locked, pre-validated tool paths that replace open-ended code generation at query time. Median runtime fell by a reported 1.9× on tutorial queries and 2.9× on novel queries relative to the direct-repository baseline.

Scaling Across 100 Biology Papers — and What the Failures Reveal

The AlphaGenome case study was chosen because the paper is well-maintained, heavily documented, and unusually accessible for a computational biology repository. The large-scale evaluation was deliberately different: 100 computational biology papers sampled retrospectively from bioRxiv without filtering for documentation quality, repository maintenance status, or code completeness, representing the actual heterogeneity of research code in practice.

Of those 100, 74 were successfully agentified. The 26 that failed broke down into four failure categories: missing executable code, missing data or model artifacts, environment or dependency failures, and scripts too specific to their original dataset to generalize into reusable functions. Across the 74 successful papers, Paper2Agent generated 599 proposed tools and validated 593 — a 99% tool pass rate within successfully converted papers. On 300 tutorial-derived benchmark questions across those papers, the system achieved 91.2 ± 1.6% accuracy using Sonnet 4, versus 80.3 ± 2.3% for Claude Code given direct repository access, and 86.3 ± 1.1% for Claude Code using the newer Sonnet 4.6 model.

The team also tested generalization beyond biology, applying Paper2Agent to 10 computational papers spanning causal inference (grf), mechanistic interpretability (SAELens), computer vision (SAM2), tabular machine learning (TabPFN), AI-generated text detection (Binoculars), and computational game theory (Nashpy), among others. Across 42 execution-based questions, Paper2Agent achieved 98.1 ± 0.8% accuracy, suggesting the pipeline is not specific to biology repositories.

The failure taxonomy is itself analytically significant. The four categories that prevented agentification — missing code, missing data, broken environments, non-generalizable scripts — are exactly the categories that prevent reproducibility by conventional means. The authors drew this conclusion explicitly, writing that "the ease with which a paper can be transformed into an agent may itself serve as a practical measure of reproducibility." A paper that cannot be agentified automatically is almost certainly a paper that a new lab would struggle to reproduce manually. This reframes Paper2Agent's 26% failure rate not only as a system limitation but as an audit result for a large corpus of published computational biology.

Paper Agents That Talk to Each Other

The most forward-looking demonstration in the Nature paper involves not a single agent but a chain of three. To identify the causal gene behind a psoriasis-associated genetic variant (rs887314), the team connected the AlphaGenome paper agent — which predicts the regulatory effects of DNA variants — to two additional agents: one built from an MPRA-coupled single-cell CRISPR interference paper, and one built from a genome-scale Perturb-seq dataset of primary human CD4+ T cells.

The AlphaGenome agent initially ranked GPR137 as the top predicted affected gene in CD4+ T cells (RNA-seq quantile score 0.997). To validate that prediction, the AI co-scientist — working under human supervision for strategy selection — correlated the downstream gene expression effects of perturbing the rs887314 cis-regulatory element against the expression effects of knocking down each candidate gene across three stimulation conditions. Only GPR137 knockdown showed significant concordance with the CRE perturbation signature under stimulated conditions (Spearman ρ = 0.613, P = 0.0038 at Stim8hr; ρ = 0.630, P = 0.0047 at Stim48hr, FDR < 0.05). The other top candidates showed no significant correlation.

The signature-correlation approach used to arrive at this result — correlating CRE perturbation signatures from a CRISPR screen with gene-knockdown signatures from a Perturb-seq dataset — was not proposed in either of the source papers. The agent designed it by reasoning about what comparative evidence would be available across the two datasets it had access to. The authors are careful to present this as a computationally supported prediction rather than an established finding; the result requires follow-up experimental validation before it should be treated as settled. The importance is methodological: multiple paper agents pooling their executable methods can generate novel analytical strategies that no single paper's author proposed.

A second multi-agent case study in the paper's supplementary note applied AlphaGenome and ADHD GWAS agents to identify rs1626703 as a likely causal variant, predicting that it alters splicing of MPHOSPH9 and increases its expression in glutamatergic neurons.

Read more: MIT Study Finds AI Loses to Statistics in One of Every Four Scientific Comparisons

What MCP Makes Possible — and What the Protocol Still Lacks

MCP was introduced by Anthropic in late 2024 as an open standard for connecting AI agents to external tools and data via a standardized server interface. It has since been adopted by OpenAI and other major platforms as a common integration layer, functioning, as its documentation describes, like a USB-C port for AI systems: write the server once, connect any compatible agent.

Paper2Agent is the first system to apply MCP at scale to scientific publishing, treating the paper's codebase as the server content rather than a database or business application. The implications for the research community extend beyond convenience. Currently, scientific knowledge transmission requires a reader to find the paper, locate the repository, install the correct software environment, and determine how inputs and outputs map to the paper's methods — a process that the authors characterize as erecting technical barriers that limit dissemination and reuse. Paper2Agent compresses that pipeline into a single Claude Code command.

The security surface that comes with MCP exposure of research code is not trivial. Research in the MCP security space has identified tool poisoning attacks — in which malicious descriptions in an MCP server can manipulate an agent's planning process without executing code — and hallucinated privilege scenarios, in which a model may assert or act on access beyond what was intended. The Paper2Agent paper acknowledges "security, intellectual property and attribution challenges that warrant careful handling" without fully resolving them.

There are also copyright and licensing considerations. A research paper's code repository may be licensed under terms that restrict redistribution or commercial use; automatically wrapping that code as a public MCP service may implicate those terms, particularly if the service is accessed by parties outside the original intended user group. The paper does not address this directly.

The ongoing maintenance burden is also real. Paper agents can break as upstream codebases and dependencies evolve, just as software packages break. The authors treat this as inherent to publishing executable research rather than a reason to forgo agentification, but it implies that agent availability — like data and code availability — will require active stewardship by authors or institutions over time.

Reproducibility as a Benchmark, Publishing as Infrastructure

The Paper2Agent authors close their Nature paper with a comparison to existing research norms. Data availability sections are now standard in most major journals. Code availability sections have become increasingly required. The authors propose that an "agent availability" section — specifying whether and how the paper's contribution has been embodied as an interactive agent — should follow the same trajectory.

That proposal has an asymmetric adoption path. A journal that mandates agent availability before the tools and standards are mature would create compliance burdens; a journal that waits until the ecosystem stabilizes risks watching earlier adopters set citation and attribution norms that become difficult to displace. Emerging benchmarks for agent-based experiment reproduction — evaluating whether agents can correctly reproduce published experiments across large corpora of ML and scientific papers — are already beginning to build the evaluation infrastructure that would make agent-availability auditing feasible at scale.

The 26% failure rate in the large-scale biology evaluation means Paper2Agent is not ready to be a universal journal submission requirement. But it is ready to be a laboratory tool — a way for method-heavy groups to expand the reach of their published work by making it callable, and a way for readers to interrogate reproducibility in minutes rather than days. Whether Nature or another top-tier journal begins hosting Paper2Agent MCP servers alongside PDFs is the concrete milestone that would transform this from a research demonstration into standard publishing infrastructure. That decision is now a product question as much as a scientific one.