Stanford’s Paper2Agent Turns Research Papers Into AI Agents That Can Rerun Their Own Experiments

TL;DR

• Stanford researchers led by James Zou published Paper2Agent, an open-source framework that turns scientific papers into interactive AI agents.
• The tool uses the Model Context Protocol (MCP) to wrap a paper’s code, data, and methods into a live agent you can question, run, and reuse.
• Across a test set of 136 papers, 74 of 100 computational biology papers were successfully converted into working paper agents.
• The team is blunt about the limits: don’t treat these agents as authoritative, and don’t feed them unprotected sensitive health data.

From Static PDF to Something You Can Argue With

Paper2Agent, or P2A, comes out of a Stanford lab run by James Zou, and it landed in Nature on September 16, 2026. The pitch is almost embarrassingly simple once you hear it: instead of a paper sitting there as thirty pages of prose, tables, and a GitHub link nobody clicks, P2A wraps the paper’s underlying code and data into an agent you can actually talk to.

That agent can answer questions about the method. It can rerun the original analysis. It can take a new dataset and apply the paper’s approach to it, and it can even hand off work to other paper agents built the same way. The mechanism doing the heavy lifting is the Model Context Protocol, the same MCP standard quietly becoming the plumbing for how LLM agents reach outside their own context window and touch real tools, real code, real files.

“Papers have been static documents for centuries,” the team writes. “Paper2Agent turns them into active AI agents that can answer questions, apply their methods, and collaborate with other papers to make new discoveries.” That’s a big claim for a research tool, and the numbers behind it are more modest than the sentence suggests, which is honestly refreshing for a paper about AI. Across 136 papers put through the pipeline, the benchmark reporting focused on a subset of 100 computational biology papers. Of those, 74 came out the other side as functioning agents. The other 26 didn’t. The code is on GitHub under jmiao24/Paper2Agent, open for anyone who wants to try agentifying their own work.

Why Turning a Paper Into Software Changes Who Gets to Trust It

There’s one detail that makes this more than a neat demo. Most “chat with your research” tools floating around right now are glorified RAG pipelines: they read a paper’s text, chunk it, embed it, and let you ask questions answered purely from the words on the page. They’re good at summarizing what a paper says. They’re useless at actually doing what the paper did.

Paper2Agent is a different animal because it doesn’t stop at the text. It reaches into the paper’s codebase and dataset and converts them into executable MCP tool servers, meaning the agent can literally run the analysis, not just describe it. That’s my one analogy for the day: it’s the difference between a cookbook that tells you a recipe worked and a kitchen robot that can go make the dish again, tonight, with your ingredients, and tell you if it comes out different.

I’ve watched enough “chat with your PDF” pitches fall apart the moment someone asks a follow-up question the summarizer wasn’t built to answer, and this is the first framework I’ve seen that sidesteps that failure mode by refusing to stay in the text layer at all.

So what happens when a paper stops being a record of what someone did and starts being software that can redo it on demand? For one, it puts pressure on the parts of science that survived purely because nobody had time to check them. A method that only works when you squint at the supplementary materials the right way is going to have a much harder time hiding once it’s an agent that either runs or doesn’t. Is a 74 percent conversion rate a triumph or a quiet indictment of how much published computational biology code doesn’t reproduce cleanly on the first try? Both, probably.

But the competitive angle matters too. Plenty of outfits are building “chat with science” products that are really just search wrapped in a chatbot. Paper2Agent’s bet is that the actual value was never in summarizing text, it was in the code nobody was running. If that bet is right, the summarization-only tools end up looking like a translator who can describe a machine but can’t switch it on.

The Reproducibility Problem This Is Actually Trying to Fix

The background here matters more than it might seem. Scientific publishing has run on static PDFs and supplementary zip files for decades, and reusing someone else’s method has traditionally meant downloading their code, fighting their dependencies, and hoping their README wasn’t written at 2am the night before a deadline. That friction is a big part of why so much published computational work never gets reused by anyone outside the original lab.

Paper2Agent’s entire premise depends on collapsing that friction. If a paper can be converted into an agent automatically, the labor of “can I get this to run on my machine” theoretically moves from every downstream reader to a one-time conversion step done at publication. That’s a genuinely different economics of reuse, assuming the conversion actually works reliably, which right now it does for about three-quarters of the biology papers tested and clearly not for all of them.

Consider why 26 out of 100 papers failed to convert. The story doesn’t spell out the specific reasons, but the honest framing from the authors, that this is an augmentation tool and not an authoritative source, tells you they already know the failures matter as much as the successes. Papers with messy dependencies, missing data, or code that was never meant to run outside one grad student’s laptop are exactly the kind of thing that would break a system trying to automate execution. What does it say about decades of published computational biology that a quarter of it can’t be coaxed back into running at all?

Three Things Worth Watching as Paper2Agent Spreads

Watch whether Paper2Agent gets adopted beyond computational biology, where it was benchmarked, into fields with messier data and less standardized code, like clinical research or materials science. Watch how journals respond: does Nature or any other publisher start asking authors to submit an agent-ready repository alongside the manuscript, the way they already ask for data availability statements? And watch the failure rate over time. If future versions push that 74-out-of-100 number meaningfully higher, it means the tooling is maturing. If it stays flat, the ceiling might just be set by how badly research code gets written in the first place, and no amount of clever MCP wrapping fixes that.

Source: The Register