Paper deep dive

ToolRosetta: Bridging Open-Source Repositories and Large Language Model Agents through Automated Tool Standardization

Shimin Di, Xujie Yuan, Hanghui Guo, Chaoqian Ouyang, Zhangze Chen, Ling Yue, Libin Zheng, Jia Zhu, Shaowu Pan, Jian Yin, Min-Ling Zhang, Yong Rui

Year: 2026Venue: arXiv preprintArea: cs.SEType: PreprintEmbeddings: 62

Intelligence

Status: succeeded | Model: google/gemini-3.1-flash-lite-preview | Prompt: intel-v1 | Confidence: 96%

Last extracted: 3/13/2026, 12:07:38 AM

Summary

ToolRosetta is an automated framework that bridges the gap between heterogeneous open-source code repositories and LLM-based agents by standardizing code into Model Context Protocol (MCP) services. It utilizes a multi-agent architecture (Planning, Tool-search, MCP-construction, Security, and Review agents) to autonomously discover, convert, and validate tools, significantly reducing human effort and improving task completion performance across diverse scientific domains.

Entities (5)

GitHub · platform · 100%LLM · technology · 100%Model Context Protocol · protocol · 100%ToolRosetta · framework · 100%RosettaEval · benchmark · 95%

Relation Signals (4)

ToolRosetta → standardizes → GitHub Repositories

confidence 100% · ToolRosetta implements an open tool pool invocation mechanism that autonomously converts arbitrary GitHub repositories into standardized MCP services.

ToolRosetta → utilizes → Model Context Protocol

confidence 100% · translates open-source code repositories and APIs into MCP-compatible tools

ToolRosetta → evaluatedby → RosettaEval

confidence 95% · using the 387-task RosettaEval benchmark as the retrieval source

ToolRosetta → augments → Agent Systems

confidence 90% · We inject ToolRosetta-converted tools into RepoMaster and OpenAgents... both systems improve consistently.

Cypher Suggestions (0)

No Cypher suggestions yet.

Abstract

Abstract:Reusing and invoking existing code remains costly and unreliable, as most practical tools are embedded in heterogeneous code repositories and lack standardized, executable interfaces. Although large language models (LLMs) and Model Context Protocol (MCP)-based tool invocation frameworks enable natural language task execution, current approaches rely heavily on manual tool curation and standardization, which fundamentally limits scalability. In this paper, we propose ToolRosetta, a unified framework that automatically translates open-source code repositories and APIs into MCP-compatible tools that can be reliably invoked by LLMs. Given a user task, ToolRosetta autonomously plans toolchains, identifies relevant codebases, and converts them into executable MCP services, enabling end-to-end task completion with minimal human intervention. In addition, ToolRosetta incorporates a security inspection layer to mitigate risks inherent in executing arbitrary code. Extensive experiments across diverse scientific domains demonstrate that ToolRosetta can automatically standardize a large number of open-source tools and reduce the human effort required for code reproduction and deployment. Notably, by seamlessly leveraging specialized open-source tools, ToolRosetta-powered agents consistently improve task completion performance compared to commercial LLMs and existing agent systems.

PDF

Open source PDF →Open local PDF →

Trouble viewing inline? Open PDF directly →

Full Text

62,044 characters extracted from source content.

Expand or collapse full text

ToolRosetta: Bridging Open-Source Repositories and Large Language Model Agents through Automated Tool Standardization Shimin Di 1† , Xujie Yuan 2† , Hanghui Guo 1† , Chaoqian Ouyang 2 , Zhangze Chen 3 , Ling Yue 4 , Libin Zheng 2 , Jia Zhu 3 , Shaowu Pan 4 , Jian Yin 2 , Min-Ling Zhang 1* , Yong Rui 1 1 Southeast University, Nanjing, China . 2 Sun Yat-sen University, Zhuhai, China . 3 Zhejiang Normal University, Jinhua, China . 4 Rensselaer Polytechnic Institute, Troy, USA . *Corresponding author(s). E-mail(s): zhangml@seu.edu.cn; Contributing authors: shimin.di@seu.edu.cn; yuanxj8@mail2.sysu.edu.cn; ghh1125@zjnu.edu.cn; ouychq@mail2.sysu.edu.cn; zjnuczz@zjnu.edu.cn; yuel2@rpi.edu; zhenglb6@mail.sysu.edu.cn; jiazhu@zjnu.edu.cn; pans2@rpi.edu; issjyin@mail.sysu.edu.cn; yongrui@lenovo.com; † These authors contributed equally to this work. Abstract Reusing and invoking existing code remains costly and unreliable, as most practi- cal tools are embedded in heterogeneous code repositories and lack standardized, executable interfaces. Although large language models (LLMs) and Model Con- text Protocol (MCP)–based tool invocation frameworks enable natural language task execution, current approaches rely heavily on manual tool curation and stan- dardization, which fundamentally limits scalability. In this paper, we propose ToolRosetta, a unified framework that automatically translates open-source code repositories and APIs into MCP-compatible tools that can be reliably invoked by LLMs. Given a user task, ToolRosetta autonomously plans toolchains, identifies relevant codebases, and converts them into executable MCP services, enabling end-to-end task completion with minimal human intervention. In addition, Tool- Rosetta incorporates a security inspection layer to mitigate risks inherent in executing arbitrary code. Extensive experiments across diverse scientific domains demonstrate that ToolRosetta can automatically standardize a large number of open-source tools and reduce the human effort required for code reproduction and deployment. Notably, by seamlessly leveraging specialized open-source tools, ToolRosetta-powered agents consistently improve task completion performance compared to commercial LLMs and existing agent systems. 1 arXiv:2603.09290v1 [cs.SE] 10 Mar 2026 Keywords: Large Language Model, Agentic AI, Model Context Protocol, AI for Science 1 Introduction Code engineering has long been plagued by the persistent challenges of reusing, repro- ducing, and invoking existing code [1–3]. Subsequent developers often need substantial time and efforts to understand, configure, and reproduce code repositories, tools, and systems that have already consumed significant resources by original develop- ers. Advanced systems either provide an executable development environment (e.g., GitHub Codespaces) or allow the model to understand repository contents and analyze files (e.g., GitMCP and GitHub MCP Server. However, they still operate at the level of code understanding. The code itself has not been automatically transformed into tools that can be directly invoked by humans at low costs. This fundamental problem has not been substantially mitigated by advances in artificial intelligence (AI). On the contrary, as programming AI [4] become increasingly required across diverse domains, the challenges of code reproduction and reuse have become even more pronounced. The rapid progress of large language models (LLMs) [5] has partially advanced low-code and no-code paradigms. The strong generative capabilities of LLMs have been demonstrated in simple code generation tasks [6, 7]. Nevertheless, due to limita- tions in the complexity and reliability of generated code, recent research has shifted toward enabling LLMs to invoke and orchestrate external tools to accomplish human tasks. This trend gives rise to tool invocation systems such as HuggingGPT [8], Tool- Former [9] and ToolLLM [10], as well as cross-disciplinary ones in scientific scenarios like ChemCrow [11], Coscientist [12], and SciToolAgent [13]. As institutions including OpenAI, Google, and Microsoft continue to strengthen tool standards such as Model Context Protocol (MCP), the LLM-based tool invocation with MCP has become a new paradigm for reducing knowledge barriers and manual costs [14, 15], such as Manus and OpenClaw. In this paradigm, users need only issue natural language instructions, and models can autonomously orchestrate a chain of standardized tools to complete complex tasks ranging from data querying [16] and code execution [17] to scientific experiment design [18, 19]. However, this paradigm conceals the fundamental tension between the massive scale of available tools and the limited availability of human labor: (1) massive tools lack standardization, resulting in low success rates for invocation, (2) tool standard- ization relies heavily on manual effort, making it difficult to scale. Most practically valuable tools remain embedded within large code repositories (e.g., GitHub), where tools exhibit heterogeneous interfaces, inconsistent dependency configurations, and diverse implementation styles. As a result, the success rate of directly invoking such tools using LLMs remains low [20, 21]. Furthermore, transforming a GitHub repository into an MCP tool requires understanding the code, parsing dependencies, rewrit- ing interfaces, designing schemas, and building servers. At present, nearly all MCP tools are manually wrapped on a case-by-case basis. This reliance on human labor fundamentally limits the scalability of LLM-based tool invocation under the MCP framework. Consequently, whether constructing tool collections [9, 13] or encapsulat- ing tools for invocation [22], the process still depends on manual coding, manual API curation, and manual environment debugging—ultimately returning to the original pain points of code engineering: high cost and slow reproducibility. 2 Different languages C++PythonJavaC# ...... Different APIs UniProt ...... Different Platforms Different Libraries ZINC Spaces RCSB PDB BenchSciDeepchem HuggingfaceTrochDrug ...... TensorFlow Sympy Numpy Pandas ...... TOOL ROSETTA MCP.CALL( "tool": [name], "arguments": [action], parameters": ... "... ) MCP Server 1 MCP Server 2 MCP Server N ...... MCP Protocol MCP Protocol MCP Protocol ............ Local files/ storage External APls & apps Remote database LLM . . . User Query User Query MCP TooL MCP Pool & API Pool LLM Github API MCP Tool Code Repository Best Tool （MCP & API） . . . Call MCP Call API MCP + Description API + Description LLM LLM (Search Topic) ... User Query Input Topic Generate Github API Input LLM (Refine Query) LLM (Repo Judge) Not Find Optimize No Github Link Yes Find Repository Input Generate Judge Report Find Repo Retrosynthesis Analysis Results STA/LTA Trigger Detection Results Mutation Predict Lesion Detection Results Pest Classification Results The model identified with 88.7% high confidence that image contains Polyphagotarsonemus latus (broad mite). ✅Successfully detected 33 seismic events Detected Major Events (Top 10): 00:01:13.77 -Duration 1.45 sec ...... COc1c( OC(C)=O)c 1 COc1c(C=O )c(OC)c1OC Two lesion areas were detected ... Physical sciences Earth and environmental sciences Biological sciences Health sciencesScientific community and society COc1c(OC(=O)/C =C/c2c(OC)c(OC)c(OC)c2)c1 Target Compound SMILES: Seismic Waveform Time Series Data 0.000000 → Amplitude 23 0.050000 → Amplitude 25 0.100000 → Amplitude 24 ... 0.950000 → Amplitude 18...... Protein Sequence MENFQKVEKIGEGTYGVV... Q145G Mutation SiteRequest Brain MRI ImagesPest Images Input examples across disciplines Existing fragmented Tools Java RCSB PDB DeepChem Platform Huggingface Platform C++ PYthon ChEMBL UniProt PubChem BenchSci Platform LLM ...... ...... Heterogeneous Hard to invoke Manual wrapping Output examples across disciplines (a) (b) Fig. 1: Overview of ToolRosetta: a) Tool Rosetta’s strength lies in how to auto- matically encapsulate existing open-source libraries into the MCP platform, enabling various specialized problems to be easily solved by calling tools. This approach differs from previous fixed tool and skill libraries; it is an automated, scalable, and unmanned method. b) The pipeline of transforming code into MCP services. As shown in Figure 1 (b), we propose a unified translation framework ToolRosetta that translates code languages from heterogeneous domains—such as code reposi- tories and API interfaces—into the MCP language that LLMs can understand and operate on. Specifically, given a user task, ToolRosetta leverages LLMs to interpret task requirements and autonomously plan an appropriate toolchain. Then it identifies relevant open-source tool libraries capable of performing the task and automatically translates them into MCP services, ensuring reliable tool invocation and execution to 3 ultimately solve the user’s problem (Figure 1 (d)). ToolRosetta introduces two key innovations. First, ToolRosetta automatically wraps existing open-source codebases and APIs into standardized MCP-compatible tools. It substantially reduces the burden on human efforts in reproducing or standardizing existing code, while simultaneously improving the success rate of tool invocation by LLMs. Second, ToolRosetta further inspects and monitors potential malicious vulnerabilities and defects within MCP tools, preventing adversaries from embedding malicious code—such as mechanisms for stealing user data or injecting trojans—into MCP standardization. Unlike existing LLM–based systems that rely on fixed and manually curated tool sets, ToolRosetta introduces a scalable, efficient, and cost-effective mechanism for large-scale tool standardization, enabling rapid scaling to a vast number of tools. Empirical results show that ToolRosetta can automatically transform 1580 open- source tools into standardized and executable interfaces, spanning a wide range of scientific domains, including bological sciences, physical sciences, and health sciences. By leveraging these standardized tools, ToolRosetta achieves substantially higher task completion performance than commercial LLMs and existing scientific agent systems, outperforming the strongest baseline by over 31% in macro-average accuracy across six scientific domains. Moreover, we demonstrate that ToolRosetta can proactively identify and reveal potential security risks in open-source tools, thereby mitigating deployment risks. Physical sciences PhysicsMathematicsChemistryAstronomy Foam - Agent PlasmaPy PyAbel PyDy scikit - hep UFL openmc yt ASE pymatgen qutip pysph atomman CVXPY mpmath PyProj Quadratic Health sciences Signs & Symptoms Neurol ogy Medical Imaging Diseases biosppy NeuroKit MNE - Python nilearn MONAI medpy Analyse S troke lifelines SageMath SciPy sympy pyomo cvxopt phonopy aizynthfinder cclib ChemlibChemPy Open Babel PySCF RDKit TenCirChem VULCAN psi 4 autodE molmass astroML astroquery Lightkurve SunPy gala rebound galpy Biological sciences Systems Biology Structural Biology Psych ology Physi ology tellurium biotite PyMC PsychoPy NeuroKit2 BPt esm SPM Neuros cience Molec ular Microbi ology Gene tics Comp. Biology Cell Bio. Techs Bioche mistry scikit - bio pybedtools deeptools DeepChem scvelo Scanpy scCellFie pysam Biopython Earth & Env. sciences Solid EarthPlanetary OceanEcology ObsPy gstools astronomy Astropy pyPDAF MetPy xarray climlab Climate pyrocko pyephem poliastro xmitgcm Prophet pySDM Society & Community Social Sciences Geography Energy Industry NetworKit pymc - marketing causalml python - igraph GeoPandas mobile - pest - id plantcv agml Agriculture NetworkX SNAP statsmodels Rasterio PyPSA oemof osmnx pygeos pyfolio EigenLedger qlib backtrader SocialSim Computer sciences NLPMachine Learning Graph & Network Data Processing Agent NLTK Stanza TextBlob vaderSentiment spaCy Flair Gensim pyro sktime tsfresh auto - sklearn pmdarima whoosh gmatch4py graph - theory deep - searcher dedupe dateutil dalle - mini langgraph Fig. 2: Overview of the ToolRosetta ecosystem. Each node represents a GitHub repos- itory automatically converted into standardized MCP tool services, organized into five major scientific areas (Physical Sciences, Earth & Environmental Sciences, Biological Sciences, Health Sciences, and Scientific Community & Society) and Computer Sci- ence. Node groupings reflect sub-domain categorization within each area. 2 Results 2.1 Overview of ToolRosetta ToolRosetta is an automated framework designed to bridge the availability- accessibility gap in scientific tool ecosystems. While GitHub hosts over 630 million repositories spanning diverse domains, tool-learning systems typically operate with limited, manually curated toolsets (e.g., 5 tools in ToolFormer [9] and 500+ tools in Sci- ToolAgent [13]). This limitation stems from the labor-intensive process of transforming 4 a b c cd e Fig. 3: Automated tool conversion performance evaluation. a, Radial bar chart of average completion time per subdiscipline for ToolRosetta, human experts, and the GPT-4o service-only baseline. b, repository-level conversion success rates across 35 subdisciplines within six domains. Here GPT-4o denotes the service-only baseline that generates only MCPservice.py, the harder end-to-end full-file baseline is discussed in the text only. c, Joint visualization of success rate versus completion time, where each point represents one subdiscipline. d, Repair-focused ablation showing cumula- tive improvement from successive rounds of the Review-Revise-Fix (RRF) mechanism across six domains. e, Dominant failure types and repairability statistics. repositories into standardized services. To address this challenge, ToolRosetta imple- ments an open tool pool invocation mechanism that autonomously converts arbitrary GitHub repositories into standardized MCP services. As illustrated in Figure 1 (d), the system implements a hierarchical multi-agent architecture. A Planning agent orches- trates the overall conversion workflow. A Tool-search agent retrieves and evaluates candidate repositories using LLM-driven semantic parsing and functional alignment assessment. An MCP-construction agent transforms qualifying repositories into uni- fied MCP service formats through an automated pipeline encompassing repository cloning, semantic analysis, environment configuration, and service generation. Addi- tionally, a Security Agent inspects generated services for potential privacy leakage and security risks. Finally, a Review agent performs root-cause analysis and gener- ates repair plans if validation fails, triggering iterative refinement until all tests pass. As shown in Figure 2, through multi-agent collaboration, Tool Rosetta has success- fully translated 1,580 tools from 122 Github repositories covering 5 major scientific areas (Physical Sciences, Earth & Environmental Sciences, Biological Sciences, Health Sciences, Scientific Community & Society) and Computer Science. 2.2 How well does automated tool standardization work? Standardizing open-source repositories into callable tool services has traditionally required substantial manual effort from trained engineers. ToolRosetta aims to auto- mate this process at scale. To evaluate its performance, we benchmark repository-level conversion on 122 GitHub repositories spanning 35 subdisciplines and six scientific 5 domains, using the 387-task RosettaEval benchmark as the retrieval source. We com- pare ToolRosetta’s initial conversion round (hereafter “first-pass”, i.e. before the Review-Revise-Fix repair loop) against human coding engineers and a GPT-4o service- only baseline that generates only MCPservice.py. Success is defined as exposing at least three validated tool endpoints that an agent can correctly invoke with valid outputs. Overall conversion performance of effectiveness and efficiency. Tool- Rosetta achieves a first-pass success rate of 53.0% across the full 122-repository benchmark, compared with 49.6% for the GPT-4o service-only baseline and 82.9% for human engineers (Fig. 3a–c). When GPT-4o is instead asked to generate the entire repository-to-MCP stack in one shot, the success rate drops to 3.3% (4/122), confirm- ing that end-to-end repository standardization is a fundamentally harder task than single-file service-wrapper synthesis. Performance varies across domains. ToolRosetta is strongest in Health Sciences (70.9%) and Computer Science (66.7%), followed by Physical Sciences (57.3%), Earth & Environmental Sciences (56.6%), and Biological Sciences (45.1%); Scientific Com- munity & Society is the hardest category at 28.6%. The GPT-4o service-only baseline slightly exceeds ToolRosetta in Physical Sciences (61.1% vs. 57.3%) and Biological Sci- ences (47.1% vs. 45.1%), and matches it in Scientific Community & Society (28.6%), but trails in the remaining three domains. This pattern suggests that ToolRosetta’s advantage stems not from superior single-file code synthesis but from its end-to-end handling of environment construction, interface extraction, and validation. Beyond accuracy, ToolRosetta substantially reduces standardization time: it com- pletes conversion in approximately 210.1 s per repository, compared with 1589.4 s (26.5 min) for human engineers, an 86.8% reduction and a 7.6× speedup (Fig. 3c). Although the GPT-4o service-only baseline is faster when restricted to generating MCPservice.py alone, ToolRosetta offers a substantially better trade-off between speed, completeness, and reliability. Failure analysis and iterative repair. To recover first-pass failures, Tool- Rosetta employs a multi-round Review-Revise-Fix (RRF) mechanism that diagnoses errors and applies targeted repairs. As shown in Fig. 3(d), the domain-level macro- average success rate rises from 54.2% to 69.3% after three rounds of repair, an absolute gain of 15.1 percentage points; the weighted benchmark-level rate rises from 53.0% to 68.4%. Most gains accrue in the first round, with diminishing returns thereafter. The largest single-domain improvement occurs in Scientific Community & Society (+24.4 percentage points), where workflow-heavy repositories and complex dependency configurations create a low initial baseline that is nevertheless partially recoverable. Of the 57 repositories that fail in the first pass, 19 are recovered after three RRF rounds while 38 remain unresolved (Fig. 3e). These 57 failures fall into two broad groups. Environment, runtime, and repository-structure issues dominate, accounting for 40/57 (70.2%): environment setup failures alone constitute the largest bottleneck (19/57, 33.3%), followed by untoolable repository structures (10/57, 17.5%), import errors (8/57, 14.0%), and repository-internal bugs (3/57, 5.3%). The remaining 17/57 (29.8%) are code- and specification-centric: API inference errors (12/57, 21.1%) arising from ambiguous signatures or weak documentation, and MCP specification violations (5/57, 8.8%). These results indicate that the primary bottleneck in automated repos- itory standardization has shifted from generating service logic to robustly handling heterogeneous execution environments and irregular repository structures. 6 ab c Fig. 4: Downstream task evaluation on the RosettaEval benchmark. a, Task comple- tion accuracy of ToolRosetta and four baseline systems (SciToolAgent, ChemCrow, RepoMaster, OpenAgents) across 35 subdisciplines spanning six domains. Stars denote 21 out-of-distribution (OOD) subdomains that are not covered by curated baseline tool sets. b, Average task success rate per scientific domain for all five systems. c, Per- formance gain when integrating ToolRosetta-converted tools into two existing agent frameworks (OpenAgents and RepoMaster), with percentage annotations indicating absolute improvement per domain. 2.3 How effective are standardized tools for LLMs? While Section 2.2 demonstrates ToolRosetta’s capability to successfully standard- ize repositories into MCP services, the ultimate goal is to enable agents to leverage these standardized tools for solving real tasks. To evaluate task-solving capability, we compared ToolRosetta against four representative agent systems spanning distinct technical paradigms in tool-augmented agents. SciToolAgent [13] employs expert- curated tool collections with manually designed interfaces for scientific computing. ChemCrow [11] demonstrates domain-specialized agents with crafted prompting tem- plates for chemistry. RepoMaster [20] and OpenAgents [21] exemplify direct repository understanding and execution approaches that bypass standardization layers. Together, these baselines represent the spectrum from manual curation to direct invoca- tion, enabling comprehensive evaluation of ToolRosetta’s automated standardization paradigm. 7 Task-Solving Performance Across Scientific Domains. ToolRosetta achieves a macro-average task completion accuracy of 55.6% across the six scientific cate- gories and 52.1% when averaged across all 35 subdisciplines (Fig. 4a, b). It ranks first in five of the six categories: Physical Sciences (65.8%), Earth & Environmental Sci- ences (62.2%), Health Sciences (61.0%), Scientific Community & Society (60.4%), and Computer Science (44.0%)—with the sole exception being Biological Sciences, where SciToolAgent leads (47.3% vs. 40.2% for ToolRosetta). Automated standardization thus does not dominate every specialist baseline in its home domain, but yields the most balanced performance profile across the full scientific spectrum. The advantage is most pronounced on out-of-distribution (OOD) subdomains that require computational capabilities absent from prior curated tool sets. Among the 21 OOD subdomains marked with stars in Fig. 4(a), ToolRosetta achieves 57.4% average accuracy, compared with 11.7% for SciToolAgent, 3.3% for ChemCrow, 24.0% for RepoMaster, and 21.5% for OpenAgents. This gap underscores a fundamental limitation of fixed tool inventories: even when baseline systems can reason about a task, they cannot execute the required computation if the relevant tools are unavailable. Benefits of Standardized Tools for Other Systems. To disentangle whether the observed gains stem from ToolRosetta’s agent architecture or from the standard- ized tools themselves, we conduct a controlled augmentation experiment. We inject ToolRosetta-converted tools into RepoMaster and OpenAgents while preserving each system’s original architecture, prompting strategy, and reasoning pipeline. As shown in Fig. 4(c), both systems improve consistently. RepoMaster rises from 24.2% to 34.8% in macro-average category accuracy (+10.6%), while OpenAgents rises from 22.0% to 35.4% (+13.4 %). The strongest gains appear in previously under-covered categories such as Earth & Environmental Sciences and Scientific Community & Soci- ety, where the injected tools provide executable capabilities that the original systems lacked. These results confirm that the standardized MCP services function as transfer- able infrastructure. Once generated, they can augment architecturally different agent systems without modification. 2.4 Case studies To demonstrate practical utility beyond quantitative benchmarks and further validate the effectiveness of ToolRosetta, we present three real-world scientific research tasks and one security inspection case: (1) Stroke Analysis; (2) Species Prediction Based on Gene Sequence; (3) Perovskite Material Discovery. 2.4.1 Case 1: Stroke Analysis Stroke analysis is a key task in clinical and biomedical research and is of great sig- nificance for the early diagnosis of the disease, risk assessment, and development of personalized treatment plans [23, 24]. Tool Search: ToolRosetta can automatically discover and retrieve task-related analysis tools on GitHub based on the user’s query. For instance, as shown in Fig. 5, the system identified the Analyse-Stroke repository as a relevant tool for stroke analysis. It then encapsulates the repository into several standardized MCP interface tools. Once encapsulated, the system can autonomously plan and invoke the tools to perform the required tasks. Tool Execution: Based on the user’s query, ToolRosetta first invokes the per- form pcafamdtool to perform principal component analysis. Simultaneously, the system calls the performtsnetool to project high-dimensional samples into a low- dimensional space, enabling visualization of the distribution of stroke and non-stroke samples. The results of these analyses are then returned to the user for further 8 Fig. 5: Workflow and results of stroke analysis using ToolRosetta. exploration. When the user issues new analysis requests, ToolRosetta automatically analyzes and invokes the runfeatureselectiontool, applying chi-square and K-best feature selection methods to preliminarily identify factors potentially associated with stroke. Subsequently, the system calls the run predictionmodeltool to build logistic regression, random forest, and XGBoost, learning more discriminative patterns and assessing the contribution of each factor to stroke outcomes. Finally, in response to user queries regarding causal relationships, ToolRosetta integrates causal analysis meth- ods by invoking the runbatchcausalanalysistool, investigating the potential causal effects of key variables on stroke incidence. The corresponding pipelines are presented in Fig. 5. 2.4.2 Case 2: Species Prediction Based on Gene Sequence Species prediction plays a crucial role in biological, agricultural, and ecological research, significantly contributing to the identification of unknown species, ecosystem diversity assessment, and the development and utilization of agricultural and microbial resources [25, 26]. Tool Search: To satisfy the user’s query about species prediction, ToolRosetta automatically searches GitHub to identify the biopython library as a tool relevant for species prediction. The system then encapsulates it into the MCP, enabling unified management, scheduling, and invocation of the tool in subsequent analysis workflows (see Fig. 6). Tool Execution: Once the necessary tools are prepared, ToolRosetta autonomously orchestrates their invocation according to the user’s needs (see Fig. 6). The system first calls set entrezemail to verify the user’s identity, ensuring secure access to analysis services. If the input gene sequence is valid, validatesequence is invoked to check sequence integrity. Subsequently, calculategccontent is executed to compute the proportion of G and C bases, generating a sequence composition plot to provide a basic genomic feature for preliminary species estimation. In par- allel, ToolRosetta performs a blastsearch against the NCBI database to identify similar sequences, producing a bar chart of the top-k candidate species. The system then calls extractspeciesfromblast to retrieve species information from the filtered 9 Fig. 6: Workflow and results of species prediction using ToolRosetta. BLAST results, generating a heatmap to visualize species distributions. Finally, aggre- gatespeciesscores combines and weights the scores for each species, resulting in a radar chart, and predictspecies determines the most likely species based on the aggregated results. 2.4.3 Case 3: Perovskite Material Discovery Perovskite solar cells have emerged as a central focus of the third-generation pho- tovoltaic revolution due to their exceptional optoelectronic properties and potential for low-cost manufacturing [27, 28]. Consequently, the discovery of new perovskite materials has become a critical endeavor. Tool Search: To address complex user queries on the design of low-lead, high- efficiency and highly stable perovskite solar cells, ToolRossetta automatically discovers and encapsulates a suite of specialized tools. Mining tools include arxiv-mcp for real- time literature retrieval and extract-mcp for structured information extraction. Design tools include MatterGen-mcp for inverse crystal structure generation and CSLLM- mcp for synthesis feasibility reasoning. Simulation tools include CGCNN for bandgap prediction and Pero-ML for device performance regression, including power conversion efficiency (PCE) and open-circuit voltage (Voc). Analysis tools include SHAP-mcp for interpretable feature attribution, as well as Pymatgen and ASE for validating the structural consistency and physical plausibility of generated crystal structures. Tool Execution: During the knowledge preparation stage, ToolRosetta invokes search papers, downloadpaper, and readpaper in sequence to retrieve, download, and parse relevant literature on Sn–Pb mixed systems and low-toxicity additives, then per- sists the processed content via savemarkdownlocally and extracts structured prior data including compositional ratios, processing parameters, and device performance metrics through extractdatafrompapers. Building on these prior data, the materials design stage begins with generatematerialstructure sampling candidate crystal struc- tures from the latent space, after which checksynthesizability filters out physically infeasible formulations; predictsynthesismethod and predictprecursors then jointly determine the synthesis route and precursor requirements, and screencandidates produces a ranked set of experimental plans satisfying all hard constraints. These 10 candidates are subsequently fed into the virtual simulation stage, where pre- dictperovskite yields a full device performance profile covering PCE, Voc, Jsc, F, bandgap, and formation energy, and visualizepredictions, visualizeseriestrend, and visualizecomparison together provide single-material, series-level, and cross-material visualizations to identify the top-ranked candidate. In the final auditing and diagnostic stage, analyzestoichiometry and analyzeorganiccation verify structural and chemical validity, calculatecorrelation uncovers statistical feature–performance relationships, and the SHAP-based tools including shapfeatureimportance, shapsummaryplot, shapanalyzeprediction, and shapdependenceplot deliver multi-granularity inter- pretability analysis, visualizestructure and analyzemechanism then render the optimal structure and synthesize a structure–property diagnostic report returned to the user. Through this closed-loop workflow, ToolRosetta identifies a Sn–Pb mixed per- ovskite formulation with a 50% reduction in lead content, and wet-laboratory experiments validate a power conversion efficiency of 17%, which closely matches the predicted range of 16%–19% obtained from the in silico experiments. 3 Discussion 3.1 Contributions and limitations ToolRosetta is an automated framework that converts heterogeneous code reposito- ries into standardized MCP services, addressing the scalability bottleneck of manual tool curation in existing LLM-based agent systems. Previous frameworks have been restricted by their manually curated toolsets, limiting coverage to pre-defined domains. By contrast, ToolRosetta can dynamically generate domain-appropriate tools on demand from open-source repositories, achieving a 53.0% first-pass conversion suc- cess rate that rises to 68.4% after iterative repair, while reducing standardization time from approximately 26.5 to 3.5 minutes per repository. This capability allows ToolRosetta to maintain 55.6% macro-average task completion accuracy across six scientific categories, including 62.2% in Earth & Environmental Sciences and 60.4% in Scientific Community & Society, where existing systems exhibit near-zero or highly limited performance due to the absence of relevant tools. Moreover, integrating ToolRosetta-converted tools into baseline systems yielded an average improvement of 12.0 percentage points, confirming that the standardized services function as transferable infrastructure that can augment existing agent frameworks. One potential limitation of ToolRosetta lies in the gap between automated and human expert conversion. Our failure analysis reveals two categories of challenges that iterative self-correction cannot fully resolve. Environment reconstruction constitutes the dominant barrier: broken remote dependencies, platform-specific configurations, and implicit system state assumptions resist code-level repair, as they require rea- soning beyond the repository itself. The remaining failures stem from code structure heterogeneity, where repositories designed for interactive exploration (e.g., GUI appli- cations or notebook-based workflows) lack the programmatic interfaces required for standardized tool wrapping. These limitations are not unique to ToolRosetta but reflect broader, open challenges in automated code understanding and environment reproduction []. Moreover, the current implementation focuses on Python reposito- ries, leaving the substantial body of scientific software written in R and C++ outside its scope. We discuss the security implications of open-ecosystem tool ingestion in Section 3.2, and address these scope constraints regarding programming languages (Section 3.3.1) in subsequent sections. 11 System Shell “gmx mdrun –s 1a3n.tpr –nsteps 1000;curl attacker.com/rev.sh|sh” Vulnerable Wrapper Code def run_gromacs(pid,steps): cmd=f”gmx mdrun –s pid.tpr -nstepssteps” os.system(cmd)#INSECURE! Secure Wrapper Code def run_gromacs(pid,steps): cmd=[”gmx”, ” mdrun”, “–s”, fpid.tpr”, “-nsteps”,str(steps)] Subprocess.run(cmd,shell=False) #SECURE! Direct Execution [‘gmx’, ‘mdrun’, ‘–s’, ‘1a3n.tpr’, ‘-nsteps’, ’1000’] Shell Interpreter gmx mdrun (Simulation Started) gmx mdrun (Simulation Started) curl | sh (Reverse Sheli Established) Protein ID: Steps: “1a3n” “1000;curl attacker.com/rev.sh|sh” Protein Folding MCP MCP Tool (Unprotected) Physicia n User Malicious Request AnalyzeStrokeService.load_stroke_data(( file_path="./../secrets/national_1d.csv“) secret s External Attacker/ Public Leak Intended Scope: patient_data/ Intended Scope: patient_data/ Out of Memory 100% HPC Compute Cluster Trigger crash & Financlial loss Node failure Budget Drain Input: High Complexity Guardrail: Resource Quota & Complexity Estimator CPU Normal RAM: Stable HPC Compute Cluster pid="1a3n"(OK:Alphanumeric) steps="1000(OK：Integer) curl attacker.com/rev.sh|sh Guardrail: Input Validation & Parameterized Execution Guardrail : Path Whitelist & Container Isolation Log:[BLOCKED] Path traversal attempt to .../../secrets/ Est. Cost > Threshold? YES Action: BLOCK Vulnerable Flow Secure Flow Fig. 7: Vulnerable vs. secure MCP workflow. 3.2 The Security Paradox of Open Ecosystems Current scientific agent systems are fundamentally constrained by the bottleneck of manual curation. The capabilities of platforms are bounded by the velocity at which experts can maintain their tool repositories. ToolRosetta transcends this lim- itation through automated standardization, empowering agents to leverage long-tail tools from the open-source ecosystem to address out-of-distribution tasks. However, this transition from closed allowlists to an open-world paradigm effectively delegates execution authority to untrusted sources. By autonomously ingesting repositories from GitHub, agents inherit not only functionality but also latent vulnerabilities and malicious logic. Consequently, within automated scientific infrastructure, gains in scal- ability inevitably compromise default security. Without intrinsic defense mechanisms, the very automation that drives ToolRosetta risks becoming a vector for infiltrating scientific workflows. 3.2.1 Automated Governance from External Malicious Attacks To address the unique constraints of scientific computing, we embed defense mech- anisms directly into the MCP generation lifecycle, establishing an automated governance framework grounded in the CIA triad. To address the unique constraints of scientific computing, we embed defense mechanisms directly into the MCP generation lifecycle, establishing an automated governance framework grounded in the CIA triad, as shown in Fig. 7. Confidentiality: Architectural Isolation. Biomedical research demands strict data sovereignty, particularly when handling sensitive information such as patient records in stroke analysis. Since traditional code reviews cannot keep pace with the speed of agent generation, we replace trust-based access controls with mandatory path whitelisting and sandboxing enforced during the build phase. This physical isolation ensures that even erroneous agent requests are blocked at compliance boundaries, guaranteeing data sovereignty by design. Integrity: Logic Decoupling. Scientific workflows frequently rely on fragile legacy code and shell scripts, creating exposure to remote code execution attacks via command injection. Rather than attempting to patch every underlying vulnerability, ToolRosetta rearchitects invocation logic through mandatory parameterized execu- tion. By enforcing a strict separation between data and instructions at the interface level, we create an immune barrier between untrusted inputs and the core system, effectively preventing the execution of malicious payloads. 12 Availability: Computational Circuit Breaking. Unlike standard web services, scientific computing is hypersensitive to resource consumption. Malicious algorith- mic complexity attacks can instantaneously drain HPC resources or incur prohibitive financial costs, often termed financial denial-of-service. ToolRosetta implements pre- computation complexity estimation and resource quotas, shifting governance upstream to the task submission phase. This computational circuit breaker ensures shared infrastructure remains resilient against abnormal loads, preserving the continuous availability of scientific services. 3.2.2 Automated Governance from Internal Random Perturbations Open tool ecosystems face a second safety challenge that arises not from malicious repositories, but from the agent itself. Even when tools are trustworthy, LLM agents may drift from user intent owing to prompt perturbations, incomplete context, mis- interpretation of intermediate results or error accumulation over extended action chains. When such deviations are coupled with high-privilege tools, including deletion, messaging, write access or payment operations, small reasoning errors can produce irreversible consequences. Recent discussion around OpenClaw-style accidental email deletion highlights this risk: the problem is not necessarily unauthorised access, but authorised action without adequate restraint. This challenge is particularly difficult because high-impact actions are often sepa- rated from benign ones by only minor operational differences, while their consequences are profoundly asymmetric. Archiving and deleting, drafting and sending, or local editing and cross-system submission may appear adjacent in an agent’s action space, yet lead to fundamentally different outcomes. It is therefore insufficient to ask only whether a tool can be executed. The more consequential question is whether it should be executed under the current context. In open-world agent systems, permission should not be conflated with unconditional authority. ToolRosetta addresses this problem through risk-aware execution governance. Actions are stratified by consequence, with retrieval and analysis treated as low risk, reversible modification as medium risk, and irreversible or externally commit- ting operations as high risk. Medium- and high-risk actions are surfaced first as execution previews that expose expected scope, affected objects, reversibility and pos- sible side effects. High-risk operations are further placed behind explicit confirmation boundaries, so that agents may prepare actions but cannot autonomously complete irreversible commitments. This design is reinforced by reversibility-first defaults and behavioural circuit breakers, which favour recoverable actions and suspend execution when abnormal action patterns emerge. The result is a shift from binary permission control to bounded autonomy, allowing agents to retain useful operational capacity while constraining high-impact errors before they become irreversible. 3.3 Automated Standardization 3.3.1 Other Coding Languages The current implementation of ToolRosetta focuses primarily on Python repositories. This is, in part, a practical scope decision. Python remains the dominant language in scientific computing, with relatively standardised dependency declarations, accessi- ble function interfaces and a software ecosystem that is more amenable to automated environment reconstruction, tool wrapping and validation. Prioritising Python there- fore provides a stable entry point for repository standardisation under open and heterogeneous conditions. 13 This scope, however, should not be mistaken for a fundamental boundary of the framework. At the architectural level, the core stages of ToolRosetta—repository retrieval, code analysis, environment construction, interface extraction, service wrap- ping, test validation and iterative repair—are not inherently tied to any single programming language. The language-dependent components are concentrated instead in backend-specific layers, including build-system identification, dependency reso- lution, symbol extraction and execution wrapping. Extending ToolRosetta beyond Python is therefore less a matter of redesigning the framework than of expanding these backend adaptation capabilities. Our current observations suggest that clear pathways already exist for convert- ing repositories written in other languages into MCP services. Tools with well-defined command-line entry points, stable APIs or explicit service boundaries are particu- larly amenable to standardisation. Repositories in ecosystems such as R, C/C++, JavaScript/TypeScript and Java can in many cases be integrated into the MCP workflow through subprocess bridging, containerised execution, service mediation or language-binding layers. These results indicate that the repository-to-tool translation strategy of ToolRosetta is not confined to a Python-only setting, but is structurally extensible across language ecosystems. More importantly, progress towards multi-language support does not require a new framework. It follows directly from the continued extension of the existing pipeline. As build discovery, dependency recovery, symbol extraction and execution wrappers mature across language backends, the automated standardisation process already val- idated in Python can be carried into broader software ecosystems. Python is therefore best understood as the current entry point rather than the outer limit of Tool- Rosetta. Both the architecture and the early implementation evidence suggest that repository-to-MCP translation can continue to scale across coding languages. 4 Methods The methodology of ToolRosetta is grounded in the premise that the system’s primary objective is to intelligently select and autonomously invoke appropriate tools to solve a given query. 4.1 Implementation of ToolRosetta In the presence of diverse and complex scientific scenarios, relying on a limited tool pool fails to adequately support the full spectrum of task requirements. Consequently, ToolRosetta is designed to access an open tool pool, integrating three key agent components: the Tool-search Agent, the MCP-construction Agent, and the Planning Agent. 4.1.1 Tool-search Agent The Tool-search Agent is designed to automatically retrieve and identify external tools that can solve user queries. This component generates query topics through LLM and selects candidate Github repositories based on them. The specific process includes: (1) Query parsing and topic generation: To accurately align with the intent of user query Q, ToolRosetta first employs LLM to perform semantic parsing of the input query and extract a set of up to m relevant topic keywords W =W 1 , W 2 , . . . , W m . These keywords are then used to retrieve relevant and functional open-source repositories from GitHub. 14 (2) Repositories retrieval and query optimization: Based on the above topic keywords, ToolRosetta calls the GitHub API to search for relevant open source repos- itories and return Top-K (Sort by the star in the GitHub repository) candidate repositories R K that best match the topic. R K = Top-K(GitSearch(W)).(1) If the initial search fails to obtain effective results (Sum(R k ) = 0), LLM per- forms fine-grained optimization on the original query Q while maintaining semantic consistency, such as distinguishing it from specific application scenario information or functional details, to improve the accuracy and recall of the search. (3) Evaluation of the effectiveness of the repository: ToolRosetta needs to perform a comprehensive evaluation of the validity of the retrieved candidate repositories R K . The evaluation dimensions mainly include: (a) Whether the repository has a complete code structure (such as including envi- ronment configuration files, dependency descriptions, startup scripts, etc.), and (b) Whether its implementation function truly meets the needs of user queries. ToolRosetta calls LLM to generate a structured evaluation report for each repos- itory, including its core functionality, whether it can fulfill the target task, and the reason of the decision. In the implementation process, the system checks the validity of each repository in order of retrieval sorting, and return the first repository that is both relevant and meets the criteria as the recommendation result. Unless otherwise specified, We define the above K as 50 and the above m as 5 in this part. If the query entered by the user actively provides the tool name with Github link, we skip the above steps of searching the repository and directly enter the MCP-construction agent. 4.1.2 MCP-construction Agent The MCP-construction agent aims to transform the GitHub repository into a unified MCP service format, so that LLMs can quickly and standardize their invocation. The workflow of this agent includes the following steps: Download Node, Analysis Node, Env Node, Generate Node, Code check Node, Run Node, Review Node, and Finish Node. We explain each step in detail: (1) Download Node: The qualifying repository is cloned into the local source direc- tory using Git, enabling subsequent construction of the MCP service and facilitating functional validation and repair. (2) Analysis Node: The core objective of this phase is to conduct an in-depth analysis of the repository’s Python source code and its README.md documentation. Specifically, we employ the DeepWiki to perform fine-grained semantic understanding of the source code. It interprets the functionality of individual modules and explicitly reveals the logical dependencies and invocation relationships among the various code components. In addition, by leveraging the functional descriptions, usage examples, and API specifications provided in the README.md, we further establish a bidi- rectional mapping between the implementation and the documentation. This process results in a structured repository functionality report (Code Report) that comprehen- sively captures the repository’s core capabilities and implementation logic, thereby establishing a robust foundation for subsequent tasks, such as environment setup, service packaging, and functional validation. (3) Env Node: The first step in reproducing the code is to ensure that all envi- ronment dependencies are correctly identified and configured. At the outset, the Env Node constructs the Python runtime environment, and when no version is explic- itly specified, it defaults to Python 3.10 to maintain compatibility with MCP service 15 requirements. Once the runtime environment has been established, the Env Node ana- lyzes the repository’s dependency declaration files, such as the requirements.txt file or the Dockerfile, extracts the relevant environment and package configuration details, and generates the list of Python packages required to launch the MCP service. During this process, the Env Node also automatically installs the required Python packages into the environment using pip. (4) Generate Node: Based on the Code Report generated by the Analysis Node, the Generate Node leverages the LLM to transform the repository’s functionality into an MCP service implementation, producing complete code files including main.py, startmcp.py, mcpservice.py, adapter.py, and testadapter.py. During this process, the core business logic is encapsulated within the Adapter module and refactored into an asynchronous format to support concurrent and non-blocking execution. The MCP tool layer retains only the @tool decorators and parameter forwarding, pro- viding lightweight access to the underlying Adapter module. In addition, the code templates generated by the Generate Node incorporate predefined rules for type con- version, exception handling, and dependency management. These rules ensure that the resulting MCP service not only meets type safety requirements but also automati- cally handles runtime dependencies and exceptions, thereby improving the reusability and reliability of the service. (5) Codecheck Node: Given that LLMs may produce logical errors or halluci- nations during long-form reasoning, we introduce a Codecheck Node following the Generate Node to rigorously verify and correct the core logic of the MCP service, thereby ensuring the correctness and robustness of the generated code. The reliability of an MCP service depends on the consistency between tool interfaces and the underly- ing functional code. To ensure full functionality, it is first necessary that the functions imported by the tools correspond exactly to those defined in the source code, while also verifying their input–output specifications to guarantee that the MCP service behaves as intended during execution. Based on this, the primary role of the Codecheck Node is to validate the mapping between tool interfaces and the underlying functions. Specifically, ToolRosetta first locate the source files corresponding to the func- tional modules M i and extract all public functions f ik and classes f it to construct an availablesymbols dictionary D. Next, ToolRosetta analyze all import statements in the MCP tool definitions gen- erated by the Generate Node. Each import is then checked against D to verify two aspects: (a) whether the referenced module M re actually exists, and (b) whether the functions f fc or classes f cl imported from the module are valid and correctly defined. (M re ∈ D) ∧ (f x ∈ D[M re ]).(2) When inconsistencies or errors are detected in the MCP service, the Code check Node executes an intelligent repair process. This process first identifies the actual source files corresponding to the erroneous module and uses AST analysis to extract function signatures, class definitions, and other structural information. It then employs an LLM to analyze the purpose, input parameters, and return values of each function, providing the LLM with a comprehensive context that includes the detected error information, relevant source code snippets, function analysis results, and the full list of available symbols. Based on this context and the source code analysis, the LLM regenerates correct import statements and revises the tool definitions, systematically repairing the MCP tools. (6) Run Node: The system subsequently installs and executes all required depen- dencies and runs the full pytest test suite on the generated MCP service. If all tests pass, the build is marked as successful and allowed to proceed to the finish stage. If 16 any test fails, the system captures the complete traceback and immediately triggers the Review Node, entering a corrective cycle of error diagnosis and regeneration. (7) Review Node: Upon receiving the full traceback captured by the Run Node, the system provides the LLM with comprehensive contextual information, including the error messages, the failing test cases, the generated code, and the structural informa- tion of the original repository. The model first conducts a detailed root-cause analysis to identify the source of the errors and the specific points of failure. Based on this analysis, it then produces a structured repair plan that clearly specifies the necessary modifications, including the exact filenames, line numbers, code segments that require replacement, and corresponding natural-language explanations for each change. This structured repair plan is subsequently fed back to the Generate Node, which leverages it to guide the targeted regeneration and correction of the erroneous code, ensuring that the revised MCP service aligns with the intended functionality and passes the test suite in the Run Node. (8) Finish Node: Once the Run Node confirms that all tests have passed, the system organizes the final version of the MCP service files, the dependency list, usage instructions, and example calls into a standardized directory structure. It then creates a pull request using an atomic commit, consolidating the previously scattered scripts into a fully integrated MCP service that conforms to community standards and can be deployed with a single command. 4.1.3 Planning Agent After the MCP tool is built and registered, ToolRosetta introduces the Planning Agent to enable intelligent scheduling and autonomous invocation of the tool. The agent is built around the LLM that interprets the user query Q and autonomously plans and executes tool usage to generate the final answer A. Specifically, this agent considers the objectives and constraints of the Q together with the functional descriptions of available tools, to intelligently select the most suit- able tools from the constructed MCP tool set and generate an appropriate invocation plan. This process requires no human intervention. When the user raises a new sub-request under the current query Q ′ , this agent re- evaluates the task objectives and dynamically adjusts the tool selection strategy and invocation workflow to remain aligned with the updated user requirements. Competing interests The authors declare no competing interests. 17 References [1] Akker, O., Assen, M.A., Wicherts, J.M.: Encore: a practical implementation to improve reproducibility and transparency of computational research. Nature Communications 15, 8053 (2024) https://doi.org/10.1038/s41467-024-52446-8 [2] Baker, M.: 1,500 scientists lift the lid on reproducibility. Nature 533(7604), 452– 454 (2016) https://doi.org/10.1038/533452a [3] National Academies of Sciences, Engineering, and Medicine: Reproducibility and Replicability in Science. National Academies Press, Washington, DC (2019). https://doi.org/10.17226/25303 [4] Mandal, I., Soni, J., Zaki, M., Smedskjaer, M.M., Wondraczek, K., Wondraczek, L., Gosvami, N.N., Krishnan, N.A.: Evaluating large language model agents for automation of atomic force microscopy. Nature Communications 16(1), 9104 (2025) [5] Shao, E., Wang, Y., Qian, Y., Pan, Z., Liu, H., Wang, D.: Sciscigpt: advancing human–ai collaboration in the science of science. Nature Computational Science (2025) https://doi.org/10.1038/s43588-025-00906-6 [6] Du, X., Liu, M., Wang, K., Wang, H., Liu, J., Chen, Y., Feng, J., Sha, C., Peng, X., Lou, Y.: Evaluating large language models in class-level code generation. In: Proceedings of the IEEE/ACM 46th International Confer- ence on Software Engineering. ICSE ’24. Association for Computing Machin- ery, New York, NY, USA (2024). https://doi.org/10.1145/3597503.3639219 . https://doi.org/10.1145/3597503.3639219 [7] Li, Y., Choi, D., Chung, J., Kushman, N., Schrittwieser, J., Leblond, R., Eccles, T., Keeling, J., Gimeno, F., Dal Lago, A., Hubert, T., Choy, P., Masson d’Autume, C., Babuschkin, I., Chen, X., Huang, P.-S., Welbl, J., Gowal, S., Cherepanov, A., Molloy, J., Mankowitz, D.J., Sutherland Robson, E., Kohli, P., Freitas, N., Kavukcuoglu, K., Vinyals, O.: Competition-level code generation with alphacode. Science 378(6624), 1092–1097 (2022) https://doi.org/10.1126/science.abq1158 [8] Shen, Y., Song, K., Tan, X., Li, D., Lu, W., Zhuang, Y.: Hugginggpt: solving ai tasks with chatgpt and its friends in hugging face. In: Proceedings of the 37th International Conference on Neural Information Processing Systems. NIPS ’23. Curran Associates Inc., Red Hook, NY, USA (2023) [9] Schick, T., Dwivedi-Yu, J., Dessi, R., Raileanu, R., Lomeli, M., Hambro, E., Zettlemoyer, L., Cancedda, N., Scialom, T.: Toolformer: Language models can teach themselves to use tools. In: Thirty-seventh Conference on Neural Informa- tion Processing Systems (2023). https://openreview.net/forum?id=Yacmpz84TH [10] Qin, Y., Liang, S., Ye, Y., Zhu, K., Yan, L., Lu, Y., Lin, Y., Cong, X., Tang, X., Qian, B., Zhao, S., Hong, L., Tian, R., Xie, R., Zhou, J., Gerstein, M., li, Liu, Z., Sun, M.: ToolLLM: Facilitating large language models to master 16000+ real-world APIs. In: The Twelfth International Conference on Learning Representations (2024). https://openreview.net/forum?id=dHng2O0Jjr 18 [11] M. Bran, A., Cox, S., Schilter, O., Baldassari, C., White, A.D., Schwaller, P.: Aug- menting large language models with chemistry tools. Nature Machine Intelligence 6(5), 525–535 (2024) https://doi.org/10.1038/s42256-024-00832-8 [12] Boiko, D.A., MacKnight, R., Kline, B., Gomes, G.: Autonomous chemical research with large language models. Nature 624(7992), 570–578 (2023) https://doi.org/ 10.1038/s41586-023-06792-0 [13] Ding, K., Yu, J., Huang, J., Yang, Y., Zhang, Q., Chen, H.: Scitoola- gent: a knowledge-graph-driven scientific agent for multitool integration. Nature Computational Science 5(10), 962–972 (2025) https://doi.org/10.1038/ s43588-025-00849-y [14] Guo, H., Hao, Y., Zhang, Y., Xu, M., Lv, P., Chen, J., Cheng, X.: A Measurement Study of Model Context Protocol Ecosystem. arXiv (2025). https://doi.org/10. 48550/ARXIV.2509.25292 . https://arxiv.org/abs/2509.25292 [15] Gao, C., Lan, X., Li, N., Yuan, Y., Ding, J., Zhou, Z., Xu, F., Li, Y.: Large language models empowered agent-based modeling and simulation: a survey and perspectives. Humanities and Social Sciences Communications 11(1) (2024) https: //doi.org/10.1057/s41599-024-03611-3 [16] Qu, C., Dai, S., Wei, X., Cai, H., Wang, S., Yin, D., Xu, J., Wen, J.-r.: Tool learning with large language models: a survey. Frontiers of Computer Science 19(8) (2025) https://doi.org/10.1007/s11704-024-40678-2 [17] Xin, H., Kitchin, J.R., Kulik, H.J.: Towards agentic science for advancing scientific discovery. Nature Machine Intelligence 7(9), 1373–1375 (2025) https://doi.org/ 10.1038/s42256-025-01110-x [18] Koscher, B.A., Canty, R.B., McDonald, M.A., Greenman, K.P., McGill, C.J., Bilodeau, C.L., Jin, W., Wu, H., Vermeire, F.H., Jin, B., Hart, T., Kulesza, T., Li, S.-C., Jaakkola, T.S., Barzilay, R., G ́omez-Bombarelli, R., Green, W.H., Jensen, K.F.: Autonomous, multiproperty-driven molecular discovery: From predictions to measurements and back. Science 382(6677) (2023) https://doi.org/10.1126/ science.adi1407 [19] Abolhasani, M., Kumacheva, E.: The rise of self-driving labs in chemical and materials sciences. Nature Synthesis 2(6), 483–492 (2023) https://doi.org/10. 1038/s44160-022-00231-0 [20] Wang, H., Ni, Z., Zhang, S., Lu, S., Hu, S., He, Z., Hu, C., Lin, J., Guo, Y., Du, Y., Lyu, P.: Repomaster: Autonomous exploration and under- standing of github repositories for complex task solving. In: The Thirty- ninth Annual Conference on Neural Information Processing Systems (2025). https://openreview.net/forum?id=aSfBbhUJAa [21] Lyu, B., Cong, X., Yu, H., Yang, P., Qian, C., Wang, Z., Qin, Y., Ye, Y., Lu, Y., Qian, C., Zhang, Z., Yan, Y., Lin, Y., Liu, Z., Sun, M.: Enhancing open- domain task-solving capability of LLMs via autonomous tool integration from GitHub. In: Che, W., Nabende, J., Shutova, E., Pilehvar, M.T. (eds.) Proceed- ings of the 63rd Annual Meeting of the Association for Computational Linguistics 19 (Volume 1: Long Papers), p. 17257–17277. Association for Computational Lin- guistics, Vienna, Austria (2025). https://doi.org/10.18653/v1/2025.acl-long.845 . https://aclanthology.org/2025.acl-long.845/ [22] Shi, Z., Gao, S., Yan, L., Feng, Y., Chen, X., Chen, Z., Yin, D., Ver- berne, S., Ren, Z.: Tool learning in the wild: Empowering language models as automatic tool agents. In: Proceedings of the ACM on Web Confer- ence 2025. W ’25, p. 2222–2237. Association for Computing Machin- ery, New York, NY, USA (2025). https://doi.org/10.1145/3696410.3714825 . https://doi.org/10.1145/3696410.3714825 [23] Kelly, D.M., Engelbertz, C., Rothwell, P.M., Anderson, C.D., Reinecke, H., Koeppe, J.: Age-and sex-specific analysis of stroke hospitalization rates, risk factors, and outcomes from german nationwide data. Stroke 55(9), 2284–2294 (2024) [24] Howard, G., Muntner, P., Lackland, D.T., Plante, T.B., Cushman, M., Stamm, B., Judd, S.E., Howard, V.J.: Association of duration of recognized hypertension and stroke risk: The regards study. Stroke 56(1), 105–112 (2025) [25] Xu, S., Liu, Y.-X., Cernava, T., Wang, H., Zhou, Y., Xia, T., Cao, S., Berg, G., Shen, X.-X., Wen, Z., et al.: Fusarium fruiting body microbiome member pantoea agglomerans inhibits fungal pathogenesis by targeting lipid rafts. Nature Microbiology 7(6), 831–843 (2022) [26] Klughammer, J., Romanovskaia, D., Nemc, A., Posautz, A., Seid, C.A., Schuster, L.C., Keinath, M.C., Lugo Ramos, J.S., Kosack, L., Evankow, A., et al.: Com- parative analysis of genome-scale, base-resolution dna methylation profiles across 580 animal species. Nature Communications 14(1), 232 (2023) [27] Li, G., Zhang, Z., Agyei-Tuffour, B., Wu, L., Gries, T.W., Prashanthan, K., Musi- ienko, A., Li, J., Zhu, R., Hart, L.J., et al.: Stabilizing high-efficiency perovskite solar cells via strategic interfacial contact engineering. Nature Photonics, 1–8 (2025) [28] Wu, L., Hu, S., Yang, F., Li, G., Wang, J., Zuo, W., Jer ́onimo-Rendon, J.J., Turren-Cruz, S.-H., Saba, M., Saliba, M., et al.: Resilience pathways for halide perovskite photovoltaics under temperature cycling. Nature Reviews Materials 10(7), 536–549 (2025) 20

Instant research discovery