HydraGNN: Scalable Graph Neural Network Framework

• HydraGNN is a scalable graph neural network framework that leverages message-passing and multi-task learning to analyze complex scientific data.
• It integrates modular architectures, efficient data pipelines, and distributed training to predict properties in molecular, crystalline, and heterogeneous power-grid graphs.
• The platform supports various backbones and heterogeneous datasets, offering actionable insights for performance optimization and future uncertainty quantification.

Searching arXiv for HydraGNN papers and related recent work. HydraGNN is Oak Ridge National Laboratory’s open-source graph neural network framework for scalable training and inference on graph-structured scientific data, originally developed for graph convolutional neural networks on molecular and crystalline systems and later extended to graph foundation models and heterogeneous graphs. Across its published uses, HydraGNN combines message-passing backbones, multi-task learning, distributed training, and high-throughput data pipelines to support graph-level and node-level prediction on workloads ranging from tens of thousands of alloy configurations to hundreds of millions of atomistic structures, and from homogeneous atomistic graphs to heterogeneous power-grid graphs (Choi et al., 2022, Pasini et al., 2022, Pasini et al., 2024, Pasini et al., 15 Apr 2026, Pasini et al., 22 May 2026).

1. Historical development and conceptual scope

HydraGNN first appeared in work on ferromagnetic materials as a multi-task graph convolutional neural network for simultaneous prediction of global and atomic physical properties in FePt solid-solution alloys. In that setting, the model was designed to learn, from the same crystal-structure input, the global mixing enthalpy together with per-atom charge transfer and per-atom magnetic moment, using shared convolutional layers followed by task-specific heads. The stated motivation was that these properties are physically correlated in ferromagnetic alloys, so multi-task learning provides effective training even with modest amounts of data and reduces training cost relative to separate single-task models (Pasini et al., 2022).

A closely related 2022 study used HydraGNN as a surrogate for first-principles density functional theory calculations in classical Monte Carlo workflows for ferromagnetic materials. There, HydraGNN was positioned as a graph convolutional neural network surrogate for configurational energetics and related atomic properties, fast enough to replace repeated DFT evaluations during phase-space sampling while preserving substantially better predictive performance than a linear mixing model for magnetic alloy materials (Eisenbach et al., 2022).

In parallel, HydraGNN was developed as an in-house library for large-scale graph convolutional neural network training on molecular graphs. That systems-oriented line emphasized scalable prediction of material properties for millions of molecules, especially the HOMO-LUMO gap, on multi-GPU and multi-node high-performance computing systems. The library design centered on PyTorch Distributed Data Parallel, efficient data ingestion, and strong scaling on leadership-class machines (Choi et al., 2022).

Subsequent work broadened HydraGNN from a task-specific GCNN library into a graph foundation model platform for atomistic materials. In that formulation, HydraGNN became a multi-headed message-passing framework that abstracts over nearest-neighbor convolution algorithms and exposes the message-passing family itself as a categorical hyperparameter. Reported supported backbones include PNA, EGNN, SchNet, DimeNet++, MACE, PaiNN, and an equivariant PNA variant, enabling controlled comparisons and large-scale hyperparameter optimization under a common workflow (Pasini et al., 2024, Pasini et al., 15 Apr 2026).

By 2026, HydraGNN had also been extended beyond homogeneous atomistic graphs to a heterogeneous, relation-aware stack for data-driven optimal power flow in smart grids. In that work it preserved typed buses, generators, loads, shunts, AC lines, transformers, and device-to-bus couplings rather than flattening the native schema of the grid. This suggests that HydraGNN’s defining abstraction is not a single architecture, but a configurable HPC-oriented graph learning framework spanning multi-task, multi-fidelity, and heterogeneous settings (Pasini et al., 22 May 2026).

2. Architectural principles and model organization

At its core, HydraGNN is a message-passing neural network framework built on PyTorch and PyTorch Geometric. In the molecular scaling study, the library was described as having modular data loaders, stacks of graph convolution layers, graph-level readout, and fully connected regression heads, with support for PyTorch’s Distributed Data Parallel for multi-GPU and multi-node training. Each process hosts a replica of the model, consumes disjoint mini-batches, computes local gradients, and synchronizes them via NCCL collectives directly on GPUs (Choi et al., 2022).

The early ferromagnetic-alloy architecture established HydraGNN’s canonical multi-head pattern. Shared graph convolutional layers extract common structural and chemical features, and later layers or branches discriminate task-specific features before separate heads generate graph-level or node-level outputs. In the FePt study, HydraGNN used 6 Principal Neighborhood Aggregation layers with 20 hidden units, a 7 Å neighborhood cutoff, and two fully connected layers per task with 50 and 25 neurons. In the Monte Carlo surrogate study, the reported configuration was 6 PNA layers with 300 hidden units, batch normalization and ReLU between convolutional layers, sum pooling for the graph-level representation, and three heads with two fully connected layers of sizes 50 and 25 (Pasini et al., 2022, Eisenbach et al., 2022).

The message-passing formalism is explicitly configurable. A generic update used in the graph foundation model work is

$$h_i^{(k+1)} = \varphi^{(k)}\big(h_i^{(k)},\; \bigoplus_{j\in\mathcal{N}(i)} \psi^{(k)}(h_i^{(k)}, h_j^{(k)}, e_{ij})\big),$$

where $e_{ij}$ may encode bond or geometric information, and the aggregation operator is chosen according to the backbone. For PNA, HydraGNN uses a multi-aggregator set $\{ \mathrm{sum}, \mathrm{mean}, \mathrm{max} \}$ with degree-based scalers; EGNN and SchNet commonly use sum or mean aggregation; EGNN includes coordinate updates to ensure equivariance (Pasini et al., 2024).

The framework’s supported message-passing families embody different geometric inductive biases. EGNN implements $E(3)$-equivariant message passing with coordinate updates based on pairwise relative distances. SchNet uses continuous-filter convolutions parameterized by interatomic distances. DimeNet++ augments local interactions with angular basis functions. PaiNN uses rotationally equivariant scalar and vector features per atom. PNA, by contrast, uses multiple aggregators with degree scalers and is not inherently equivariant (Pasini et al., 2024, Pasini et al., 15 Apr 2026).

HydraGNN’s later benchmarking work added a controlled local–global architecture space through two switches: a local MPNN path and a global attention path. This made it possible to instantiate four model classes under the same training scripts: a baseline MPNN, an MPNN with chemistry and topology encoders, a GPS-style hybrid combining MPNN and global attention, and a fully fused local–global variant with encoders. The global branch uses multi-head self-attention with optional positional or relational signals from Laplacian positional encodings, while the local branch remains a standard message-passing operator. This established HydraGNN as a comparative framework for architectural ablations as well as a training library (Chowdhury et al., 7 Oct 2025).

3. Graph representations, features, and data management

HydraGNN has been applied to several distinct graph constructions. In molecular HOMO-LUMO prediction, each molecule is represented as a graph with atoms as nodes and chemical bonds as edges, with node and edge features capturing chemistry and topology. The graph-level target is the HOMO-LUMO gap, defined as the energy difference between the lowest unoccupied molecular orbital and the highest occupied molecular orbital, written in the source as

$\Delta_{\mathrm{HL} = E_{\mathrm{LUMO} - E_{\mathrm{HOMO}$.$$</p> <p>Graph readout is performed by global mean pooling,</p> <p>$$h_G = \mathrm{READOUT}\!\left(\{h_v^{(L)} \mid v \in V\}\right),$</p> <p>with$\mathrm{READOUT}=\mathrm{mean}$, followed by a fully connected regression head$\hat{y}=f(h_G)$$(<a href="/papers/2207.11333" title="" rel="nofollow" data-turbo="false" class="assistant-link" x-data x-tooltip.raw="">Choi et al., 2022</a>).</p> <p>In ferromagnetic FePt, each crystal configuration is converted into a graph$$G=(V,E)$ whose nodes are atoms and whose edges connect atomic pairs within a cutoff radius of 7 Å. Node features include the three Cartesian components of atomic position and proton number. The fixed body-centered tetragonal lattice and fixed volume were chosen to isolate the effects of local graph interactions and atomic positions. No explicit global features were added; instead, graph-level mixing enthalpy was derived through pooling and task-specific heads from node-level representations (Pasini et al., 2022). A related Monte Carlo study describes essentially the same alloy representation, adding that periodic boundary conditions are handled via the minimum image convention (Eisenbach et al., 2022).

In graph foundation model training for atomistic materials, HydraGNN uses atomistic graphs whose nodes carry atomic numbers and learned embeddings, while edges encode neighbor relations derived from cutoffs or dataset-provided neighbor lists. For equivariant models, relative positions enter the message function explicitly; for SchNet and DimeNet++, interatomic distances and angular basis functions act as continuous filters. Across the aggregated datasets used in the 2024 study, graphs ranged from small molecules to surface slabs with up to 400 atoms and more than 12,500 edges per graph (Pasini et al., 2024).

HydraGNN’s data pipeline is a defining systems component. In the molecular scaling paper, graph data are preprocessed from SMILES strings into compact arrays and stored as global variables in ADIOS BP files, with node features $x$, edge topology $e_{ij}$0, edge features $e_{ij}$1, and targets $e_{ij}$2. ADIOS subfile control and optimized parallel I/O reduce filesystem metadata contention and enable scalable concurrent reads. Compared with Pickle-based object loading, ADIOS reduced data loading time by up to $e_{ij}$3 on a single Summit node and approximately $e_{ij}$4 on 32 nodes; it also outperformed inline CSV/SMILES conversion (Choi et al., 2022).

The graph foundation model papers extended this I/O strategy with ADIOS2 and DDStore. On Frontier, HydraGNN was reported to achieve over 8 TB/s reading the OC2020 trainset in parallel and about 120 GB/s sustained bandwidth reading the entire 4.3 TB OC2020 dataset, ingesting 120 million graphs in approximately 35 seconds. DDStore provides in-memory distributed caching and batch shuffling via MPI one-sided RMA operations, reducing end-to-end training times by up to $e_{ij}$5 compared with naïve approaches (Pasini et al., 2024). The exascale 2026 workflow further added node-local NVMe staging and sharded data distribution for 16 open first-principles datasets totaling 544,339,063 structures (Pasini et al., 15 Apr 2026).

The heterogeneous OPF extension replaced ADIOS with a distributed HDF5 pipeline. Roughly three million heterogeneous OPF instances were converted into 129 HDF5 shards, preserving typed node and edge schemas. HydraGNN’s HeteroBase uses separate input projectors per node type and relation-specific layers so that AC lines, transformers, and structural couplings carry distinct semantics and edge-attribute widths (Pasini et al., 22 May 2026).

4. Multi-task learning, foundation-model pretraining, and uncertainty

Multi-task learning is central to HydraGNN’s identity. In the FePt alloy work, HydraGNN simultaneously predicts the graph-level mixing enthalpy $e_{ij}$6 and the atomic properties $e_{ij}$7 and $e_{ij}$8, with a weighted sum of task-specific mean-squared errors,

$e_{ij}$9

using equal weights $\{ \mathrm{sum}, \mathrm{mean}, \mathrm{max} \}$0 after normalizing all inputs and outputs to $\{ \mathrm{sum}, \mathrm{mean}, \mathrm{max} \}$1. Numerical results showed that multi-task predictions were comparable in accuracy to single-task predictions, while training one three-task model was reported as more than $\{ \mathrm{sum}, \mathrm{mean}, \mathrm{max} \}$2 faster than training three separate single-task models. Mixing enthalpy benefited most clearly from multi-task learning: adding magnetic moment as a concurrent task reduced enthalpy RMSE from $\{ \mathrm{sum}, \mathrm{mean}, \mathrm{max} \}$3 to $\{ \mathrm{sum}, \mathrm{mean}, \mathrm{max} \}$4 in normalized units (Pasini et al., 2022).

The same basic principle recurs in later atomistic graph foundation models, but on much larger and more heterogeneous corpora. The 2024 case study trained HydraGNN on five datasets totaling 154,507,686 graphs and about 5.2 TB, using multi-task learning to predict graph-level energies and node-level forces concurrently. The total loss combined energy and force terms,

$\{ \mathrm{sum}, \mathrm{mean}, \mathrm{max} \}$5

with

$\{ \mathrm{sum}, \mathrm{mean}, \mathrm{max} \}$6

That work emphasized direct-force prediction with equivariant architectures rather than constraining forces to be exact gradients of the predicted energy (Pasini et al., 2024).

The 2025 multi-task parallelism paper introduced a two-level hierarchical multi-task design. Level 1 assigns one branch per dataset or fidelity; level 2 splits each dataset branch into energy-per-atom and force heads. This yields dataset-specific supervision while retaining a shared message-passing encoder. The reported experimental backbone was a 4-layer EGNN-style encoder with 866 hidden units per layer and dataset-specific decoders with three fully connected layers of 889 units each. On five datasets totaling more than 24 million structures, the resulting GFM-MTL-All model achieved energy MAEs of 0.0007 on ANI1x, 0.0096 on QM7-X, 0.0627 on MPTrj, 0.0179 on Alexandria, and 0.0115 on Transition1x, together with force MAEs of 0.0074, 0.0925, 0.1238, 0.0039, and 0.0388, respectively (Pasini et al., 26 Jun 2025).

The 2026 exascale paper generalized this pattern to 16 open first-principles datasets with 16 per-dataset output branches. Its lead architecture was a PaiNN model with 2 convolution layers, hidden dimension 337, 126 interaction filters, 4 Bessel radial basis functions, a 5 Å cutoff radius, a maximum of 20 neighbors, and 16 graph-level output branches. The heads comprised 2 shared layers of dimension 50 followed by 2 branch layers of dimension 776. Training used AdamW with learning rate $\{ \mathrm{sum}, \mathrm{mean}, \mathrm{max} \}$7, batch size 25 per GPU, MAE loss with force weight approximately 94.8, FP64 precision, and 100 epochs; the model had approximately 12.1 million parameters and required approximately 92 MB (Pasini et al., 15 Apr 2026).

HydraGNN’s notion of trustworthiness has primarily been operationalized through hyperparameter optimization and ensembles rather than formal calibration. In the 2024 graph foundation model study, DeepHyper’s centralized Bayesian optimization searched over MPNN family, depth, and width, with early stopping at 10 epochs per trial. The 10 best HydraGNN models were then trained to convergence for 40 epochs and averaged to produce epistemic uncertainty estimates via the ensemble mean and spread. That study did not report expected calibration error or out-of-distribution tests and explicitly identified them as natural next steps (Pasini et al., 2024). The 2026 exascale work instead focused on precision sensitivity and composition-conditioned branch weighting, stating that no explicit calibration or uncertainty-quantification method was reported there (Pasini et al., 15 Apr 2026).

5. Distributed training, scaling behavior, and energy-aware HPC execution

HydraGNN has been repeatedly evaluated on leadership-class HPC systems, and scalable distributed training is one of its most documented properties. In the molecular HOMO-LUMO work, strong-scaling experiments used AdamW with learning rate 0.001, local batch size 128, and 3 epochs. Summit experiments scaled to 256 nodes and 1,536 GPUs, with near-linear scaling observed up to 1,024 GPUs and some speedup drop beyond 1,024 due to reduced batches per GPU and underutilization. Perlmutter experiments used up to 128 nodes and 512 GPUs and also showed near-linear scaling in the tested range (Choi et al., 2022).

That same study reported end-to-end convergence gains on the AISD HOMO-LUMO dataset. Training on 192 GPUs reached comparable accuracy in approximately 0.3 hours to what required approximately 8.2 hours on 6 GPUs, while maintaining MAE around 0.14 eV across training, validation, and test sets. On PCQM4Mv2, HydraGNN achieved training MAE around 0.10 eV and validation MAE around 0.12 eV, within the published OGB-LSC leaderboard range of 0.0857–0.1760 eV (Choi et al., 2022).

The 2024 atomistic graph foundation model case study pushed scaling much further. On Perlmutter, strong scaling from 64 to 2,048 GPUs on a 2-million-graph workload was near-linear across SMALL, MEDIUM, and LARGE models. On Frontier, strong scaling from 512 to 16,384 GPUs on a 120-million-graph workload was near-linear for MEDIUM and LARGE models up to 16,384 GPUs, while the SMALL model deviated from linearity beyond about 2,048 GPUs because communication overhead and load imbalance became prominent (Pasini et al., 2024).

That study also analyzed the principal bottleneck at scale: graph-size heterogeneity. The forward-pass time scales almost linearly with the number of edges, and heterogeneous graph sizes within a batch create synchronization waits. The reported load imbalance factor was near 1.0 for data loading and backward pass but increased for forward pass, especially for EGNN, which is edge-intensive. Binning by graph size was proposed as a potential mitigation, but the work noted that this could reduce training stochasticity (Pasini et al., 2024).

The 2025 multi-task parallelism work introduced a distinct scaling strategy for many-head multi-task models. Rather than replicating all heads on every device, it distributes dataset-specific decoding heads across processes while keeping the shared encoder replicated. Without model parallelism, memory per GPU is $\{ \mathrm{sum}, \mathrm{mean}, \mathrm{max} \}$8; with multi-task parallelism, it becomes $\{ \mathrm{sum}, \mathrm{mean}, \mathrm{max} \}$9. The implementation uses a 2D torch.DeviceMesh: a global group all-reduces shared encoder gradients, and local per-head groups all-reduce only the parameters of the corresponding head. Strong scaling was tested up to 640 GPUs on Frontier and Perlmutter and up to 1,920 GPUs on Aurora, with near-ideal strong scaling up to approximately 320 GPUs for larger global batches on Frontier and Perlmutter (Pasini et al., 26 Jun 2025).

The 2026 exascale workflow extended HydraGNN across Frontier, Aurora, and Perlmutter. Strong scaling with fixed total samples was near-linear up to 2,048 GPUs on Perlmutter, 6,144 GPUs on Aurora, and 1,024 GPUs on Frontier, with the largest-scale degradation attributed to network saturation during gradient aggregation. Inference was separately optimized: encoder reuse, branch skipping, fused gradient computation, and torch.compile yielded up to $E(3)$0 single-node inference speedup, and the system screened 1.1 billion atomistic structures in 50 seconds on 9,300 Frontier nodes, corresponding to approximately $E(3)$1 structures per second overall and approximately 293 structures per second per GPU (Pasini et al., 15 Apr 2026).

HydraGNN’s energy-aware execution has also been measured explicitly. On Frontier, training three epochs on 1,024 GPUs consumed 14.0 kWh for a SMALL model with 58k parameters, 42.7 kWh for a MEDIUM model with 14.5M parameters, and 366.6 kWh for a LARGE model with 163M parameters. Mean GPU utilization increased from 12.5% to 46.0% to 88.9% across those cases, and the LARGE case reached more than 520 W peak GPU power. Early stopping during HPO, invariant or equivariant features, and DDStore’s in-memory batches were identified as energy-aware strategies (Pasini et al., 2024).

6. Scientific applications and empirical performance across domains

HydraGNN’s original scientific applications were in materials science and chemistry. In molecular property prediction, it has been used to predict the HOMO-LUMO gap on two large graph datasets: PCQM4Mv2, with approximately 3.3 million molecules and 31 element types, and the AISD HOMO-LUMO dataset, with about 10.5 million molecules and 6 element types. Those experiments established HydraGNN as a practical platform for surrogate modeling of quantum chemical properties at million-molecule scale (Choi et al., 2022).

In ferromagnetic alloys, HydraGNN was demonstrated on FePt solid solutions defined on a fixed body-centered tetragonal lattice and fixed volume, using a 2×2×4 supercell. The dataset spanned the entire compositional range from 0% Fe–100% Pt to 100% Fe–0% Pt, sampled every 3 atomic percent, and after down-selection contained 28,033 configurations. HydraGNN generalized across the full compositional range and random atomic configurations on the fixed lattice. Multi-task learning reduced error and uncertainty for the global mixing enthalpy while preserving comparable performance for atomic charge transfer and magnetic moment (Pasini et al., 2022).

The Monte Carlo surrogate study framed HydraGNN as part of a hybrid MC+DFT+ML workflow. There, HydraGNN predicts the configuration-dependent mixing enthalpy that governs acceptance and thermodynamic averaging in Monte Carlo, while periodic retraining with newly generated LSMS-3 data maintains model accuracy during phase-space exploration. The work did not specify uncertainty triggers or explicit Monte Carlo acceptance formulas, but it emphasized that periodic retraining reduces the number of expensive DFT calls while preserving predictive fidelity (Eisenbach et al., 2022).

In atomistic graph foundation modeling, HydraGNN has been trained on broad chemical corpora containing organic molecules, small-molecule equilibrium and non-equilibrium structures, oxide slabs with adsorbates and relaxations, inorganic crystalline trajectories, polymers, hybrid compounds, and alloy or catalyst data. The 2024 study used ANI1x, QM7-X, OC2020, OC2022, and MPTrj; the 2026 exascale work expanded to 16 datasets covering 85+ elements and 544,339,063 structures. These studies explicitly position HydraGNN as a pretraining platform whose shared trunk learns transferable interatomic interaction features and whose dataset-specific heads absorb fidelity-dependent offsets (Pasini et al., 2024, Pasini et al., 15 Apr 2026).

Downstream transfer results in the exascale work showed the strongest gains on potential-energy-surface-aligned tasks. Starting from the 12.1M-parameter FP64 PaiNN checkpoint and replacing the multi-task heads with lightweight task-specific MLP heads, unfrozen fine-tuning reduced QM9 atomization-energy MAE from 0.047 to 0.004 eV/atom relative to scratch training; improved MD17 uracil energy MAE from 3.421 to 1.481 kcal/mol and force MAE from 8.438 to 6.543 kcal/(mol Å); improved OQMD validation MAE from 0.596 to 0.227 eV/atom; and improved ABX3 validation MAE from 0.444 to 0.310 eV/atom. Non-PES tasks such as Matbench-jdft2d and metal/nonmetal classification showed smaller gains (Pasini et al., 15 Apr 2026).

HydraGNN has also been used as a controlled benchmarking platform for atomistic graph learning. In the unified study of global attention, encoder-augmented MPNNs emerged as a strong default for local scalar regression tasks such as ZINC, QM9, TMQM, and OGB-PCQM4Mv2, while fused local–global models yielded the clearest benefits on tasks with stronger global-context dependence such as OGB-PPA and OGB-molPCBA. The reported best PCQM4Mv2 configuration was an encoder-augmented PaiNN with 2 convolutional layers, hidden width 45, edge embedding width 9, and 71.1k parameters, achieving MSE 0.03032, MAE 0.12474, and Pearson $E(3)$2 (Chowdhury et al., 7 Oct 2025).

A distinct non-atomistic extension applied HydraGNN to heterogeneous optimal power flow surrogate modeling. Using three million heterogeneous graph instances from ten PGLib-OPF cases ranging from 14 to 13,659 buses, the framework instantiated six heterogeneous backbones: HeteroSAGE, HeteroGAT, HeteroRGAT, HeteroHGT, HeteroHEAT, and HeteroPNA. HeteroSAGE at approximately 1.6M parameters and HeteroHEAT at approximately 1.7M parameters achieved the lowest validation losses on the full ten-case corpus, and downstream fine-tuning on IEEE-118 showed that partial fine-tuning improved low-data accuracy, stability, convergence speed, and adaptation cost relative to training from scratch (Pasini et al., 22 May 2026).

7. Limitations, reproducibility, and future directions

HydraGNN’s published limitations are largely dictated by scale, data heterogeneity, and inductive-bias choices. In ferromagnetic FePt, transferability beyond the fixed body-centered tetragonal lattice and fixed volume was not evaluated, and explicit edge features such as bond angles or crystallographic encodings were not included. The authors noted that methods such as ALIGNN and iCGCNN suggest additional structural features can improve enthalpy accuracy, especially for ordered compounds (Pasini et al., 2022).

In large-batch molecular training, a slight generalization gap was observed at larger batch sizes, described as a known issue in large-batch training. Adaptive learning-rate schedules, batch-size-aware training strategies, and quasi-Newton accelerations were mentioned as plausible remedies, but were outside the scope of that study (Choi et al., 2022). In graph foundation model training, strict energy–force consistency was not enforced; forces were predicted directly as node-level targets rather than as exact gradients of a learned energy, and the papers identified this as a natural direction for future model heads or training regimes (Pasini et al., 2024).

At extreme scale, the dominant bottleneck is communication and load imbalance. The 2024 study found that weak-scaling efficiency dropped at larger sizes as communication dominated and load imbalance increased. The 2026 exascale work similarly attributed strong-scaling degradation at the largest GPU counts to network saturation during gradient aggregation, especially on Frontier, and emphasized the continuing need for co-design of sampling, weighting, and multi-task architectures for imbalanced, multi-fidelity datasets (Pasini et al., 2024, Pasini et al., 15 Apr 2026).

Precision sensitivity is another recurring limitation. In the exascale 2026 work, FP64 produced bit-exact accuracy across pipeline optimizations, FP32 introduced a constant energy deviation of $E(3)$3 eV, and BF16 introduced $E(3)$4 eV. Fine-tuning results showed BF16 to be degraded or unstable relative to FP32 and FP64, so FP64 was used for large-scale HPO and training to stabilize derivative-based force learning (Pasini et al., 15 Apr 2026).

Formal trust calibration remains underdeveloped in the published HydraGNN literature. Ensemble uncertainty was demonstrated in the 2024 graph foundation model paper, but expected calibration error, reliability diagrams, and out-of-distribution evaluations were not reported there. The 2026 exascale work focused instead on precision-performance tradeoffs and composition-conditioned routing, again without a formal uncertainty-calibration protocol (Pasini et al., 2024, Pasini et al., 15 Apr 2026).

HydraGNN’s reproducibility practices are unusually explicit for an HPC-oriented graph-learning framework. Reported software foundations include PyTorch and PyTorch Geometric; open-source releases include HydraGNN v3.0 and v4.0; and multiple papers cite public repositories, configuration-driven architecture specification, object-oriented layer templating, exact preprocessing pipelines, documented cleaning criteria, and full-application timing with GPTL or Omnistat. The ferromagnetic FePt dataset, the HydraGNN source code, and platform-specific installation scripts for Frontier, Aurora, and Perlmutter are all documented in the published record (Pasini et al., 2022, Pasini et al., 2024, Pasini et al., 15 Apr 2026, Pasini et al., 26 Jun 2025).

Taken together, the published work presents HydraGNN as a scalable research infrastructure for graph learning rather than a single fixed model. Its most stable through-line is the combination of message-passing backbones, multi-task heads, and HPC-oriented data and training systems. This suggests that HydraGNN’s long-term significance lies in making large, heterogeneous, and physically structured graph-learning experiments operational at leadership scale across molecular science, materials modeling, and, more recently, heterogeneous power-system optimization (Choi et al., 2022, Pasini et al., 22 May 2026).