Mini-MuMMI: Portable ML-Driven MD Workflow

• Mini-MuMMI is a curated subset of MuMMI that reduces computational footprint while retaining key workflow logic for ML-driven multiscale MD simulations.
• It employs a pre-trained autoencoder and a two-layer (application and coordination) workflow to adaptively generate and validate coarse-grained protein structures.
• Demonstrated on RAS-RAF membrane interactions, mini-MuMMI delivers rapid, efficient sampling by bridging discrete metastable states through distributed short-run simulations.

Mini-MuMMI is a curated version of the massively parallel Multiscale Machine-Learned Modeling Infrastructure (MuMMI), designed to run on modest HPC systems or even laptops, whereas MuMMI requires larger HPC systems. It addresses the longstanding difficulty of bridging different time and length scales in multiscale biomolecular modeling by combining machine learning-driven conformational proposal, molecular dynamics orchestration, and workflow management for thousands of simulations operating at different timescales, spanning from millisecond to nanosecond. In the reported implementation, mini-MuMMI is demonstrated on RAS-RAF membrane interactions and positioned as a lightweight, end-to-end substrate for ML-driven multiscale MD campaigns (Pottier et al., 10 Jul 2025).

1. Conceptual scope and relation to full MuMMI

Multiscale models are described as collections of internal models operating at difference scales, ranging from microscopic to macroscopic length and time scales. Within that setting, mini-MuMMI retains the workflow logic of MuMMI while reducing the system footprint, dependency surface, and infrastructure requirements. The reported mini-MuMMI system size is approximately $50\,\mathrm{K}$ particles, corresponding to approximately $1\,280$ lipids plus KRAS plus RBD plus CRD, which is approximately $3\times$ fewer particles than the published “medium” system and approximately $6\times$ fewer than ongoing production runs (Pottier et al., 10 Jul 2025).

The distinction from production MuMMI is structural as well as computational. Mini-MuMMI uses a pre-trained 32-dimensional autoencoder trained on a few hundred thousand CG frames, rather than millions in production. Full MuMMI includes a continuum (mesoscale) macro model for membrane remodeling; this is absent in mini. No GPU-heavy continuum code is included, and all GROMACS inputs, ML code, sampler, and helper scripts are curated and pinned, with fewer Python/C++ libraries. A common source of confusion is therefore the assumption that mini-MuMMI is merely a smaller deployment of the same stack; the paper instead presents it as a curated subset with explicit omissions, most notably the absence of the macro-model and the corresponding production-scale multiscale coupling (Pottier et al., 10 Jul 2025).

The reported software footprint reflects this reduction in scope. Mini-MuMMI occupies approximately $1\,\mathrm{GB}$ on disk, versus dozens in full MuMMI, and is stated to run on $1$–$128$ GPUs plus matching CPUs or on laptops. This suggests a deliberate repositioning of MuMMI from a facility-scale workflow to a portable research platform for controlled experimentation with ML-in-the-loop MD.

2. Workflow architecture and execution model

Mini-MuMMI is organized as a two-layered workflow. The Application Layer, described as “what to do,” contains Structure-Generator (SG), Createsims, and CGAnalysis. The Coordination Layer, described as “how to do it,” contains the Workflow Manager (WM, in Python), a RabbitMQ message broker, Maestro plus Flux for job scheduling, and persistent storage for trajectories and feedback (Pottier et al., 10 Jul 2025).

Within SG, the Sampler selects novel latent-space points to explore, the Generator decodes latent points into coarse-grained protein structures, and the Validator runs a short in-vacuo energy minimization in GROMACS and rejects any structure whose energy exceeds a threshold. Createsims uses “insane” to embed CG proteins in a pre-equilibrated eight-component plasma membrane model, solvates with water/ions, and then runs energy-minimization and short equilibration in NPT to yield production-ready CG systems. CGAnalysis launches production CG MD using GROMACS together with in-situ Python analysis threads and writes feedback files summarizing lipid–protein contacts, orientation metrics, and related observables (Pottier et al., 10 Jul 2025).

The WM continuously requests new structures from SG, schedules Createsims and CGAnalysis jobs, and monitors feedback. The SG–WM exchange uses RabbitMQ for structure-requests and structure-offers, specifically to avoid filesystem overhead for small messages. Simulation frames are written to disk, feedback files are approximately $8\,\mathrm{KB}$ each, and optional in-memory metadata can be maintained in Redis or local sqlite (Pottier et al., 10 Jul 2025).

The reported data flow is iterative. WM sends a request for $K$ new latent points to simulate; SG returns a list of $K$ validated CG structures; WM submits one Createsims job per structure and creates input directories; on completion, WM submits matching CGAnalysis jobs; CGAnalysis runs GROMACS for up to $1\,280$0, writes snapshots every $1\,280$1, and in-situ threads consume snapshots every $1\,280$2 frames to produce feedback files; WM reads feedback and updates sampler priorities. The loop continues until quota. In effect, mini-MuMMI operationalizes multiscale exploration as a tightly coupled queue-driven control loop rather than a static ensemble submission (Pottier et al., 10 Jul 2025).

3. Machine learning formulation and multiscale coupling

The ML component is centered on an autoencoder for conformational sampling. The input $1\,280$3 is the concatenated 3D coordinates of $1\,280$4 CG beads, specifically protein backbone beads. The encoder is $1\,280$5 with $1\,280$6, parameterized by a 5-layer feed-forward network, and the decoder $1\,280$7 has a symmetrical architecture. Training uses the reconstruction loss

$1\,280$8

Sampling is then carried out in latent space, with $1\,280$9 and an exploration/exploitation balance through a UCB-like score,

$3\times$0

where $3\times$1 and $3\times$2 are mean and uncertainty estimated from prior trajectories (Pottier et al., 10 Jul 2025).

The ML system does not by itself define a complete simulation state. Decoding $3\times$3 CG structure yields bead positions only; Createsims adds explicit membrane plus solvent to produce CG MD initial conditions. This division of labor is central to the workflow: ML proposes conformations, while the MD pipeline restores the environmental context required for physical simulation. The paper also states that there is no on-the-fly all-atom mapping in mini, although in production the CG snapshots can be backmapped to all-atom for high-resolution refinement (Pottier et al., 10 Jul 2025).

A compact expression of the multiscale bridge is given through an effective free-energy coupling,

$3\times$4

where $3\times$5 is estimated from the density of accepted CG samples in latent space. Feedback can then be used to refine coarse or continuum potentials in full MuMMI. In mini-MuMMI this coupling remains limited by the absence of the macro-model, but the formulation indicates how latent-space occupancy, MD acceptance, and downstream multiscale refinement are intended to interact in the broader MuMMI framework.

4. Scheduling, resource allocation, and throughput

The workflow manager periodically queries RabbitMQ for pending simulation feedback, re-prioritizes latent-space grid cells by score, requests up to $3\times$6 new CG structures from SG, submits Createsims and then CGAnalysis jobs via Maestro to Flux, and resubmits any failed jobs automatically through Flux node-failure restart (Pottier et al., 10 Jul 2025). The simplified control logic is an event-driven loop in which proposal, validation, simulation, and feedback are repeatedly interleaved until walltime expires or sampling converges.

On Frontier, the reported node configuration is 8 “GPUs” (GCDs) plus 56 usable CPU cores. Each CGAnalysis uses 1 GPU plus 6 CPU cores, with 4 cores for GROMACS and 2 for Python analysis, so each node supports 8 concurrent CGAnalysis jobs arranged as $3\times$7. Createsims also uses 1 GPU plus 6 CPU and runs at approximately $3\times$8 for mini, versus approximately $3\times$9 on medium systems (Pottier et al., 10 Jul 2025).

The measured performance scaling is explicitly reported. Mini-MuMMI reaches $6\times$0 per GPU, with a spread of $6\times$1, on Frontier. The medium system at 132K beads reaches $6\times$2 per GPU, and the large system at 300K beads reaches $6\times$3 per GPU. The end-to-end campaign achieved $6\times$4 aggregated CG sampling in $6\times$5 on 64 nodes, corresponding to approximately 512 concurrent GPUs (Pottier et al., 10 Jul 2025).

These figures contextualize the paper’s claim that mini-MuMMI aggregates milliseconds of CG sampling in less than 2 days. The reported performance advantage is not described as a speed-up of single-trajectory time-to-solution alone; rather, it is tied to ensemble landscape coverage under an actively managed scheduler with in-situ analysis and adaptive resubmission.

5. RAS-RAF membrane interaction study

The primary demonstration system is KRAS in G-domain active conformation bound to RAF1 RBD+CRD, embedded in an eight-component mammalian plasma membrane from Ozturk et al. 2024, with 600 lipids per leaflet and coarse-graining with Martini 3. The solvent is explicit Martini-level water plus $6\times$6 NaCl. The reported CG MD protocol uses the NPT ensemble at $6\times$7 and $6\times$8 with Berendsen thermostat/barostat, $6\times$9 and $1\,\mathrm{GB}$0, a timestep $1\,\mathrm{GB}$1, production length capped at $1\,\mathrm{GB}$2, snapshots every $1\,\mathrm{GB}$3, and a short energy minimization of less than $1\,\mathrm{GB}$4 plus $1\,\mathrm{GB}$5 equilibration before production (Pottier et al., 10 Jul 2025).

The ML-in-the-loop procedure begins with Round 0, where SG is initialized with an autoencoder trained on manually run A-ensemble and B-ensemble data. The A-ensemble is defined by CRD–membrane distance $1\,\mathrm{GB}$6 and the B-ensemble by CRD–membrane distance $1\,\mathrm{GB}$7. In each round, SG generates approximately 200 new $1\,\mathrm{GB}$8 points. CGAnalysis produces feedback files containing instantaneous CRD distance, orientation angles, and local lipid fingerprints, and the sampler uses feedback to avoid re-sampling regions that have high empirical coverage, steering instead toward unexplored latent regions (Pottier et al., 10 Jul 2025).

The principal reported result is the generation of 1,983 new CG structures bridging the A and B states, with the distribution of CRD–membrane distance smoothly filling in the $1\,\mathrm{GB}$9–$1$0 range. The campaign aggregated $1$1 of CG sampling in $1$2 on 64 nodes plus 4 h on 5 nodes. Average simulation length was $1$3 with a spread of $1$4. The paper further reports newly observed intermediate orientations not present in the original ensembles, which is taken to indicate successful interpolation by the autoencoder, and a speed-up relative to a naive one-long run of approximately $1$5–$1$6 in landscape coverage per unit wall-time, achieved by distributing 2,000 short runs instead of one monolithic $1$7 CG run (Pottier et al., 10 Jul 2025).

In methodological terms, the case study shows how mini-MuMMI uses latent-space interpolation together with adaptive queue-based execution to fill sparsely sampled configurational regions between manually curated boundary ensembles. This suggests a workflow for conformational bridging in systems where distinct metastable regimes are known a priori but the transition region is incompletely characterized.

6. Generalization, portability, and limits of abstraction

The paper explicitly discusses obstacles to generalization. As new feedback accumulates, one must decide when to re-train $1$8 to avoid outdated latent representations; mini-MuMMI uses manual checkpoint-retraining, while full MuMMI aims for on-the-fly retraining. Code coupling is another limitation: SG, Createsims, and CGAnalysis are domain-specific, so swapping in a different MD engine or coarse-grain force field requires updating multiple scripts. The workflow also depends on network services such as RabbitMQ or Redis, and many HPC centers are said to lack mature support for containerized network services (Pottier et al., 10 Jul 2025).

The corresponding mitigation strategy is configuration-driven modularity. All sampler parameters, including latent dimension $1$9, number of proposals $128$0, and exploration weight $128$1, as well as simulation parameters such as $128$2, ensemble, snapshot rate, and compute-resource specifications, are exposed in YAML. Containerization is planned through packaging each job type as a Docker/Singularity image with its Spack environment for reproducibility across clusters or cloud. The ML interface is deliberately narrow: sampler and generator are black boxes that conform to a simple API of request $128$3 return $128$4, allowing users to plug in Boltzmann Generators, normalizing flows, or VAMPnet priors (Pottier et al., 10 Jul 2025).

Resource tuning is also stated concretely. On a laptop with 4 cores and no GPU, mini-MuMMI can run with $128$5 and single-threaded Createsims/CGAnalysis for approximately $128$6 aggregate. On a small cluster, the recommendation is to scale $128$7 to the number of GPUs and adjust the 6 CPU/1 GPU split. For adaptation to a new system, the paper gives a five-step procedure: collect initial A/B MD ensembles for a new protein–membrane or protein–protein system; train a new autoencoder on concatenated $128$8 frames using the same MSE loss; edit YAML to point to new MD input templates such as topology, force field, and insane parameters; tune sampler hyperparameters including latent-space grid resolution and rounds per retraining; and optionally implement a new Validator to screen for system-specific steric clashes (Pottier et al., 10 Jul 2025).

In this form, mini-MuMMI serves as a lightweight messaging plus scheduling substrate that bridges user-coded ML samplers to real MD engines. A plausible implication is that its portability derives less from any one model class than from the separation between latent-space proposal, physical system assembly, production simulation, and feedback ingestion. The paper’s broader claim is therefore not that the RAS-RAF workflow is universally reusable as-is, but that the curated, pinned, and container-ready structure lowers the entry barrier for experimenting with ML-driven multiscale simulations in biomolecular or other particle-based systems.