Dynamic Graphs and Large Language Models: A Survey of Mutual Enhancement

1. Introduction

Graphs provide a fundamental abstraction for modeling relational data, where entities are represented as nodes and their interactions as edges [1,2,3,4]. They have been widely used to represent and analyze relational systems across domains such as social networks [5], recommender systems [6,7], knowledge graphs [8], and financial transaction networks [8,9]. Many real-world relational systems are inherently dynamic rather than static, as entities and their interactions evolve over time. Dynamic Graphs (DyGs) therefore extend traditional graph representations by incorporating an explicit temporal dimension, enabling the modeling of evolving relational systems such as temporal interactions in social networks [10], recommender systems [11], temporal knowledge graphs [12], and financial transaction networks [13]. Formally, a dynamic graph model operates on a time-indexed sequence of graph states or interaction events, mapping historical structural and temporal information to predictions about future graph properties, such as node representations [10,11], link formation [14,15], or event occurrence probabilities [14]. A canonical application is temporal link prediction, where the objective is to forecast whether a new edge will appear between two nodes at a future time step given past interaction history [10,15]. While early approaches relied on probabilistic temporal point processes or sequence-based factorization techniques [14,16], the dominant modern paradigm for representation learning on dynamic graphs is dynamic graph neural networks (DGNNs) [10,13]. DGNNs extend graph neural networks by incorporating temporal encoding mechanisms, such as recurrent updates, memory modules, or time-aware message passing, to process either discrete graph snapshots or continuous time event streams [10,13,14]. At a high level, a DGNN iteratively updates node embeddings by integrating structural neighborhood information with temporal dynamics, and then applies task-specific decoders to downstream objectives, such as an MLP that maps the final hidden embedding to a probability distribution over link labels for temporal link prediction.

Despite their success, existing dynamic graph models face several persistent limitations. (i) Simple embedding layer is not enough. Node and edge attributes are often sparse, missing, or represented only by simple identifiers, which makes it difficult for DGNNs to capture the semantic meaning of interactions [11,17]. Large language models (LLMs), pretrained on large-scale corpora, provide a natural remedy by generating richer contextual representations for nodes and edges through background knowledge, entity relations, and implicit semantics [18,19]. (ii) Over-smoothing in long interaction histories. DGNNs rely on repeated temporal message passing, which can compress node representations over long interaction histories and lead to over-smoothing, making it harder to preserve long-range dependencies [10,14,20,21]. In contrast, LLMs offer strong long-context modeling and reasoning abilities without recursive aggregation [18,22]. (iii) Limited robustness under distribution shift. DGNNs are often tightly coupled to historical interaction patterns and may generalize poorly when those patterns shift over time [12,13,23]. LLMs, however, exhibit strong zero-shot and cross-domain generalization due to their diverse pretraining [18,24]. Taken together, these complementary strengths make it natural to integrate LLMs into dynamic graph learning in different ways, including enriching semantic representations, supporting temporal reasoning over graph evolution, and generating plausible dynamic scenarios under incomplete or changing conditions.

From the reverse perspective, LLM-based systems also exhibit notable limitations. For temporal question answering, LLMs often struggle with temporal reasoning because they lack sufficient temporal history and tend to over-reliance on more recent information. In addition, although many LLM-based agents are equipped with memory, such memory is often stored in a flat and unstructured form without explicit connections among memory items, leading to inefficient retrieval and suboptimal agent performance. To address these limitations, two main directions have emerged for using dynamic graphs to assist LLMs. First, dynamic temporal knowledge graphs support time-aware retrieval and reasoning by explicitly encoding time-stamped facts and enabling retrieval of subgraphs relevant to a target time period, thereby providing temporally valid evidence for LLM reasoning [18,25,26,27]. Second, dynamic memory graphs support long-term memory in self-evolving agents by organizing entities, events, preferences, actions, and outcomes as nodes connected through time-aware relations, which enables incremental updates, selective retrieval, and more consistent personalization, temporal coherence, and experience reuse across interactions [28,29,30,31]. In this way, dynamic graphs serve as structured and time-aware external states that complement the limitations of LLMs in both temporal reasoning and long-term memory.

Motivated by the growing recognition that LLMs and dynamic graphs can support each other in multiple ways, recent work has rapidly expanded along both lines of interaction. However, the field still lacks a systematic survey that unifies these emerging approaches under a lens of DG-LLM mutual enhancement, clarifying both how LLMs enhance dynamic graph learning and how dynamic graphs, in turn, support temporally grounded LLM reasoning. To fill this gap, this survey provides a structured and comprehensive review of research at the intersection of LLMs and dynamic graphs. In particular, we organize the literature into two broad directions: LLMs for Dynamic Graphs and Dynamic Graphs for LLMs. Within LLMs for Dynamic Graphs, we further classify existing work according to how LLMs are integrated into systems over temporally evolving graph structures. We identify three recurring roles. First, LLMs as time-aware semantic augmenters, where LLMs enrich node or edge representations with semantic, textual, or multimodal context while the dynamic graph model remains the main predictor, helping address sparse attributes, semantic drift, and evolving interaction semantics [32,33]. Second, LLMs as temporal reasoning engines, where LLMs directly reason over graph evolution to support forecasting, rule adaptation, and explanation of temporal relational patterns beyond standard DGNN mechanisms [34,35,36]. Third, LLMs as dynamic scenario simulators, where they generate temporally consistent event streams or future graph trajectories for simulation or data augmentation under incomplete or noisy observations [37,38]. Within Dynamic Graphs for LLMs, we organize existing research around how dynamic graph structures can serve as external temporal knowledge graphs and internal dynamic memory graph. First, external dynamic temporal knowledge graphs provide an explicit representation of time-stamped facts and evolving relations, enabling LLMs to perform temporally consistent retrieval and reasoning. Second, internal dynamic memory graphs serve as structured and continuously updated memory organizations for LLM-based agents operating over extended horizons.

• Differences from Existing Surveys. Several recent surveys have examined the intersection of LLMs and graph learning [33,39,40], as well as broader graph-assisted LLM paradigms [41]. However, their scope and organizing principles differ substantially from ours. Table 1 provides a structured comparison. Ren et al. [33] offers an early overview of graph–LLM integration and categorizes methods according to broad capabilities such as representation learning, reasoning, and generation. While it discusses interactions between graphs and LLMs, dynamic graphs are not treated as a primary focus, and temporal modeling regimes are not systematically analyzed. Chen et al. [39] concentrates on architectural mechanisms that connect graph neural networks and LLMs, including prompt design, embedding alignment, and hybrid model construction. Its emphasis lies in static or heterogeneous graph settings, and temporal evolution is only briefly mentioned without distinguishing discrete-time and continuous-time dynamic formulations. Li et al. [40] discusses dynamic instability in graph learning more broadly and includes temporal graphs as one of several problem scenarios. However, dynamic graphs are treated as a subtopic within general graph challenges, rather than as a central organizing dimension, and the survey does not provide a dedicated taxonomy for LLM–dynamic graph interaction. More broadly, Luo et al. [41] study graph-assisted LLM systems and focus on how graph structures enhance LLM capabilities such as knowledge augmentation, reasoning, and multi-agent collaboration. In this survey, dynamic graphs are mentioned only as one possible representation (e.g., evolving memory graphs or planning graphs), rather than being treated as a primary modeling object. As a result, temporal dynamics and the unique challenges of dynamic graph learning are not explicitly analyzed.
• Paper Structure Together, this bidirectional complementarity establishes the foundation for the two major research directions surveyed in this work: LLMs for Dynamic Graphs and Dynamic Graphs for LLMs. To organize the rapidly growing literature at this intersection, we propose a taxonomy that categorizes existing methods according to how the two paradigms interact. The overall structure of this taxonomy is illustrated in Figure 1. Under the direction of LLMs for Dynamic Graphs (Section 4), we identify three primary roles that LLMs play in dynamic graph learning pipelines. First, LLMs as time-aware semantic augmenters (Section 4.1) enrich node or edge representations with contextual semantic information derived from text or external knowledge sources. Second, LLMs as temporal reasoning engines over graph evolution (Section 4.2) perform higher-level reasoning about how relational patterns evolve over time. Third, LLMs as dynamic scenario simulators (Section 4.3) generate temporally consistent interaction events or graph trajectories to support simulation and data augmentation. Complementary to this direction, the second part of the survey studies Dynamic Graphs for LLMs (Section 5). In this setting, Dynamic Temporal Knowledge Graph for LLM Temporal Reasoning (Section 5.1) supports LLM reasoning over evolving relational information, while also Dynamic Memory Graph for Self-evolving LLM-based Agents (Section 5.2) functioning as external knowledge and memory infrastructures that compensate for the lack of a persistent structured state in LLM-based systems.

We hope this survey will serve as a foundation for unifying temporal graph learning with language-driven reasoning and will encourage further research at the intersection of evolving structure, semantics, and learning over time. Our contributions are threefold:

• We provide the first systematic review of how graph dynamics fundamentally reshape LLM–graph integration, highlighting challenges that arise uniquely in temporally evolving settings, such as semantic drift, time-sensitive reasoning, and long-horizon relational evolution.
• We introduce a structured taxonomy for LLMs for Dynamic Graphs by organizing existing methods according to the functional roles played by LLMs in dynamic graph systems, namely (i) time-aware semantic augmenters that enrich node and edge representations with contextual information, (ii) temporal reasoning engines over graph evolution that directly perform forecasting and reasoning over dynamic interactions, and (iii) dynamic scenario simulators that generate temporal events or graph trajectories for data augmentation and simulation. We also develop an organizing framework for Dynamic Graphs for LLMs by reviewing how temporally evolving graph structures serve as (i) Dynamic Temporal Knowledge Graph for LLM Temporal Reasoning and (ii) Dynamic Memory Graph for Self-evolving LLM-based Agents, acting as external knowledge backbones that compensate for LLM limitations in time-sensitive reasoning and long-horizon state tracking.
• We review representative benchmarks, applications, and open challenges in LLM-assisted dynamic graph modeling and dynamic graph assisted LLMs, outlining future directions toward more temporally consistent, semantically grounded, and generalizable LLM–dynamic graph systems.

Table 1. Comparison of recent surveys related to graphs and large language models. To avoid conflating static-graph and dynamic-graph settings, we distinguish four directions explicitly: LLMs for static graphs, static graphs for LLMs, LLMs for dynamic graphs, and dynamic graphs for LLMs. Here, ∘ denotes limited mention, ⊙ denotes partial focus, and • denotes primary focus. Our survey is the first to place both LLMs for DGs and DGs for LLMs at the center under a unified bidirectional taxonomy.

Survey	LLMs for Static Graphs	Static Graphs for LLMs	LLMs for DGs	DGs for LLMs	Taxonomy
Ren et al. [33]	•	⊙	∘	∘	Capability-based
Chen et al. [39]	•	⊙	∘	∘	Architecture-based
Li et al. [40]	•	⊙	⊙	∘	Problem-centric
Luo et al. [41]	⊙	•	∘	∘	Graph-assisted LLM capabilities
Ours	∘	∘	•	•	Mutual Enhancement

Table 1. Comparison of recent surveys related to graphs and large language models. To avoid conflating static-graph and dynamic-graph settings, we distinguish four directions explicitly: LLMs for static graphs, static graphs for LLMs, LLMs for dynamic graphs, and dynamic graphs for LLMs. Here, ∘ denotes limited mention, ⊙ denotes partial focus, and • denotes primary focus. Our survey is the first to place both LLMs for DGs and DGs for LLMs at the center under a unified bidirectional taxonomy.

Survey	LLMs for Static Graphs	Static Graphs for LLMs	LLMs for DGs	DGs for LLMs	Taxonomy
Ren et al. [33]	•	⊙	∘	∘	Capability-based
Chen et al. [39]	•	⊙	∘	∘	Architecture-based
Li et al. [40]	•	⊙	⊙	∘	Problem-centric
Luo et al. [41]	⊙	•	∘	∘	Graph-assisted LLM capabilities
Ours	∘	∘	•	•	Mutual Enhancement

2. Background and Preliminaries

This section reviews foundational concepts in dynamic graph modeling and modern LLM-based reasoning, and highlights the limitations and complementary strengths that motivate their integration.

2.1. Dynamic Graphs

In this subsection, we introduce the basic concepts, modeling paradigms, and representative learning frameworks for dynamic graphs, with a focus on temporal evolution and commonly studied prediction tasks.

• Definition of Dynamic Graphs. Generally, a dynamic graph models relational structure that evolves over time [10,12]. A concise unified view is to represent it as a time-indexed relational object $\mathcal{G}\left(t\right)=\left(V\right(t),E(t),X(t\left)\right)$, where $V\left(t\right)$, $E\left(t\right)$ and $X\left(t\right)$ denote the node set, edge set, and their associated features at time t, respectively. In the discrete-time dynamic graph (DTDG) setting, this evolution is observed as a sequence of snapshots $(\mathcal{G}={\left\{G_t\right\}}_{t=1}^T,G_t=(V_t,E_t,X_t))$ (1) at indexed time steps [10,13]. In the continuous-time dynamic graph (CTDG) setting, it is observed as a stream of timestamped events:

  $$\mathcal{E}={\left\{(u_i,v_i,x_i,t_i)\right\}}_{i=1}^N,$$

  (2)

  which updates the graph whenever a new interaction occurs [10,14]. Thus, the main distinction is whether temporal evolution is modeled through discrete snapshots or continuous event arrivals, while in both cases the goal is to capture how relational structure and attributes change over time.
• Dynamic Graph Learning and DGNN Backbone. Graph learning has traditionally focused on static graphs, where nodes, edges, and features are assumed to remain fixed, enabling graph neural networks to achieve strong performance on tasks such as node classification, link prediction, and recommendation [6,7,20,76,77,78]. However, many real-world systems are inherently dynamic: interactions in social networks evolve, user preferences in recommender systems shift, and facts in temporal knowledge graphs appear or change over time [10,11,12]. These settings motivate dynamic graph learning, where the goal is to model not only relational structure but also how it changes over time. While early approaches used temporal point processes or sequence-based factorization techniques [14,16], the dominant modern paradigm is dynamic graph neural networks (DGNNs) [10,13,14], which learn time-dependent node representations through message passing and temporal updates.In continuous-time settings, each node u has a representation $h_u\left(t\right)\in {\mathbb{R}}^d$, and an event $(u_i,v_i,x_i,t_i)$ produces a message $m_{u_i\leftarrow v_i}\left(t_i\right)=m_{\theta }\left(h_{u_i}\left(t_i^{-}\right),h_{v_i}\left(t_i^{-}\right),x_i,\Delta t_i\right)$, where $\Delta t_i=t_i-t_{i-1}$. Node representations are then updated through a shared temporal operator:

  $$h_u\left(t_i\right)={\varphi }_{\theta }\left(h_u\left(t_i^{-}\right),m_u\left(t_i\right)\right),$$

  (3)

  where ${\varphi }_{\theta }$ may be implemented with GRU, LSTM, or attention-based temporal aggregation [10,76,79,80].This update is recurrent over time rather than increasing network depth, so the same parameters are reused across events while node representations are progressively refined with structural and temporal information.
• Dynamic Graph Tasks. Dynamic graphs support a wide range of learning tasks, including node classification, link prediction, time prediction, anomaly detection, and recommendation [10,12,13]. In this survey, we focus on the most fundamental and widely studied tasks, namely temporal link prediction, dynamic node classification, and temporal event time prediction, which form the basis for many downstream applications [14,15]. For clarity and consistency, we describe these core tasks under the continuous-time formulation in Eq. 2, where the observed data consist of timestamped events $\mathcal{E}={\left\{(u_i,v_i,x_i,t_i)\right\}}_{i=1}^N$. In the discrete-time setting (Eq. 1), the same tasks can be defined over graph snapshots ${\left\{G_t\right\}}_{t=1}^T$, where predictions at time t depend on historical snapshots $\{G_1,\dots ,G_{t-1}\}$. We build on the shared DGNN backbone described in Eq. 3 and focus on task-specific prediction objectives.

Definition 2.1

(Temporal Link Prediction). Given past history ${\mathcal{E}}_{<t}$, The goal is to estimate the probability that a future interaction occurs between nodes u and v at time t, i.e., $p_{\theta }\left((u,v,t)\mid {\mathcal{E}}_{<t}\right),$ where θ denotes model parameters and $p_{\theta }\in [0,1]$. Nodes may represent users and items, subjects and objects in temporal knowledge graphs, or accounts in transaction networks, while edges correspond to time-stamped interactions such as purchases, factual relations, or financial transfers.

Following the shared DGNN backbone in Eq. 3, node representations $h_u\left(t\right)$ evolve through event-driven updates that encode structural and temporal history. The interaction probability is typically modeled as $p_{\theta }((u,v,t)\mid {\mathcal{E}}_{<t})=\sigma \left(f_{\theta }(h_u\left(t^{-}\right),h_v\left(t^{-}\right))\right),$ where $f_{\theta }$ is usually a bilinear function [81] or an MLP, and $\sigma$ is a sigmoid function. Training commonly uses binary cross-entropy with negative sampling [82], $\mathcal{L}=-{\sum }_{(u,v,t)\in \mathcal{E}}log\sigma \left(s_{\theta }(u,v,t)\right)-{\sum }_{(u^{\prime },v^{\prime },t)\notin \mathcal{E}}log\left(1-\sigma \left(s_{\theta }(u^{\prime },v^{\prime },t)\right)\right).$ In continuous-time DGNNs, irregular time gaps are often incorporated through time encoding or decay mechanisms [10]. In terms of limitations, DGNN-based temporal link prediction compresses long interaction histories into fixed-dimensional node representations, which may weaken long-range dependency modeling under long or irregular event streams. In addition, shallow link scoring functions often struggle to capture higher-level semantic intent or contextual factors, and purely structural message passing may be brittle under sparse or noisy interactions.

Definition 2.2

(Temporal Event Time Prediction). Continuous-time temporal event prediction aims to estimate when the next interaction event between a pair of entities $(u,v)$ will occur, given past history ${\mathcal{E}}_{<t}$. Here, an interaction event is a timestamped edge $(u,v,t)$, such as a purchase, a factual relation, or a financial transaction. Unlike temporal link prediction, which models whether an event occurs at a given time, this task models the distribution over event times for a given pair $(u,v)$. Formally, the goal is to model ${\lambda }_{\theta }(t_{\mathrm{next}}\mid u,v,{\mathcal{E}}_{<t}),\mathrm{s}.\mathrm{t}.t_{\mathrm{next}}>t,$ where ${\lambda }_{\theta }$ is a conditional intensity function. Typical applications include predicting the next purchase time, forecasting communication events, or estimating when a new relation will appear in a temporal knowledge graph.

Following the shared DGNN backbone in Eq. 3, temporal event time prediction is typically modeled through a conditional intensity ${\lambda }_{\theta }(u,v,t)=\varphi \left(f_{\theta }(h_u\left(t^{-}\right),h_v\left(t^{-}\right))\right),$ where $f_{\theta }$ is usually a bilinear function or an MLP, and $\varphi (·)$ ensures non-negativity. Under a temporal point process formulation, the log-likelihood over horizon $[0,T]$ is $log\mathcal{L}\left(\theta \right)={\sum }_{i=1}^{N}log{\lambda }_{\theta }(u_i,v_i,t_i)-{\int }_0^T{\sum }_{(u,v)}{\lambda }_{\theta }(u,v,\tau )d\tau .$ The first term rewards high intensity at observed event times, while the second penalizes excessive predicted intensity across time. In practice, training minimizes the negative log-likelihood and proceeds similarly to temporal link prediction through backpropagation over the recursive updates in Eq. 3. In terms of limitations, DGNN-based temporal event time prediction compresses interaction history into fixed-dimensional node representations, which can weaken long-range temporal modeling. Moreover, simple intensity parameterizations may fail to capture higher-level semantic or contextual factors that influence when events occur.

Definition 2.3

(Dynamic Node Classification). Dynamic node classification aims to predict time-dependent labels for nodes based on their evolving interaction history. This task arises in applications where node properties change over time as new interactions occur. For example, in financial transaction networks the goal may be to classify whether an account becomes fraudulent at a given time, in social networks the objective may be to predict user roles or interests as they interact with others, and in communication networks nodes may be classified according to behavioral patterns or activity types. Formally, each node u is associated with a time-varying label $y_u\left(t\right)$, and the objective is to estimate $p_{\theta }\left(y_u\left(t\right)\mid {\mathcal{E}}_{<t},X_u,{\mathcal{G}}_{<t}\right),$ where ${\mathcal{E}}_{<t}$ denotes all interactions prior to time t, $X_u$ denotes node attributes, and ${\mathcal{G}}_{<t}$ represents the historical graph structure up to time t.

To predict the label of node u at time t, a classifier head $g_{\theta }$ is applied to the node representation, $p_{\theta }\left(y_u\left(t\right)\mid {\mathcal{E}}_{<t},X_u,{\mathcal{G}}_{<t}\right)=\mathrm{softmax}\left(g_{\theta }\left(h_u\left(t^{-}\right)\right)\right).$ The model is trained using cross-entropy loss, $\mathcal{L}=-{\sum }_{(u,t)}log{p}_{\theta }\left(y_u\left(t\right)\mid {\mathcal{E}}_{<t},X_u,{\mathcal{G}}_{<t}\right),$ where $y_u\left(t\right)$ denotes the ground-truth label of node u at time t, obtained from labeled observations such as node attributes, class annotations, or externally provided supervision signals. In terms of limitations, DGNN-based dynamic node classification relies mainly on interaction patterns and local message passing, which may obscure higher-level contextual signals that influence label evolution. In addition, these models often assume stable structural patterns over time, so performance may degrade under distribution shift or sparse interaction histories [12,13].

• Dynamic Graphs’ Benefit as a Knowledge Carrier. Beyond serving as prediction targets, dynamic graphs also provide a structured carrier of evolving knowledge. By explicitly encoding time-stamped entities and relations, they can organize historical context, maintain consistency across updates, and support reasoning over temporally grounded facts [12,25]. This perspective is especially important in settings where one must retrieve or track information across time, such as temporal question answering, evolving memory, or long-horizon interaction modeling [31,63,83]

2.2. Large Language Models

Large language models (LLMs) such as GPT [22,24] and LLaMA [84] have demonstrated strong generalization across a wide range of natural language tasks, enabled by large-scale pretraining on diverse text corpora. Beyond syntactic and semantic understanding, modern LLMs exhibit powerful instruction-following behavior, contextual reasoning, and few-shot adaptation, making them flexible foundations for downstream decision-making and knowledge-intensive applications [19,22]. Let $\mathcal{V}$ denote a finite vocabulary and let $x=(x_1,\dots ,x_n)\in {\mathcal{V}}^n$ represent a prompt sequence. An autoregressive LLM with parameters $\theta$ defines a conditional distribution over output sequences $y=(y_1,\dots ,y_m)\in {\mathcal{V}}^m$. The model factorizes the conditional likelihood of y given x as

$$p_{\theta }(y\mid x)={\displaystyle \prod _{i=1}^m}{p}_{\theta }(y_i\mid x,y_{<i}),$$

(4)

where $y_{<i}=(y_1,\dots ,y_{i-1})$ denotes the previously generated tokens. Equation (4) expresses the standard autoregressive assumption that each token is generated conditionally on the prompt and all preceding outputs. This probabilistic token-level generation mechanism enables LLMs to operate over arbitrarily serialized inputs and supports their use as general-purpose conditional sequence models across textual, multimodal, and structured domains.

2.3. Temporal Knowledge Graph and Agent Memory Graph

• Temporal Knowledge Graph. A temporal knowledge graph (TKG) is a dynamic graph in which facts are represented as time-stamped relational tuples, typically in the form $(s,r,o,t)$, where s and o denote entities, r denotes the relation, and t denotes the associated timestamp [12,85]. Unlike static knowledge graphs, TKGs explicitly model how relations evolve over time, allowing the system to distinguish between facts that are valid at different time periods [12,86]. This structured representation supports time-aware reasoning by enforcing temporal constraints such as ordering, recency, and validity over time [25,27,63]. In the context of LLMs, TKGs provide an external and structured representation of evolving knowledge, helping address the limitation of implicit and temporally inconsistent memory in language models [26,27,63].
• Agent Memory Graph. An agent memory graph is a dynamic graph that represents the evolving memory of an LLM-based agent as it interacts with its environment [28,29,30,31]. Nodes correspond to memory units such as observations, actions, entities, or internal states, while edges capture relationships such as temporal transitions, causal dependencies, or semantic similarity [28,29]. As new interactions occur, the graph is incrementally updated, enabling the agent to maintain a structured and persistent memory over time [30,31]. Compared to flat text-based memory, this graph-based representation supports more efficient retrieval, better organization of past experiences, and more consistent long-horizon reasoning [28,29,30]. As a result, agent memory graphs provide a natural mechanism for equipping LLM-based agents with structured, evolving memory that improves decision-making and adaptability [30,31].

3. Challenges and Complementarity Between LLMs and Dynamic Graphs

Despite substantial progress, both dynamic graph learning and large language models face fundamental limitations when applied independently. Their growing integration is motivated by the fact that the strengths of one paradigm directly address the weaknesses of the other.

3.1. Challenges in Modeling Dynamic Graphs and the Strengths of LLMs

Challenge 1: Simple embedding layer is not enough. Dynamic graph models primarily learn from interaction structure and historical event patterns. In many real-world systems, node and edge attributes are sparse or missing, and are often represented as simple identifiers or low-dimensional features. As a result, models have limited information about what nodes and interactions actually represent. Inductive temporal models such as TGAT rely on structural interaction history together with simple feature vectors [11], while earlier approaches rely on latent space evolution without incorporating rich semantic context [17]. Consequently, DGNNs may capture structural patterns but fail to represent the meaning behind interactions when contextual information is available but not explicitly integrated. Strength of LLMs. Large language models provide strong semantic understanding learned from large-scale textual corpora. Their pretrained representations encode rich contextual knowledge and relationships between entities [22,24]. Beyond processing text, LLMs can actively enrich dynamic graph data in two ways. First, they can generate or refine node and edge attributes by extracting semantic information from unstructured sources such as user reviews, event descriptions, or knowledge bases. Second, they can augment the graph by generating plausible new interactions or events based on contextual knowledge. These capabilities provide higher-quality initial representations and improve coverage for sparse or incomplete data, directly addressing the limitations of simple embedding layers in DGNNs.

Challenge 2: Over-smoothing in long interaction histories. Dynamic graph models update node representations by repeatedly aggregating information from past interactions [10,14,20]. As interaction histories grow longer, this repeated aggregation can make node representations increasingly similar to each other, a phenomenon related to over-smoothing in graph neural networks [21]. As a result, important differences between nodes are lost, and the model has difficulty distinguishing between entities or predicting fine-grained interactions. This problem becomes more severe in long-horizon settings, where many updates are applied over time, making it difficult to preserve long-range dependencies. Strength of LLMs. Large language models are designed to process long contexts and perform reasoning over extended sequences through attention-based architectures [22,24]. Their ability to model long-range dependencies without repeated aggregation allows them to preserve distinctions between entities and capture higher-level temporal patterns. In this sense, LLMs can act as temporal reasoning engines over graph evolution, directly reasoning over long interaction histories and identifying patterns that are difficult to retain in recursively updated DGNN embeddings.

Challenge 3: Limited robustness under distribution shift. Dynamic graph models are typically trained on historical interaction patterns and assume that future interactions follow similar distributions. However, in many real-world systems, interaction patterns evolve due to external factors such as changes in user behavior, system updates, or new events. When such shifts occur, models that rely on previously learned structural patterns often fail to generalize, leading to degraded performance in long-horizon or cross-domain settings [12,13]. Strength of LLMs. Large language models exhibit strong zero-shot and cross-domain generalization abilities due to their pretraining on diverse data [18,24]. Unlike DGNNs, which are tightly coupled to observed interaction patterns, LLMs can incorporate external knowledge and adapt to new contexts. This makes them suitable for handling distribution shifts, either by acting as robust predictors or by generating plausible future interactions that reflect changing dynamics.

3.2. Challenges in LLMs and the Strengths of DGs.

Challenge 1: Limitations of LLMs for Temporal Reasoning. LLMs have achieved strong performance on many reasoning tasks, especially when combined with retrieval-augmented generation (RAG) frameworks. However, they still face major challenges in temporal reasoning, because they represent knowledge as implicit token sequences rather than explicit time-aware structures. As a result, LLMs often struggle to distinguish outdated facts from current ones, enforce temporal constraints consistently, and track how entities and relations evolve over time. Strength of Dynamic Graphs. Dynamic temporal knowledge graphs provide a natural way to address these limitations. By explicitly representing entities, relations, and facts together with timestamps or validity intervals, they offer a structured and time-aware view of evolving knowledge. This explicit temporal structure enables temporally valid retrieval and provides more reliable evidence for LLM reasoning under time-sensitive queries.

Challenge 2: Limitations of Existing Memory Mechanisms in LLM-Based Agents. LLM-based agents increasingly rely on memory to support long-horizon interaction and adaptation [31,83,87]. However, existing memory mechanisms are often flat and weakly structured, making it difficult to organize evolving information, track state changes, and retrieve relevant past experience efficiently. These limitations become especially pronounced in settings such as long-document reading [66], dialogue systems [28], and embodied environments [29], where agents must continuously interact with changing contexts. Strength of Dynamic Graphs. Dynamic graphs provide a natural solution as their structural and time-evolving properties are well-suited for memory organization. By representing memories as interconnected entities, events, and relations that can be incrementally updated over time, they support a memory system that is both organized and continuously evolving. This makes dynamic graphs a strong foundation for LLM-based agent memory, enabling more coherent state tracking, effective retrieval, and better adaptation over time.

Together, these complementary properties motivate the integration of dynamic graphs with LLMs. Dynamic graphs provide structured, updateable relational memory, while LLMs contribute semantic understanding and reasoning capabilities. Their combination enables reasoning systems that can both interpret complex information and maintain consistent knowledge in evolving environments.

4. LLMs for Dynamic Graphs

This section focuses on LLMs for Dynamic Graphs, examining how LLMs are incorporated to address core limitations of dynamic graph learning. As discussed earlier, dynamic graph models often operate under sparse or noisy node and edge attributes, which limits the ability of learned embeddings to capture the semantic meaning of interactions. In addition, as temporal dependencies extend over long horizons, recursive message passing may lead to information compression or over-smoothing in node representations, making it difficult to preserve informative signals from distant interactions. Finally, dynamic graph models may struggle under distribution shift, where interaction patterns evolve over time and previously learned representations no longer align with current dynamics. These challenges motivate the integration of LLMs, whose pretrained semantic knowledge, abstraction capability, long-context reasoning, and strong generalization ability provide complementary strengths that enhance temporal relational modeling beyond purely structural signals.

From this perspective, LLMs can intervene in dynamic graph systems in several functionally distinct ways. We adopt a role-based taxonomy that categorizes LLMs according to how they participate in the dynamic graph pipeline. Specifically, we distinguish three primary roles: (1) LLMs as time-aware semantic augmenters, where LLMs enrich sparse or noisy graph features while prediction remains primarily performed by dynamic graph neural networks; (2) LLMs as temporal reasoning engines over graph evolution, where LLMs directly perform temporal inference, forecasting, or rule induction over evolving relational structures; and (3) LLMs as dynamic scenario simulators, where LLMs synthesize temporal events or graph trajectories to support augmentation, simulation, or robustness under distribution shift. Next, we elaborate on these roles and review representative methods under each category.

4.1. LLMs as Time-Aware Semantic Augmenters

Existing methods leveraging LLMs as time-aware semantic augmenters can be understood through a unified perspective that connects the purpose of LLM enhancement with a shared modeling pipeline. In particular, LLMs address three core limitations of DGNN-based dynamic graph learning while naturally corresponding to different stages of the pipeline. (1) Addressing simple and weak feature representations. LLMs mitigate semantic sparsity and noisy features by transforming textual descriptions, contextual metadata, or external knowledge into dense semantic embeddings. Because LLMs are pretrained on large-scale corpora, they can encode contextual meaning and entity relations even when structured graph features are limited [18,19,24]. This corresponds to the semantic extraction stage, where an LLM processes node, edge, or temporal context to produce enriched semantic representations. (2) Addressing over-smoothing in long interaction histories. LLMs can model long-range dependencies without relying on repeated aggregation. Their attention-based architectures allow direct reasoning over long interaction sequences, helping preserve informative signals that may otherwise be compressed in recursive DGNN updates [18,22]. This aligns with the temporal integration stage, where extracted semantic signals are fused with structural embeddings inside a DGNN through mechanisms such as concatenation [32], attention-based gating [32], cross-modal alignment [44], or distillation [44]. (3) Improving robustness under distribution shift. By injecting more stable semantic abstractions, this step mitigates information compression and imbalance in temporal representations. LLMs exhibit strong generalization due to diverse pretraining, allowing them to adapt to evolving interaction patterns by incorporating external knowledge and contextual signals [18,24]. This is reflected in the graph-based prediction stage, where DGNNs perform downstream tasks such as temporal link prediction or node classification with LLM-derived signals acting as auxiliary guidance, improving robustness under changing environments. Finally, LLMs also enable integration of external and multimodal information across all stages, allowing dynamic graph models to incorporate signals from text, logs, documents, or other unstructured sources that are not naturally represented within graph topology [88,89]. Within this unified view, most methods can be interpreted as variations of this three-stage pipeline, differing primarily in how semantic signals are extracted, integrated, and utilized during prediction.

Following this shared pipeline, different works introduce distinct design choices depending on which limitations of DGNNs they emphasize. Importantly, these limitations are not isolated, and a single method often addresses multiple issues simultaneously. The three challenges—simple and weak feature representations, over-smoothing in long interaction histories, and limited robustness under distribution shift—should therefore be viewed as complementary perspectives rather than strict categories.

Figure 2. LLMs as Time-aware Semantic Augmenters. The figure shows how an LLM takes a dynamic graph with weak or noisy features and edges, and produces a semantically enriched dynamic graph. In this process, the LLM improves weak feature representations, helps mitigate over-smoothing in long interaction histories, and enhances robustness under evolving conditions by refining existing edges, removing or improving noisy ones, adding plausible new connections, and enriching node features with contextual semantics.

Figure 2. LLMs as Time-aware Semantic Augmenters. The figure shows how an LLM takes a dynamic graph with weak or noisy features and edges, and produces a semantically enriched dynamic graph. In this process, the LLM improves weak feature representations, helps mitigate over-smoothing in long interaction histories, and enhances robustness under evolving conditions by refining existing edges, removing or improving noisy ones, adding plausible new connections, and enriching node features with contextual semantics.

• (1) Addressing simple and weak feature representations. Many methods focus on strengthening the semantic extraction stage by leveraging LLMs to provide richer contextual information. LKD4DyTAG [44] uses an LLM as a semantic teacher to inject text-informed supervision into the DGNN, improving the quality of learned representations. DynLLM [32] constructs multi-faceted user profiles from textual interaction history and integrates them with temporal graph embeddings. Similarly, CasMLN [42] and CROSS [43] enrich node and edge representations by integrating LLM-generated semantic signals into graph learning. CasMLN uses LLM-generated textual summaries of node types and relations as additional features fused with graph embeddings, improving representations for sparse nodes. CROSS generates time-aware semantic summaries of evolving neighborhoods and combines them with structural embeddings through co-encoding, allowing the model to capture both structural patterns and changing semantics over time. These approaches primarily target weak initial features, but the resulting semantic signals also provide more stable representations over time. Beyond representation enhancement, some works extend the same idea to the data level by generating semantically meaningful interactions conditioned on existing graph context. For example, SynGraph [38] synthesizes intermediate user interactions based on historical behavior, enriching sparse temporal signals and improving coverage for long-tail nodes while preserving consistency with observed patterns.
• (2) Addressing over-smoothing in long interaction histories. Several works use LLM-derived semantic signals to complement recursive temporal updates and preserve informative distinctions over long horizons. DynLLM [32] combines slowly evolving semantic profiles with short-term structural embeddings, helping retain high-level information that may otherwise be compressed through repeated aggregation. LKD4DyTAG [44] similarly introduces LLM-based supervision that acts as a global semantic reference, reducing the risk of representation collapse. More generally, methods that inject external semantic information at each step can counteract the tendency of DGNN embeddings to become indistinguishable as interaction histories grow.
• (3) Improving robustness under distribution shift. LLM-enhanced methods also improve robustness by incorporating external knowledge and more general reasoning capabilities. LLM-enabled UAV Graph Systems [46] use LLMs to interpret heterogeneous inputs and guide decision-making under changing environments, reducing reliance on fixed historical patterns. SceneLLM [47] applies LLM-based reasoning over multimodal temporal inputs, enabling adaptation to evolving visual contexts. In addition, some methods improve robustness by explicitly modifying or refining graph structure through controlled updates. For instance, GraphModQA [45] performs sequential graph edits conditioned on the current state, requiring the model to maintain temporal consistency and stable entity identities across updates. By enforcing coherent step-by-step modifications, such approaches improve the model’s ability to operate under evolving and partially observed conditions.

Overall, these examples illustrate that existing methods do not fall into disjoint categories. Instead, they instantiate the shared pipeline in different ways, with each component—semantic extraction, temporal integration, and prediction—contributing to multiple challenges simultaneously.

Applications Table 2 summarizes representative applications of LLM-enhanced modeling across diverse dynamic graph tasks. In transactional and interaction networks (e.g., Aminer, Enron, GDELT, Tmall), semantic embedding injection and distillation methods are most effective for node classification, link prediction, and recommendation under sparse or evolving relational semantics. In text-attributed dynamic graphs, time-aware semantic encoding improves robustness to semantic drift and heterogeneous interaction patterns. For multimodal and embodied settings (e.g., UAV coordination, video scene graphs), LLM-enhanced models enable joint reasoning over structural evolution and high-level semantic intent, supporting trajectory planning, dynamic scene understanding, and modular agent execution. Overall, LLM-enhanced modeling is particularly suited for dynamic graphs where structural signals alone are insufficient to capture evolving semantics, user intent, or long-range contextual dependencies.

Take-away and Discussion. In LLM-enhanced dynamic graph modeling, the goal is to improve DGNNs rather than replace them. DGNNs perform temporal message passing to model evolving interactions, but their embeddings can drift over time and may be biased toward highly active nodes. LLMs are therefore introduced as auxiliary semantic modules that stabilize and enrich these representations. Most existing methods follow a similar pattern: LLMs first extract semantic signals, these signals are then fused into DGNN representations, and final predictions remain graph-based. While different approaches vary in how semantic information is injected and updated during temporal learning, they ultimately follow a consistent architectural design. Across these variants, DGNNs remain the structural–temporal backbone responsible for modeling interaction dynamics, while LLMs act as semantic regularizers that enhance representation quality under sparse supervision, non-stationarity, and imbalance. From this perspective, the literature reveals a clear unifying principle: LLMs provide higher-level semantic abstractions that complement graph-based temporal inductive biases, stabilizing and enriching dynamic graph learning rather than replacing the underlying DGNN mechanisms.

4.2. LLMs as Temporal Reasoning Engines Over Graph Evolution

Unlike LLMs as time-aware semantic augmenters, where DGNNs remain the final predictors, the paradigm of LLMs as temporal reasoning engines over graph evolution places the LLM itself at the center of temporal inference. This shift is motivated by the previously discussed limitations of DGNNs, including over-smoothing under long interaction histories and the inability to fully capture rich semantic context from sparse structural features. In contrast, large language models possess strong semantic understanding [24], long-context reasoning ability [18], and the capacity to integrate external knowledge sources [19,22], making them well suited for reasoning over complex temporal patterns in evolving relational systems. Here, the dynamic graph is treated as input to the language model, and the LLM directly produces predictions over future interactions, attributes, or relations. Dynamic graph tasks such as temporal link prediction, event time prediction, and node classification, traditionally addressed using DGNNs with temporal message passing, are instead solved through LLM-based reasoning without maintaining explicit evolving node states.

Figure 3. LLMs as temporal reasoning engines over graph evolution.

Figure 3. LLMs as temporal reasoning engines over graph evolution.

From the perspective of how dynamic graphs are interfaced with language models, existing work can be organized into three categories (see Figure 1) (1) Dynamic graphs as serialized time-ordered text, where sequences of time-stamped events are converted into textual descriptions that can be processed by the LLM as natural-language-like input; (2) Dynamic graphs as embeddings from temporal graph encoders, where temporal graph neural networks first produce structure-aware embeddings that are then injected into the LLM as continuous representations; and (3) Dynamic graphs as structured temporal rules, where symbolic rules describing relational evolution are extracted or generated and used as interpretable reasoning structures for the LLM. Consequently, reasoning may occur implicitly through sequence modeling over serialized inputs or embeddings, or explicitly through interpretable rule-based structures. Details of each interface are discussed below.

(1) Dynamic Graphs as Serialized Time-Ordered Text. In this input mode, each temporal interaction $(u,v,x,t)$ is converted into a short textual statement, forming a time-ordered narrative that the LLM processes directly. Prediction tasks are then framed as next-event prediction or question answering over this sequence. The main advantage of this approach is its simplicity, since no additional graph encoder is required. However, scalability becomes a major bottleneck: long interaction histories produce very long text sequences, leading to large token counts and weaker temporal signals. LLM4DyG [34] follows full serialization, relying on event ordering and prompt design to expose temporal dependencies. TGTalker [48] reduces context length by focusing on recent interactions of a source node, leveraging the recency bias commonly observed in dynamic graphs. LGA [49] uses serialized local neighborhoods not for direct prediction, but to identify informative interactions that guide downstream temporal aggregation. Across these works, temporal reasoning is performed implicitly through sequence modeling, without maintaining explicit evolving node embeddings.

(2) Dynamic Graphs as Embeddings from Temporal Graph Encoders. To mitigate scalability issues of full serialization, some methods adopt a two-stage interface. First, a temporal graph encoder (e.g., TGNNs such as TGAT [11], TGN [10], or temporal knowledge graph models such as RE-NET [85]) summarizes dynamic interactions into compact embeddings that capture structural and temporal dependencies. Second, these embeddings are projected into the LLM input space, where the LLM performs reasoning over compressed graph states rather than raw event sequences. In this design, the graph encoder handles structural evolution and local aggregation, while the LLM focuses on higher-level temporal inference. Under this framework, different methods emphasize different components of the pipeline. TGL-LLM [35] focuses on forecasting in temporal knowledge graphs, using a Relational Graph Convolutional Network (R-GCN) with a GRU-based temporal encoder to compress long interaction histories into temporal graph embeddings. These embeddings are aligned with LLM inputs through entity and relation adapters and incorporated into hybrid prompts, enabling the LLM to perform temporal reasoning over candidate future events. GAT-LLM [50] applies a similar separation in high-frequency systems, such as wireless communication or networked control environments where system states (e.g., connectivity, bandwidth, or resource allocation) change rapidly over time. In these settings, the graph encoder captures fast-changing relational dynamics, while the LLM predicts future system evolution without converting graph states into text. AnomalyLLM [51] uses a hybrid GNN + Transformer-based dynamic encoder to represent each interaction and its temporal neighborhood by constructing time-aware subgraphs around edges and encoding them into embeddings. These embeddings are then reprogrammed into token-compatible representations and passed to the LLM, which leverages in-context learning for few-shot anomaly detection. Compared with full text serialization, this interface improves scalability while preserving the structural inductive bias of temporal graph models.preserving the structural inductive bias of temporal graph models.

(3) Dynamic Graphs as Structured Temporal Rules. A third paradigm represents dynamic graphs through symbolic temporal rules rather than continuous embeddings or serialized events. In this setting, the dynamic graph is summarized as a collection of interpretable rules that describe how relations tend to evolve over time. This differs from the previous two input modes. Instead of feeding graph history directly to an LLM as text or embeddings, the LLM operates over a rule set that captures recurring temporal patterns. The typical pipeline consists of three stages. First, rule construction: candidate temporal rules are discovered from the training graph by mining frequent relational patterns or by prompting an LLM to generate potential rules. Each rule usually contains a set of time-ordered relational conditions and a predicted future relation that becomes likely when those conditions are satisfied. For example, a rule may take the form: if $(u,\mathrm{works\_at},c,t_1)$ and $(c,\mathrm{located\_in},l,t_2)$ with $t_1<t_2$, then $(u,\mathrm{lives\_in},l,t_3)$ is likely to occur at a future time $t_3$. Second, rule retrieval: given a query event such as predicting a future relation between two entities, the system retrieves rules whose conditions match the recent interaction history of those entities. Third, rule-based inference: the retrieved rules are evaluated against the current graph history, where the current graph history refers to the set of observed interactions up to the prediction time (i.e., all events that have already happened before the target timestamp). The confidence scores of matched rules are then used to rank candidate future events. Most existing methods apply this paradigm to temporal knowledge graph forecasting and related link prediction tasks. LLM-DA [52] focuses on rule revision: when interaction patterns shift over time, the LLM updates existing rules so that their conditions better reflect current dynamics. For instance, an initial rule such as “if a user clicks an item, then they will purchase it” may be revised into a more context-aware rule like “if a user clicks an item multiple times within a short time window, then they are likely to purchase it,” capturing changing behavioral patterns. LLM-DR [36] emphasizes rule generation: the LLM proposes candidate rules and filters out semantically inconsistent ones, improving rule discovery beyond purely structural mining. SPARK [54] and TV-LLM [53] instead focus on rule validity control, where the LLM evaluates whether a rule remains applicable under evolving temporal contexts and adjusts its scope accordingly. Although the representation differs from the previous two input modes, the underlying principle remains similar: dynamic graph history is compressed into an LLM-compatible structure that enables temporal reasoning without maintaining explicit evolving node embeddings.

Applications Table 2 summarizes representative applications of LLM-centric prediction across dynamic graph tasks. When dynamic graphs are serialized as time-ordered text, LLMs are applied to spatio-temporal QA, temporal link prediction, and node attribute forecasting, demonstrating that pretrained language models can perform DGNN-free reasoning directly from interaction narratives. When dynamic graphs are interfaced through temporal graph embeddings, LLMs serve as higher-level predictors for temporal knowledge graph forecasting, multivariate system prediction, and few-shot anomaly detection, leveraging structural encoders for scalability while retaining strong reasoning capacity. Finally, when dynamic graphs are represented as structured temporal rules, LLMs support adaptive rule editing, generation, and validity control, enabling interpretable forecasting under temporal distribution shifts. Overall, LLM-centric prediction is particularly suited for settings where reasoning flexibility, rule interpretability, or few-shot generalization is prioritized over purely structural message passing.

Take-away and Discussion. In LLM-centric prediction, the LLM acts as the final reasoning module, and the core challenge is how to encode evolving graph history into its input space under limited context and temporal complexity. Existing methods differ in the interface used. Serialized event approaches convert interaction history into time-ordered text, offering flexibility but facing scalability limits. Embedding-based approaches compress temporal structure through graph encoders before passing compact representations to the LLM, improving efficiency while preserving structural bias. Rule-based approaches abstract history into temporal rules, enabling more interpretable forecasting through rule execution. The key trade-off lies between scalability, structural fidelity, and interpretability. Designing principled criteria for selecting or combining these interfaces remains an open direction.

4.3. LLMs as Dynamic-Scenario Graph Constructor

LLMs are also used to construct or augment dynamic graphs themselves. Dynamic graphs are typically constructed from observed event streams such as user interactions, communication logs, transactions, or multimodal observations [10,14]. However, real-world dynamic graph data is often sparse, incomplete, or irregularly sampled. As a result, dynamic graph generation becomes useful for several purposes. First, generated temporal interactions can augment limited datasets and improve supervision for downstream learning models. Second, simulation environments require realistic evolving graph structures to evaluate prediction, reasoning, and decision-making systems [37]. Third, in multimodal environments such as video understanding or embodied agents, relational structure may not be directly observable and must be constructed incrementally from raw inputs [55]. In these scenarios, LLMs naturally act as dataset constructors that help build or expand dynamic graph structures.

Figure 4. LLMs as Dynamic-Scenario Graph Constructors. The figure illustrates from-scratch dynamic graph generation, where the LLM sequentially produces timestamped events $e_t=(u,v,x,t)$ that incrementally update the evolving graph over time. At each step, the current graph state provides implicit temporal context that supports identity continuity and relational coherence, allowing the model to preserve consistent entities and long-horizon temporal structure without reconstructing the full history at every generation step.

Figure 4. LLMs as Dynamic-Scenario Graph Constructors. The figure illustrates from-scratch dynamic graph generation, where the LLM sequentially produces timestamped events $e_t=(u,v,x,t)$ that incrementally update the evolving graph over time. At each step, the current graph state provides implicit temporal context that supports identity continuity and relational coherence, allowing the model to preserve consistent entities and long-horizon temporal structure without reconstructing the full history at every generation step.

Unlike static graph generation, which focuses on sampling a single topology consistent with structural statistics [90,91], dynamic graph generation must additionally model how relational structure evolves over time. This means generating not only nodes and edges, but also their temporal ordering and state transitions. Because each new interaction depends on previous events, the generation process is inherently sequential and history-dependent.

Generating dynamic graphs also introduces several challenges. First, temporal consistency: generated events must respect chronological dependencies and avoid contradictions across time [12]. Second, identity persistence: entities that reappear across timestamps must maintain consistent identities and relational semantics. Third, incremental scalability: long interaction histories must be extended without reconstructing the entire graph state at each step [14]. Large language models are naturally suited to address these challenges. Because LLMs operate autoregressively over sequences, they can generate temporally ordered events while maintaining contextual coherence across steps [18,24]. Their semantic reasoning capabilities also help preserve consistent entity identities and relational meaning when information is extracted from unstructured or multimodal sources [88,89]. Consequently, LLMs can be used not only for reasoning over existing dynamic graphs but also for constructing or extending them.

Existing work [37,55] in this setting focuses on from-scratch dynamic graph generation, where the dynamic graph emerges entirely from an LLM-driven process. In this paradigm, the model generates entities (nodes), relations (edges), and temporal interactions (events with timestamps) directly, often through multi-agent interaction or multimodal reasoning, producing evolving graph structure and semantics jointly over time. Details are discussed below.

From-scratch dynamic graph generation. In this setting, no fully specified initial graph is assumed. Instead, the LLM drives the evolution process itself, generating nodes (e.g., users or objects), edges (e.g., interactions or relations), and timestamps as part of a coherent temporal simulation. Because there is no external evolving state to anchor generation, the main challenge is maintaining long-horizon temporal consistency and stable entity identities while scaling generation over extended time horizons. The model must internally preserve relational coherence and incremental evolution without reconstructing the full history at each step. This setting is therefore suited for simulation, dataset construction, and multimodal graph extraction, where both structure and semantics must emerge jointly. GAG [37] addresses these challenges through persistent agent-based simulation, where nodes correspond to agents, edges correspond to interactions such as replies or connections, and events correspond to time-ordered communication actions. Each LLM-controlled agent maintains contextual memory and identity across interactions, and graph structure emerges from their time-ordered exchanges. Temporal consistency is achieved through stable agent personas and dialogue continuity, while scalability arises from decentralized local interactions. GraphVideoAgent [55] follows a similar from-scratch construction paradigm in a multimodal setting, where nodes correspond to entities detected in video frames (e.g., person, dog, object), edges correspond to time-stamped relations between entities (e.g., plays_with, takes, barks_at), and events correspond to frame-level interactions and state changes. The graph is constructed incrementally as the LLM processes video-derived descriptions and updates entity states and relations over time. Unlike static graph construction, the LLM iteratively refines the graph by selecting additional frames, updating relations, and reasoning over the evolving structure, enabling temporally consistent and causal understanding of long video sequences.

Applications Table 2 summarizes representative applications of LLM-based dynamic graph generation. In from-scratch dynamic graph generation, LLM-driven agents or multimodal systems construct evolving interaction graphs directly through generation processes, enabling realistic multi-agent simulation, benchmark construction, and long-horizon video reasoning. Overall, this paradigm is particularly suited for scenarios where temporal data are unavailable or incomplete, where controllable simulation is required, or where relational structure must be incrementally constructed from unstructured or multimodal inputs.

Take-away and Discussion. LLM-based dynamic graph generation differs from embedding enhancement or direct prediction because it operates at the level of graph evolution itself. In the from-scratch setting, LLMs generate evolving relational structures through simulation or multimodal construction, enabling flexible and interpretable modeling of temporal environments. Although promising, existing approaches remain application-specific, and developing general principles for temporally consistent and controllable dynamic graph generation remains an open research direction.

5. Dynamic Graphs for LLMs

The interaction between dynamic graphs and LLMs is inherently bidirectional. The previous section has examined how LLMs enhance dynamic graph tasks. We now explore the reverse direction: how dynamic graphs can augment LLMs. Graph structures are well-suited for knowledge representation, as they explicitly encode relational dependencies among entities. In dynamic environments, where knowledge evolves over time, dynamic graphs provide an effective carrier for modeling temporal changes. They not only represent static relations but also capture the evolution and updating of knowledge. From this perspective, we identify two primary scenarios in which dynamic graphs enhance LLMs. The first involves external dynamic temporal knowledge graphs for LLM temporal reasoning, where temporal knowledge graphs serve as dynamic external repositories that reflect evolving information. The second concerns internal dynamic memory graphs for self-evolving LLM-based agents, where dynamic memory graphs model evolving internal memory states to support continual adaptation and long-horizon reasoning. Next, we elaborate on these two directions.

5.1. Dynamic Temporal Knowledge Graph for LLM Temporal Reasoning

LLMs have achieved strong performance on diverse reasoning tasks, particularly when augmented with retrieval-augmented generation (RAG) [92,93,94] frameworks that incorporate external knowledge. However, temporal reasoning, where queries involve explicit time constraints such as before, after, or last, remains challenging for LLMs. This challenge stems from the difficulty of reliably modeling and enforcing temporal constraints within implicit language representations, especially in multi-step reasoning scenarios where temporal inconsistencies are prone to arising. Most existing RAG systems do not explicitly account for the temporal properties of knowledge and instead treat facts from different time periods as static and interchangeable. Consequently, they are limited in their ability to support time-sensitive reasoning. Temporal graphs provide a natural extension to address this limitation by explicitly encoding time-dependent facts and relations in structured representations, thereby enabling temporally consistent retrieval and reasoning. This section focuses on temporal graph–augmented approaches for enhancing LLM temporal reasoning. Based on the source of retrieved knowledge, existing methods can be broadly divided into two categories: text corpus–driven temporal knowledge graph (TKG) construction and retrieval, and augmentation with off-the-shelf temporal knowledge graphs. We review these two lines of work in detail below.

• (1) Text Corpus–Driven TKG-Augmented LLM Reasoning RAG enhances LLM generation by retrieving relevant evidence from textual corpora, while GraphRAG methods [26,27] further introduce structured graph indices to model entities and relations across documents, improving retrieval coverage and accuracy. However, most existing GraphRAG approaches overlook the temporal dimension. In real-world scenarios, knowledge is inherently time-sensitive and continuously evolving [25]. For example, a company’s financial information varies across fiscal years and is updated as new documents are released. Without explicit temporal modeling, conventional GraphRAG systems often fail to distinguish facts associated with different time contexts, such as revenue figures from different years. Consequently, knowledge from different time periods may be encoded into highly similar representations or even identical graph indices, leading to temporal ambiguity. This issue is particularly severe for time-constrained queries and reasoning over evolving knowledge. To address this limitation, recent work incorporates temporal information by transforming textual corpora into temporal knowledge graphs (TKGs) and performing time-aware indexing and retrieval. As shown in Figure 5(a), these approaches typically first construct a TKG from documents and then design temporal retrieval mechanisms to support LLM generation. For example, T-GRAG [56] builds a timestamped knowledge graph by grouping documents into temporal segments, partitioning them into knowledge blocks, where extracted entities are represented as nodes, semantic relations between entities form edges, and timestamps are associated with the corresponding nodes, edges, and knowledge blocks according to their temporal segment. It then extracts time-stamped triples, followed by query decomposition and temporally constrained subgraph retrieval. Specifically, the query is first decomposed into sub-queries with explicit temporal conditions, and retrieval is restricted to the subgraph induced by the relevant time segment(s). This reduces conflicts between outdated and current facts, while narrowing the search space to temporally consistent evidence for generation. TG-RAG [57] further introduces a hierarchical temporal structure (e.g., day–month–quarter–year), aggregates knowledge across time scales, and applies personalized PageRank to identify relevant temporal subgraphs and text chunks for generation.
• (2) Off-the-shelf TKG Augmented LLM Reasoning Beyond using textual corpora as retrieval sources, another line of research directly leverages existing temporal knowledge graphs to enhance the temporal reasoning capabilities of LLMs. In this setting, a central challenge lies in retrieving facts from TKGs that simultaneously satisfy semantic relevance and temporal constraints. According to the retrieval mechanism, existing approaches can be broadly categorized into two classes: (i) retrieval–filtering methods and (ii) agent-based interactive retrieval methods.
• (i) Retrieval–Filtering Methods Retrieval–filtering methods typically follow a two-stage paradigm. They first perform coarse retrieval from a TKG using entity alignment or approximate matching, and then rely on LLMs to filter candidate facts based on temporal and semantic consistency, as shown in Figure 5(b). For example, GenTKGQA [58] utilizes LLMs to identify implicit temporal constraints in queries and assess the relevance between TKG relations and the query, thereby retrieving a relevant knowledge subgraph. It then further fine-tunes the LLM to better align with graph-structured information for temporal question answering. For more complex temporal reasoning scenarios, such as multiple temporal constraints, multi-hop reasoning, and multi-granularity time modeling, direct retrieval becomes less effective. Several works, therefore, adopt divide-and-conquer strategies that decompose complex queries into simpler subproblems. RTQA [59] recursively splits the original query into a sequence of subqueries and applies a cascaded retrieval–filtering process, where earlier answers constrain later retrieval steps, leading to improved performance on complex temporal questions. Similarly, MemoTime [60] introduces a Tree of Time framework that constructs a temporal subgraph via entity alignment and performs hierarchical filtering based on temporal consistency before jointly ranking candidates by semantic relevance and temporal proximity. Plan of Knowledge [61,62] further formulates temporal reasoning as a sequence of executable subgoals, each supported by time-aware retrieval from the TKG, followed by global reasoning with an LLM.
• (ii) Agent-Based Interactive Retrieval Methods In contrast to coarse retrieval and filtering, another class of approaches models a retrieval agent that incrementally acquires fine-grained evidence through multi-round interactions with a TKG, as illustrated in Figure 5(c). These methods equip the LLM with a set of predefined TKG operation tools, such as SearchAfterDay and SearchOnMonth, enabling the agent to query the graph until sufficient evidence is collected iteratively. ARI [63] formulates temporal reasoning as an explicit step-by-step interaction process. Starting from a topic entity, the system enumerates executable candidate actions on the TKG and filters out invalid or semantically irrelevant ones to reduce the search space. The LLM then selects the most appropriate action, which is executed by an external environment to produce intermediate results and update the reasoning state. This process iterates until termination. TempAgent [64] further adopts a ReAct-style [95] multi-round interaction framework, in which the LLM performs both reasoning and tool invocation. In each round, the agent generates a Thought to analyze temporal constraints, invokes a predefined time-aware retrieval function as an Action, and receives an Observation consisting of top-k temporally filtered facts. The accumulated interaction history guides subsequent decisions until complete information.
• Applications Table 3 summarizes the representative task applications of targeting different temporal reasoning scenarios. Temporal GraphRAG methods are best suited for long-context, document-centric QA over evolving text corpora, where temporal conflicts and redundancy arise across documents. Retrieval–filtering methods over existing temporal knowledge graphs are more appropriate for structured temporal QA with explicit or mildly implicit time constraints, especially in multi-hop settings with high-quality TKGs. Agent-based interactive retrieval methods are most effective for complex temporal reasoning tasks involving implicit constraints or compositional temporal conditions, where iterative, tool-driven interaction with the TKG is required to enforce temporal consistency.
• Take-away and Discussion By explicitly representing time-dependent events and relations, temporal graphs enable precise identification of reference information that satisfies temporal constraints, thereby enhancing the temporal reasoning capabilities of large language models. Text-corpus–driven temporal graph–based retrieval-augmented generation methods organize evolving document collections into temporally coherent structures, off-the-shelf TKG–based retrieval–filtering approaches constrain reasoning to temporally valid subgraphs, and agent-based methods further enable iterative, tool-driven validation of temporal constraints. Overall, these paradigms demonstrate that temporal graphs provide an effective structural mechanism for reliable temporal reasoning with LLMs.

5.2. Dynamic Memory Graph for Self-evolving LLM-based Agents

The real-time and structural properties of dynamic graphs make them well-suited for LLM-based agent memory [31,83,87], which maintains an ever-changing yet well-organized memory. Agent memory is a key mechanism that enables self-evolving agents by allowing them to continuously adapt to their environments and tasks. In practice, agents interact with their environments in various forms, such as human interaction in long-document reading [66], dialogue systems [28], and interaction with external environments in embodied settings [29], as shown in the following examples.

Illustrative Examples of Three Memory Sources(1) Historical information within the same task. Example: During a customer-support chat, a user has already specified constraints such as a preferred delivery date and budget earlier in the conversation. When the user later asks for product recommendations within the same session, the agent should reuse these previously stated constraints to provide consistent and relevant suggestions without asking redundant questions. (2) User information across different tasks. Example: A user frequently asks the agent to summarize technical papers in a concise, bullet-point format across multiple sessions. Even in a new session on a different topic, the agent can recall this preference and automatically present summaries in the user’s favored style, improving personalization and user experience. (3) Historical experiential information across tasks. Example: In an automated web-navigation or booking system, the agent repeatedly encounters failures when selecting non-refundable options under uncertain schedules. By retaining this experience, the agent learns to prioritize flexible or refundable options in future, related tasks, even when the specific booking context changes.

Agent Memory Sources Building on these three typical task types, given a sequence of sequentially executed tasks $T_1,T_2,\dots ,T_K$, the memory available to the agent at step i for task $T_k$ can be derived from one of three sources, corresponding to the examples.

• Historical information within the same trial, denoted as ${\xi }_i^k=\{a_1^k,o_1^k,\dots ,a_{i-1}^k,o_{i-1}^k\},$ where $a_j^k$ and $o_j^k$ represent the action and observation at step j of task $T_k$, respectively, and the superscript k indicates the task index. This source captures short-term interaction history within a single task.
• Personalized information across different trials, denoted as ${\mathsf{\Xi }}_i^k=\{{\xi }^1,{\xi }^2,\dots ,{\xi }^{k-1},{\xi }_i^k\},$ where ${\xi }^j$ denotes the user-related interaction history from the j-th task or session, and ${\xi }_i^k$ denotes the current interaction history up to step i, both of which contribute to the subsequent $(i+1)$-th step. This source captures personalized behavioral patterns accumulated across multiple tasks.
• Historical experiential information across tasks, denoted as ${\mathsf{\Xi }}_i^k=\{{\xi }^1,{\xi }^2,\dots ,{\xi }^{k-1},{\xi }_i^k\},$ where ${\xi }^j$$(j\in \{1,\dots ,k-1\left\}\right)$ denotes complete trial trajectories from previous tasks, and ${\xi }_i^k$ denotes the partial history of the current task. This source captures experiential knowledge accumulated across tasks. Note that the notation is the same as that used for personalized information, but the underlying setting and objective are different. Experiential information typically arises from business workflows and captures experience distilled from task outputs, whereas personalized information is associated with personal agents and reflects user preferences inferred from interactions.

Therefore, at step i of task $T_k$, the agent’s memory source may originate from the within-trial history ${\xi }_i^k$, the cross-trial personalized information ${\Pi }_i^k$, or the cross-task experiential history ${\mathsf{\Xi }}_i^k$, depending on the task characteristics and system design objectives.

Definition of the Agent Memory System. Following [31], we formalize an agent with explicit memory as $\mathcal{A}=({\mathtt{F}}_{\theta },\mathtt{U},\mathtt{R},\mathtt{C},\mathtt{H},\mathtt{E},\mathtt{M})$, where ${\mathtt{F}}_{\theta }$ denotes the base language model, $\mathtt{M}$ is the memory repository that stores accumulated memory units, $\mathtt{R}$ is the memory retrieval function, $\mathtt{C}$ is the context construction function, $\mathtt{H}$ is the memory generation function, $\mathtt{U}$ is the memory update and management function, and $\mathtt{E}$ denotes the environment or feedback function. At time step t (where $t=i$ corresponds to an intra-trial step and $t=k$ corresponds to a cross-task stage), the agent executes a memory-centric interaction loop. First, the agent retrieves relevant memory conditioned on the current input, $R_t=\mathtt{R}({\mathtt{M}}_t,x_t)$, where $x_t$ denotes the current input, instantiated as an observation $o_t$ within a task or a task description $T_t$ at the cross-task level. The retrieved memory is then integrated with the input to construct the model context, ${\mathtt{C}}_t=\mathtt{C}(x_t,R_t)$, based on which the base model produces an output ${\widehat{y}}_t={\mathtt{F}}_{\theta }\left({\mathtt{C}}_t\right)$. Subsequently, the agent receives feedback from the environment, $f_t=\mathtt{E}(x_t,{\widehat{y}}_t)$, which is used to synthesize a new memory unit, $m_t=\mathtt{H}(x_t,{\widehat{y}}_t,f_t)$. Finally, the memory repository is updated via ${\mathtt{M}}_{t+1}=\mathtt{U}({\mathtt{M}}_t,m_t)$, thereby completing one iteration of memory retrieval, utilization, generation, and maintenance. This formulation characterizes agent memory as an iterative closed-loop process that evolves continuously with agent–environment interactions. Different memory systems mainly differ in memory organization (e.g., text, trees, triplets, or graphs), retrieval strategies, memory granularity (such as facts, summaries, opinions, temporal and causal information), and update or eviction mechanisms, which together determine their effectiveness and applicability across tasks.

As shown in Figure 6(a), such memory can be naturally represented in dynamic graph form because dynamic graphs address several key limitations of flatten memory organization: (i) Memory conflict resolution. By explicitly modeling timestamped subject–relation–object triples, dynamic graphs make the evolution of old and new memories traceable and updatable rather than simply accumulated; (ii) Enriched memory representation. By integrating dispersed memory items via node neighborhoods and local subgraphs, it can form richer and more complete semantic representations that support higher-level cross-memory reasoning; and (iii) Improved retrieval performance. Dynamic graphs capture dependencies and structural constraints among memory units, thereby connecting fragmented knowledge, reducing redundancy, increasing diversity, and enabling faster, more comprehensive, and more accurate memory recall. Among these benefits, conflict resolution primarily exploits the temporal dynamics of dynamic graphs, while enriched representation and retrieval performance stem from their structural properties. Overall, the advantages of memory graphs are broadly applicable across different memory scenarios, although their concrete implementations vary with application context. In terms of the memory source, we categorize agent memory into three types: (1) working memory graphs, which store long-context information; (2) personal memory graphs, which model personal user preferences acquired through interactions; and (3) experience memory graphs, which store experiential insights from the agent’s outputs and interactions with the environment.

(1) Working Memory Graphs Working memory aims to mitigate the limitations of LLMs in long-context scenarios, where finite context windows and limited long-range modeling capacity hinder factually consistent responses. A common approach is to transform long conversational histories [65] or long documents [66] into external memory representations and retrieve only task-relevant information at the current inference step. In this process, dynamic graphs serve as evolving memory carriers: they incrementally incorporate new information, update existing relations, and support both memory conflict resolution and efficient retrieval over changing context. As shown in Figure 6(a,b), contextual information, such as multi-turn dialogues, is first organized into a memory graph that can be continuously expanded or revised as interactions proceed. When a new query arrives, relevant contextual information is retrieved from the graph to help the agent generate responses that are more consistent with prior context. For the dynamic advantages of graphs for conflict resolution, D-SMART [65] constructs a dynamic dialogue knowledge graph for long conversations and leverages LLMs to identify potential conflicts when integrating new and existing memories, thereby maintaining an up-to-date and consistent memory. For the structural advantages of graphs for retrieval performance, in long-document reading scenarios, CAM [66] introduces a hierarchical memory graph that incrementally aggregates dispersed document fragments into higher-level semantic structures through bottom-up abstraction. This design captures latent cross-paragraph dependencies and alleviates information fragmentation during retrieval.

(2) Personal Memory Graphs Personal memory is primarily used to store personalized information gradually accumulated through user-agent interactions, supporting the long-term personalization of LLM- or agent-based behavior. As shown in Figure 6(a,c), systems typically extract knowledge triples from multi-session dialogues to construct a personal information knowledge graph, from which relevant subgraphs are retrieved on demand during inference to support personalized decision making. For the dynamic advantages of dynamic graphs for conflict resolution, Zep [67] continuously updates user memory using an entity graph augmented with timestamps and expiration mechanisms, maintaining memory freshness and hiding potential outdated conflicts. This achieves information freshness in long-term personalization. For the structural advantages of dynamic graphs for memory representation and retrieval performance, Zep also proposes a multi-level, multi-granularity memory design: episode subgraphs preserve raw interactions, entity subgraphs store fine-grained knowledge triples for reasoning, and community subgraphs summarize clustered knowledge, collectively improving retrieval efficiency. EMG-RAG [28] organizes mobile personal data into a hierarchical memory graph with high-level categories, refined subclasses, and interconnected knowledge triples, enabling frequent insertion, deletion, and update operations while capturing complex personalized relations. SGMem [68] decomposes dialogue histories into sentence-level units and constructs sentence graphs that connect related content across turns and sessions, reducing redundancy and improving the completeness and accuracy of contextual retrieval. H-MEM [70] organizes interactions into a four-level hierarchy (Domain, Category, Trace, Episode) and introduces a layer-wise retrieval router that prunes irrelevant branches during top-down traversal, improving efficiency and reducing interference from unrelated history. More recent work emphasizes time-aware and casual retrieval. For example, THEANINE [69] argues that deleting historical memories harms explainability and instead preserves all factual memories in a graph with explicit temporal and causal relationships, enabling retrieval of complete timeline-based memory chains for consistent and explainable personalization. Further, several works address over-mixed relational representations. MAGMA [71] decomposes memory into aligned temporal, causal, semantic, and entity subgraphs that share common event nodes, enabling intent-aligned and structure-aware retrieval for temporal and causal reasoning. Similarly, SYNAPSE [96] employs a heterogeneous memory graph that separates episodic and semantic nodes connected by typed relations, enabling structured and logical queries, while Hindsight [97] adopts a heterogeneous multi-graph design that models world knowledge, experience, observations, and opinions as distinct graphs, preventing representational entanglement and supporting consistent long-term agent behavior.

(3) Experience Memory Graphs Experience memory stores environmental knowledge and distilled insights acquired through multi-step agent–environment interactions of the form (state, observation, action). It is widely studied in embodied intelligence [98] and web agent settings [99]. Dynamic graphs provide a structured way to organize such experiences, enriching insight representations and improving retrieval for downstream tasks. As illustrated in Figure 6(a,d), experiential feedback is extracted/abstracted, stored, and reused across tasks to increase success rates and execution efficiency. From a dynamic perspective, AriGraph [29] maintains experience memory via a continuously updated hierarchical graph. New observations are converted into knowledge triples, aligned with existing memory, and outdated relations are pruned, ensuring temporal consistency. At inference time, relevant episodic and semantic experiences are jointly retrieved to guide current decisions. From a structural perspective, graph-based abstractions address the dispersion and heterogeneity of experiential data. AriGraph adopts a dual-layer episodic–semantic memory to ease cross-granularity retrieval. A-Mem [72] models each interaction as a semantically enriched node with relational links, propagating information exchange and enhancing the memory representation. G-Memory [73] decouples raw interactions, semantic organization, and high-level insights using a three-layer graph, preserving multi-granularity information while improving retrieval efficiency. MemTree [74] organizes online experiences into a tree-structured hierarchy, enabling efficient reuse for complex reasoning. Beyond topology, optimizable edge weights offer an additional graph benefit by implicitly encoding the utility of memory items. Xia et al. [75] propose a trainable three-layer graph memory that abstracts trajectories into decision paths and higher-level insights, with reinforcement learning adapting edge weights to prioritize the useful memories for downstream tasks.

Applications. Table 4 summarizes representative task applications of dynamic graph–assisted agent memory. Existing methods can be categorized into working, personal, and experience memory, each corresponding to distinct task focuses. Working memory graphs are designed for short-term, task-scoped reasoning, such as dialogue coherence and long-document understanding, where relevant information is scattered within a single interaction. Their graph structures emphasize local organization and short-term consistency to aggregate fragmented contextual information. Personal memory graphs focus on long-term conversational and personalization tasks, aiming to maintain stable user models across sessions. These methods address challenges including memory conflicts, incomplete and inefficient retrieval, and temporal or causal evolution. Hierarchical or heterogeneous graph structures enable efficient and comprehensive retrieval, supporting consistent personalized behavior. Experience memory graphs are tailored for interactive decision-making tasks, including embodied environments, games, and multi-hop question answering. They emphasize reusing past trajectories by abstracting interactions into transferable experiences or insights, and rely on dynamic updates and adaptive retrieval to prioritize experiences that are most useful for future decision making.

Take-away and Discussion Dynamic graph–assisted memory offers two fundamental and complementary advantages that are critical for agent behavior. (1) Dynamic benefits. By explicitly modeling temporal evolution, dynamic graphs enable continuous memory updates that preserve information freshness while maintaining consistency. Operations such as incremental insertion and selective deactivation or down-weighting of outdated relations allow agents to adapt to new observations without catastrophic forgetting. (2) Structural benefits. Graph structure provides a principled way to organize memory at multiple granularities, substantially improving retrieval accuracy and coverage. Hierarchical and heterogeneous designs disentangle different semantic roles (e.g., episodic vs. semantic, factual vs. subjective), reducing retrieval noise and enabling more comprehensive context construction. Moreover, structural components such as adaptive edge weights and multi-view subgraphs allow memory organization to be optimized for downstream tasks, prioritizing the most relevant information during retrieval. As a result, dynamic graphs serve not only as evolving memory stores but also as task-aware retrieval scaffolds that co-adapt with agent objectives.

6. Open Problems and Future Directions

Despite recent progress, the integration of large language models and dynamic graphs remains at an early stage. Existing approaches are often tailored to specific tasks and rely on loosely coupled or heuristic integration strategies. As a result, there is a lack of unified modeling principles, scalable system designs, and evaluation protocols that explicitly account for temporal and relational structure. Addressing these limitations requires moving toward more principled, generalizable, and theoretically grounded frameworks. We outline several key research directions below.

Temporal Grounding and Faithfulness A fundamental challenge is that current LLM–dynamic graph systems do not explicitly enforce temporal consistency, often relying on implicit correlations rather than structured temporal reasoning. This can lead to errors such as using future information, violating causal order, or generating inconsistent event sequences. A key research direction is therefore to develop methods that make temporal reasoning both explicit and verifiable. In particular, this requires addressing three related issues: (i) formal temporal faithfulness, by defining clear constraints such as causal ordering, timestamp validity, and consistency between predicted events and historical interactions; (ii) time-aware retrieval guarantees, by ensuring that graph-supported retrieval uses only temporally valid evidence and avoids information leakage; and (iii) diagnostics for temporal hallucination, by designing benchmarks that explicitly detect inconsistent timelines, incorrect state transitions, and fabricated historical relations rather than relying only on predictive accuracy.

Unified Representation Design LLMs and dynamic graphs operate on fundamentally different representations: LLMs process sequence-based tokens, whereas dynamic graphs encode structured temporal relations. Current integration methods often rely on ad hoc conversions, such as graph serialization or embedding injection, which may discard structural information or weaken temporal dependencies. A central challenge is therefore to design unified interfaces that bridge these two paradigms while preserving both structural and temporal information. In particular, this requires addressing three related issues: (i) structure-preserving interfaces, so that graph connectivity and relational inductive biases are retained while remaining compatible with LLM processing; (ii) adaptive temporal compression, so that long interaction histories can be summarized without relying on fixed truncation heuristics that discard important dependencies; and (iii) cross-modal temporal alignment, so that text, graph structure, and multimodal signals evolving at different rates can be integrated without introducing representation drift. Addressing these issues is essential for building LLM–dynamic graph systems that are both expressive and temporally faithful.

Evaluation Beyond Predictive Accuracy Most current evaluations focus on downstream task performance, which does not fully reflect whether models correctly capture temporal and relational dynamics. This creates a gap between empirical performance and actual reasoning quality. A more complete evaluation framework should therefore consider three complementary directions: (i) temporal consistency metrics, which measure whether models preserve entity identity, respect temporal ordering, and avoid invalid interactions; (ii) continual update evaluation, which tests whether models can incorporate new information over time without corrupting prior knowledge; and (iii) realism in dynamic graph generation, which assesses whether generated graphs exhibit long-term temporal coherence, plausible trajectories, and realistic structural evolution beyond static graph statistics.

Scalable Memory and Continual Adaptation When dynamic graphs are used as external memory for LLMs, new system-level challenges arise as the memory grows over time. Current designs often struggle with scalability, maintenance, and long-term consistency. Addressing this requires progress along three related directions: (i) continual growth and forgetting, so that outdated information can be selectively removed without losing temporal traceability; (ii) learning-based memory management, so that memory organization and updates are guided by adaptive policies rather than fixed heuristics; and (iii) long-horizon stability, so that dynamic graph memory remains both consistent and efficient over extended periods of interaction.

Understanding When Dynamic Graphs Are Necessary Finally, it remains unclear when dynamic graph representations provide significant advantages over simpler alternatives such as vector retrieval or prompt-based reasoning. This lack of understanding limits principled system design. A clearer characterization is needed along three related directions: (i) the boundary between graph and vector retrieval, to determine when relational temporal modeling provides measurable benefits over non-graph approaches; (ii) failure mode analysis, to identify scenarios where LLMs fail without structured temporal representations; and (iii) cost–benefit tradeoffs, to quantify when the additional complexity of maintaining dynamic graph structures leads to meaningful improvements in performance or robustness. Overall, progress in this area will depend on moving beyond isolated hybrid architectures toward principled approaches that ensure temporally grounded reasoning, scalable integration, and reliable evaluation in evolving relational environments.

Temporal Graph-Augmented LLMs Although recent studies have shown the value of temporal graphs for improving time-aware retrieval and reasoning in LLMs, several important challenges remain open. In particular, future progress depends on addressing at least two related directions: (i) integration of heterogeneous temporal knowledge sources, since document-driven temporal graphs and curated temporal knowledge graphs provide complementary coverage and granularity, yet aligning their representations, resolving conflicts, and reasoning jointly across them remain largely unexplored; and (ii) continual and online temporal graph updates, since real-world knowledge evolves continuously while most existing methods still assume static or periodically rebuilt temporal graphs. Supporting efficient online updates without destabilizing retrieval quality or reasoning consistency is essential for enabling LLM systems to reason reliably over up-to-date and evolving knowledge.

Dynamic Graph-Assisted Agent Memory Although dynamic graph-assisted agent memory has shown strong empirical benefits, several challenges remain. Future research is likely to depend on progress along three related directions: (i) task-adaptive graph construction and reconfiguration, so that memory structure can adjust to different objectives rather than relying on fixed graph designs; (ii) efficiency, scalability, and robustness, so that dynamic graph memory can support long interaction histories with low latency, bounded resources, and resilience to noisy or adversarial inputs; and (iii) integration with broader agent learning paradigms, so that memory graphs are not treated as isolated components but are jointly optimized with planning, test-time adaptation, and multi-agent coordination.

7. Conclusion

In this survey, we systematically reviewed the intersection of large language models and dynamic graphs through a unified bidirectional perspective. We organized existing work into two complementary directions: LLMs for Dynamic Graphs and Dynamic Graphs for LLMs, and further structured the first direction into three functional roles of LLMs, namely time-aware semantic augmentation, temporal reasoning over graph evolution, and dynamic scenario simulation. Based on this taxonomy, we synthesized representative methods, clarified their underlying design patterns, and highlighted how LLM capabilities are integrated at different stages of dynamic graph learning. We also summarized how dynamic graphs can be used as structured temporal memory and retrieval backbones for LLM-based systems. Overall, this survey provides a structured view of the design space, identifies common modeling principles across seemingly diverse approaches, and outlines key challenges that remain open for future research.