Intelligent tool orchestration for rapid mechanistic model prototyping: MCP servers as AI-biology interfaces Authors: Marco Ruscone, Miguel Vazquez, Alfonso Valencia Published: 2026 ABSTRACT Constructing multicellular mechanistic models traditionally requires extensive time and computational expertise. We introduce intelligent tool orchestration via Model Context Protocol (MCP) servers, enabling Large Language Model (LLM) agents to act as AI laboratory assistants for rapid model prototyping. We demonstrate this approach by constructing a multiscale model of cancer cell fate in response to TNF using an AI agent connected to MCP servers interfacing with three complementary tools: NeKo for gene regulatory networks construction, MaBoSS for Boolean models simulation, and PhysiCell for setting up multicellular agent-based models. This workflow was executed entirely through natural language interactions, without manual coding, direct parameter editing, or manual modification of generated model files. Through this use case, we identified key principles for biological AI-tool integration, specifically regarding tool granularity, session management, and flexible orchestration. Testing across multiple LLMs demonstrated our framework’s portability, though model-dependent variations emphasize the need for rigorous validation. Ultimately, this work establishes a foundation for AI-assisted rapid prototyping, enabling researchers to explore computational hypotheses more rapidly through natural language interaction. Introduction Biological systems exhibit emergent behavior across multiple scales—from molecular interactions and gene regulatory networks to cellular dynamics and tissue-level phenomena. Understanding these multiscale processes is fundamental to biology, as cellular phenotypes emerge from complex interactions between genetic networks, signaling pathways, mechanical forces, and environmental cues1–3. Multiscale mechanistic models have become essential tools for integrating this complexity, serving as “virtual laboratories” that enable researchers to test hypotheses, predict outcomes, and quickly explore untested scenarios. Frameworks such as PhysiCell4, PhysiBoSS5, CompuCell3D6, BioDynaMo7, and Morpheus8 have been developed to support such multiscale exploration, offering powerful virtual laboratories for biological hypothesis testing. The models simulated by the aforementioned tools allow the study of cancer cell differentiation, drug responses, and the effects of mechanical stimuli on cellular phenotypes1,9. However, the construction of such models presents a significant entry barrier for many researchers. Traditional mechanistic modeling requires expertise across multiple domains: deep knowledge of biological pathways, proficiency in programming languages, familiarity with specialized software architectures, and understanding of complex mathematical frameworks3. Researchers must navigate intricate workflows involving database queries, network construction algorithms, parameter estimation, and simulation software. This complexity has led to the development of automated pipelines10 and graphical user interfaces8,11, yet these solutions still require substantial technical expertise and often lack the flexibility needed for novel research questions12. Most recently, human-interpretable grammar systems, as demonstrated in the paper by Johnson and colleagues13, have shown how natural language statements can be directly translated into mathematical models, representing a critical effort toward more accessible model construction. Large Language Models (LLMs) have introduced natural language interfaces for complex computational tasks, opening new possibilities for scientific computing14. However, integrating LLMs with specialized scientific software has remained challenging due to the need for structured, reliable connections between AI systems and domain-specific tools. The key breakthrough in this integration challenge was tool calling15,16, which enables LLMs to invoke external capabilities in a structured way. Building on this, the Model Context Protocol (MCP) provides a standardized, REST-like framework for packaging tools and supporting secure, mostly remote use. MCP connects LLMs to external tools and data sources, enabling controlled, reliable interactions between AI assistants and scientific software. With MCP, LLMs can access vast knowledge bases, execute computational tasks, query databases, and generate results, while maintaining proper attribution and reproducibility. In systems biology, this opens new possibilities for conversational modeling. Rather than requiring researchers to master complex software interfaces, MCP enables natural language interactions with computational tools. The protocol allows LLMs to access vast biological knowledge while executing computational tasks, querying databases, and generating reproducible results. This shifts model construction from code-centric workflows toward conversation-driven interaction, with AI assistants acting as structured modeling partners. Following a digital-twin perspective, our objective is to construct a mechanistic multiscale model, from gene regulation to tissue dynamics, through interaction with an LLM alone. To achieve this, we developed the first modeling-oriented MCP servers for three established systems biology tools: NeKo, a Python package for automatic gene regulatory network construction17, MaBoSS, a C++ Boolean network simulator with a Python interface18, and PhysiCell4, a multiscale agent-based modeling framework C++ based. Each of these three modeling frameworks has an MCP server implementation. Each server is dedicated to exposing to the LLM the internal functionalities of its related framework as independent tools. Tools are functions or methods that perform specific modeling steps. Designing this system required selecting modular frameworks that support a controlled, step-by-step modeling process. Among them, PhysiCell is particularly well suited to this approach thanks to its interpretable human grammar feature13, which uses a dictionary of signals (cellular stimuli) and behaviors (cellular phenotypes) to generate hypotheses using a natural language processing approach. The whole ecosystem encompasses more than 60 specialized modeling tools, supporting the complex tasks that span from data collection to model construction. These tools are organized following a set of architectural guidelines that we defined to optimize tool granularity, ensure comprehensive session management, and enable intelligent workflow orchestration specifically designed for biological AI-tool integration. In this structure, the MCP layer allows the LLM to access NeKo, MaBoSS, and PhysiCell through standardized tool definitions rather than direct software calls. This design ensures a clear hierarchy, from biological questions to servers to individual tools, enabling seamless transitions across modeling scales, as illustrated in Fig. 1. The integration of these tools allows each modeling scale to feed naturally into the next: molecular networks → gene regulation → cellular behavior → tissue dynamics → emergent population properties.Fig. 1Conversational modeling ecosystem enabled by MCP servers.A Conceptual overview. An LLM agent mediates natural language requests and orchestrates workflows through the Model Context Protocol (MCP), which provides standardized access to specialized modeling servers. This design allows domain experts to interact with computational tools via conversation rather than code. B Servers implementation. Three MCP servers---NeKo, MaBoSS, and PhysiCell---collectively provide over 60 tools spanning molecular network construction, Boolean model dynamics, and multiscale tissue simulation. Together, they form a pipeline from molecular to tissue-level modeling, illustrating how conversational interfaces can unify the full mechanistic modeling workflow. Conversational modeling ecosystem enabled by MCP servers. A Conceptual overview. An LLM agent mediates natural language requests and orchestrates workflows through the Model Context Protocol (MCP), which provides standardized access to specialized modeling servers. This design allows domain experts to interact with computational tools via conversation rather than code. B Servers implementation. Three MCP servers---NeKo, MaBoSS, and PhysiCell---collectively provide over 60 tools spanning molecular network construction, Boolean model dynamics, and multiscale tissue simulation. Together, they form a pipeline from molecular to tissue-level modeling, illustrating how conversational interfaces can unify the full mechanistic modeling workflow. Through a case study of TNF response modeling, we demonstrate how tool-enabled AI assistants can support biologically informed workflow decisions, automatically selecting appropriate molecular components, cell types, and parameters leveraging curated resources. This use case builds upon a well-studied Boolean model of TNF response originally introduced by Calzone et al.19, which has since been applied both in the MaBoSS environment20, and in the PhysiBoSS framework5,21. The complete multiscale workflow, from molecular network construction through Boolean dynamics to tissue simulation, can be assembled within minutes, compared with the substantial time typically required to learn the underlying tools, review the relevant literature, and manually set up equivalent modeling pipelines. In this TNF use case, the resulting models remained compatible with baseline biological expectations and incorporated biologically motivated parameter estimates where available in the literature. While this approach drastically accelerates model construction, reliability remains a central consideration. The use of MCP servers ensures that each modeling step relies on deterministic, well-validated software components, making every operation reproducible when the same parameters and configurations are maintained. However, full autonomy of the language model can introduce variability, different LLMs or prompting strategies may select distinct parameters or workflows. This highlights the importance of clearly defined operational guardrails and standardized workflows to guarantee consistent and interpretable modeling outcomes. Our approach aligns with the current shift from code-centric to assistant-centric modeling, where AI systems serve as research assistants that can rapidly prototype models for hypothesis exploration22. This work establishes the foundational architecture of AI-assisted scientific modeling and demonstrates the capacity of this technology to assemble a working system that can be integrated into a broader experimental and computational ecosystem that supports data querying, autonomous model construction, validation, and optimization. In our case, we focus on the development of an intelligent-lab application for cell-level mechanistic modeling, where MCP servers connect molecular, cellular, and tissue-scale simulators (NeKo, MaBoSS, and PhysiCell) into a coherent multiscale environment. To assess portability and robustness of assistant-centric modeling, we explored how three different LLMs perform model construction and analysis across three scenarios — TNF multiscale simulation construction, PhysiCell rule synthesis, and MaBoSS model refinement — using identical prompts. All tested LLMs successfully orchestrated the tools in the correct order, completing the full workflows. We observed that more advanced LLMs tended to execute a greater number of tool calls and generate more detailed mechanistic models. While the MCP servers ensure deterministic execution for each tool, reproducibility and accuracy at the system level remain influenced by the choice of the LLM and its reasoning strategy, highlighting the need for standardized validation procedures. Results MCP as a framework for scientific tool orchestration The convergence of LLMs with domain-specific scientific tools represents a fundamental shift in how computational biology can be practiced. Rather than requiring researchers to master programming languages and complex software interfaces, conversational modeling enables direct dialogue between domain experts and computational tools through natural language interactions. We therefore first describe how the MCP-based orchestration works in practice and how it supports mechanistic modeling workflows. MCP servers act as a central hub that exposes different AI tools and data sources so they can work together in a secure and standardized way. Tools are the individual computational functions that the AI can invoke. Each tool represents a specific scientific operation with well-defined inputs, outputs, and biological meaning. Once the server is installed, the language model gains access to all the tools it contains. The metadata embedded in the servers helps the model understand how to use each tool and orchestrate them together. As shown in Fig. 1A, this architecture places the LLM agent at the top, mediating natural language requests and orchestrating workflows through the MCP layer, which in turn provides access to the specialized modeling servers. A conversational workflow for mechanistic modeling Traditional mechanistic modeling follows a code-centric workflow: researchers write scripts to query databases, construct molecular networks, implement mathematical models, and analyze results. Each step requires specific programming knowledge and tool expertise. Conversational modeling inverts this relationship: researchers express their biological questions and modeling intentions in natural language, while AI assistants orchestrate the underlying computational tools. This transformation affects the entire modeling ecosystem. Network construction shifts from manual database queries and scripting to guided conversations about pathway biology. Dynamic modeling transitions from writing mathematical equations to describing biological relationships and regulatory logic. Multiscale integration evolves from complex simulation programming to discussions about cellular behaviors and tissue-level phenomena. Architecture of the MCP server ecosystem Our implementation demonstrates this paradigm through three complementary MCP servers (Fig. 1B) that collectively provide more than 60 specialized tools spanning the complete mechanistic modeling workflow. The architecture follows a layered design with natural language interface capabilities at the top, standardized tool interface protocols in the middle, and specialized computational biology servers at the foundation. The NeKo MCP server (currently 28 tools) exploits the NeKo Python package to construct molecular network from prior knowledge databases including OmniPath23 and SIGNOR24, providing gene-to-network expansion, pathway connectivity analysis, and standard format export capabilities (SIF and BNET). The MaBoSS MCP server (currently 20 tools) is based on the MaBoSS framework, which simulates Boolean models by applying stochastic Markov processes on Boolean network. This server provides tools to analyze and simulate a Boolean model, changing the initial conditions, performing mutations and providing attractors (network stable states) analysis. The PhysiCell MCP server (currently 33 tools) leverages the PhysiCell-Settings Python package (https://github.com/marcorusc/PhysiCell_Settings) allowing to draft multiscale tissue simulation with 3D modeling capabilities. It includes MaBoSS integration (PhysiBoSS) and drafting of cellular rules through Physicell’s human-interpretable grammar. All the 3 MCP servers include session management tools. The key architectural insight is that effective conversational modeling requires more than simple API wrapping. The servers implement domain-specific language processing, cross-server biological context management, multi-session workflow orchestration, and biological validation guidance. Each server maintains standalone operation capability while supporting seamless data exchange through standardized formats (SIF, BNET), creating a multiscale pipeline from molecular networks through gene regulation to tissue dynamics. Design principles for biological AI-tool integration Designing MCP servers for biological modeling is more than wrapping APIs: tools that are too fine-grained can confuse the LLM (leading to incorrect tool calls), while tools that are too coarse lock entire workflows into single calls. The challenge is to balance granularity and guidance so the model can reason about biology, chain tools effectively, and recover from errors without losing flexibility. Through extensive experimentation with different LLM models and architectural patterns, we proposed key principles that distinguish effective biological tool orchestration from simple API wrapping: Optimal Tool Granularity, Comprehensive Session Management, Intelligent Error Handling and Tool Chaining, and structured output with biological context. Optimal tool granularity: as stated in different MCP developing guidelines from Anthropic https://modelcontextprotocol.io/quickstart/server or Visual Studio Code https://code.visualstudio.com/api/extension-guides/ai/mcp, we found that high-level granularity enables better modularity and AI reasoning. Each tool is extensively documented with comprehensive docstrings and parameter explanations. Tools that are too granular (micro-operations) prevent the AI from effective reasoning, while tools that are too coarse (complex workflows) limit flexibility. We achieved an optimal granularity by designing tools around workflow steps where biological knowledge is needed. For example, choosing the right parameters for constructing a network, deciding on relevant mutations to simulate, or defining a cell type and its cell cycle model. This allows the AI to reason about the biology rather than micromanaging technical operations. Comprehensive session management Complex biological workflows require state tracking across multiple tool calls. We implemented a session manager with unique identifiers that maintains workflow history and completion percentage tracking. This prevents incompatible XML structures and enables workflow resumption, as incomplete configurations cannot interface with standard PhysiCell inputs. Intelligent error handling and tool chaining Robust error messages with biological context trigger are injected in the LLM to enable tool chaining responses. Rather than generic API failures, errors include biological interpretation and suggest the LLM next steps to take, enabling the AI to adaptively modify workflows based on biological constraints. Structured output with biological context Each tool provides clear documentation of operations performed and biological significance of results. This enables the AI to maintain biological reasoning chains across tool calls and make informed decisions about subsequent steps. These principles were derived from iterative testing across different LLMs, ranging from lightweight models that required explicit guidance to more advanced models capable of autonomous biological reasoning. We found that maintaining optimal tool granularity at biological decision points, explicit session/state management, and structured, self-describing outputs are pivotal for robust orchestration across different LLMs. Together, these elements help to reduce prompt sensitivity, support tool chain recovery during the workflow orchestration, and can support reproducibility despite differences in the underlying language model. Evaluation setup We have explored how three different LLMs (GPT-5.1, GPT-o4-mini, Sonnet-4) adapt and respond to three different scenarios using identical prompts and the same MCP toolchain (NeKo, MaBoSS, PhysiCell). For each scenario, we formulated a single high-level prompt to assess the ability of each LLM to manage the workflow and autonomously call the appropriate tools (Fig. 2). This allowed us to test how the MCP servers operate both in combination and stand-alone mode, and then qualitatively compared the outputs produced by the different LLMs: the PhysiBoSS models generated in scenario 1, the sets of cell rules inferred in scenario 2, and the Boolean network trajectories obtained in scenario 3. It is important to mention that at this stage our goal was not to assess the biological accuracy of the generated models, but rather to test whether the whole ecosystem works end-to-end. This study is intended as a framework demonstration rather than a comprehensive benchmark of LLM performance. This is motivated by two considerations: 1) none of the selected LLMs (accessible through GitHub Copilot), are specifically trained on biological information (which could in principle lead to more accurate models) and 2) our focus was on validating interoperability and tool orchestration rather than biological accuracy.Fig. 2One-shot prompt tool orchestration.A single high-level prompt is provided to the LLM, which autonomously selects and sequences the appropriate tools. The model iterates internally with feedback from the MCP servers until a complete output is produced (e.g., a summary of the whole worflow, a Boolean model, or PhysiCell configuration files). One-shot prompt tool orchestration. A single high-level prompt is provided to the LLM, which autonomously selects and sequences the appropriate tools. The model iterates internally with feedback from the MCP servers until a complete output is produced (e.g., a summary of the whole worflow, a Boolean model, or PhysiCell configuration files). Scenario 1 — Building a multiscale model of cancer cell fate in response to TNF This first scenario tested whether each model could autonomously execute the full NeKo → MaBoSS → PhysiCell (PhysiBoSS integration) workflow to construct a full multiscale model of cancer cell fate upon TNF stimulation. We initiated the interaction with a single high-level prompt specifying: (i) the biological objective ("build a model of cancer cell fate in response to TNF capable of capturing apoptosis or proliferative outcomes”), and (ii) a coarse workflow outline: start from an initial gene pool, create a molecular interaction network with NeKo using OmniPath, export to MaBoSS for Boolean simulation to identify attractors, then generate a PhysiCell configuration specifying domain size, microenvironment substrates, cell types, and MaBoSS input/output mappings to phenotype rules. No explicit gene list size, network depth, or parameter values were provided in the initial prompt, allowing us to assess autonomous tool selection and parameter choice. To evaluate biological plausibility, we assessed three criteria: the logical mapping of inputs/outputs between the Boolean and spatial models, the dynamical probability of key output nodes of the Boolean models, and the emergent population-level cell death over time. We compared the autonomously generated Boolean trajectories against the manually curated baseline model by ref. 19. All three LLMs completed the required tool chain with only occasional user confirmation during execution. Interestingly, each model autonomously selected different initial genes and phenotypic markers (e.g., BAX, CASP3, CCND1, MYC) compared to the baseline. The autonomous selection of the initial seed genes varied significantly in both size and composition (6 genes for GPT-o4-mini, 25 for Sonnet-4, and 22 for GPT-5.1). This divergence in the initial gene pool is the primary driver of the resulting variations in network configuration and emergent dynamics (The effect of prompt specificity on seed nodes selection on the generated model is illustrated in the Suppl. Material, Section 4.2): GPT-o4-mini generated a functional PhysiBoSS configuration with appropriate TNF diffusion and decay rates, though it mapped “intracellular TNF” to the TNFRSF1A receptor instead of extracellular TNF (Fig. 3A). The Boolean nodes chosen for proliferation (cycle_entry) and apoptosis are respectively CCND1 and CASP3. Its Boolean model triggered a rapid drop in CASP3 and an increase in CCND1 (Fig. 3B), leading to a sharp apoptotic event where the cell population dropped to approximately 100 cells within 10 h (Fig. 3C).Fig. 3Scenario 1 - Output comparison of multiscale TNF response models generated by different LLMs (Scenario 1).A Comparison of PhysiCell configuration settings and signal-to-behavior mappings autonomously generated by GPT-o4-mini, Sonnet-4, and GPT-5.1. Filled blue circles indicate successful mapping between PhysiCell variables and MaBoSS nodes. B MaBoSS node activation probabilities over time for the automatically generated models, compared against the manually curated baseline model by Calzone et al. C Left: Representative 2D spatial snapshot of the PhysiBoSS simulation showing the TNF gradient and active/inactive TNF receptors generated by Sonnet-4. Right: Cell count over time for the three LLM-generated simulations. While GPT-o4-mini and Sonnet-4 generated Boolean networks capable of triggering apoptosis (resulting in population decline), GPT-5.1's Boolean model failed to activate apoptotic executioner nodes, resulting in no cell death despite a fully configured spatial TNF gradient. Scenario 1 - Output comparison of multiscale TNF response models generated by different LLMs (Scenario 1). A Comparison of PhysiCell configuration settings and signal-to-behavior mappings autonomously generated by GPT-o4-mini, Sonnet-4, and GPT-5.1. Filled blue circles indicate successful mapping between PhysiCell variables and MaBoSS nodes. B MaBoSS node activation probabilities over time for the automatically generated models, compared against the manually curated baseline model by Calzone et al. C Left: Representative 2D spatial snapshot of the PhysiBoSS simulation showing the TNF gradient and active/inactive TNF receptors generated by Sonnet-4. Right: Cell count over time for the three LLM-generated simulations. While GPT-o4-mini and Sonnet-4 generated Boolean networks capable of triggering apoptosis (resulting in population decline), GPT-5.1's Boolean model failed to activate apoptotic executioner nodes, resulting in no cell death despite a fully configured spatial TNF gradient. Sonnet-4 produced the most biologically coherent mappings, correctly linking extracellular TNF to TNFRSF1A and assigning appropriate phenotypic outputs (BAX and CASP3 to apoptosis; CCND1 and MYC to cycle entry, (Fig. 3A)). Its Boolean dynamics most closely resembled the results from19, leading to a gradual and complete apoptotic event over 60 hours in response to the diffusing TNF gradient (Fig. 3C). GPT-5.1 provided different microenvironment parameterization, autonomously specifying a TNF uptake rate and a high Dirichlet boundary condition (Fig. 3A). However, its generated Boolean network failed to capture the TNF-induced apoptosis. The probabilities of all the phenotypic nodes rapidly decayed to zero (Fig. 3B). Because Sonnet-4 successfully produced coherent dynamics with a similarly sized network (111 nodes and 983 edges vs. 102 nodes and 885 edges for GPT-5.1), this failure is likely not due to network scale. Instead, it underscores how differences in the LLM-selected seed genes can lead NeKo’s automated rule-inference to construct topologies with different dynamical attractors. Consequently, the PhysiCell simulation resulted in no cell death, with the initial population remaining constant despite a strong TNF gradient (Fig. 3C). All generated configuration files were correctly executed in PhysiCell-Studio, indicating proper tool orchestration despite the absence of details in the initial prompt. The variability observed in the results highlights that while the MCP framework ensures the robust and deterministic execution of complex multiscale setups, the biological accuracy of the resulting model remains highly sensitive to the LLM’s internal reasoning. Limitations of this scenario include the absence of systematic literature cross-validation within the conversational loop and a lack of automated parameter fitting. We report the initial prompts, continuation prompts, MCP tool-call summaries, and generated outputs in the Suppl. Material, Section 3 (Workflow summaries across LLMs and scenarios). The full chat with all the LLMs (including tool calls output), the code for the output analysis, and the file with all the PhysiCell rules produced can be found at https://github.com/marcorusc/Supp_mat_MCP_orchestrator. Scenario 2 — Rule extraction/extension for an existing PhysiCell configuration As previously mentioned, PhysiCell allows the specification of cellular dynamics through a natural language interpretation. We tested the capability of different LLMs to extract biological information from an existing PhysiCell configuration file (https://github.com/MathCancer/PhysiCell/blob/master/sample_projects/rules_sample/config/PhysiCell_settings.xml) and to generate rules to enrich the simulation (See Suppl. Material, Sections 3.3, 3.7, and 3.11). This scenario was designed to test whether the LLM could combine tools from a single server (PhysiCell) with its own ability to extract and summarize information (thus composing the biological scenario). The rules generated were then compared against the original, manually curated rule set containing 27 entries. Given the input XML, all models successfully inferred the biological scenario (a tumor immune microenvironment) and synthesized rules, though they produced fewer rules overall than the manual baseline: GPT-o4-mini generated 5 rules, GPT-5.1 generated 13, and Sonnet-4 generated 15. A rule-by-rule comparison highlights significant divergence both from the manual baseline and among the LLMs themselves Table 1. Notably, “housekeeping” and biomechanical rules present in the manual set were overlooked by all three LLMs. For example, rules governing the physical constraints of the microenvironment (e.g., Volume Decreases Phagocytose Apoptotic/Necrotic Cell and Pressure Decreases Cycle Entry) were missed. Instead, the models focused on generating higher-level chemical and phenotypic interactions. For instance, both Sonnet-4 and GPT-5.1 autonomously introduced macrophage polarization rules, dictating that M0 macrophages transform into M1 or M2 phenotypes in response to pro- and anti-inflammatory cytokines, respectively.Table 1Scenario 2 - Rule-by-rule comparison of updated LLM-generated rules, grouped by cell typeSignalDirectionBehaviorManualGPT-o4-miniSonnet-4GPT-5.1M0 MacrophagePro-Inflammatory FactorIncreasesTransform To M1 Macrophage——✓✓Anti-Inflammatory FactorIncreasesTransform To M2 Macrophage——✓✓Substrate Gradient: Apoptotic DebrisIncreasesChemotactic Response To Substrate—✓——M1 MacrophagePro-Inflammatory FactorIncreasesChemotactic Response To Pro-Inflammatory Factor——✓✓Substrate Gradient: Necrotic DebrisIncreasesPhagocytose Necrotic Cell—✓——Contact With Malignant Epithelial CellIncreasesAttack Malignant Epithelial Cell——✓—Apoptotic DebrisIncreasesApoptotic Debris Uptake——✓—Pro-Inflammatory FactorIncreasesAttack Malignant Epithelial Cell———✓M2 MacrophageSubstrate: Anti-Inflammatory FactorIncreasesMigration Speed—✓——Contact With Malignant Epithelial CellDecreasesMigration Speed——✓—Apoptotic DebrisIncreasesApoptotic Debris Uptake——✓—Anti-Inflammatory FactorIncreasesChemotactic Response To Anti-Inflammatory Factor———✓Anti-Inflammatory FactorIncreasesPhagocytose Apoptotic Cell———✓Effector T CellAnti-Inflammatory FactorIncreasesTransform To Exhausted T Cell✓—✓✓Pro-Inflammatory FactorIncreasesAttack Malignant Epithelial Cell✓——✓Pro-Inflammatory FactorIncreasesMigration Speed✓—✓—Pro-Inflammatory FactorIncreasesChemotactic Response To Pro-Inflammatory Factor——✓✓Substrate: Pro-Inflammatory FactorIncreasesAttack Cell Type Malignant Epithelial Cell—✓——Contact With Malignant Epithelial CellIncreasesAttack Malignant Epithelial Cell——✓—OxygenIncreasesAttack Malignant Epithelial Cell———✓Exhausted T CellAnti-Inflammatory FactorDecreasesMigration Speed✓—✓—Anti-Inflammatory FactorDecreasesAttack Malignant Epithelial Cell———✓Malignant Epithelial CellOxygenDecreasesNecrosis✓——✓OxygenIncreasesCycle Entry✓——✓OxygenDecreasesMigration Speed✓—✓—Substrate: OxygenIncreasesCycle Entry—✓——Contact With Effector T CellIncreasesPro-Inflammatory Factor Secretion——✓—OxygenDecreasesCycle Entry——✓—Rows present only in the manual rule set (absent from all LLM outputs) are excluded. ✓ indicates rule is present, — indicates absent. The files (rules.csv) with all the rules generated by the LLMs can be found at https://github.com/marcorusc/Supp_mat_MCP_orchestrator. Table 1Scenario 2 - Rule-by-rule comparison of updated LLM-generated rules, grouped by cell typeSignalDirectionBehaviorManualGPT-o4-miniSonnet-4GPT-5.1M0 MacrophagePro-Inflammatory FactorIncreasesTransform To M1 Macrophage——✓✓Anti-Inflammatory FactorIncreasesTransform To M2 Macrophage——✓✓Substrate Gradient: Apoptotic DebrisIncreasesChemotactic Response To Substrate—✓——M1 MacrophagePro-Inflammatory FactorIncreasesChemotactic Response To Pro-Inflammatory Factor——✓✓Substrate Gradient: Necrotic DebrisIncreasesPhagocytose Necrotic Cell—✓——Contact With Malignant Epithelial CellIncreasesAttack Malignant Epithelial Cell——✓—Apoptotic DebrisIncreasesApoptotic Debris Uptake——✓—Pro-Inflammatory FactorIncreasesAttack Malignant Epithelial Cell———✓M2 MacrophageSubstrate: Anti-Inflammatory FactorIncreasesMigration Speed—✓——Contact With Malignant Epithelial CellDecreasesMigration Speed——✓—Apoptotic DebrisIncreasesApoptotic Debris Uptake——✓—Anti-Inflammatory FactorIncreasesChemotactic Response To Anti-Inflammatory Factor———✓Anti-Inflammatory FactorIncreasesPhagocytose Apoptotic Cell———✓Effector T CellAnti-Inflammatory FactorIncreasesTransform To Exhausted T Cell✓—✓✓Pro-Inflammatory FactorIncreasesAttack Malignant Epithelial Cell✓——✓Pro-Inflammatory FactorIncreasesMigration Speed✓—✓—Pro-Inflammatory FactorIncreasesChemotactic Response To Pro-Inflammatory Factor——✓✓Substrate: Pro-Inflammatory FactorIncreasesAttack Cell Type Malignant Epithelial Cell—✓——Contact With Malignant Epithelial CellIncreasesAttack Malignant Epithelial Cell——✓—OxygenIncreasesAttack Malignant Epithelial Cell———✓Exhausted T CellAnti-Inflammatory FactorDecreasesMigration Speed✓—✓—Anti-Inflammatory FactorDecreasesAttack Malignant Epithelial Cell———✓Malignant Epithelial CellOxygenDecreasesNecrosis✓——✓OxygenIncreasesCycle Entry✓——✓OxygenDecreasesMigration Speed✓—✓—Substrate: OxygenIncreasesCycle Entry—✓——Contact With Effector T CellIncreasesPro-Inflammatory Factor Secretion——✓—OxygenDecreasesCycle Entry——✓—Rows present only in the manual rule set (absent from all LLM outputs) are excluded. ✓ indicates rule is present, — indicates absent. The files (rules.csv) with all the rules generated by the LLMs can be found at https://github.com/marcorusc/Supp_mat_MCP_orchestrator. Scenario 2 - Rule-by-rule comparison of updated LLM-generated rules, grouped by cell type Rows present only in the manual rule set (absent from all LLM outputs) are excluded. ✓ indicates rule is present, — indicates absent. The files (rules.csv) with all the rules generated by the LLMs can be found at https://github.com/marcorusc/Supp_mat_MCP_orchestrator. However, this autonomy also introduced syntax errors and biological contradictions: Syntax errors When the MCP tool loads the PhysiCell configuration file, it automatically generates a dictionary of available signals and behaviors, injecting this directly into the LLM’s context to guide rule generation. Despite this contextual grounding, the tool does not currently feature an internal validation loop to verify the grammatical correctness of the rules before finalizing the output. Consequently, GPT-o4-mini struggled with the strict PhysiCell grammar, frequently generating non-standard names (e.g., “Substrate Gradient: Apoptotic Debris” instead of “Apoptotic Debris”, and “Attack Cell Type Malignant Epithelial Cell” instead of just “Attack Malignant Epithelial Cell”). This highlights the smaller LLM’s tendency to hallucinate vocabulary even when provided with the correct reference dictionary. Biological inconsistencies The LLMs occasionally inferred rules that contradicted established biological principles or the manual baseline. For instance, Sonnet-4 proposed that Oxygen decreases Cycle Entry in Malignant Epithelial Cells, whereas the manual model indicates that Oxygen increases cycle entry. Similarly, GPT-5.1 formulated a rule where Oxygen increases the attack rate of Effector T Cells against Malignant Epithelial cells. While the LLMs demonstrated the capacity to extract the underlying biological context and to propose a valid set of interactions (such as chemotaxis and polarization), the omissions of core physical rules and the presence of syntax hallucinations, despite the provided dictionary, highlights the current limitations of automated rule inference. These results demonstrate that both hallucination risks and the complexity of the chosen LLM have a major impact on rule generation. Therefore, rather than acting as fully autonomous agents, these models function best as assistants that require human guidance, intervention, and rigorous review to correct the outputs before simulation. Scenario 3 — Iterative Boolean model refinement through network pruning The third scenario explored whether LLMs can identify flaws or inconsistencies in automatically generated Boolean models and improve their dynamics through iterative refinement, by solely using the tools from the NeKo and MaBoSS servers. We prompted the LLMs to create a workflow of the form build-prune-convert-simulate-mutate-curate. In practice, the LLMs first constructed a regulatory network with NeKo, autonomously detected inconsistent pathways, pruned them, converted the network into a MaBoSS model, simulated the wild-type (WT) dynamics (i.e., random initial conditions), and finally tested a set of mutations to assess biological plausibility. Importantly, the initial prompt contained no explicit guidance about which genes to choose as output or which mutants to test, in order to maximize the reasoning and orchestration performed by the LLMs themselves. GPT-o4-mini generated a concise 22-node network and successfully simulated both WT and mutant conditions. The LLM observed a balance in the WT simulation results (Fig. 4A) and interpreted the mutant behaviors as consistent with known biology, concluding that the model already aligned with the expected scenario. Therefore, it did not attempt to iterate and requested user confirmation before further refinements. However, upon manual simulation of the TP53 mutant, we found that this interpretation was incorrect, as CASP3 remained highly represented in the model fixpoint rather than being abolished (Suppl. Material, Fig. S9). This suggests that, with limited guidance, smaller LLMs may struggle with the interpretation of simulation outputs.Fig. 4Scenario 3 - Iterative Boolean model refinement and conversational steering.A MaBoSS node activation probabilities generated autonomously by the three LLMs, compared against the manually curated baseline model by Calzone et al. B Stepwise conversational refinement of the GPT-5.1 model. Left: Explicit prompts to prune the topology did not affect the model dynamics. Middle: Constraining the LLM to use specific phenotypic markers from the literature resulted in a dominant NFKB1-driven survival response. Right: Providing explicit stable state target probabilities allowed the LLM to infer dynamics that closely align with the established biological baseline. Scenario 3 - Iterative Boolean model refinement and conversational steering. A MaBoSS node activation probabilities generated autonomously by the three LLMs, compared against the manually curated baseline model by Calzone et al. B Stepwise conversational refinement of the GPT-5.1 model. Left: Explicit prompts to prune the topology did not affect the model dynamics. Middle: Constraining the LLM to use specific phenotypic markers from the literature resulted in a dominant NFKB1-driven survival response. Right: Providing explicit stable state target probabilities allowed the LLM to infer dynamics that closely align with the established biological baseline. Sonnet-4 successfully executed an autonomous refinement loop. It initially generated a 129-node network and evaluated its dynamics with the MaBoSS mutation tool. By testing specific in silico perturbations (such as TP53 knockout, BCL2 and MYC overexpression, Suppl. Material, Figs. S10, S11, and S12) and observing the resulting behaviors (e.g., verifying that MYC overexpression triggered both proliferation and apoptotic stress), the LLM iteratively pruned the network. Through this process, it reduced the topology to a 19-node model with 77 interactions that captured the balance between TNF-induced survival and apoptosis (Fig. 4A). GPT-5.1 generated a massive 134-node network. Its WT simulation reported activation of RIPK1 and NFKB1, with no apoptotic execution. While it correctly interpreted the mutant validations (for example, RIPK3 knockout correctly abolished necroptosis in favor of a survival/inflammatory fate, Suppl. Material, Fig. S16), it halted the iteration process. Interestingly, the LLM justified this halt by reasoning that the lack of apoptotic attractors stemmed from the rigid logic rules automatically inferred with NeKo. It stated that achieving multi-stability (balancing survival, apoptosis, and necroptosis) required manual curation of the Boolean rules rather than further automated topological pruning, effectively recognizing the limitations of the single-prompt automated pipeline. Conversational refinement To demonstrate how human interactions can attenuate these limitations, we utilized GPT-5.1’s underperforming baseline to conduct a conversational refinement, explicitly testing how different prompting strategies affect model evolution. Topology pruning We first explicitly instructed GPT-5.1 to resume pruning nodes and interactions irrelevant to TNF-induced cell fate. While the network size decreased, the resulting dynamics remained unaltered, with RIPK1 and NFKB1 highly activated while CASP3 and BAX remained entirely suppressed (Fig. 4B). Rule updating using literature references In the next iteration, we constrained the prompt by defining specific phenotypic markers that were present in the Calzone et al. model (NFKβ, CASP3, RIP1K). We instructed the LLM to compare its output to this publication, prune accordingly, and modify Boolean rules while providing literature justifications for each change. This refinement led to a limited change in the dynamics, mitigating the role of RIPK3, and resulting in NFKB1 (survival) response with no cell death (Fig. 4B). Topology and rule updates guided by target probabilities Finally, we provided the LLM with the explicit stable state probabilities reported in the Calzone et al. model and engaged in an iterative dialogue to prune specific non-relevant nodes. Grounded by these explicit mathematical targets, the LLM successfully re-inferred the rules and pruned the topology. The resulting dynamics exhibited a closer alignment with the biological baseline, correctly capturing the rise in BAX, the stabilization of RIPK1, and keeping the mutual exclusivity between NFKB1 and CASP3 (Fig. 4B). These results indicate that while advanced LLMs can occasionally self-correct (Sonnet-4) or accurately diagnose pipeline limitations (GPT-5.1), fully autonomous iteration is generally unreliable for complex systems biology. However, a conversational approach, where a human expert provides specific literature benchmarks, targeted probability states, and explicit pruning directives, allows the AI assistant to systematically refine and rescue a flawed mechanistic model. A full report of the simulations and mutations tested by the LLMs is available in the Supplementary Material. Model dependence and prompt sensitivity MCP servers enable LLM-agnostic orchestration, but the choice of model still strongly affects the resulting networks in terms of size, logical depth, and emergent attractors. We also found that prompt design plays a central role: increasing specificity, exposing tool calls, and clearly defining boundary conditions (e.g., TNF diffusion sources), output nodes, and mutation panels can reduce bias toward single-attractor outcomes and improve interpretability. In this study, we deliberately focused on a one-shot orchestration mode to test whether LLMs can autonomously manage complex workflows. However, better results can often be obtained in a conversational mode, where tool calls and modeling choices are refined iteratively through dialogue with the user. This prompt sensitivity is illustrated in Scenario 3 (Fig. 4B), while more detailed examples are provided in the Supplementary Material. AI-assisted rapid prototyping and biological reasoning AI-assisted mechanistic modeling can transform the time scales of computational hypothesis testing. Traditional model development requires months of literature research, coding, parameter fitting, and expert consultation. In the demonstrated use cases, our approach compresses this initial prototyping phase to minutes while maintaining biological logic, allowing rapid exploration of multiple hypotheses and scenarios. This acceleration can lower the barrier between biological questions and computational exploration, making computational modeling accessible to a broader community. Importantly, the generated models reflect more than simple pattern matching. The ability of the LLMs to connect molecular, cellular, and tissue-level information suggests a practical form of multiscale reasoning within the workflow. When properly coupled with domain-specific tools and models, AI assistants can function as useful modeling assistants rather than simple tool orchestrators. This capability scales with model sophistication: advanced LLMs manage general prompts effectively, while simpler ones require more detailed guidance. Technical and practical limitations In our experience, the main bottlenecks arise from the underlying tools rather than the AI model itself. Large network searches in NeKo or large Boolean models with many output nodes in MaBoSS may demand significant computational time. Failures usually stem from insufficient tool documentation or software bugs rather than flawed reasoning by the LLM. When biological choices appear suboptimal, they usually reflect general prompts requiring more specific guidance rather than only failures of tool execution, although misinterpretation of simulation outputs can also occur. More detailed conversational interactions consistently improve model quality and biological specificity, as illustrated in the Supplementary Material Sections 4.2 and 6. Validation and reproducibility challenges Model validation remains the primary limitation of current implementations. Systematic comparison against experimental data and established models still requires manual intervention. Based on our implementation, quality assessment of AI-generated models should combine three complementary criteria: (1) compliance with available experimental data, (2) validation by human biological experts, and (3) evaluation by specialized AI agents with access to literature databases. Our current framework lacks such protocols, but the architecture supports their integration. Reproducibility across different prompts and users also requires systematic evaluation. Preliminary observations suggest that similar biological questions yield consistent model structures, but formal studies on prompt sensitivity and user variability are still needed for widespread adoption. Discussion This first implementation demonstrates the promise of conversational mechanistic modeling, but its evolution and consolidation will require advances across multiple technical domains. Enhanced model quality will depend on improved automated curation algorithms, sophisticated parameter optimization workflows, and robust validation protocols. Integration with experimental data streams could enable real-time model refinement and validation against emerging datasets. Building on our server-centered ecosystem, scaling challenges must be addressed to handle genome-wide networks, detailed kinetic models, and complex multiscale systems. This includes both computational efficiency improvements and more sophisticated AI-tool integration patterns. The development of specialized LLMs trained on systems biology knowledge could improve biological reasoning and model quality, particularly for complex cross-server integration scenarios25. Finally, reproducibility and provenance tracking represent critical infrastructure needs. Conversational workflows must maintain the same standards of scientific reproducibility as traditional computational approaches. This requires enhanced logging, version control, and standardized reporting mechanisms that capture the full conversational modeling process while preserving intelligent tool chain discovery capabilities. At the same time, reproducibility in this setting is complicated by the inherent variability of LLMs: different prompts or sampling settings can lead to divergent outputs, and these dependencies are not yet systematically controlled. Addressing this will require not only technical solutions but also governance frameworks and guardrails that constrain tool use, record decision paths, and ensure that results remain verifiable and interpretable across users and models. AI-assisted mechanistic modeling represents part of a broader transformation in scientific computing toward agentic systems development. Recent work on multi-agent scientific problem solving26 demonstrates how specialized AI agents can collaborate to solve complex problems across domains. Our MCP servers provide foundational orchestration capabilities that enable such collaborative approaches in systems biology. The long-term vision encompasses integrated agent ecosystems where specialized AI assistants collaborate on model construction, validation, and optimization. A model-building agent (demonstrated here) can collaborate with literature synthesis agents, parameter optimization specialists, and experimental data integration systems. Each agent would communicate through natural language and structured file exchange, creating human-readable workflows that maintain scientific transparency. Such systems could reshape collaboration patterns by enabling faster hypothesis-to-experiment cycles and democratizing access to computational tools. This shift may increasingly focus researchers on higher-level conceptual work, hypothesis generation, and biological interpretation, while AI systems handle routine computational tasks. Intelligent tool orchestration through MCP servers represents a promising advancement in AI-assisted mechanistic modeling for systems biology. Our example of TNF response modeling developed here demonstrates how AI assistants can support rapid multiscale model prototyping through natural language interaction, while coordinating established modeling tools across successive abstraction levels. In this work, we make three main contributions. First, we propose an architectural framework for biological AI-tool integration, in which modeling tasks are decomposed into decision-based tools and coordinated through session-aware orchestration. Second, we show that modern LLMs can support biologically informed decisions across multiple stages of the workflow. Third, we provide a proof of concept for rapid model prototyping that reduces traditional development timelines while preserving structural coherence and demonstrating reproducibility under controlled conditions (i.e., consistent prompts, LLMs, and configurations). These elements are not only expected features of effective AI-assisted modeling but also represent our proposed framework for how such systems can be implemented in computational biology. However, realizing this potential requires development of validation protocols, quality control mechanisms, and further integration with established computational biology frameworks (such as Compucell3D, Biodynamo, Corneto27, CellNopt28, etc.). The developments presented here, and others that are surely underway14,26, are only the beginning of a broader vision. We anticipate the emergence of multi-agent collaborative systems, in which specialized AI assistants coordinate on model construction, validation, and optimization. Realizing this vision will demand not only human oversight but will require the appropriate tools and systems to make it effective. Maintaining scientific rigor must be a priority, requiring appropriate control mechanisms and systematic grounding of all developments in biological evidence. Our implementation supports human control through session-aware orchestration, which makes tool calls transparent and traceable, while structured outputs and informative error handling provide interpretable checkpoints where users can intervene. Scientific rigor is reinforced by relying on established modeling software for network construction, simulation of Boolean models, and multicellular dynamics, ensuring that all computations are grounded on validated methods. Progress will require collaboration between AI researchers, systems biologists, and the broader scientific community to ensure that these systems support scientific discovery while meeting standards for validation, reproducibility, and quality control. As these technologies mature, intelligent tool orchestration could become an integral component of the scientific toolkit, accelerating discovery through AI partnership while preserving the biological insight and scientific rigor essential for advancing our understanding of complex biological systems. Although our demonstrations focus on systems biology, the principles developed here are not restricted to this domain. The same architectural ideas — modular tool orchestration, transparent workflows, and conversational interfaces — are broadly applicable to other scientific fields that depend on complex computational pipelines and heterogeneous data integration. Methods Performance benchmarking To characterize the efficiency of conversational modeling workflows, we collected benchmarking metadata across all reported scenarios and LLMs, including wall-clock time, token usage when available from the client, number of user interventions, number of MCP tool calls, and workflow completion outcomes (Suppl. Material, Section 4.1). We also performed repeated runs to examine the robustness of the orchestration under identical or more constrained prompting conditions (Suppl. Material, Section 4.2). Execution time and workflow completion In Scenario 1, complete multiscale model construction required 3.0 minutes with GPT-o4-mini, 7.0 minutes with GPT-5.1, and 12.6 minutes with Sonnet-4. Across all three scenarios, the recorded wall-clock times ranged from 1.2 to 70.6 minutes depending on the LLM and task complexity (see Suppl. Material, Fig. S1 for a full list of the execution time per scenario). In all reported benchmarked runs, the requested workflows were completed successfully, although differences across models were evident in execution time, workflow verbosity, and the number of MCP tool calls required. Assessment of user intervention The reported workflows required between 0 and 3 user interventions beyond the initial prompt. As detailed in the Suppl. Material, Fig. S4, these interventions corresponded to short continuation or confirmation messages required by the client interface, for example when execution paused after reaching interaction limits. They did not involve manual coding, direct file editing, or manual parameter tuning. Token usage and workflow overhead Token usage was available for GPT-5.1 and Sonnet-4 through the client metadata, but not for GPT-o4-mini. For Scenario 1, the full multiscale workflow required 123,044 tokens with GPT-5.1 and 201,544 tokens with Sonnet-4. Across scenarios, differences in token usage were accompanied by differences in the number of MCP tool calls and user interventions, indicating that workflow overhead depends not only on the biological task but also on the interaction style of the LLM and client. The full token usage by scenario per LLM is reported in Suppl. Material, Fig. S1. Execution environment To facilitate reproducibility, we report the execution environment used for all benchmarked runs. All runs were performed in Visual Studio Code (version 1.109.5) using the GitHub Copilot extension. The MCP servers were implemented with the MCP Python SDK (version 1.26.0), and the underlying modeling tools used the following versions: NeKo 1.1, MaBoSS 0.8.12, and PhysiCell_Settings 0.6.1. Prompts used in the study Below we report the initial prompts used to start the main scenarios described in this study. Scenario 1 You are my multiscale modelling assistant. Together we are creating a multiscale multicellular model of cancer cell fate in response to TNF. In order to achieve this we are going to use NeKo, MaBoSS, and PhysiCell to create a simulation where an initial group of cancer cell will grow while TNF diffuses in the microenvironment. When the cells sense the TNF they will activate the input nodes of their boolean network. According to the final state of the network, they will perform behaviors such as die for apoptosis or proliferate. Those are the steps to follow: (1) create a network using OmniPath that describes cancer cell fates in response to TNF. This network should contain TNF-sensing receptors as well as genes responsible for proliferation and apoptosis. Once the network is created, remove the bimodal interactions and check the connectivity. If the network is connected, export it in .bnet format. After that, generate the MaBoSS files (.bnd and .cfg), create a simulation, and select some nodes as outputs to represent apoptotic and proliferative states. Once those nodes are set as outputs, run the MaBoSS simulation, retrieve the results, and evaluate the outcome (does the network make sense? Are the states biologically feasible?). In the second part we will build the PhysiCell simulation and add MaBoSS to the cancer cell type. Is everything clear? You are my multiscale modelling assistant. Together we are creating a multiscale multicellular model of cancer cell fate in response to TNF. In order to achieve this we are going to use NeKo, MaBoSS, and PhysiCell to create a simulation where an initial group of cancer cell will grow while TNF diffuses in the microenvironment. When the cells sense the TNF they will activate the input nodes of their boolean network. According to the final state of the network, they will perform behaviors such as die for apoptosis or proliferate. Those are the steps to follow: (1) create a network using OmniPath that describes cancer cell fates in response to TNF. This network should contain TNF-sensing receptors as well as genes responsible for proliferation and apoptosis. Once the network is created, remove the bimodal interactions and check the connectivity. If the network is connected, export it in .bnet format. After that, generate the MaBoSS files (.bnd and .cfg), create a simulation, and select some nodes as outputs to represent apoptotic and proliferative states. Once those nodes are set as outputs, run the MaBoSS simulation, retrieve the results, and evaluate the outcome (does the network make sense? Are the states biologically feasible?). In the second part we will build the PhysiCell simulation and add MaBoSS to the cancer cell type. Is everything clear? Scenario 2 I have a PhysiCell configuration file #file:PhysiCell_settings.xml that I would like to extend with biologically accurate rules. Load the PhysiCell configuration file, extract the biological scenario, extract the substrates, cell types and custom parameters that compose the simulation and, carefully examining the available signals and behaviors, add a series of rules to improve the model. I have a PhysiCell configuration file #file:PhysiCell_settings.xml that I would like to extend with biologically accurate rules. Load the PhysiCell configuration file, extract the biological scenario, extract the substrates, cell types and custom parameters that compose the simulation and, carefully examining the available signals and behaviors, add a series of rules to improve the model. Scenario 3 I want to create a Boolean model that describes how TNF affects cancer cell fate. In order to do so, I want you to create a network using Omnipath as interactions database. Once created the network, remove the bimodal interactions, export the network in bnet format, and convert it into a MaBoSS model. Run the MaBoSS model (set thread count to 10) and get the results. If the results are biologically accurate and relevant, test some known mutations end verify the accuracy of the results. If the network is not satisfying, check important pathways within the network and individuate nodes or interactions that may not be relevant and bring inaccuracies in the model. Finally, make sure the final network always contains relevant nodes, important for our scenario. Iterate the process until the MaBoSS model is accurate enough. I want to create a Boolean model that describes how TNF affects cancer cell fate. In order to do so, I want you to create a network using Omnipath as interactions database. Once created the network, remove the bimodal interactions, export the network in bnet format, and convert it into a MaBoSS model. Run the MaBoSS model (set thread count to 10) and get the results. If the results are biologically accurate and relevant, test some known mutations end verify the accuracy of the results. If the network is not satisfying, check important pathways within the network and individuate nodes or interactions that may not be relevant and bring inaccuracies in the model. Finally, make sure the final network always contains relevant nodes, important for our scenario. Iterate the process until the MaBoSS model is accurate enough. Reproducibility guardrails While the underlying tools used in our framework behave deterministically once valid inputs and parameters are provided, we acknowledge that variability can still arise from the LLM itself. Because GitHub Copilot runs as an extension within Visual Studio Code, it does not allow direct control over model hyperparameters such as temperature, top-p, or random seed. To estimate the effect of this limitation, we repeated a simplified NeKo-to-MaBoSS workflow using both a general and a more specific prompt (Supplementary Section 4.2, Prompt robustness analysis). These repeated runs showed variability in the biological outputs, including differences in the inferred network structure, selected input/output nodes, and resulting MaBoSS trajectories (more details in Suppl. Material, Fig. S7). At the same time, the MCP orchestration remained stable across runs. This stability is supported by the strict schemas imposed by the MCP tools (example in Supplementary Material), which require well-defined argument structures, explicit parameter types, and valid configurations before execution can proceed. In practice, this means that although the biological choices proposed by the LLM may vary, the execution of the downstream tools remains constrained by a rigid interface. As a result, when users provide specific seed genes and pathway parameters, the subsequent NeKo inference and MaBoSS simulations run in a deterministic and reproducible manner. Repositories and generated outputs are described in the Data availability and Code availability statements below. The MCP servers were installed and executed in Visual Studio Code. Supplementary information Supplementary information Supplementary information