A Stanford-led research team has unveiled Paper2Agent, an automated framework that converts scientific papers, their code, datasets and supplementary material into interactive artificial-intelligence agents capable of answering questions, reproducing analyses and applying published methods to new data. The system, described in a peer-reviewed Nature paper published on September 16, does not turn an academic article into an autonomous scientist. Instead, it creates a structured, executable interface around the work and lets a language model use that interface through natural-language requests. The distinction is central to both the promise and the limits of the research.
From static paper to executable research object
For more than three centuries, the research paper has been the default unit of scientific communication: a fixed record of methods, results, figures and interpretation that other researchers must read, understand and then translate into their own workflows. That process can be straightforward when a study is conceptual. It can be far more difficult when a paper introduces a software package, computational model or analysis pipeline whose practical use depends on locating a repository, installing the correct dependencies, reproducing an environment, understanding unfamiliar parameters and discovering which pieces of code correspond to which claims in the manuscript.
Paper2Agent attempts to compress that technical burden into a machine-readable layer. According to the Nature study by Jiacheng Miao, Joe R. Davis, Yaohui Zhang, Jonathan K. Pritchard, James Zou and colleagues, the framework analyses the manuscript and its associated codebase, identifies the main computational functions, builds a Model Context Protocol server, tests the generated tools against reference outputs and then exposes those validated tools to an AI agent. A scientist can subsequently ask the agent to perform a task in ordinary language rather than manually reconstructing the paper’s software workflow.
The system is therefore closer to a translation and execution layer than to a chatbot that merely summarizes a PDF. A conventional retrieval system can search a paper and answer textual questions about what its authors wrote. Paper2Agent is designed to go further: where the underlying research code permits, it can invoke the method itself, feed it new inputs, generate outputs and combine those outputs with information from other papers. That is why the Stanford team describes the resulting agent as a kind of “virtual corresponding author,” although the published work repeatedly emphasizes that human researchers remain responsible for scientific judgment.
How Paper2Agent is built
The technical architecture relies on the Model Context Protocol, or MCP, an open standard originally introduced by Anthropic in 2024 to give AI applications a consistent way to connect with external tools and data sources. MCP has since spread across a wider software ecosystem and, in late 2025, Anthropic donated the protocol to the Agentic AI Foundation under the Linux Foundation. In Paper2Agent, the protocol becomes a bridge between the language model and the executable parts of a research project.
The framework creates three main kinds of assets. The first are tools: executable functions that embody a paper’s analytical methods. The second are resources, such as manuscript text, supplementary tables, datasets and code. The third are prompts that encode multi-step workflows, giving the AI agent instructions about the sequence in which operations should be performed. The aim is to avoid a common failure mode in agentic systems, where a model has access to useful tools but does not reliably know which tool to call, in what order or with which parameters.
The researchers used a multi-agent construction pipeline. One component works on the software environment, another extracts core functions, and a testing component compares generated outputs with expected results. The study says a tool is accepted only if it passes automated validation criteria such as producing the required files, matching numerical outputs within tolerance and recreating reference figures. Tools that repeatedly fail are excluded rather than exposed to the final agent. The paper’s authors argue that this validation step reduces the risk of so-called code hallucination, in which an AI system produces plausible-looking but incorrect software.
The resulting MCP server can be hosted remotely, including on platforms such as Hugging Face Spaces, and connected to a compatible AI agent. The Stanford team used Claude Code and Claude Sonnet 4 in its principal experiments, while stressing that the MCP layer is designed to be modular and can in principle be connected to other compatible models and agents. That separation matters because it means the research object is not necessarily tied to one AI vendor or one conversational interface.
The AlphaGenome test
The most detailed demonstration used AlphaGenome, a genomic foundation model designed to predict how changes in DNA may influence processes including gene expression, splicing and chromatin accessibility. AlphaGenome is powerful but technically demanding: using it programmatically requires a researcher to understand its application programming interface, construct genetic-variant inputs correctly, choose relevant biological modalities and interpret model outputs across tissues and cell types.
Paper2Agent generated 22 tools around the AlphaGenome work. The Nature paper reports that all 22 passed automated validation and that the conversion took about 45 minutes on a personal laptop at an estimated one-time cost of $14. Those figures describe the researchers’ test environment rather than a universal deployment cost; actual costs would vary with models, infrastructure, software changes and the complexity of a paper’s codebase. The generated tools covered single and batch variant scoring, tissue exploration and visualization tasks.
The team then benchmarked the resulting AlphaGenome agent on questions for which human-executed ground truth had been established. Across five runs, the agent recorded 98.7% average accuracy on 15 tutorial-derived queries and 100% on 15 novel queries. In the same tests, a Claude agent given direct access to the underlying repository scored 82.7% and 78.7%, while the biomedical agent Biomni scored 37.3% and 56%, respectively. The comparison suggests that carefully packaging a research method into validated tools can be more reliable than asking a general-purpose agent to navigate an unfamiliar repository from scratch.
The advantage narrowed on more open-ended questions requiring biological synthesis. On 30 multi-step researcher-style queries, Paper2Agent achieved 82.7% accuracy, compared with 72.2% for Biomni and 56.7% for the Claude-plus-repository baseline. The researchers also reported shorter median runtimes than the two comparison systems. Those results are notable, but they are not evidence that Paper2Agent is generally 82.7% “correct at science.” The benchmark was designed around specific tasks and reference answers, and the authors caution that open scientific questions can have more than one defensible interpretation.
A result that challenged the original interpretation
One of the most interesting demonstrations involved a genetic variant associated with low-density lipoprotein cholesterol. The original AlphaGenome paper had emphasized two nearby genes, CELSR2 and PSRC1, in interpreting the locus. When the Paper2Agent-built AlphaGenome agent was asked to analyze the same association, it prioritized another gene, SORT1, drawing on a strong predicted expression effect in liver tissue and known biological relevance to lipid secretion.
The Stanford team then checked public GTEx data and confirmed that the variant is strongly associated with SORT1 expression in liver. Yet the same region also showed strong evidence involving CELSR2 and PSRC1. Rather than presenting the agent’s answer as a correction of the earlier paper, the researchers used the discrepancy to illustrate a broader point: complex genomic loci can support multiple plausible causal explanations, and an executable paper agent can make it easier to revisit assumptions using the original method.
That distinction is important for general readers. Paper2Agent did not conduct a new biological experiment that settled which gene is definitively causal. It reorganized existing computational methods and public data in a way that allowed a different analytical path to be explored quickly. The episode shows how the system can help researchers interrogate a published conclusion, but it also shows why outputs still require domain expertise and independent validation before they can be treated as scientific findings.
From one paper to hundreds
A technology can look impressive in a carefully chosen case study and still fail when exposed to the uneven reality of scientific software. The Stanford researchers therefore tested Paper2Agent at larger scale. They processed 100 computational-biology papers, 26 data- and discovery-focused papers, and 10 non-biology computational papers spanning areas including artificial intelligence, statistics, econometrics, computer vision, game theory and astrophysics.
Among the 100 computational-biology papers, 74 were successfully converted into executable agents. Paper2Agent proposed 599 tools for those papers, and 593 passed automated validation. The 26 papers that could not be fully agentified failed for familiar reasons: missing executable code, absent model artefacts or datasets, broken dependencies, incomplete documentation, environmental problems or scripts that were too specific to one original analysis to be generalized safely.
That 74% success rate is arguably as informative as the performance of the successful agents. It shows that Paper2Agent does not magically erase the reproducibility problems of research software. A paper that does not publish usable code, omits required files or depends on a fragile software environment remains difficult to turn into an executable system. The framework can repair some errors, but the quality of the underlying research artefacts still matters.
On 300 tutorial-derived benchmark questions across the larger computational-biology sample, Paper2Agent using Sonnet 4 achieved 91.2% average accuracy. The Nature paper reports 80.3% for Claude Code with direct repository access using Sonnet 4 and 86.3% when that baseline used the newer Sonnet 4.6 model. Query cost and latency were also lower in the researchers’ configuration: about 20 cents and 1.6 minutes per query for Paper2Agent versus 38 cents and 4.3 minutes for the direct-repository Sonnet 4 baseline.
The authors also tested 42 execution-based tasks from 10 non-biology computational papers. Paper2Agent achieved 98.1% average accuracy across five independent runs. For 26 papers where the main value was data or discovery rather than an easily executable method, the framework’s structured resource layer reached 89% accuracy on 100 synthesis questions, compared with 82% for a browser-use baseline. The researchers report that this resource-based approach was also substantially faster and cheaper in their tests.
A reproducibility machine, but only when the source is reproducible
One of the clearest implications of the work concerns reproducibility, a persistent challenge across computational science. Reproducing a published result often requires more than obtaining the paper itself. Researchers may need the exact version of a library, a particular model checkpoint, hidden preprocessing steps, configuration files, data-access permissions and knowledge that was never fully documented because it seemed obvious to the original authors.
Paper2Agent’s approach effectively turns reproducibility into a software test. A generated tool is run, compared with known outputs and rejected if it does not behave as expected. The framework also includes an execute-diagnose-repair loop intended to recover from problems such as broken paths, typos, dependency changes and deprecated software interfaces. In adversarial tests described in the Nature paper, the system was able to recover functional MCP servers from several deliberately introduced repository failures.
Yet the larger evaluation also reveals the boundary of that capability. No AI system can reliably infer a missing dataset that was never released, reconstruct a proprietary model artefact it cannot access or guarantee the intended behavior of code whose assumptions are undocumented. The authors suggest that the ease with which a paper can be “agentified” might itself become a practical measure of research reproducibility. That is a provocative idea because it would turn good documentation from an optional convenience into a prerequisite for machine-executable scholarship.
If that idea gains traction, journals and funding agencies could eventually ask not only whether data and code are available, but whether a published method can be exposed through a maintained agent or standardized interface. The Nature paper explicitly anticipates the possibility of an “agent availability” section sitting alongside data- and code-availability statements. Such a change would be evolutionary rather than immediate, but it points toward a publishing model in which scientific outputs are expected to remain operational after publication.
The Scanpy example and why workflow order matters
A second demonstration used Scanpy, a widely adopted software package for analyzing single-cell RNA sequencing data. Unlike a simple function that accepts one input and returns one output, a typical single-cell analysis involves a chain of decisions: quality control, filtering, normalization, feature selection, dimensionality reduction, graph construction, clustering and cell-type annotation. Performing those steps in the wrong order or with poorly chosen parameters can materially change the result.
Paper2Agent generated seven tools for a Scanpy preprocessing and clustering workflow, again in about 45 minutes in the researchers’ experiment, at a reported cost of roughly $13. The framework also inferred a structured MCP prompt that encoded the sequence of operations. The user could then provide the path to a dataset and ask the agent to perform the standard workflow rather than manually specifying every command.
The researchers compared the agent’s outputs with analyses performed by human researchers following official reference tutorials. Across the tested datasets, the agent reproduced key processing steps and recovered equivalent cell and gene counts after quality control as well as comparable marker genes under matched parameters. The demonstration highlights a less dramatic but potentially practical use of agentic AI: not discovering something new, but making a complex, established method easier to execute consistently.
When paper agents begin to collaborate
The more ambitious part of the research connects multiple paper agents to the same AI co-scientist. Because each agent exposes a paper’s methods or data through standardized MCP interfaces, an AI system can in principle apply a method from one publication to a dataset from another and then compare the result with evidence in a third. In conventional research, that integration may require a scientist to learn several unrelated codebases and harmonize file formats manually.
The Stanford team explored this idea in a psoriasis case study. It created agents representing AlphaGenome, a study using MPRA-coupled single-cell CRISPR interference and a Perturb-seq dataset involving human CD4-positive T cells. The agents were used together to investigate a disease-associated genetic locus and rank candidate causal genes. AlphaGenome prioritized GPR137 as the strongest predicted target among the genes examined.
The AI co-scientist then examined supplementary data from the other studies and proposed several strategies for testing that prediction. A human researcher selected one of those strategies: comparing gene-expression signatures produced by perturbing a regulatory element with signatures produced by knocking down candidate genes. In the published analysis, GPR137 was the only tested candidate showing significant concordance under the stimulated-cell conditions examined.
The result is intriguing because the specific cross-dataset signature-correlation analysis was not proposed in the source papers. But it remains an analysis of existing data, not a new laboratory validation conducted independently after the AI generated the hypothesis. The Nature authors describe the finding as support for GPR137 as a probable causal gene at that locus and explicitly keep human researchers in the loop. Further biological work would still be required before treating the proposed mechanism as settled.
Why the MCP layer changes the AI-science debate
Much of the public discussion about AI in science has focused on whether a model can read enough literature to generate a novel hypothesis. Paper2Agent shifts attention toward a different problem: whether published knowledge can be represented in a form that AI systems can use safely and reproducibly. That is less cinematic than an autonomous robot scientist, but it may prove more consequential in the near term.
A language model working directly from text must infer how a method operates, and a coding agent exploring a repository must discover which files matter. A validated MCP server gives the agent a more constrained set of operations. The tools have names, inputs, outputs and links back to source code. The environment has already been tested. The workflows can be encoded in prompts. This does not eliminate model error, but it narrows the space in which the model is improvising.
The architecture also illustrates why interoperability standards are becoming strategically important in AI. If every research group builds a custom assistant around a proprietary interface, paper agents will remain isolated. A common protocol makes it possible to connect many independent research objects to different AI systems. The same logic has already driven MCP adoption in software development and enterprise tools; Paper2Agent applies it to scientific methods and datasets.
That openness can reduce vendor lock-in, but only partially. The agents used in the study still depend on commercial or hosted AI models, compute resources, software packages and external services. Model behavior and pricing can change. Some scientific tools require API keys or licensed data. Interoperability at the protocol level does not guarantee that every underlying resource will be open, inexpensive or permanently available.
What the system does not prove
The strongest claims that could be made about Paper2Agent are also the ones that require the greatest caution. The study demonstrates that an AI framework can transform many computational papers into useful, validated interfaces and can perform well on the authors’ benchmarks. It does not demonstrate that any arbitrary paper can be converted successfully. In the 100-paper computational-biology sample, more than a quarter could not be fully agentified.
Nor do high benchmark scores establish that an agent’s open-ended scientific interpretations are automatically trustworthy. Many benchmark questions have objective or reproducible answers: a score, a figure, a result produced by a reference pipeline. Scientific reasoning often involves ambiguous evidence, competing models and incomplete data. The Nature authors explicitly state that agreement with a single reference on open questions is better understood as a measure of faithful execution than as proof of analytical validity.
The paper also does not show autonomous discovery in the popular sense of an AI independently choosing a research programme, conducting new laboratory experiments and establishing a finding without human oversight. In the psoriasis example, the system proposed analytical strategies and combined existing datasets, but a human selected the validation approach. The authors say hypothesis generation and mechanistic interpretation remain human-in-the-loop.
Those caveats make the work more, not less, relevant. The practical value of an AI research assistant may depend less on grand claims of replacement and more on whether it reliably handles the repetitive, technical and integration-heavy work that consumes scientists’ time. A system that makes published methods easier to reuse could accelerate research without needing to become an autonomous authority.
Security, intellectual property and maintenance
Turning static papers into active software also creates new risks. A PDF cannot normally execute code when another researcher reads it. An agent can. Once research methods become callable tools connected to language models, the familiar security problems of software systems enter scientific publishing more directly: vulnerable dependencies, malicious repositories, exposed credentials, unsafe tool permissions and untrusted inputs all become relevant.
The Paper2Agent authors acknowledge security, intellectual-property and attribution challenges. Those issues could become significant if agentified papers begin to incorporate licensed datasets, patented techniques, patient-level information or commercial software. A journal may have the right to publish an article but not to redistribute every external resource required to run its methods. An agent that automatically composes tools across papers could also blur lines around credit if provenance is not preserved carefully.
Maintenance is another problem. Scientific code ages. Dependencies are deprecated, APIs change, model files move and operating systems evolve. The paper argues that agents should be maintained alongside code repositories and notebooks, but that creates a long-term responsibility that academic publishing has not fully solved even for existing software. A useful paper agent today could become misleading tomorrow if the server continues to answer questions after its underlying environment has drifted.
The Stanford framework tries to mitigate this by recording tool provenance and validating generated functions against source code and expected outputs. But a durable ecosystem would likely require versioning, automated revalidation, security review and clear indicators showing whether an agent is current. Those governance questions lie beyond the immediate Nature study, yet they will determine whether agent-native publishing can move from research prototype to dependable infrastructure.
A different kind of interface for scientific knowledge
The larger conceptual shift is about interface design. A paper is written for people. A code repository is written for programmers. A dataset may be documented for specialists. Paper2Agent tries to make all three accessible through a conversational layer without discarding their underlying structure. The user can ask a question in ordinary language, while the agent maps that request onto a validated analytical operation.
That could be particularly valuable across disciplinary boundaries. A geneticist may want to use an econometric method, or an astrophysicist may need a statistical package developed in another field. Today, the barrier is not always conceptual difficulty; it is often the time required to understand the implementation conventions of a different research community. An executable paper agent could lower that friction by exposing a common interaction model.
There is also an educational implication. Researchers in training could use an agent to explore why a method behaves as it does, reproduce figures and test alternative inputs. Used carefully, that could make sophisticated computational work more accessible. Used carelessly, it could also hide assumptions behind a friendly interface. The more convenient an agent becomes, the easier it may be for users to run a method without understanding whether its assumptions fit their data.
For that reason, provenance may become as important as convenience. Paper2Agent’s tools include references back to the original source code, and the framework records steps during construction. A mature scientific agent ecosystem would need to preserve that traceability so researchers can move from a conversational answer back to the exact code, data and version that produced it.
Implications for journals and publishers
If research papers become interactive, publishers face a decision about whether they remain distributors of documents or evolve into hosts of executable research objects. The infrastructure requirements are very different. Static articles can be archived for decades with comparatively modest maintenance. Active agents need compute, dependency management, access controls, security updates and monitoring.
One possibility is that journals would not host the agents themselves but require authors to provide standardized endpoints, much as papers now link to repositories or data archives. Another is that universities, funders or public infrastructure providers would operate trusted agent registries. The use of an open protocol such as MCP makes either architecture more plausible because the interface can remain consistent even if the underlying hosting model varies.
Peer review could also change. Reviewers might be able to query a method directly, rerun key analyses or test a paper’s code against alternate inputs before publication. That could strengthen scrutiny of computational work, but it could also add to reviewers’ workload and create disputes about what exactly must be validated. An agent that faithfully reproduces flawed code is reproducible, but not necessarily scientifically correct.
The possibility of an “agent availability” statement is therefore more than a technical footnote. It raises questions about what future scientific publication is expected to contain. Data availability asks where the evidence resides. Code availability asks how the analysis was performed. Agent availability would ask whether the research contribution has been packaged in a form that another scientist—and increasingly another AI system—can use directly.
The economics of reusable research
There is a practical economic argument behind the idea. Scientific institutions spend enormous amounts of skilled labor reproducing setup work that has already been performed elsewhere: configuring environments, reading documentation, translating file formats and writing glue code between tools. If a validated agent can turn a published method into a reusable service, some of that labor could shift toward interpretation, experiment design and verification.
The reported costs in the Stanford study are small at the level of individual demonstrations—around $13 to $14 to generate the Scanpy and AlphaGenome tool sets in the researchers’ configurations, with lower per-query costs than a direct-repository baseline. But those numbers should not be extrapolated simplistically. At the scale of millions of papers, hosting, model inference, security, maintenance and repeated validation could become substantial expenses.
The economic question may therefore be who pays to keep scientific agents alive. Authors may maintain them for a few years; commercial publishers may bundle them into subscriptions; universities may operate shared infrastructure; or open-source communities may support the most widely used methods. Different disciplines are likely to adopt different models, particularly where data-access rules and commercial licensing vary.
Why the timing matters
Paper2Agent arrives as agentic AI is moving from demonstration to infrastructure. Language models are increasingly being connected to browsers, coding environments, databases and specialized scientific tools. At the same time, researchers and regulators are questioning how much autonomy such systems should have and how their actions can be audited. Scientific use raises those questions in unusually demanding form because an incorrect answer may contaminate later research rather than merely inconvenience a user.
The Stanford approach is notable because it does not rely only on making the underlying model more capable. Instead, it tries to improve reliability by structuring the environment around the model. The AI is given tested tools, explicit resources, encoded workflows and traceable code references. That design philosophy mirrors a broader shift in applied AI: useful systems increasingly depend on orchestration, permissions, evaluation and interface standards as much as on raw model intelligence.
For science, that may be a more realistic route to near-term gains than waiting for a model that can understand every paper perfectly. A paper-specific agent can be narrower, better grounded and easier to test. Thousands of such agents, each representing a method or dataset, could then be combined when needed. The challenge is ensuring that modularity does not create a new layer of complexity, security risk and maintenance debt.
What happens next
The Paper2Agent code has been made publicly available, and the study provides public examples including AlphaGenome, Scanpy and TISSUE MCP servers. That openness will allow outside researchers to test whether the results hold across different models, disciplines and software environments. Independent replication will be particularly important because much of the evaluation was designed and conducted by the same team that built the system.
The most informative next tests may be deliberately mundane. Can an agent still reproduce a paper six months after key dependencies change? Can a third-party laboratory build a paper agent without help from the original authors? Can the system detect when a repository is incomplete rather than silently inventing a substitute? Can two institutions run the same agent and obtain consistent outputs? Those questions will matter more for scientific infrastructure than a single dramatic benchmark.
Another test will be whether researchers actually want to publish methods in agent-ready form. Doing so could increase reuse and citations, but it may also require additional documentation and maintenance. Incentives in academic science have historically favored publishing new results more than maintaining old software. Agent-native publishing would work best if institutions reward the less glamorous work required to keep methods reproducible.
A promising prototype, not an autonomous scientist
Paper2Agent is best understood as a significant experiment in how scientific knowledge might be packaged for an AI-mediated research environment. Its strongest demonstrated capability is not independent scientific authority but reliable access to published computational methods. In the Nature study, validated paper agents frequently outperformed general-purpose agents given direct access to repositories, and the framework generalized beyond the initial genomics examples.
At the same time, the failures are part of the result. Twenty-six of 100 computational-biology papers in the large-scale test could not be fully converted into executable agents. Open-ended interpretations remained less reliable than structured execution tasks. Security, intellectual-property and maintenance issues remain unresolved. And the authors themselves insist that hypothesis selection and scientific evaluation remain human responsibilities.
That combination of capability and limitation may be precisely what makes the work important. Scientific AI does not need to replace the scientist to change the practice of science. If research papers can become tested, queryable and interoperable objects—capable of reproducing their own methods and collaborating with other published tools—the friction between discovery and reuse could fall substantially.
The immediate story is a new Stanford system published in Nature. The larger story is a possible change in the architecture of scientific communication: from papers that describe what researchers did to research objects that can help others do it again. Whether that model becomes standard will depend not only on better AI, but on reproducible code, open interfaces, durable infrastructure and a culture willing to treat maintenance and provenance as part of the scientific record.
