GRAPHIC APPAREL SHOPResearch papers are traditionally require readers and reviewers to interpret code, methods, and results independently. Paper2Agent aims to transform published research into interactive AI agents allowing quick and easy validation of technical claims.
Developed by a team at Stanford University, the framework enables research papers to respond to questions, execute their own code, and guide users through methodologies, helping to make advanced scientific knowledge more accessible and actionable for a broad range of researchers and engineers.
The Problem & The Solution
Anyone who has tried to reproduce results from a research paper knows the frustration. Whether you are interested in using the technology or are helping with peer reviews, reproducibility is a notorious problem.
You may download the code, wrestle with dependencies, decipher minimal documentation, and often spend more time fighting with the setup than exploring the actual science. This barrier between published research and real life implementation creates a significant bottleneck in scientific progress, limiting both reproducibility and the adoption of innovations.
Paper2Agent aims to simplify this process by automatically converting research papers and their associated codebases into interactive AI agents available through an MCP server(Model Context Protocol).
These agents actively assist users through natural language interactions, execute complex workflows, and provide the kind of guidance that would typically require direct communication with the original authors.
Key Features
- Automated Agent Generation: Transforms any research codebase into an interactive AI agent with minimal human intervention
- Multi-Agent Pipeline: Uses specialized AI agents for tutorial scanning, code execution, tool extraction, and testing
- MCP Integration: Creates Model Context Protocol servers that work seamlessly with Claude Code and other AI assistants
- Comprehensive Testing: Automatically generates and runs tests to ensure extracted tools work reliably
- Natural Language Interface: Enables complex scientific queries through conversational interactions
Why I Like It
What makes Paper2Agent particularly compelling is its approach to democratizing access to cutting-edge research and facilitating peer review. Rather than requiring users to become experts in every tool and method they want to use, it creates knowledgeable assistants that can guide both novices and experts through complex scientific workflows.
The framework's focus on the Model Context Protocol (MCP) architecture also means these agents can integrate seamlessly with existing AI coding assistants like Claude Code, creating a natural workflow for computational scientists.
Under the Hood
Paper2Agent employs a four-stage pipeline orchestrated by specialized AI agents. The framework is built primarily in Bash and Python, leveraging the FastMCP library for creating MCP servers. The system begins with environment setup and tutorial discovery, where it clones the target repository and identifies valuable tutorial materials using intelligent filtering.
The core of the system lies in its main orchestration script, which coordinates six specialized agents. The tutorial-scanner agent systematically identifies and categorizes tutorial materials, applying quality criteria to determine which tutorials contain reusable functionality.
The tutorial-executor agent then runs these tutorials in isolated environments, ensuring they work correctly and capturing their outputs. The tool extractor analyzes the executed tutorials to identify reusable functions and wraps them in standardized API interfaces.
# Basic Paper2Agent usage
bash Paper2Agent.sh \
--project_dir TISSUE_Agent \
--github_url https://github.com/sunericd/TISSUE
# With tutorial filtering
bash Paper2Agent.sh \
--project_dir Scanpy_Agent \
--github_url https://github.com/scverse/scanpy \
--tutorials "Preprocessing and clustering"
The most innovative aspect of Paper2Agent is its use of the Model Context Protocol, which creates standardized interfaces for AI agents to interact with external tools and services. This allows the generated paper agents to be easily integrated into existing AI-powered workflows, making them immediately useful to researchers who are already using tools like Claude Code or Gemini CLI for their computational work.
Use Cases
The framework has shown to be particularly valuable in computational biology and genomics research. The team has successfully created agents for AlphaGenome, enabling researchers to interpret genomic variants and identify causal genes for diseases like Hypoalphalipoproteinemia, a condition characterized by extremely low levels of high-density lipoprotein (HDL) cholesterol in the blood. Users can simply provide gene expression data and variant information, and the agent handles the complex analysis pipeline automatically.
In single-cell genomics, Paper2Agent has transformed tools like Scanpy and TISSUE into interactive agents. Researchers can now perform sophisticated spatial transcriptomics analysis by simply uploading their data and describing their analysis goals in natural language, rather than spending hours learning complex APIs and parameter configurations.
Beyond genomics, Paper2Agent represents a potential powerful tool for any field where computational methods are published with accompanying code. Whether in machine learning, computational physics, or bioinformatics, the framework can transform static research artifacts into active, helpful assistants that lower the barrier to adopting new methodologies.
Community
Paper2Agent is released under the MIT License, encouraging widespread adoption and contribution. The project is positioned to garner attention in the AI and computational biology communities, with a space for discussions on platforms like Hugging Face about its potential applications and implications.
The team has made several pre-built agents available as remote MCP servers hosted on Hugging Face, allowing users to immediately start using agents for AlphaGenome, Scanpy, and TISSUE without going through the full setup process. This demonstrates the framework's potential for creating a collaborative ecosystem of AI-powered research tools.
Usage & License Terms
Paper2Agent is distributed under the MIT License, which grants users broad permissions to use, modify, and distribute the software. The license allows for both academic and commercial use, with the only requirements being to include the original copyright notice and license text in any redistributions. This permissive licensing approach aligns with the project's goal of democratizing access to research tools and encouraging widespread adoption.
About the Authors
Paper2Agent was developed by a team of researchers at Stanford University. Jiacheng Miao, the lead author, is a postdoctoral scholar in the Department of Genetics working under the supervision of Jonathan Pritchard. The project also involves James Zou, an Associate Professor of Biomedical Data Science at Stanford who leads research on making machine learning more reliable and human-compatible, particularly in health applications.
The work emerges from Stanford's rich ecosystem of AI and biomedical research, where Dr. Zou's lab focuses on developing AI systems that are statistically rigorous and practical for real-world applications. As a two-time Chan-Zuckerberg Investigator and director of Stanford's Data4Health hub, Dr. Zou brings significant expertise in translating AI research into practical tools for the scientific community.
Impact Potential
Paper2Agent addresses one of the most pressing challenges in modern science: the reproducibility crisis. By automatically converting research papers into interactive, well-tested agents, it significantly lowers the technical barriers that prevent researchers from building upon each other's work. This could accelerate the pace of scientific discovery by making cutting-edge methods immediately accessible to researchers who lack the technical expertise to implement them from scratch.
The framework represents a step toward a future where AI agents serve as collaborative research partners and than just tools. By creating a standardized way to wrap research functionality in conversational interfaces, Paper2Agent enables a new mode of scientific interaction where researchers can explore methodologies through natural dialogue, ask "what if" questions, iteratively refine their analyses and potentially uncover new discoveries.
Perhaps most importantly, Paper2Agent democratizes access to advanced computational methods. Graduate students, researchers in developing countries, and scientists working outside their primary expertise can now leverage sophisticated techniques without investing months in learning new programming frameworks or debugging complex installations.
Background & Related Work
Paper2Agent sits within a rapidly evolving ecosystem of agentic frameworks and Model Context Protocol (MCP)-aligned systems. Its distinctive contribution is the end-to-end automation that starts from a research paper’s codebase and generates a robust, testable MCP server wired with tools distilled from runnable tutorials and not just API wrappers.
Open-source peers include multi-agent coding and orchestration frameworks such as AutoGen (Microsoft), LangGraph (LangChain’s DAG/graph runtime for agents), AgentScope, and research prototypes like OpenDevin.
In the MCP-specific space, recent work like Code2MCP explores automated transformation of code repositories into MCP services, and MCP for Science & HPC documents lessons from deploying MCP in scientific settings. These efforts are complementary: Paper2Agent is uniquely focused on extracting research workflows from tutorials, running them, testing them, and standardizing them as MCP tools.
On the closed-source or service side, platforms like Claude Code (used directly by Paper2Agent), OpenAI Assistants (Now Responses), Azure AI Agents, and NotebookLM provide agentic interfaces but typically require developers to hand-author tools or skills. Paper2Agent reduces that authoring burden by programmatically discovering, executing, and distilling tools from the source tutorials themselves.
Architecture Deep Dive
At a high level, Paper2Agent orchestrates six steps via Bash scripts and prompt-defined agents.
The main entrypoint Paper2Agent.sh manages the steps: (1) project setup; (2) repository clone; (3) working folders; (4) adding a context MCP; (5.1) environment setup and tutorial scanning; (5.2) notebook execution; (5.3) tool extraction; (5.4) MCP wrapping; and (6) MCP launch. Each step writes progress markers and rich artifacts (JSON/MD reports, notebooks, tool modules).
The framework’s agents (documented in agents/)include: (i) tutorial-scanner, which classifies candidate tutorials and enforces quality gates; (ii) tutorial-executor, which executes notebooks in an isolated environment; (iii) tutorial-tool-extractor-implementor, which lifts reusable functions into tool modules with clear IO; and (iv) a test-verifier-improver loop that iteratively hardens tools. Prompts in prompts/ define strict validation and output schemas (e.g., JSON reports for scans and includes).
Outputs are structured to support auditability and reuse: reports/ for scanning and environment summaries, notebooks/ for executed tutorials (with images), tests/ for generated test harnesses and logs, src/tools/ for tool modules, and a generated src/<repo_name>_mcp.py that mounts the tools as an MCP server via FastMCP. Templates under templates/ illustrate the end product—e.g., a minimal MCP server that imports tools and runs over HTTP.
For reliability, Paper2Agent provisions an isolated Python environment (≥3.10) per project, installs dependencies (often via uv/pip), and records environment details. This isolation is crucial when executing third-party tutorials that may assume specific package versions or OS-level libraries.
Working With The Generated Notebooks
After execution, finalized notebooks are written under notebooks/<tutorial_file_name>/<tutorial_file_name>_execution_final.ipynb, with any generated figures under images/. These notebooks capture the runnable, verified workflow distilled from the original tutorial, including data loading, preprocessing, model calls, and visualization.
You can open these notebooks in JupyterLab or VS Code:
# From your project directory
python -m pip install jupyterlab # if needed
jupyter lab # or: code notebooks/ (to open in VS Code)
To reuse a workflow cell-by-cell with your data, identify the cells that encapsulate parameter inputs (e.g., file paths, model names, thresholds). Many extracted tools also have Python modules under src/tools/. You can import and call them directly from a fresh notebook or script:
# Example: calling a generated tool function (pattern)
from src.tools.score_batch import score_batch_variants
result = score_batch_variants(
api_key="<YOUR_API_KEY>",
vcf_file="data/variants.csv",
organism="human",
sequence_length="1MB",
score_rna_seq=True,
score_atac=True,
out_prefix="my_results"
)
print(result["message"]) # e.g., path to artifacts
Paper2Agent’s orchestration uses Bash scripts. On Windows, it’s recommended to run within WSL or Git Bash to execute .sh scripts reliably. The generated MCP servers and Python tools work cross-platform as long as the environment dependencies are satisfied.
Conclusion
Paper2Agent embodies a vision of science where knowledge is not just published but actively shared through intelligent, helpful agents. By transforming static research papers into dynamic, interactive systems, it creates new possibilities for scientific collaboration and discovery.
Whether you're a computational researcher looking to make your work more accessible, a scientist seeking to adopt new methods, or an AI enthusiast interested in the intersection of large language models and scientific computing, Paper2Agent offers a compelling glimpse into the future of research dissemination. Explore the repository, try the pre-built agents, or contribute to this exciting new paradigm for scientific knowledge sharing.
References
(Miao et al., 2025) Paper2Agent: Reimagining Research Papers As Interactive and Reliable AI Agents.
(Ouyang et al, 2025) Code2MCP: A Multi-Agent Framework for Automated Transformation of Code Repositories into Model Context Protocol Services.
(Pen et al, 2025) Experiences with Model Context Protocol Servers for Science and High Performance Computing.
(Microsoft, 2023–2025) AutoGen multi-agent framework.
(LangChain, 2024–2025) LangGraph agent runtime.
(Agenscope, 2025) AgentScope 1.0.
(OpenDevin, 2024–2025) OpenDevin: autonomous coding agents.
(Anthropic, 2024–2025) Claude Code (used to connect MCP servers).
Paper2Agent: Transforming Research Papers into Interactive AI Agents
Paper2Agent: Reimagining Research Papers As Interactive and Reliable AI Agents