Online Continual Learning on Graphs

• Online continual learning on graphs is a dynamic research area that adapts models to evolving, non-i.i.d. graph data while mitigating catastrophic forgetting.
• Techniques include replay-based memory, graph condensation, coarsening, and replay-free regularization to efficiently manage large and expanding graph structures.
• Evaluations focus on task-incremental and node-streaming metrics, ensuring immediate prediction and bounded computation in real-time graph environments.

Searching arXiv for relevant papers on online continual learning on graphs and related subareas. First, I’ll look up recent arXiv papers directly related to online/continual graph learning, replay, streaming graph learning, and graph-structure adaptation. Online continual learning on graphs studies sequential adaptation under graph-structured non-stationarity: graph data, graph topology, labels, or tasks arrive over time, historical raw data are often unavailable or bounded by memory, and the learner must update without catastrophic forgetting while remaining computationally viable on evolving neighborhoods and large graphs. In the current literature, this umbrella spans at least three closely related regimes: continual graph learning on sequences of task graphs or timestamped subgraphs, stricter node-streaming formulations in which a growing graph is updated online with bounded per-batch computation, and online graph-signal or graph-topology adaptation in which the graph or graph filter itself is learned from streaming observations (Febrinanto et al., 2022, Guo et al., 2024, Donghi et al., 5 Aug 2025, Das et al., 2023, Natali et al., 2021).

1. Conceptual scope and problem formulation

A persistent theme in graph continual learning is that graph samples are not i.i.d. objects. In node-level settings, later graph data can be correlated with earlier graph data through topology, including inter-task edges, so the disappearance of old graph context can directly distort the distribution of new tasks (Guo et al., 2024). More generally, graph lifelong learning has been framed as learning over an evolving graph sequence

$$G=(G_1,G_2,\dots,G_t), \qquad G_t = G_{t-1} + \Delta G_t,$$

together with a sequential task stream

$T=(T_1,T_2,\dots,T_t),$

while preserving performance on prior tasks (Febrinanto et al., 2022).

The literature does not use a single protocol. Many influential methods are task-sequential rather than fully instance-online. E-CGL studies continual node classification on an evolving graph split into timestamped subgraphs/tasks $G_1,\dots,G_T$, with replay from a bounded memory bank and sequential class or task expansion (Guo et al., 2024). RAM-CG also assumes a task-incremental setting in which time step is visible during both training and testing, and only current graph data are available at each step (Shen et al., 2023). G$^2$LoRA is explicitly framed as sequential/task-stream continual learning with explicit task sessions rather than fully instance-online learning (Wang et al., 1 Jun 2026). CaT, PUMA, PromptCGL, and TA$\mathbb{CO}$ likewise process incoming graph tasks or temporal subgraphs one period at a time rather than event by event (Liu et al., 2023, Liu et al., 2023, Wang et al., 10 Feb 2025, Han et al., 2024).

By contrast, “Online Continual Graph Learning” formalizes a stricter node-streaming regime in which the graph at time $t$ is

$$\mathcal{G}^t=(\mathcal{V}^t,E^t,X^t), \qquad \mathcal{V}^t=\{v_i\}_{i\le t},$$

and each arriving unit is a node tuple

$(v_t,\mathcal{N}(v_t),x_t),$

with anytime prediction and bounded per-batch compute central to the definition (Donghi et al., 5 Aug 2025). This stricter formulation was motivated by the observation that much prior “streaming” graph CL still processes large subgraphs or snapshots offline with multiple passes (Donghi et al., 5 Aug 2025).

A second boundary of the field concerns what is being learned. Most graph continual learning papers target downstream prediction, usually node classification (Guo et al., 2024, Liu et al., 2023, Liu et al., 2023, Han et al., 2024). A different line targets online graph filters or graph topology itself: online FIR filter adaptation on expanding graphs (Das et al., 2023), online graph topology estimation under dynamic environments (Zhang, 2021), and a model-independent framework for learning time-varying graph structure from online data (Natali et al., 2021). This suggests that “online continual learning on graphs” includes both continual prediction on graphs and continual adaptation of graph operators.

2. Learning regimes, task structure, and evaluation

The survey literature organizes graph lifelong learning through the continual-learning scenarios of new instances (NI), new classes (NC), and new instances and classes (NIC), with NI and NIC described as often more realistic for graph domains (Febrinanto et al., 2022). More recent graph papers use the now-standard continual-learning taxonomies more explicitly. E-CGL benchmarks both task-incremental learning and class-incremental learning with disjoint label sets across tasks (Guo et al., 2024). G$^2$LoRA supports class-incremental, domain-incremental, and task-incremental modes for text-attributed graphs, unifying node-, link-, and graph-level tasks under a graph–text alignment objective (Wang et al., 1 Jun 2026). UGCL broadens the scope further to node-unit node classification, graph-unit graph classification, and graph-unit node classification, all under class-incremental evaluation without task identity at inference (Hoang et al., 2023).

Temporal formulations need not coincide with class partitioning. TA$\mathbb{CO}$ defines tasks by time periods in an expanding temporal graph, with edges assigned to period $T=(T_1,T_2,\dots,T_t),$0 according to the source-node timestamp and with overlap between old and new periods through shared nodes and cross-time edges (Han et al., 2024). ContinualGNN is even closer to task-free continual adaptation: it treats each graph update $T=(T_1,T_2,\dots,T_t),$1 as the current signal, detects nodes whose representations change significantly, and trains only on newly influenced nodes plus memory nodes (Wang et al., 2020).

Evaluation is highly standardized around a lower-triangular performance matrix. E-CGL uses $T=(T_1,T_2,\dots,T_t),$2, where $T=(T_1,T_2,\dots,T_t),$3 is accuracy on task $T=(T_1,T_2,\dots,T_t),$4 after training through task $T=(T_1,T_2,\dots,T_t),$5, and derives average accuracy and average forgetting from it (Guo et al., 2024). OCGL defines

$T=(T_1,T_2,\dots,T_t),$6

and adds

$T=(T_1,T_2,\dots,T_t),$7

to measure anytime performance over the stream (Donghi et al., 5 Aug 2025). Other papers use closely related metrics such as ACC/BWF (Shen et al., 2023), AP/BWT (Liu et al., 2023, Liu et al., 2023), or task-wise rNMSE for online interpolation on expanding graphs (Das et al., 2023).

A recurring protocol detail is that many graph benchmarks are transductive. CaT and PUMA explicitly assume the whole graph structure is observable for the current task, including test nodes, though only training nodes contribute supervision (Liu et al., 2023, Liu et al., 2023). OCGL also uses a transductive setup in which validation and test nodes are available for message passing but excluded from the training loss (Donghi et al., 5 Aug 2025). This is important because, on graphs, unlabeled nodes still alter receptive fields and therefore the continual-learning dynamics.

3. Replay, condensation, coarsening, and structure-preserving memory

The survey taxonomy places rehearsal among the primary families of graph lifelong learning methods, alongside architectural, regularization, and hybrid approaches (Febrinanto et al., 2022). In graph settings, however, replay is rarely just sample rehearsal: the stored object may be nodes with neighborhoods, sparsified computational subgraphs, condensed synthetic graphs, or a bounded reduced graph that preserves topology.

Family	Representative methods	Memory object
Node/subgraph replay	ER-GNN, SSM, E-CGL	replay nodes, labels, or sparsified subgraphs (Febrinanto et al., 2022, Guo et al., 2024)
Condensation-based replay	CaT, PUMA	condensed synthetic graphs or edge-free synthetic memories (Liu et al., 2023, Liu et al., 2023)
Coarsened graph memory	TA$T=(T_1,T_2,\dots,T_t),$8	bounded reduced graph with node-to-supernode mapping (Han et al., 2024)
Replay with structural distillation	UGCL	graph-associated items plus local/global structure consistency losses (Hoang et al., 2023)

E-CGL exemplifies graph-aware node replay. It stores replay nodes and labels rather than full old subgraphs, but selects replay nodes using a combined importance and diversity score rather than random sampling (Guo et al., 2024). Importance starts from PageRank and is augmented with attribute-aware transitions under a homophily assumption via an AttriRank-style approximation, while diversity is defined as the distance between a node feature and the average feature of its 1-hop neighbors (Guo et al., 2024). Under a fixed memory budget, replay nodes are drawn from both selectors, with the best setting using 75% importance-sampled nodes and 25% diversity-sampled nodes (Guo et al., 2024).

CaT and PUMA turn replay into graph condensation. CaT first condenses each incoming graph into a small synthesized replay graph and then updates the model using only the Condensed Graph Memory rather than the whole incoming graph plus memory, a scheme called Training in Memory (Liu et al., 2023). PUMA extends this idea in three ways stated explicitly in the paper: it incorporates pseudo-labeled unlabeled nodes during condensation, retrains from scratch on the evolving memory bank to rebalance optimization, and accelerates both condensation and replay via one-time propagation, wide random encoders, and MLP-based replay training on edge-free memories (Liu et al., 2023). The result is a replay memory that stores only synthetic node features and labels, not explicit edges, while still approximating the original graph distribution in an embedding space (Liu et al., 2023).

TA$T=(T_1,T_2,\dots,T_t),$9 pursues a different memory design. Instead of storing sampled nodes or synthetic edge-free graphs, it maintains a bounded reduced graph $G_1,\dots,G_T$0 plus a node-to-supernode mapping $G_1,\dots,G_T$1, expands that reduced graph by combining it with the new temporal subgraph, and then coarsens the combined graph again to maintain stable size (Han et al., 2024). Its RePro coarsening algorithm merges connected node pairs according to cosine similarity of first-layer GNN representations, while Node Fidelity Preservation penalizes merges involving replay-buffer nodes to alleviate minority-class erosion under majority-vote coarsening (Han et al., 2024). The paper proves that the reduced-graph node count is upper-bounded by $G_1,\dots,G_T$2, where $G_1,\dots,G_T$3 is the maximum number of new nodes in any task (Han et al., 2024).

UGCL shows that replay need not only preserve labels. Its memory stores graph-associated items so that rehearsal can be combined with Local Structure Distillation, which aligns node-vs-neighbor relational geometry, and Global Structure Distillation, which aligns graph-level embeddings between the current model and the previous-task model (Hoang et al., 2023). This line of work treats local and global structure consistency as first-class replay targets rather than incidental side effects.

Empirically, replay-based graph-specific methods are repeatedly reported as stronger than generic regularization baselines in class-incremental graph learning. E-CGL states that replay-based graph-specific methods clearly outperform classical parameter-regularization methods in graph CL, especially in class-IL (Guo et al., 2024). UGCL reports that rehearsal is much more effective than parameter regularization in its graph-unit node-classification experiments (Hoang et al., 2023). CaT and PUMA further argue that replay quality and replay balance are distinct problems: better memory objects are insufficient if a large current graph still overwhelms a tiny historical memory during optimization (Liu et al., 2023, Liu et al., 2023).

4. Replay-free regularization, prompting, and parameter-efficient adaptation

Replay is not the only design axis. A major body of work seeks replay-free continual graph learning through regularization, masking, prompting, or parameter-efficient adaptation. The survey already identified topology-aware regularization as a graph-specific departure from vanilla EWC-style penalties, with TWP preserving important aggregation parameters rather than only generic weights (Febrinanto et al., 2022).

Recent replay-free work has pushed this substantially further. “Unbiased Online Curvature Approximation for Regularized Graph Continual Learning” formulates a general regularization framework in the curved parameter space induced by the Fisher Information Matrix and shows that EWC and its variants are special cases based on diagonal empirical FIM approximations at previous-task parameters (Yin et al., 16 Sep 2025). Its main contribution is an unbiased online approximation of the full current-state FIM regularizer, computed implicitly through sampled predictive-label gradients without explicitly forming or storing the FIM itself (Yin et al., 16 Sep 2025). In the paper’s replay-free class-incremental node-classification setting, this markedly improves forgetting relative to EWC-style baselines.

RAM-CG offers a different replay-free answer: preserve invariant latent relations while isolating task-specific decision structure (Shen et al., 2023). The method learns relation-aware message passing channels intended to capture latent relations behind edges, freezes the relation-discovery module after the first task, and uses a task-awareness masking classifier that updates only previously unused or task-selected parameters (Shen et al., 2023). This places the method between full parameter sharing and full architecture expansion, but it requires task identity at inference and is explicitly task-incremental (Shen et al., 2023).

PromptCGL replaces replay with prompt tuning. After pretraining a base GNN on an initial task, the backbone is frozen and later tasks learn only node-level and subgraph-level prompts plus a prediction layer (Wang et al., 10 Feb 2025). Personalized prompts are generated for each node by a prompt generator that softly combines a small maintained prompt set, so storage scales as $G_1,\dots,G_T$4 rather than the replay-style $G_1,\dots,G_T$5 reported in the paper (Wang et al., 10 Feb 2025). The framework assumes known task boundaries and retrieves the corresponding prompt bank entry at inference, so it is task-aware rather than task-agnostic (Wang et al., 10 Feb 2025).

G$G_1,\dots,G_T$6LoRA carries the same replay-free spirit into text-attributed graphs. It freezes a dual graph–text encoder and trains only lightweight adapters, but adds category-aware gradient projection, conditional backward transfer, and gradient magnitude modulation to balance update speeds between graph and text encoders (Wang et al., 1 Jun 2026). Its setting is sequential and task-bounded rather than fully online, yet it is notable for unifying node-, link-, and graph-level tasks under a shared graph–text alignment loss and supporting class-, domain-, and task-incremental modes in one framework (Wang et al., 1 Jun 2026).

A practical misconception addressed by these papers is that replay-free necessarily means memory-free. PromptCGL stores task-specific prompts (Wang et al., 10 Feb 2025). G$G_1,\dots,G_T$7LoRA stores historical subspaces, prototypes, and adapter structure (Wang et al., 1 Jun 2026). Curvature-based replay-free regularization stores historical parameter snapshots and gradient queues rather than raw data (Yin et al., 16 Sep 2025). Replay-free graph CL therefore removes raw-data rehearsal, not auxiliary state.

5. Strictly online adaptation: node streams, expanding graphs, filters, and graph topology

The stricter online regime emphasizes single-pass or low-pass updates, bounded per-batch computation, and predictions that are valid immediately after each batch. “Online Continual Graph Learning” crystallizes this regime and argues that graph OCL differs from standard OCL because message passing ties each sample to an $G_1,\dots,G_T$8-hop neighborhood whose size scales roughly as $G_1,\dots,G_T$9 and can grow over time through densification (Donghi et al., 5 Aug 2025). Its proposed systems-level remedy is neighborhood sampling: instead of feeding the full ego-graph $^2$0, the learner receives a subsampled version $^2$1 so that per-batch memory and compute remain bounded (Donghi et al., 5 Aug 2025).

ContinualGNN is an earlier snapshot-based precursor to this online perspective. It decomposes each update into learning new patterns on nodes whose $^2$2-layer representations change significantly,

$^2$3

plus consolidation of existing patterns through replay and Fisher-weighted regularization estimated from memory (Wang et al., 2020). This is not class-incremental learning; it is task-free continual node classification on evolving attributed graphs, where new nodes, changed edges, and changed node attributes alter neighborhood patterns over time (Wang et al., 2020).

A narrower but theoretically clean online formulation appears in “Online Filtering over Expanding Graphs”. There the graph grows by node arrivals only, with adjacency

$^2$4

and the learner performs online gradient descent on FIR graph-filter coefficients to interpolate the incoming node’s signal (Das et al., 2023). The paper proves a static regret bound

$^2$5

so average regret vanishes with appropriate step-size scaling (Das et al., 2023). This does not address catastrophic forgetting in the CL sense, but it is a canonical example of online graph adaptation under strict sequential arrivals.

A related line studies online graph topology learning rather than downstream prediction. “Online Graph Learning in Dynamic Environments” updates an edge-weight vector $^2$6 for a weighted undirected graph by projected online gradient steps plus a dynamic prior $^2$7, obtaining sublinear dynamic regret relative to the best time-varying graph sequence in hindsight (Zhang, 2021). “Learning Time-Varying Graphs from Online Data” generalizes this idea into a model-independent prediction-correction framework in which the evolving sufficient statistic is the recursively updated covariance

$^2$8

and the learned graph parameter may be a precision matrix, SEM coefficient matrix, or smoothness-based adjacency, depending on the model specialization (Natali et al., 2021). These papers show that online graph learning can be formulated as continual tracking of graph structure itself, not only continual training of predictors defined on a fixed graph.

The efficiency problem remains central even in task-sequential graph CL. E-CGL argues that repeated GNN message passing is too expensive for large evolving graphs and trains an MLP whose weights are transferred into a GCN only at inference, obtaining reported average speedups of $^2$9 in training and $\mathbb{CO}$0 in inference across four datasets (Guo et al., 2024). This is not strict online learning, but it addresses the same systems bottleneck highlighted by OCGL: message passing becomes the dominant cost when graph neighborhoods grow.

6. Empirical regularities, misconceptions, and open problems

Several empirical regularities recur across the literature. First, graph-specific replay or memory mechanisms are usually stronger than generic regularization in difficult class-incremental settings (Guo et al., 2024, Hoang et al., 2023). Second, preserving topology or structural geometry is repeatedly beneficial: UGCL’s local/global structure distillation, TA$\mathbb{CO}$1’s reduced-graph memory, and graph-aware replay buffers such as SSM or PDGNN in OCGL all outperform baselines that treat old samples as isolated feature-label pairs (Hoang et al., 2023, Han et al., 2024, Donghi et al., 5 Aug 2025). Third, efficiency innovations matter as much as anti-forgetting innovations; E-CGL’s MLP-training scheme, CaT/PUMA’s condensed memories, and OCGL’s sampled neighborhoods all target the cost of message passing on expanding graphs (Guo et al., 2024, Liu et al., 2023, Liu et al., 2023, Donghi et al., 5 Aug 2025).

A common misconception is that all “streaming” graph continual learning is online in the strict OCL sense. Multiple papers explicitly reject that interpretation. E-CGL is task-by-task with delayed replay and 200 epochs per task, not one-shot online learning (Guo et al., 2024). G$\mathbb{CO}$2LoRA is sequential and replay-free but uses task sessions, AdamW, and early stopping rather than single-pass updates (Wang et al., 1 Jun 2026). RAM-CG, CaT, PUMA, PromptCGL, and TA$\mathbb{CO}$3 all assume explicit task or time-period boundaries and process each period as a batch (Shen et al., 2023, Liu et al., 2023, Liu et al., 2023, Wang et al., 10 Feb 2025, Han et al., 2024). This distinction matters because the requirements of bounded latency, anytime prediction, and one-pass data processing are much stricter than those of ordinary task-sequential continual learning (Donghi et al., 5 Aug 2025).

Open problems are correspondingly layered. OCGL calls for stronger streaming evaluation protocols, better bounded-cost handling of neighborhood expansion, more effective memory designs for topology-aware replay, and methods that remain robust on heterophilous graphs, where its Roman Empire benchmark remains difficult (Donghi et al., 5 Aug 2025). E-CGL identifies stricter online settings with single-pass updates, privacy-preserving replay, richer dynamic topology evolution, heterogeneous graphs, graph-level tasks, and mechanisms for actively forgetting stale knowledge as open directions (Guo et al., 2024). PUMA points to inductive or dynamic-graph settings with inter-task edges, uncertainty-aware pseudo-labeling, adaptive memory budgeting, and richer condensed memory representations (Liu et al., 2023). The survey emphasizes uncertain neighborhoods, extreme evolution, global dependency learning, class imbalance, and the lack of standardized graph continual-learning benchmarks (Febrinanto et al., 2022).

Taken together, the literature defines online continual learning on graphs less as a single benchmark than as a design space with competing constraints: retention vs plasticity, topology preservation vs memory budget, expressive message passing vs bounded online computation, and task-aware sequential adaptation vs truly task-free streaming. Current methods are strongest when the stream can be segmented into tasks or periods and when some form of structured memory—raw, synthetic, reduced, or parametric—is allowed. Strict node-streaming continual learning with dynamic topology, bounded compute, no raw replay, and task-agnostic inference remains substantially open (Donghi et al., 5 Aug 2025).