obeypunctuation=true]^*University of Chicago; Chicago, IL, United States obeypunctuation=true]^†Argonne National Laboratory; Lemont, IL, United States obeypunctuation=true]^‡University of Illinois Chicago; Chicago, IL, United States

Experiences with Model Context Protocol Servers for Science and High Performance Computing

Haochen Pan^*^†, Ryan Chard^†^*, Reid Mello^*, Christopher Grams^†^‡, Tanjin He^† Affiliation: [ , Alexander Brace^†^*, Owen Price Skelly^*, Will Engler^*, Hayden Holbrook^*, Song Young Oh^* Affiliation: [ and Maxime Gonthier^*^†, Michael Papka^†^‡, Ben Blaiszik^*, Kyle Chard^†^*, Ian Foster^†^* Affiliation: [ Affiliation: [ Affiliation: [

Abstract.

Large language model (LLM)-powered agents are increasingly used to plan and execute scientific workflows, yet most research cyberinfrastructure (CI) exposes heterogeneous APIs and implements security models that present barriers for use by agents. We report on our experience using the Model Context Protocol (MCP) as a unifying interface that makes research capabilities discoverable, invokable, and composable. Our approach is pragmatic: we implement thin MCP servers over mature services, including Globus Transfer, Compute, and Search; status APIs exposed by computing facilities; Octopus event fabric; and domain-specific tools such as Garden and Galaxy. We use case studies in computational chemistry, bioinformatics, quantum chemistry, and filesystem monitoring to illustrate how this MCP-oriented architecture can be used in practice. We distill lessons learned and outline open challenges in evaluation and trust for agent-led science.

1. Introduction

Generative AI is reshaping how scientists design, run, and manage computational experiments. Rapid development of reasoning models (Jaech et al., 2024; Guo et al., 2025b) and agentic libraries (Chase, 2022; Pauloski et al., 2025) encourage us to envision the scientific process being driven by AI agents, capable of planning multi-step analyses, designing and running experiments, and coordinating workflows across distributed facilities. However, realizing this vision in practice requires overcoming the inherent heterogeneity of research cyberinfrastructure (CI), where each computer, service, instrument, tool, and database has its own APIs, security models, and operational requirements.

We explore the Model Context Protocol (MCP) as a unifying interface to empower AI agents to discover, invoke, and coordinate capabilities for scientific workloads. MCP defines simple, typed interfaces for tools and resources, plus feedback channels that let agents observe progress and recover from errors. Here, we implement MCP servers for three mature research services—Globus Transfer (Ananthakrishnan et al., 2015), Compute (Chard et al., 2020), and Search (Ananthakrishnan et al., 2018); facility status endpoints at the Argonne Leadership Computing Facility (ALCF) and National Energy Research Scientific Computing Center (NERSC); Octopus event fabric (Pan et al., 2024); and the Garden (Garden-AI, 2025) and Rhea (Christopher Grams, 2025) domain ecosystems. The full collection of MCP servers will be available soon at our GitHub repository (Science-MCPs Authors, 2025). These servers provide agents with capabilities needed to perform distributed scientific computing at scale, for example by enabling secure, high-performance data transfer between storage systems and execution of Python functions on remote computers.

We evaluate this MCP-oriented architecture through four classes of workflows: (i) computational chemistry model discovery and inference; (ii) multi-site bioinformatics pipelines; (iii) quantum chemistry with federated computations; and (iv) filesystem monitoring and usage evaluation. In each case, we show how an AI agent can orchestrate complex, and even multi-site workflows, by invoking and dynamically generating the necessary functions to leverage heterogeneous resources.

Our contributions include investigating MCP-oriented architecture for scientific computing and research CI, developing reference MCP implementations, and distilling lessons on reliably connecting HPC and scientific services to agentic workflows. We observe that it is beneficial to build thin MCP adapters for broad research services rather than to create new services, and to separate discovery from invocation (e.g., in Rhea) to manage large tool ecosystems, and that agents can remove the need to create custom glue code to combine scientific applications—instead generating it as needed. We also note challenges, including hosting MCP services for research CI that span administrative domains under existing authentication models, evaluating the reliability of agent-driven workflows, and strengthening resilience and recovery for long-running tasks.

2. Background & Related Work

We first describe MCP and its use in science, and then review other methods used to provide agents with access to tools.

2.1. Model Context Protocol

MCP, proposed in 2024, is an open interface specification for connecting agents to data sources and tools (Anthropic, 2024). It defines three core primitives: resources, read-only data sources from which an agent can gather information, such as a file, database records, or system status feed; tools, capabilities that an agent can invoke to perform an action, such as executing a computational analysis or transferring a file; and prompts, reusable templates that can be used to generate contextualized prompts for an agent, such as an HPC batch submission template that can be parameterized with job name and number of required nodes. MCP allows agents to discover available resources, tools, and prompts; use tools; and incorporate structured results into reasoning processes. Here, we focus on resources and tools as two primary means of exposing research CI to agents.

MCP has attracted broad interest, with more than 8000 open-source servers now listed in the Glama MCP directory (Glama, 2025). MCP is also being adopted in scientific domains to connect tools and datasets to LLMs. For example, mcp.science (Path Integral Institute, 2025) publishes MCP servers for various science applications, such as the Materials Project (Horton et al., 2025) to query and visualize materials data, GPAW (Mortensen et al., 2024) for density functional theory calculations, and neuroscience model analysis through the NEMAD API (Itani et al., 2024). In biomedicine, Bio-Agents MCP (Albert Chung, 2025) provides MCP servers for the Protein Data Bank (Berman et al., 2000) and ChEMBL (Gaulton et al., 2012). Other MCP servers (Frank, 2025; Ruchiranga, 2025) enable agents to search and retrieve scholarly content from arXiv, PubMed, bioRxiv, and medRxiv, returning structured metadata or full texts to support evidence gathering and experiment planning.

2.2. Other Methods for Agent Tool Use

FutureHouse’s AI agent PaperQA2 (Skarlinski et al., 2024; Future House, 2025) generates Wikipedia-style summaries grounded in evidence extracted from scientific papers. The agent orchestrates several tools to retrieve documents, extract relevant paragraphs, and synthesize answers with citations.

Biomni (Huang et al., 2025) couples an agentic planner with a curated execution environment. It leverages LangChain’s tool-calling protocol (LangChain, 2025) to integrate 150 specialized tools, 59 domain databases, and 105 software packages; the agent iteratively plans, executes code, inspects results, and updates its strategy until objectives are met.

Broadly, research on tool-using agents spans several fronts. Synthetic data pipelines are used to generate large-scale, high-quality data to train models to effectively use tools (Tang et al., 2023; Liu et al., 2025; Wang et al., 2025). Well-structured API documentation can also lead to reliable tool use without specific training (Hsieh et al., 2023). The development of ecosystems helps connect models to vast APIs (Liang et al., 2024) and can proactively assemble MCP toolchains to reduce context overhead (Fei et al., 2025). Other efforts include benchmarks to stabilize and evaluate MCP tool use (Guo et al., 2025a; Fan et al., 2025; Gao et al., 2025), reliability efforts to test and codify tool use (Milev et al., 2025; Ding et al., 2025), and security studies surface new risks and vulnerabilities (Hasan et al., 2025; Li et al., 2025a).

3. Problem Definition

When presented with a prompt, an AI agent (e.g., Claude Desktop) engages an LLM (e.g., Claude Sonnet 4) to develop and run an execution plan, including by making calls to MCP servers.

This plan constitutes an agentic application that is executed as a result of the supplied user prompt. Such an application executes within a particular application context that comprises the user prompt ( $p$ ), the coordinating LLM ( $L$ ), any user credentials ( $\Phi_{\text{user}}$ ), and a set of MCP servers ( $\mathcal{M}$ ), plus (optionally) a set of computing sites ( $\mathcal{S}$ ) that can be accessed via MCP servers.

An MCP server exposes a collection of capabilities and handles authorization requests. Each server $M_{k}\in\mathcal{M}$ is defined as $M_{k}=\langle\mathcal{C}_{k},\Phi_{k}\rangle$ , where $\mathcal{C}_{k}$ is the set of capabilities exposed by the server and $\Phi_{k}$ is the authentication and authorization client it employs (e.g., OAuth 2.0 client). For discovery-enabled servers, the set of capabilities is dynamic. A discovery call using a natural-language query $q$ can materialize additional capabilities, denoted $\mathcal{C}_{k}(q)$ , which are added to the server’s initially available set. As noted above, an MCP server can also define resources ( $\mathcal{X}$ ) and prompts ( $\mathcal{P}$ ). For brevity, we omit these in the following, but a complete definition of an MCP server is a 4-tuple $\langle\mathcal{C}_{k},\Phi_{k},\mathcal{P}_{k},\mathcal{X}_{k}\rangle$ .

An MCP server capability is an invokable action defined by its interface (inputs and outputs), description, and execution requirements, $C_{j}=\langle\mathcal{I}_{j},\mathcal{E}_{j},\mathcal{D}_{j},\mathcal{R}_{j}\rangle$ , where $\mathcal{I}_{j}$ is required inputs, $\mathcal{E}_{j}$ expected outputs, $\mathcal{D}_{j}$ description (name and documentation), and $\mathcal{R}_{j}$ requirements on site software ( $\Pi_{i}$ ) and resources ( $\Sigma_{i}$ ).

Finally, a computing site is an execution environment, such as a specific supercomputer (e.g., Aurora or Polaris at ALCF). Each site $S_{i}\in\mathcal{S}$ is defined by its software and hardware, $S_{i}=\langle\Pi_{i},\Sigma_{i}\rangle$ , where $\Pi_{i}$ is the set of installed software packages and $\Sigma_{i}$ is the set of available computational resources (CPUs, GPUs, etc.).

Having defined these various terms, we now return to describing what happens during execution of an agentic application. The core process is a three-step workflow in which the coordinating LLM $L$ converts a user prompt $p$ into a final output $\mathcal{O}$ , as follows.

Plan: The agent uses LLM $L$ to convert the user prompt $p$ into an abstract plan, $\mathcal{T}$ : a set of high-level goals not yet tied to specific capabilities or sites: $\mathcal{T}=\textsf{Plan}(p,L)$ . This stage succeeds if the LLM generates a coherent, actionable abstract plan.

Resolve: The agent then translates the abstract plan $\mathcal{T}$ into a concrete plan $\mathcal{R}$ by finding a feasible tuple $(S_{i},C_{j},M_{k})$ for each abstract task $t\in\mathcal{T}$ : $\mathcal{R}=\textsf{Resolve}(\mathcal{T},\mathcal{M},\mathcal{S})$ . $L$ evaluates each capability’s interface, description, and execution requirements to select an appropriate $C_{j}$ for each task $t$ . A tuple is feasible if:

•

The capability $C_{j}$ is available from server $M_{k}$ . For discovery-enabled servers, the capability set of $M_{k}$ is materialized as $\mathcal{C}_{k}(q)$ using a query $q$ derived from an abstract task $t$ .
•

The site $S_{i}$ satisfies all technical requirements $\mathcal{R}_{j}$ of the capability $C_{j}$ : i.e., the required software and hardware are available in the site’s definition, $\langle\Pi_{i},\Sigma_{i}\rangle$ .

This stage succeeds if a feasible tuple is found for every abstract task in $\mathcal{T}$ , resulting in a complete concrete plan $\mathcal{R}$ .

Execute: The agent executes the concrete plan $\mathcal{R}$ by processing each tuple $(S_{i},C_{j},M_{k})$ in turn. Each step comprises two phases:

(1)

The agent requests authorization using the server’s client, $\Phi_{k}$ , with the user’s credentials, $\Phi_{\text{user}}$ .
(2)

If authorization is granted, the agent invokes the capability $C_{j}$ on the target site $S_{i}$ .

This stage succeeds if every step in $\mathcal{R}$ is authorized and invoked without error, yielding the final output $\mathcal{O}=\textsf{Execute}(\mathcal{R},\Phi_{\text{user}})$ .

The complete workflow, $\mathcal{W}(p)$ , which can be expressed as the composition of these three stages, is considered successful if and only if all three stages complete successfully:

(1)

\boxed{\mathcal{W}(p)=\textsf{Execute}\left(\textsf{Resolve}\left(\textsf{Plan}(p,L),\mathcal{M},\mathcal{S}\right),\Phi_{\text{user}}\right)}

4. Scientific MCP Servers

We have implemented MCP servers for Globus Transfer, Compute, and Search services; facility status for ALCF and NERSC; the Octopus event fabric; the Garden platform; and Rhea. All servers are deployed as separate Docker containers using the streamable-HTTP transport, which supports multi-client, bidirectional communication and avoids the per-process overhead of the stdio transport. The use of containers also isolates SDK dependencies and allows credentials to be provided at runtime rather than hardcoded into images. Each container includes a minimal Python runtime, only the necessary service-specific packages, and a lightweight entrypoint script with optional server parameters. We describe these servers and their capabilities below.

The Globus Transfer MCP server implements tools that agents can use to interact with the Globus Transfer service to discover collections, browse file systems, and transfer files between collections. The server handles authentication flows, manages transfer task lifecycles, and provides interactive status monitoring.

The Globus Compute MCP server exposes tools for agents to execute Python and Shell functions on remote endpoints, monitor function execution, and retrieve function results. It manages authentication flows to perform actions securely on the user’s behalf.

The Globus Search MCP server exposes tools for agents to create, delete, and list Globus Search indexes, and to ingest, delete, and query records in specific indexes. Thus, it allows agents to discover datasets and research artifacts across distributed repositories, with conversational queries translated into structured search requests and results converted into structured responses.

The Computing Facility MCP server implements resources and tools that agents can use to obtain real-time operational status and resource availability of ALCF and NERSC computers. It exposes facility information as MCP resources representing the state of individual systems, and provides MCP tools for retrieving system health, queue status, maintenance schedules, and resource utilization. The server translates complex operational data into structured, queryable reports, enabling decision-making about where and when to submit computational tasks.

The Octopus MCP server equips agents with event streaming capabilities. Its backend, the Octopus event fabric, is a cloud-to-edge streaming platform built on AWS Managed Streaming for Kafka and secured with Globus Auth. Users can create and delete topics, update configurations, and truncate events within topics. Agents can publish or consume events directly under a user’s identity.

The Garden MCP server provides tools for agents to discover and run scientific machine learning models. The Garden platform catalogs a diverse collection of domain-specific models and, through the MCP interface, agents can discover and inspect published models, and invoke them to perform inference tasks on either the cloud or available HPC resources.

The Rhea MCP server provides agents with access to the many bioinformatics tools in the Galaxy Toolshed (Community, 2024). Handling many tools in MCP servers risks overwhelming the agent’s context window. Rhea addresses this challenge by providing a dynamic interface. Specifically, the MCP server uses Retrieval-Augmented Generation (RAG) (Lewis et al., 2020) over textual descriptions from Galaxy Toolshed documentation, help strings, and parameter schemas. These descriptions are embedded using Qwen3-Embedding-0.6B, and the MCP server exposes one tool, find_tools, that accepts a natural-language query for a desired capability. When invoked, it performs RAG to identify the top- $k$ bioinformatics applications most relevant to the query in embedding space and then dynamically generates corresponding MCP tools. The MCP server uses the protocol’s notification channel mechanism to alert the agent of the new tools, prompting the agent to refresh its tool list and enabling the agent to invoke the new tools.

5. Application Case Studies

Refer to caption — (a) The Garden workflow. The MACE model is discovered via the Garden MCP server and then inference is run on AWS or HPC.

We employ four use cases, shown in Figure 1, to explore how our MCP-oriented architecture applies to scientific workflow development. In each case, we use Claude Desktop as the agentic assistant and Claude Sonnet 4 as the LLM. (We have also experimented with other assistants and LLMs, but not yet in any systematic manner.) We present the user prompts for each use case in the Appendix.

5.1. Molecular Structure with Garden

We evaluate the Garden MCP server through an end-to-end use case that demonstrates the full machine learning workflow cycle, from rapid prototyping to production-scale execution. The application involves molecular structure relaxation using machine-learned interatomic potentials (MLIPs), progressing from single-structure exploration to batch processing of multiple structures.

The two-part appendix A defines an agentic application that first uses the Garden MCP server to discover a collection of MLIP models, from which it selects a MACE (Batatia et al., 2023) model variant for rapid prototyping. Given local user data, specified in the prompt, describing a single 32-atom copper structure, the agent manages data staging and then optimizes the structure to its lowest energy state (-130.71 eV) with typical FCC copper lattice parameters. It then leverages the Garden MCP server to relax the structure remotely and returns the results with a brief analysis for the user, enabling quick exploration of ML models without local dependency management. The application then scales to production execution, batch processing 49 copper structures with the same MACE model on ALCF’s Edith cluster using standard HPC patterns for job submission, status polling, and results retrieval.

5.2. Multi-site Phylogenetic Analysis

Computational biology can benefit from workflows that leverage specialized computing resources, but researchers face challenges coordinating data and analyses across distributed HPC systems.

We perform this task via an agentic application that employs Globus MCP servers to run a multi-method phylogenetic analysis workflow using FastTree (Price et al., 2010), RAxML (Stamatakis, 2014), and IQ-TREE (Minh et al., 2020) to validate evolutionary relationships among motor proteins. The application uses Globus MCP servers to distribute tasks across ALCF Polaris, for data acquisition and sequence alignment, and NERSC Perlmutter, for computationally intensive RAxML phylogenetic reconstruction with bootstrap analysis. The MCP servers handle authentication, job submission, status monitoring, and data transfer between ALCF and NERSC systems, abstracting the complexity of multi-site resource management.

Appendix B provides context about relevant Globus infrastructure, including Transfer and Compute endpoints for both ALCF Polaris and NERSC Perlmutter; their configured execution environments; and available bioinformatics software. It also specifies target bacterial species for evolutionary analysis and requests that the agent verify that Polaris and Perlmutter were available, then download protein sequence accessions to Polaris, perform sequence alignment, replicate the aligned data to NERSC, execute phylogenetic reconstruction using different algorithms across both sites for comparative validation, and finally, return results.

The agent runs the workflow by dynamically creating Python functions for the necessary analysis steps and correctly passing inputs between tools. This approach eliminates the need for researchers to develop custom glue code between different computational tools or to adapt their code to specific HPC systems, as the agent autonomously handles integration complexities.

5.3. Quantum Chemistry

Workflows in this domain typically require that researchers manually orchestrate sequences of quantum chemistry calculations—work that can require significant software integration effort. The computational expertise needed to translate conceptual questions into executable code creates bottlenecks that slow exploration.

We evaluate our MCP servers using a quantum chemistry workflow that demonstrates automated computational pipeline generation for materials science applications. This approach uses quantum chemistry computational codes to provide computation-backed results rather than relying on potentially inaccurate estimates from LLMs. We configured an environment on ALCF’s Polaris with various quantum chemistry software, including PySCF (Sun et al., 2018) and GPU4PySCF (Li et al., 2025b). We equip an agent with the Globus Compute MCP server to orchestrate the remote execution of code.

We use appendix C to instruct an agent to perform Highest Occupied Molecular Orbital (HOMO) – Lowest Unoccupied Molecular Orbital (LUMO) gap calculations (Griffith and Orgel, 1957) for six common organic solvents used in battery electrolytes. HOMO-LUMO gaps provide valuable information for determining electrochemical stability windows when designing battery electrolytes. This calculation involves multiple steps that traditionally require significant chemistry expertise: guessing initial molecular structures, optimizing structures to stable states, calculating orbital energies, and determining HOMO-LUMO energy differences with proper software inputs and parameter selection. Using the Globus Compute MCP and quantum chemistry software, the agent wrote and registered the necessary Python functions for execution via Globus Compute on Polaris, monitored task status, and upon completion, generated visualizations of the calculated HOMO-LUMO gaps. The computed HOMO-LUMO gaps (see Figure C.2) are consistent with published literature (Shakourian-Fard et al., 2016), confirming that the agent correctly executed this complex quantum chemistry computation and demonstrating the potential for this capability to accelerate more sophisticated computational chemistry research.

5.4. Filesystem Monitoring

In this fourth use case, we consider the problem of understanding user behavior and system performance in complex storage systems, via synthesis of data from multiple monitoring tools and time scales.

The Icicle application (Icicle Authors, 2025) leverages the MCP architecture for real-time HPC filesystem monitoring and analytics. In this use case, we deployed the Icicle monitoring software on a Lustre filesystem to continuously monitor filesystem events and report them through the Octopus event fabric. These events are then processed and published into a Globus Search index for storage and exploration.

Appendix D engages the agent to use the Octopus MCP server to evaluate recent filesystem activity by querying an Octopus topic and retrieving information about filesystem events over the preceding hour, providing insight into system utilization patterns and potential performance bottlenecks. The workflow then uses the Globus Search MCP server to generate data summaries for individual users by querying the search index and producing a report and visualization of their data usage, including file count, average file size, and total volume used across the filesystem.

This dual-phase approach enables administrators to correlate system-wide activity trends with individual user behaviors, facilitating informed decisions about resource allocation, storage optimization, and system maintenance scheduling.

6. Discussion

MCP presents a promising architecture for providing agents with access to research CI and enabling agents to orchestrate complex workflows across heterogeneous systems that span different administrative domains, authentication systems, and computing platforms. In our use cases, agents equipped with scientific MCP servers demonstrate a remarkable ability to recover from failures, adapt to changing resource availability, and dynamically adjust strategies when initial approaches encounter problemsadding flexibility to traditionally rigid systems while also lowering barriers to entry.

6.1. Dynamic Tool Discovery

Rhea demonstrates how MCP servers can overcome the challenges associated with exposing thousands of tools by replacing static registries with retrieval-based discovery. Vectorizing large collections of tool descriptions and applying semantic similarity search is especially valuable when the query and tool descriptions differ in terminology or level of abstraction. The approach may be even more valuable in scenarios where the search corpus extends beyond static metadata to include execution logs, user feedback, and runtime metrics, enabling discovery informed by both descriptions and historical performance in relevant contexts. Such a mechanism may enable each user query to contribute to and benefit from the collective knowledge embedded in the tool repository, fostering an extensible ecosystem that grows more capable as new scientific tools are added.

To evaluate Rhea’s approach, we used Llama-3.3-70B to generate a benchmark of 380 queries derived from Galaxy training tutorials (Galaxy Training Network (2025), GTN). Each tutorial defines one or more workflows, where each workflow specifies the sequence of Galaxy tools required to complete the analysis task. We used these workflows to establish ground-truth mappings between natural-language problem descriptions and the corresponding tools. For example, from the “proteogenomics-1-database-creation” tutorial (Mehta et al., 2018), we derived the query “I need a tool to compare and evaluate the accuracy of RNA-Seq transcript assemblers,” which maps to the Galaxy tool gffcompare (Pertea and Pertea, 2020). This evaluation design enables direct measurement of retrieval precision against real training materials.

Figure 2 reports Rhea’s retrieval performance as Recall@k across four documentation embedding strategies. Each query maps to a single ground-truth tool; Recall@k reflects whether the correct tool appears within the top- $k$ retrieved results, averaged over 380 queries. Incorporating richer textual context improves performance: embeddings based solely on tool names perform worst, while adding descriptions, extended documentation, and repository README files progressively enhances retrieval accuracy.

Figure 2. Rhea’s Galaxy Tool retrieval performance (Recall@k) across four documentation embedding strategies.

6.2. Authentication

Our implementation revealed important lessons regarding authentication and authorization within the MCP framework, particularly when integrating with Globus services that rely on OAuth-based authorization protocols. For example, handling OAuth token management and session persistence directly within hosted MCP server deployments adds complexity associated with secure token passing, token refresh cycles, and iterative authentication and scope management. To avoid these challenges, we instead operate the MCP servers locally within the user’s trusted environment and wrap all Globus service interactions with an authentication handler that dynamically manages authentication flows and acquires additional scopes as needed. This architecture simplifies credential management, eliminates session synchronization issues between remote servers and OAuth providers, and provides users with direct control over their authentication flows while maintaining the security and authorization benefits of the Globus ecosystem.

As the authentication scheme for MCP is rapidly evolving, we will continue our investigation by evaluating emerging methods like fastMCP’s new Remote OAuth capabilities (Lowin, 2025). This feature may offer new solutions for managing distributed authentication in hosted MCP server environments.

6.3. Resilience

Our experiences with the MCP-oriented architecture revealed surprising capabilities in agent self-correction when encountering errors during scientific workflows. We observed agents successfully diagnosing and recovering from various failure modes, such as when a Globus Compute function failed and the agent processed the resulting Python error to determine that an analysis invocation was malformed, then automatically reformulated the request. Similarly, agents would submit Globus Transfer tasks with incorrect paths. When a task failed, the agent processed the error returned when checking task status and then resubmitted the transfer with the correct path. This autonomous error handling demonstrated the potential for resilient scientific computing workflows that can adapt to common failure scenarios without human intervention.

Our evaluation also revealed limitations in agent resilience patterns. Agents made repetitive mistakes, suggesting limited learning from previous errors within the same session. Furthermore, they would not always complete outlined tasks as specified, or would produce inconsistent outputs such as different visualizations for similar requests, indicating variability in task interpretation and execution. These findings highlight the need for improved resilience mechanisms for agent-driven scientific workflows, including techniques for learning from past failures, maintaining consistency across similar tasks, and implementing systematic approaches to error recovery and workflow completion verification.

7. Conclusion

We have presented MCP servers for scientific research and evaluated their effectiveness in four scientific use cases. These implementations show how the MCP architecture can reduce barriers to using complex and distributed research CI. We discussed the advantages of building thin MCP adapters for existing research services and separating discovery from invocation to manage large tool ecosystems, and showed how agents can resiliently and dynamically generate the glue code needed for scientific workloads. Open challenges include hosting cross-domain MCP services under current authentication models, evaluating agent workflow reliability, improving resilience for long-running tasks, and evaluating MCP use with different agents and LLMs.

References

Albert Chung (2025) Albert Chung. 2025. Bio-Agents MCP: MCP servers for Protein Data Bank, ChEMBL, and other life science data. Retrieved Aug 18, 2025 from https://github.com/dogeplusplus/bio-agents-mcp.
Ananthakrishnan et al. (2018) Rachana Ananthakrishnan, Ben Blaiszik, Kyle Chard, Ryan Chard, Brendan McCollam, Jim Pruyne, Stephen Rosen, Steven Tuecke, and Ian Foster. 2018. Globus Platform Services for Data Publication. In Proceedings of the Practice and Experience on Advanced Research Computing: Seamless Creativity (Pittsburgh, PA, USA) (PEARC ’18). Association for Computing Machinery, New York, NY, USA, Article 14, 7 pages. doi:10.1145/3219104.3219127
Ananthakrishnan et al. (2015) Rachana Ananthakrishnan, Kyle Chard, Ian Foster, and Steven Tuecke. 2015. Globus platform-as-a-service for collaborative science applications. Concurrency and Computation: Practice and Experience 27, 2 (2015), 290–305. doi:10.1002/cpe.3262
Anthropic (2024) Anthropic. 2024. Model Context Protocol. Retrieved Aug 18, 2025 from https://www.anthropic.com/news/model-context-protocol.
Batatia et al. (2023) Ilyes Batatia, Dávid Péter Kovács, Gregor N. C. Simm, Christoph Ortner, and Gábor Csányi. 2023. MACE: Higher Order Equivariant Message Passing Neural Networks for Fast and Accurate Force Fields. arXiv:2206.07697 https://arxiv.org/abs/2206.07697
Berman et al. (2000) Helen M. Berman, John Westbrook, Zukang Feng, Gary Gilliland, Talapady N. Bhat, Helge Weissig, Ilya N. Shindyalov, and Philip E. Bourne. 2000. The Protein Data Bank. Nucleic Acids Research 28, 1 (2000), 235–242. doi:10.1093/nar/28.1.235
Chard et al. (2020) Ryan Chard, Yadu Babuji, Zhuozhao Li, Tyler Skluzacek, Anna Woodard, Ben Blaiszik, Ian Foster, and Kyle Chard. 2020. funcX: A Federated Function Serving Fabric for Science. In Proceedings of the 29th International Symposium on High-Performance Parallel and Distributed Computing (Stockholm, Sweden) (HPDC ’20). Association for Computing Machinery, New York, NY, USA, 65–76. doi:10.1145/3369583.3392683
Chase (2022) Harrison Chase. 2022. LangChain: A Framework for Building Applications with Large Language Models. Retrieved Aug 18, 2025 from https://github.com/langchain-ai/langchain.
Christopher Grams (2025) Christopher Grams. 2025. Rhea: A RAG+MCP Tool Server for Galaxy Toolshed. Source repository to be released soon at https://github.com/chrisagrams/rhea.
Community (2024) The Galaxy Community. 2024. The Galaxy Platform for Accessible, Reproducible, and Collaborative Data Analyses: 2024 Update. Nucleic Acids Research 52, W1 (2024), W83–W94. doi:10.1093/nar/gkae410
Ding et al. (2025) Hanxing Ding, Shuchang Tao, Liang Pang, Zihao Wei, Jinyang Gao, Bolin Ding, Huawei Shen, and Xueqi Cheng. 2025. ToolCoder: A Systematic Code-Empowered Tool Learning Framework for Large Language Models. arXiv:2502.11404 https://arxiv.org/abs/2502.11404
Fan et al. (2025) Shiqing Fan, Xichen Ding, Liang Zhang, and Linjian Mo. 2025. MCPToolBench++: A Large Scale AI Agent Model Context Protocol MCP Tool Use Benchmark. arXiv:2508.07575 https://arxiv.org/abs/2508.07575
Fei et al. (2025) Xiang Fei, Xiawu Zheng, and Hao Feng. 2025. MCP-Zero: Active Tool Discovery for Autonomous LLM Agents. arXiv:2506.01056 https://arxiv.org/abs/2506.01056
Frank (2025) Frank. 2025. Open Search MCP: Enterprise-Grade Secure MCP Server with 33 Specialized Search Tools for Claude Desktop. Retrieved Aug 18, 2025 from https://github.com/flyanima/open-search-mcp.
Future House (2025) Future House. 2025. PaperQA2: High accuracy RAG for answering questions from scientific documents with citations. Retrieved Aug 18, 2025 from https://github.com/Future-House/paper-qa.
Galaxy Training Network (2025) (GTN) Galaxy Training Network (GTN). 2025. The Galaxy Community. Retrieved Aug 18, 2025 from https://training.galaxyproject.org/.
Gao et al. (2025) Xuanqi Gao, Siyi Xie, Juan Zhai, Shqing Ma, and Chao Shen. 2025. MCP-RADAR: A Multi-Dimensional Benchmark for Evaluating Tool Use Capabilities in Large Language Models. arXiv:2505.16700 https://arxiv.org/abs/2505.16700
Garden-AI (2025) Garden-AI. 2025. Publish and Run Scientific AI Models with Garden. Retrieved Aug 18, 2025 from https://thegardens.ai/.
Gaulton et al. (2012) Anna Gaulton, Louise J. Bellis, A. Patricia Bento, Jon Chambers, Mark Davies, Anne Hersey, Yvonne Light, Shaun McGlinchey, David Michalovich, et al. 2012. ChEMBL: A large-scale bioactivity database for drug discovery. Nucleic Acids Research 40, D1 (2012), D1100–D1107. doi:10.1093/nar/gkr777
Glama (2025) Glama. 2025. Open-Source MCP Servers Directory. Retrieved Aug 18, 2025 from https://glama.ai/mcp/servers.
Griffith and Orgel (1957) JS Griffith and LE Orgel. 1957. Ligand-field theory. Quarterly Reviews, Chemical Society 11, 4 (1957), 381–393.
Guo et al. (2025b) Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Ruoyu Zhang, Runxin Xu, Qihao Zhu, Shirong Ma, Peiyi Wang, Xiao Bi, et al. 2025b. DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning. arXiv:2501.12948 https://arxiv.org/abs/2501.12948
Guo et al. (2025a) Zhicheng Guo, Sijie Cheng, Hao Wang, Shihao Liang, Yujia Qin, Peng Li, Zhiyuan Liu, Maosong Sun, and Yang Liu. 2025a. StableToolBench: Towards Stable Large-Scale Benchmarking on Tool Learning of Large Language Models. arXiv:2403.07714 https://arxiv.org/abs/2403.07714
Hasan et al. (2025) Mohammed Mehedi Hasan, Hao Li, Emad Fallahzadeh, Gopi Krishnan Rajbahadur, Bram Adams, and Ahmed E. Hassan. 2025. Model Context Protocol (MCP) at First Glance: Studying the Security and Maintainability of MCP Servers. arXiv:2506.13538 https://arxiv.org/abs/2506.13538
Horton et al. (2025) Matthew K. Horton, Patrick Huck, Ruo Xi Yang, Jason M. Munro, Shyam Dwaraknath, Alex M. Ganose, Ryan S. Kingsbury, Mingjian Wen, et al. 2025. Accelerated Data-Driven Materials Science with the Materials Project. Nature Materials online (2025), 1–11. doi:10.1038/s41563-025-02272-0
Hsieh et al. (2023) Cheng-Yu Hsieh, Si-An Chen, Chun-Liang Li, Yasuhisa Fujii, Alexander Ratner, Chen-Yu Lee, Ranjay Krishna, and Tomas Pfister. 2023. Tool Documentation Enables Zero-Shot Tool-Usage with Large Language Models. arXiv:2308.00675 https://arxiv.org/abs/2308.00675
Huang et al. (2025) Kexin Huang, Serena Zhang, Hanchen Wang, Yuanhao Qu, Yingzhou Lu, Yusuf Roohani, Ryan Li, Lin Qiu, Gavin Li, Junze Zhang, et al. 2025. Biomni: A general-purpose biomedical AI agent. arXiv:656746 doi:10.1101/2025.05.30.656746
Icicle Authors (2025) Icicle Authors. 2025. Icicle: Real-time Monitoring of Lustre Metadata Updates. Source repository to be released soon at https://github.com/globus-labs/icicle/.
Itani et al. (2024) Suman Itani, Yibo Zhang, and Jiadong Zang. 2024. Northeast Materials Database (NEMAD): Enabling Discovery of High Transition Temperature Magnetic Compounds. arXiv:2409.15675 https://arxiv.org/abs/2409.15675
Jaech et al. (2024) Aaron Jaech, Adam Kalai, Adam Lerer, Adam Richardson, Ahmed El-Kishky, Aiden Low, Alec Helyar, Aleksander Madry, Alex Beutel, Alex Carney, et al. 2024. OpenAI o1 System Card. arXiv:2412.16720 https://arxiv.org/abs/2412.16720
LangChain (2025) LangChain. 2025. LangChain Tool calling. Retrieved Aug 22, 2025 from https://python.langchain.com/docs/concepts/tool_calling/.
Lewis et al. (2020) Patrick Lewis, Ethan Perez, Aleksandra Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich Küttler, Mike Lewis, Wen-tau Yih, Tim Rocktäschel, Sebastian Riedel, and Douwe Kiela. 2020. Retrieval-augmented generation for knowledge-intensive NLP tasks. In Proceedings of the 34th International Conference on Neural Information Processing Systems (Vancouver, BC, Canada) (NIPS ’20). Curran Associates Inc., Red Hook, NY, USA, Article 793, 16 pages. doi:10.48550/arXiv.2005.11401
Li et al. (2025b) Rui Li, Qiming Sun, Xing Zhang, and Garnet Kin-Lic Chan. 2025b. Introducing GPU acceleration into the python-based simulations of chemistry framework. The Journal of Physical Chemistry A 129, 5 (2025), 1459–1468. doi:10.1021/acs.jpca.4c05876
Li et al. (2025a) Zhihao Li, Kun Li, Boyang Ma, Minghui Xu, Yue Zhang, and Xiuzhen Cheng. 2025a. We Urgently Need Privilege Management in MCP: A Measurement of API Usage in MCP Ecosystems. arXiv:2507.06250 https://arxiv.org/abs/2507.06250
Liang et al. (2024) Yaobo Liang, Chenfei Wu, Ting Song, Wenshan Wu, Yan Xia, Yu Liu, Yang Ou, Shuai Lu, Lei Ji, Shaoguang Mao, Yun Wang, Linjun Shou, Ming Gong, and Nan Duan. 2024. TaskMatrix.AI: Completing tasks by connecting foundation models with millions of APIs. Intelligent Computing 3 (2024), 0063.
Liu et al. (2025) Weiwen Liu, Xu Huang, Xingshan Zeng, Xinlong Hao, Shuai Yu, Dexun Li, Shuai Wang, Weinan Gan, Zhengying Liu, Yuanqing Yu, Zezhong Wang, Yuxian Wang, Wu Ning, Yutai Hou, Bin Wang, Chuhan Wu, Xinzhi Wang, Yong Liu, Yasheng Wang, Duyu Tang, Dandan Tu, Lifeng Shang, Xin Jiang, Ruiming Tang, Defu Lian, Qun Liu, and Enhong Chen. 2025. ToolACE: Winning the Points of LLM Function Calling. arXiv:2409.00920 https://arxiv.org/abs/2409.00920
Lowin (2025) Jeremiah Lowin. 2025. Remote OAuth: Integrate your FastMCP server with external identity providers like WorkOS, Auth0, and corporate SSO systems. Retrieved Aug 22, 2025 from https://gofastmcp.com/servers/auth/remote-oauth.
Mehta et al. (2018) Subina Mehta, Timothy J. Griffin, Pratik Jagtap, Ray Sajulga, James Johnson, and Praveen Kumar. 2018. Proteogenomics 1: Database Creation. Retrieved Aug 25, 2025 from https://gxy.io/GTN:T00231.
Milev et al. (2025) Ivan Milev, Mislav Balunović, Maximilian Baader, and Martin Vechev. 2025. ToolFuzz – Automated Agent Tool Testing. arXiv:2503.04479 https://arxiv.org/abs/2503.04479
Minh et al. (2020) Bui Quang Minh, Heiko A Schmidt, Olga Chernomor, Dominik Schrempf, Michael D Woodhams, Arndt von Haeseler, and Robert Lanfear. 2020. IQ-TREE 2: New Models and Efficient Methods for Phylogenetic Inference in the Genomic Era. Molecular Biology and Evolution 37, 5 (02 2020), 1530–1534. doi:10.1093/molbev/msaa015
Mortensen et al. (2024) Jens Jørgen Mortensen, Ask Hjorth Larsen, Mikael Kuisma, Aleksei V. Ivanov, Alireza Taghizadeh, Andrew Peterson, Anubhab Haldar, Asmus Ougaard Dohn, et al. 2024. GPAW: An open Python package for electronic structure calculations. The Journal of Chemical Physics 160, 9 (March 2024), 092503. doi:10.1063/5.0182685
Pan et al. (2024) Haochen Pan, Ryan Chard, Sicheng Zhou, Alok Kamatar, Rafael Vescovi, Valérie Hayot-Sasson, André Bauer, Maxime Gonthier, Kyle Chard, and Ian Foster. 2024. Octopus: Experiences with a Hybrid Event-Driven Architecture for Distributed Scientific Computing. In SC24-W: Workshops of the International Conference for High Performance Computing, Networking, Storage and Analysis. IEEE, Atlanta, GA, USA, 496–507. doi:10.1109/SCW63240.2024.00071
Path Integral Institute (2025) Path Integral Institute. 2025. MCP.Science: Open Source MCP Servers for Scientific Research. Retrieved Aug 18, 2025 from https://github.com/pathintegral-institute/mcp.science.
Pauloski et al. (2025) J. Gregory Pauloski, Yadu Babuji, Ryan Chard, Mansi Sakarvadia, Kyle Chard, and Ian Foster. 2025. Empowering Scientific Workflows with Federated Agents. arXiv:2505.05428 https://arxiv.org/abs/2505.05428
Pertea and Pertea (2020) Geo Pertea and Mihaela Pertea. 2020. GFF Utilities: GffRead and GffCompare. F1000Research 9 (2020), 304. doi:10.12688/f1000research.23297.2
Price et al. (2010) Morgan N Price, Paramvir S Dehal, and Adam P Arkin. 2010. FastTree 2–approximately maximum-likelihood trees for large alignments. PloS one 5, 3 (2010), e9490.
Ruchiranga (2025) Prashal Ruchiranga. 2025. Arxiv MCP Server: MCP Server that Enables Interacting with the arXiv API Using Natural Language. Retrieved Aug 18, 2025 from https://github.com/prashalruchiranga/arxiv-mcp-server.
Science-MCPs Authors (2025) Science-MCPs Authors. 2025. A Collection of Science MCPs: Globus, Compute Facility, Diaspora, and More. Retrieved Aug 25, 2025 from https://github.com/globus-labs/science-mcps.
Shakourian-Fard et al. (2016) Mehdi Shakourian-Fard, Ganesh Kamath, and Subramanian KRS Sankaranarayanan. 2016. Evaluating the free energies of solvation and electronic structures of lithium-ion battery electrolytes. ChemPhysChem 17, 18 (2016), 2916–2930. doi:10.1002/cphc.201600338
Skarlinski et al. (2024) Michael D. Skarlinski, Sam Cox, Jon M. Laurent, James D. Braza, Michaela Hinks, Michael J. Hammerling, Manvitha Ponnapati, Samuel G. Rodriques, and Andrew D. White. 2024. Language agents achieve superhuman synthesis of scientific knowledge. arXiv:2409.13740 https://arxiv.org/abs/2409.13740
Stamatakis (2014) Alexandros Stamatakis. 2014. RAxML version 8: a tool for phylogenetic analysis and post-analysis of large phylogenies. Bioinformatics 30, 9 (01 2014), 1312–1313. arXiv:https://academic.oup.com/bioinformatics/article-pdf/30/9/1312/48923136/bioinformatics_30_9_1312.pdf doi:10.1093/bioinformatics/btu033
Sun et al. (2018) Qiming Sun, Timothy C Berkelbach, Nick S Blunt, George H Booth, Sheng Guo, Zhendong Li, Junzi Liu, James D McClain, Elvira R Sayfutyarova, Sandeep Sharma, et al. 2018. PySCF: The Python-based simulations of chemistry framework. Wiley Interdisciplinary Reviews: Computational Molecular Science 8, 1 (2018), e1340. https://doi.org/10.1002/wcms.1340
Tang et al. (2023) Qiaoyu Tang, Ziliang Deng, Hongyu Lin, Xianpei Han, Qiao Liang, Boxi Cao, and Le Sun. 2023. ToolAlpaca: Generalized Tool Learning for Language Models with 3000 Simulated Cases. arXiv:2306.05301 https://arxiv.org/abs/2306.05301
Wang et al. (2025) Zezhong Wang, Xingshan Zeng, Weiwen Liu, Liangyou Li, Yasheng Wang, Lifeng Shang, Xin Jiang, Qun Liu, and Kam-Fai Wong. 2025. ToolFlow: Boosting LLM Tool-Calling Through Natural and Coherent Dialogue Synthesis. arXiv:2410.18447 https://arxiv.org/abs/2410.18447

Table 1. Characteristics of the four MCP-based scientific applications considered in this article.

Phylogenetic

Molecular Design

Quantum Chemistry

Icicle

LLM (

\mathcal{L}

)

Claude Sonnet 4

Agent Platform

Claude Desktop

MCP Servers (

\mathcal{M}

)

Globus Compute

Globus Transfer

Facility Status

Garden

Globus Compute

Octopus

Globus Search

Sites (

\mathcal{S}

)

ALCF, NERSC

ALCF, Cloud

ALCF

Local

Key Software (

\Pi

)

FastTree,

RAxML, IQ-TREE

MACE,

ASE

PySCF,

GPU4PySCF

N/A

Appendix

The appendices provide supplementary details for the applications presented in the main text, including the initial prompts, additional explanations, analysis results, and their visualization. For a summary of LLM, agent platform, MCP servers, sites, and software involved, see Table 1.

Appendix A Molecular Structure with Garden

This application showcases a complete molecular materials science workflow, from rapid prototyping to production-scale execution. We use MACE for molecular structure relaxation, first testing on a single structure before scaling up to a batch of 49 structures on ALCF’s Edith HPC cluster. Appendix A shows the initial prompt given to Claude Desktop (with Claude Sonnet 4) to launch the workflow.

As shown in the redacted screenshot in Figure A.1, the final output panel lists the models chosen for each task, provides storage paths for the results, and summarizes key outcomes like the number of relaxed structures, hardware used, and computational precision.

Appendix B Multi-site Phylogenetic Analysis

This use case performs a phylogenetic analysis workflow that coordinates computations between ALCF Polaris and NERSC Perlmutter. To explore the evolutionary relationships among bacterial motor proteins, the workflow downloads data, performs a sequence alignment, and runs three different phylogenetic reconstruction tools (FastTree, RAxML, and IQ-TREE) across the sites for validation. Appendix B supplied Claude Desktop with the necessary infrastructure details, experiment steps, and scientific goals.

The final output is a comprehensive summary presented in four sections. It begins with an “Analysis Summary” of key metrics and a list of the six “Analyzed Species and Genes”. The main results are presented under “Tree Reconstructions,” which displays the five trees generated by the three methods (i.e., FastTree, RAxML, IQ-TREE); two examples, IQ-TREE on ALCF Polaris and RAxML on NERSC Perlmutter, are shown in Figure B.2 and Figure B.2, respectively. The output concludes with “Phylogenetic Analysis Results,” which provides some key observations and technical notes as paragraphs.

Appendix C Quantum Chemistry

This application calculates the HOMO-LUMO gap, a key property for designing stable battery electrolytes. We investigate six common carbonate solvents: three linear (DMC, EMC, DEC) and three cyclic (EC, PC, VC), as shown in Figure C.2. Although all share a core carbonate functional group –O–C(=O)–O–, their differing structures and substituents influence their electrochemical behavior, motivating this comparative study.

To automate this task, we provided Claude Desktop with the high-level prompt shown in appendix C. Claude Desktop orchestrated the entire two-step workflow—structure optimization followed by orbital energy calculation—by generating the necessary Python functions. It then executed these functions using the GPU4PySCF software on ALCF Polaris, managing the process via the Globus Compute MCP server and returning the final results for analysis. The calculated HOMO-LUMO gaps are shown in Figure C.2.

Appendix D File System Monitoring

This use case applies the MCP architecture to an HPC administration task: real-time filesystem monitoring and analytics. Using the Icicle monitoring software, filesystem events are published to the Octopus event fabric and indexed in Globus Search. The workflow first uses the Octopus MCP server to get real-time changelogs of system activity and then uses the Globus Search MCP server to perform a historical analysis and comparison of specific users’ storage patterns. The prompt shown in appendix D instructs Claude Desktop to perform this two-phase analysis.

In response to the prompt, Claude Desktop generated a two-part visualization panel.

The first panel, titled “Today’s Lustre Activity Summary,” presents a pie chart about the event type distribution, as shown in Figure D.2. The visualization is interactive: clicking a legend removes the corresponding section on the ring. From sampled changelogs, Claude Desktop inferred several key activity patterns, summarized in three paragraphs, titled “Repetitive Workflow,” “Automated Process,” and “Resource Usage,” respectively. This panel concludes with a table detailing the sampled changelog types in four columns: “Operation Type”, “Count”, “Percentage”, and “Description”.

The second panel, “User Activity Comparison: UserA vs. UserB,” provides a comparative analysis of two users based on data queried from Globus Search. It begins with a high-level summary comparing metrics such as “Total Files,” “Storage Used,” “Avg File Size,” “Activity Period,” and “Peak Activity.” This is complemented by a comparative bar chart, shown in Figure D.2, which visualizes four attributes: total file count, total storage used, average file size, and maximum file size. Note that the summary and the bar chart have three attributes in common. Hovering the mouse over bars reveals the underlying numerical data. Claude Desktop also provides three paragraphs of behavioral analysis based on the queried data, titled “UserA,” “UserB,” and “Efficiency Insight” respectively. Finally, it concludes with another summary table of attributes as rows: “Total Storage (TB)," “Avg File Size (MB),” “Max File Size (GB),” “Median File Size (KB).” All except the median file size have appeared in previous visualizations. The table has an additional column of a calculated ratio of UserB’s metrics relative to UserA’s, offering an intuitive comparison.