DevoTG: Temporal Graphs in Neural Development

• DevoTG is a temporal graph framework that integrates continuous-time and discrete-time dynamic graphs to capture the evolving neural development of C. elegans.
• It employs Temporal Graph Neural Networks with memory modules to update node states based on developmental events, significantly improving lineage prediction accuracy.
• The framework provides detailed connectomic analysis by classifying connections into stable, developmental, and variable, and supports interactive 3D visualizations of network evolution.

DevoTG, short for “Developmental Temporal Graph,” is a temporal graph learning and analysis framework for modeling C. elegans neural development using Temporal Graph Neural Networks (TGNs) together with dynamic graph representations of developmental data. It combines a Continuous-Time Dynamic Graph (CTDG) built from cell lineage and cell division events with a Discrete-Time Dynamic Graph (DTDG) built from developmental connectome snapshots, thereby treating development as a sequence of biologically ordered events rather than as a single static wiring diagram (Gayen et al., 20 Jun 2026).

1. Conceptual scope and motivation

DevoTG addresses a central problem in developmental neuroscience: how to computationally model the emergence of the C. elegans nervous system from developmental history and connectomic measurements (Gayen et al., 20 Jun 2026). The framework is built around two complementary biological structures. The first is cell lineage data, which records who divided from whom, when, and where. The second is connectome data, which records synaptic connectivity at multiple developmental stages. The framework’s central premise is that development is inherently dynamic: cells divide at specific times, developmental fate depends on lineage history, and synaptic connections appear, strengthen, persist, or disappear across larval stages.

A defining claim of the framework is that static graph methods are inadequate for this setting because they discard temporal ordering, accumulated developmental history, the distinction between early and late interactions, and the evolution of connectivity across time (Gayen et al., 20 Jun 2026). In DevoTG, these missing elements are handled by TGNs that maintain node memories over a stream of timestamped events. This aligns the model’s inductive bias with developmental biology: each event updates the latent state of participating nodes, and future predictions depend on the accumulated state rather than only the current neighborhood.

The framework makes four principal contributions in the source paper. It introduces an integrated pipeline combining a CTDG for lineage and a DTDG for connectomics; applies TGN-based temporal link prediction to C. elegans cell lineage; analyzes developmental connectome changes using a three-class stability taxonomy; and provides interactive visualizations including 3D temporal network animations, centrality heatmaps, circuit-level views, and a spatiotemporal lineage graph (Gayen et al., 20 Jun 2026). The strongest quantitative result is that the TGN achieves test AUC $0.839 \pm 0.007$ on lineage prediction, compared with $0.577 \pm 0.080$ for a static GNN of otherwise identical architecture, which the authors interpret as evidence that temporal memory is the decisive factor.

2. Dynamic graph representations of development

DevoTG uses two graph formalisms, one continuous-time and one discrete-time, to represent complementary aspects of neural development (Gayen et al., 20 Jun 2026).

The CTDG models the developmental lineage as an event graph

$\mathcal{G} = (V, E, \mathcal{T}),$

where $V$ is the set of cell states, $E$ is the set of division events, and $\mathcal{T} \subseteq \mathbb{R}_{+}$ is the set of event times. Each node corresponds to a cell state. Each biological division event becomes two directed edges, parent $\rightarrow$ daughter 1 and parent $\rightarrow$ daughter 2, and each edge is timestamped by the daughter’s birth time in minutes post-fertilization. Node features are vectors

$\mathbf{x}_i \in \mathbb{R}^{172},$

encoding 3D position, birth time, generation depth, and zero-padding. Edge features are

$\mathbf{m}_{ij} \in \mathbb{R}^{172},$

encoding the spatial displacement between parent and daughter centroids. The lineage dataset contains 642 division events, 1,203 unique cell states, birth times from 0 to $0.577 \pm 0.080$0 minutes, and developmental coverage from the zygote (P0) through roughly five generations of division. Because each division yields two edges, the CTDG contains 1,203 nodes and 1,284 events (Gayen et al., 20 Jun 2026).

The DTDG models the developing synaptic connectome as

$0.577 \pm 0.080$1

with a common node set $0.577 \pm 0.080$2 and eight developmental snapshots (Gayen et al., 20 Jun 2026). The processed node set covers 225 nodes across all timepoints, consisting of sensory, interneuron, motor, muscle, modulatory, glia, and unknown classes. The paper refers to these as “225 neurons across all timepoints,” while also listing non-neuronal classes such as muscle and glia; this is how the source presents the processed node set. Edges represent chemical synapses and gap junctions, and a connection is retained if it has at least one synapse. Edge weights $0.577 \pm 0.080$3 are synapse counts.

The eight reconstructed datasets correspond to L1 larvae at 0 h, 5 h, 8 h, and 16 h post-hatching; L2 at 23 h; L3 at 27 h; and two young-adult datasets at 45 h (Gayen et al., 20 Jun 2026). Across these snapshots, the connectome grows from 858 edges and 1,400 synapses at L1 birth to 2,496 edges and 8,400 synapses in adulthood. The strongest edge-count increase occurs during the L1 $0.577 \pm 0.080$4 L2 transition, from 858 to 1,807 edges, described in the paper as a 110% increase. Chemical synapses increase monotonically, whereas electrical connections follow a more irregular trajectory and peak at L1 16 h before plateauing.

3. TGN architecture and computational formulation

The predictive component of DevoTG follows the TGN formulation of Rossi et al. and is implemented in PyTorch Geometric (Gayen et al., 20 Jun 2026). It uses three modules: a memory module, a graph attention embedding module, and a link predictor. The paper is explicit that DevoTG does not introduce a new TGN architecture from scratch; the methodological novelty lies instead in the biological event formulation, the feature design, the temporal prediction setup, and the connectome-scale downstream analysis.

Each node $0.577 \pm 0.080$5 maintains a memory vector

$0.577 \pm 0.080$6

When node $0.577 \pm 0.080$7 participates in a division event, its memory is updated by a GRU: $0.577 \pm 0.080$8 where $0.577 \pm 0.080$9 is the time encoding dimension, $\mathcal{G} = (V, E, \mathcal{T}),$0 is a learned time encoding, and $\mathcal{G} = (V, E, \mathcal{T}),$1 denotes concatenation (Gayen et al., 20 Jun 2026). The message function is IdentityMessage and the aggregation function is LastAggregator, meaning the model retains the most recent message. The memory module has 103,200 trainable parameters.

Given memory states, node embeddings are computed through temporal neighborhood aggregation with TransformerConv: $\mathcal{G} = (V, E, \mathcal{T}),$2 where $\mathcal{G} = (V, E, \mathcal{T}),$3 is the relative time between node $\mathcal{G} = (V, E, \mathcal{T}),$4’s last event and event $\mathcal{G} = (V, E, \mathcal{T}),$5 (Gayen et al., 20 Jun 2026). The TransformerConv layer uses 2 attention heads, input dimension 100, output dimension 100, and dropout 0.1.

For a candidate edge $\mathcal{G} = (V, E, \mathcal{T}),$6, the link predictor computes

$\mathcal{G} = (V, E, \mathcal{T}),$7

with $\mathcal{G} = (V, E, \mathcal{T}),$8 and $\mathcal{G} = (V, E, \mathcal{T}),$9 (Gayen et al., 20 Jun 2026). This yields a scalar score for whether a parent-to-daughter division edge should exist.

Training uses Adam with learning rate 0.001 and BCEWithLogitsLoss, with positive edges defined as observed future division events and negative edges defined as randomly sampled non-edges at a 1:1 ratio (Gayen et al., 20 Jun 2026). Other reported hyperparameters are batch size 200, 20 epochs, 10 temporal neighbors per node using LastNeighborLoader, and total trainable parameters 132,501. Training was run on an NVIDIA GeForce GTX 1650, 4 GB GDDR5, with runtime of $V$0 s per seed for 20 epochs.

4. Lineage prediction task and quantitative performance

The CTDG supports a temporal link prediction task in which the model must predict whether a candidate directed edge $V$1 corresponding to a parent-to-daughter division event will occur, given the event history up to time $V$2 (Gayen et al., 20 Jun 2026). The split is temporal rather than random: 70% training, 15% validation, and 15% test, ordered by event time so that validation and test contain strictly future events. This makes the evaluation a forecasting problem rather than interpolation.

Performance is reported using AUC and Average Precision over 5 independent random seeds, with checkpoint selection based on validation AUC (Gayen et al., 20 Jun 2026). The benchmark table in the paper reports four models.

Model	Test AUC	Test AP
Random baseline	$V$3	$V$4
Degree heuristic (PA)	$V$5	$V$6
Static GNN (GAT, no memory)	$V$7	$V$8
DevoTG TGN	$V$9	$E$0

The TGN also achieves validation AUC

$E$1

The source paper describes the improvement over the static GNN as “26 AUC points,” corresponding to an absolute difference of about $E$2 (Gayen et al., 20 Jun 2026). The paper interprets this as evidence that temporal memory, rather than graph attention alone, is the crucial ingredient for developmental event prediction.

The baseline comparison is designed to isolate temporal memory. The static GNN uses the same link prediction head and a similar graph attention structure, but no temporal memory. It is trained on a static adjacency matrix built from all training events. Appendix B specifies two GATConv layers, with layer 1 mapping $E$3 per head with 2 heads and concatenated output 100, and layer 2 mapping 100 $E$4 100 with 1 head, ELU activations, and dropout 0.1 (Gayen et al., 20 Jun 2026). The contrast is therefore between accumulated static structure and event-driven temporal memory. The authors’ interpretation is that development depends on lineage history, not just on current graph structure. A plausible implication is that two cells with similar local topology may nonetheless require distinct predictions if they reached that neighborhood through different temporal sequences.

5. Developmental connectome analysis and biological findings

The DTDG component is used primarily for descriptive temporal graph analysis rather than supervised forecasting (Gayen et al., 20 Jun 2026). The paper does not train a TGN to predict synapse formation on the DTDG. Instead, it performs connection stability classification, topology analysis across snapshots, centrality tracking, and circuit-level analysis of command interneurons.

Each unique connection triplet $E$5 across the eight timepoints is assigned to one of three stability classes based on temporal persistence (Gayen et al., 20 Jun 2026).

Stability class	Definition	Count / share
Stable	present in $E$6 of 8 timepoints	650 / 15.1%
Developmental	present in 2–5 timepoints	1,207 / 28.1%
Variable	present in exactly 1 timepoint	2,440 / 56.8%

The paper interprets stable connections as the persistent core architecture of the nervous system, developmental connections as transitional or scaffolding structure during larval maturation, and variable connections as highly transient links that may reflect both weak or transient biology and measurement variability (Gayen et al., 20 Jun 2026). The authors note that many variable connections are weight-1 edges near the detection threshold. They explicitly frame this taxonomy as complementary to Witvliet et al.’s classification: Witvliet et al. classify connections by variability across isogenic individuals, whereas DevoTG classifies them by persistence across developmental timepoints.

A detailed biological analysis focuses on six command interneurons: AVAL/AVAR, AVBL/AVBR, and AVEL/AVER (Gayen et al., 20 Jun 2026). The reported findings are that the core command circuitry is already present at birth, adult stages show many more direct neighbors, the integration roles of these interneurons are progressively reinforced, and AVE neurons add the most connections between L1 and adult. The paper further states that AVAL/AVAR are especially prominent in betweenness centrality, even though Appendix C lists top adult degree-centrality neurons as RIML, AIBL, AIBR, AVEL, and RMDL. The text therefore suggests that the importance of AVAL/AVAR is better captured by betweenness and integration role than by raw degree ranking.

In the adult connectome, the top five nodes by degree centrality, averaged across the two adult datasets, are RIML (0.252), AIBL (0.252), AIBR (0.243), AVEL (0.239), and RMDL (0.234), all interneurons (Gayen et al., 20 Jun 2026). This supports the interpretation that interneurons act as hub integrators. The paper’s broader developmental interpretation is that hub-like integration roles strengthen over time and that chemical synaptogenesis is the main driver of connectome maturation.

6. Visualization, interpretation, and limitations

A notable feature of DevoTG is its emphasis on visual analytics as an integral component of developmental interpretation (Gayen et al., 20 Jun 2026). The framework includes 3D animated network visualizations, centrality heatmaps, and a spatiotemporal lineage graph. In the 3D animated connectome views, timepoints are stacked along the $E$7-axis, within-layer edges are shown in gray, newly appearing connections between adjacent timepoints are shown as orange dashed edges, and nodes are colored by temporal stability class: blue for stable, salmon for developmental, and gray for variable. These views are intended to make topological change visually explicit.

The spatiotemporal lineage visualization includes a lineage tree for the first five generations of division, nodes colored by birth time, node size proportional to number of descendants, and a spatial scatter plot of all 642 parent cell birth positions, also colored by birth time (Gayen et al., 20 Jun 2026). The visualizations show canonical binary branching, faster division in the AB lineage than the P lineage, and an inside-out embryogenic pattern in which early births cluster centrally and later births spread toward the periphery. The centrality heatmaps track node importance across developmental time, although the paper does not provide a complete mathematical specification of the heatmap construction beyond stating that centrality metrics are tracked across all eight snapshots.

The framework is open-source and designed for extension to other developing nervous systems (Gayen et al., 20 Jun 2026). The paper reports code availability at https://github.com/DevoLearn/DevoGraph/tree/main/DevoTG, and the appendix lists an updated maintained version at https://github.com/Jayadratha/DevoTG_GSoC, branch research. The software stack includes Python 3.12, PyTorch 2.5.1, and PyTorch Geometric 2.6.1.

The paper also identifies several limitations. The TGN is trained only on lineage events, not directly on connectome formation. The threshold defining stable connections as present in 6 of 8 timepoints is fixed and should be sensitivity-tested. Gap junctions are treated equivalently to chemical synapses, despite their different biophysical and developmental properties. The connectome analysis is limited by the availability of only eight timepoints. The authors additionally note that many variable connections are weak single-synapse edges near detection threshold, which introduces potential measurement or annotation variability (Gayen et al., 20 Jun 2026). Finally, the framework has been demonstrated only for C. elegans. The paper proposes future directions including training TGN directly on the connectome DTDG to predict synapse formation between timepoints, integrating multiple animals per timepoint to model both temporal and inter-individual variability, analyzing gap junctions separately from chemical synapses, and extending the approach to comparative developmental connectomics across species.

Taken together, these elements define DevoTG as both a predictive temporal graph framework for lineage and a descriptive temporal graph framework for connectomics. Its central technical claim is that developmental history must be modeled as temporally ordered structure rather than collapsed into static graphs, and its central biological contribution is a temporally grounded view of how a persistent core architecture and increasingly reinforced hub circuitry emerge across C. elegans development (Gayen et al., 20 Jun 2026).