Are Graph Foundation Models Actually Foundation Models?

13 July, 2026

For the last few months, every third graph paper I opened seemed to contain the phrase foundation model. Sometimes it meant a GNN trained on many datasets, sometimes an LLM taught to read graphs as text, and sometimes a very large graph transformer. All of these can be useful. But after a point I started wondering whether the phrase described a real new paradigm or was simply doing unpaid marketing work for graph learning.

The problem is that graphs make the dream unusually slippery. Language models inherit a shared alphabet. Vision models inherit pixels and patches. A molecule and an Instagram network may both be written as \(G=(V,E)\), but an atom feature is not a user feature, a chemical bond is not a follow edge, and their labels arise from completely different worlds.

So this blog is me trying to answer one question properly: what must a graph model do before we call it a foundation model? I will move from prompting and in-context learning to feature-invariant models, structural vocabularies, synthetic graph priors, and billion-parameter graph transformers. Then comes the awkward evidence: a June 2026 reevaluation found that most recent GFMs for node prediction still lose to properly tuned GNNs, with the main exceptions coming from prior-data fitted networks [11].

My answer is this: some GFMs are already foundation models, but only after we state the universe they are foundational for. A model may be foundational for molecules, knowledge-graph reasoning, or node classification across arbitrary feature spaces without being the graph equivalent of GPT. The dangerous part is not the term. It is silently changing its scope.

First, what does “foundation model” even mean?

The modern use of the term comes from the Stanford report by Bommasani and many others [1]. Their definition is broad but not meaningless: a foundation model is trained on broad data at scale and can be adapted to a wide range of downstream tasks. The word foundation was chosen because the model is not a finished application. It becomes a base on top of which many applications are built.

That definition contains three separate promises that often get mixed together. There is breadth of pretraining, meaning the model has seen enough varied data to learn reusable regularities. There is breadth of adaptation, meaning the same backbone can support many tasks. And there is adaptation efficiency, meaning we do not have to train an equally expensive model from scratch every time the world changes.

We can write the dream in a very boring mathematical way. Let \(\mathcal{D}_{\text{pre}}\) be a broad collection of pretraining datasets and tasks. We first learn shared parameters:

\[ \theta^* = \arg\min_{\theta} \mathbb{E}_{(D,\tau)\sim\mathcal{D}_{\text{pre}}} \left[\mathcal{L}_{\tau}(f_{\theta};D)\right]. \]

Then, for a new task \(\tau'\) with a small amount of task data \(D_{\tau'}\), an adaptation mechanism \(A\) produces a useful predictor:

\[ f_{\tau'} = A(\theta^*, D_{\tau'}). \]

In an ordinary one-model-per-dataset pipeline, almost all useful intelligence is learned inside \(D_{\tau'}\). In a foundation-model pipeline, a meaningful fraction of the intelligence is already inside \(\theta^*\). The adaptation data tells the model what we want, not how the entire world works from zero.

This gives us a useful first test. If a model is pretrained on one citation graph and then evaluated on a held-out set of nodes from that same citation graph, it may be an excellent GNN, but it is not doing the important foundation-model trick. If it moves to a new graph with new labels and needs only a small head, a prompt, a demonstration set, or one forward pass, now the claim becomes interesting.

The foundation-ness ladder

A lot of confusion disappears if we stop treating foundation-ness as binary. Graph transfer has levels. Moving from train nodes to test nodes inside one graph is not the same achievement as moving from a social network to a molecular graph. A model can pass one level and fail the next.

Most classic GNNs are comfortable around level one and sometimes level two. GraphSAGE is inductive in the traditional sense: the learned neighborhood aggregator can be applied to unseen nodes or graphs, as long as the feature semantics and task remain compatible. But if the training graph has 128-dimensional paper embeddings and the test graph has 17 continuous road features, the first learned weight matrix itself no longer fits:

\[ X_A\in\mathbb{R}^{n_A\times 128}, \qquad X_B\in\mathbb{R}^{n_B\times 17}. \]

The issue is not only that the dimensions differ. Dimension seven in \(X_A\) may represent a latent topic. Dimension seven in \(X_B\) may represent average road speed. A universal graph encoder cannot assume that columns have stable meanings. It must either align them, ignore their identities, translate them through another modality, or learn an inference procedure that treats the entire feature table as context.

Labels are equally annoying. One graph may have three classes, another may have forty, and class index two means nothing across them. The model must be invariant to label permutations. If I rename “fraud” from class zero to class one, the answer should rename itself, not collapse. This is why fully inductive graph models care about feature permutation, label permutation, and changing dimensionality in a way ordinary GNN papers rarely had to.

Why molecules and knowledge graphs got there first

Some graph domains have a secret advantage: they already contain a shared vocabulary. Molecular graphs are the cleanest example. Carbon in one molecule is still carbon in another. Bonds have stable physical meaning. A model pretrained over millions of molecules does not have to ask what a node is every morning. It can learn reusable chemical structure because the alphabet survives across datasets.

Knowledge graphs have a weaker but still useful version of this. Entity identities and relation names may change, but the task often has a stable form: infer a missing head, tail, or relation from triples. Models such as ULTRA learn transferable relation-level reasoning patterns and can perform zero-shot link prediction on knowledge graphs with unseen entity and relation vocabularies [15]. The words change; the logical shape of the problem stays recognisable.

This is why a domain-specific foundation model is not a contradiction. A biomedical foundation model can be foundational across proteins, molecules, assays, and property-prediction tasks while remaining useless for a friendship network. The term should describe breadth relative to a meaningful universe, not mystical universality over every adjacency matrix humanity can generate.

The trouble begins when evidence from these friendly domains is used to imply universal graph intelligence. A molecule graph, a road network, and a recommender graph differ in much more than size. Their edges encode different mechanisms. Their labels arise from different causal processes. Their useful symmetries differ. A model transferring inside chemistry has learned something broad and valuable, but it has not automatically discovered the grammar of all relations.

Route one: turn every task into the same graph-shaped question

One major line of work attacks task heterogeneity. Node classification, edge classification, and graph classification appear to require different output heads. Prompt-based GFMs try to rewrite them into one common interface.

PRODIGY was an early important example [4]. It constructs an in-context graph containing query instances and demonstrations, allowing a pretrained model to handle new graph classification tasks on unseen graphs without parameter updates. The analogy to language-model prompting is direct: instead of changing the model, show it examples of the new task inside the input.

One For All, or OFA, pushes the unification idea further [5]. It represents node-, edge-, and graph-level classification through prompted subgraphs and uses text-attributed nodes to align features and labels across domains. A class label is no longer merely integer four. It can be a textual class node with semantic meaning. This creates a common interface because text becomes the bridge between incompatible graph datasets.

GOFA then combines graph encoding with generative language modeling [6]. Instead of restricting the model to a fixed classification head, it asks for three attractive properties: self-supervised pretraining, fluid movement across tasks, and graph awareness. A graph encoder preserves topology; an LLM decoder gives a flexible task language. In principle, this lets the same model answer graph questions, classify objects, and generate explanations.

Serializing topology into text also creates its own mess. A graph does not have one canonical reading order. Long adjacency lists are expensive. Multi-hop relations can disappear inside a linear prompt. An LLM may know the meanings of node descriptions but still struggle to execute precise graph algorithms. So LLM-based GFMs are often strongest when semantic text is central and the graph is a supporting structure, not when raw topology is the whole problem.

Route two: make the model indifferent to feature and label identities

GraphAny takes almost the opposite approach [7]. Instead of translating arbitrary graphs into natural language, it designs an inference rule that can operate when feature dimensions and label classes change. It treats node classification on a new graph as a closed-form linear problem over several graph propagations, then learns how to combine those candidate solutions.

A simplified version looks like this. Start with several graph operators \(S_k\): perhaps no propagation, one-step smoothing, two-step smoothing, or other linear graph filters. Each operator produces a view:

\[ Z_k = S_k X. \]

Using the labeled nodes \(L\), solve a regularized linear classifier analytically:

\[ W_k^* = (Z_{k,L}^{\top}Z_{k,L}+\lambda I)^{-1} Z_{k,L}^{\top}Y_L. \]

Each operator gives a candidate prediction \(\hat{Y}_k=Z_kW_k^*\). GraphAny then learns an attention rule that mixes these predictions per node. Crucially, the attention is built from entropy-normalized distances between predictions rather than raw feature coordinates or fixed class identities. This makes the learned combination robust to changing feature dimensions and label permutations.

I find this conceptually beautiful because the pretrained object is not a universal representation of every node. It is a reusable strategy for choosing graph computations. The model learns something like: when the candidate predictions look this uncertain and disagree in this pattern, trust this amount of smoothing. That strategy can survive when the input columns and class names change.

But the same elegance exposes the limitation. If all candidate experts are simple linear graph filters, then the foundation model cannot magically express a function outside that basis. The original GraphAny paper itself notes limited expressiveness as an open issue [7]. It can generalize broadly across feature spaces, but its computation vocabulary is fixed.

AnyGraph uses a different mechanism: a graph mixture-of-experts and lightweight routing to handle structural and feature distribution shifts across dozens of datasets [8]. Again, the core idea is not one monolithic universal transformation. It is a reusable router that chooses among specialised graph experts. This may be a clue. The graph equivalent of a foundation model might look less like one homogeneous transformer and more like a system that composes the right graph operator for the current dataset.

Route three: invent a graph vocabulary

Language models transfer because words and subwords recur. Vision models transfer because edges, textures, shapes, and object parts recur. What is the graph version of a reusable token?

GFT proposes computation trees [9]. When a message-passing GNN updates a node, the node receives a tree-shaped unfolding of its neighborhood. Different original graphs can produce similar computation trees even if their global identities and domains are unrelated. GFT treats these trees as entries in a transferable structural vocabulary, pretrains by reconstructing them, and adapts the learned vocabulary across tasks and domains.

This is a clever shift. Instead of asking whether a football player and a carbon atom share semantics, ask whether the local relation pattern around them shares a computational shape. A central node connected to two dense communities, a bridge between clusters, a hub with many leaves, or a repeated cycle can occur in wildly different domains. Structure is the candidate common language.

The hard question is whether structural similarity implies transferable predictive meaning. A star motif in a social network may indicate an influencer. A star motif in a transaction graph may indicate a merchant or a fraud mule. A star motif in a molecule may indicate a particular chemical arrangement. The structure recurs, but the label mechanism may invert. Transferable vocabulary is necessary; it is not sufficient.

This is where negative transfer enters. If a model confidently imports the wrong meaning of a motif, pretraining can make it worse than starting fresh. A serious GFM must know not only what patterns repeat, but when the interpretation of those patterns has changed.

Route four: learn to solve datasets, not just examples

The most convincing recent progress comes from prior-data fitted networks, or PFNs. Instead of pretraining on one enormous natural dataset, they generate many synthetic datasets from a broad prior over possible data-generating processes. The transformer receives an entire labeled dataset as context and learns to predict missing labels. One forward pass approximates inference under the learned synthetic prior.

For graphs, the model is trying to learn:

\[ p(Y_U\mid G,X,Y_L) \approx f_{\theta}(G,X,Y_L), \]

where \(L\) is the set of labeled nodes and \(U\) the unlabeled nodes. The model is not given a fixed classifier head for “seven classes from Cora.” It sees the features, graph, and currently available labels together, then infers the target rule in context.

GraphPFN builds a synthetic prior over attributed graph datasets [10]. It samples graph structure using combinations of stochastic block models and preferential attachment, then uses graph-aware structural causal models to generate node attributes and targets. The network is exposed during pretraining to many possible relationships among topology, features, and labels. At test time, a real graph becomes one more dataset-level inference problem.

The June 2026 fair evaluation is important because it compared nine recent GFMs against strongly tuned GNNs under one protocol [11]. The results split the field into two groups. Non-PFN graph foundation models consistently underperformed the tuned GNN baselines on the considered node-property datasets. PFN-based methods, especially GraphPFN, were the ones that usually won. Fine-tuned GraphPFN was reported as the best overall model across all evaluated datasets.

There is a cost. GNN inference is usually fast after training. PFNs inspect the dataset in context and can use inference-time ensembling. In the reevaluation, GNN inference was typically below a second, while PFN-based GFMs could take seconds to minutes, with some configurations much longer [11]. Foundation models shift cost around. They reduce task-specific model development and hyperparameter search, but they do not make computation disappear.

Route five: scale the graph model until laws appear

GraphBFF is the most literal attempt to bring the language-model scaling story to general industrial graphs [12]. The work presents a 1.4-billion-parameter heterogeneous graph transformer pretrained on one billion graph samples. It introduces a full recipe for sampling, batching, pretraining, extending to new feature and node types, probing, and fine-tuning. More importantly, it reports the first neural scaling-law study over general heterogeneous graphs.

The familiar form is:

\[ L(N,D)=L_{\infty}+\frac{A}{N^{\alpha}}+ \frac{B}{D^{\beta}}, \]

where \(N\) is model size and \(D\) is training data size. If data is fixed, making the model larger eventually saturates. If model size is fixed, adding more data eventually saturates. Loss keeps falling predictably when both scale together. This is exactly the kind of evidence that made foundation-model scaling feel like a paradigm rather than a collection of lucky pretrained checkpoints.

GraphBFF is evaluated on ten unseen real-world downstream graph tasks spanning node- and link-level classification and regression. Frozen representations with simple probes outperform task-specific baselines across the ten tasks, sometimes by very large margins. The paper also evaluates few-shot probing and zero-shot link prediction. This is serious evidence that large-scale heterogeneous graph pretraining can create reusable representations [12].

But there are caveats. The pretraining data is proprietary and cannot be released. The tasks come from a large industrial graph universe whose node types, relations, and semantics may share hidden regularities. This does not weaken the industrial result, but it narrows what we can conclude. A model can be foundational across a company’s connected ecosystem without being foundational across molecules, football, roads, and arbitrary scientific graphs.

The vocabulary problem is only half the problem

Suppose we solve feature alignment. We can accept arbitrary column counts, map text to a common space, or use a PFN to infer feature meaning from examples. Suppose we also solve label alignment. Are we done?

No, because the correct graph algorithm can change across tasks. Consider a two-layer message-passing GNN:

\[ H^{(\ell+1)}=\sigma(\tilde{A}H^{(\ell)}W^{(\ell)}). \]

After two layers, a node representation mainly depends on a two-hop neighborhood. This may be perfect for local homophily. It may be fundamentally wrong for a task that needs information from twenty hops away, a high-pass filter, exact counting, long cycles, or global connectivity. Pretraining does not remove the receptive-field limit.

A 2026 paper asks this directly: can graph foundation models generalize over architecture? [13] Its criticism is that models such as GraphAny may be tested across many datasets but still use a fixed basis of short-range message-passing operators. The benchmark diversity looks broad in domain, graph size, feature count, and homophily, yet the underlying tasks may all be solvable by similar local architectures. The model therefore appears universal partly because the evaluation never asks it to change its computational personality.

The proposed GOBLIN framework discovers and mixes task-specific linear graph operators at inference time. The broad lesson matters more than the particular method: a true universal GFM may need to infer how to compute on the graph, not only how to map its final embedding to labels.

This reminds me of model selection in classical machine learning. We would never expect one fixed kernel bandwidth to work for every dataset merely because the final classifier is adaptable. Graph depth, propagation direction, frequency response, positional encoding, and global attention are all graph equivalents of architectural assumptions. A foundation model that freezes them forever is foundational only over tasks compatible with those assumptions.

So what did the fair evaluation actually expose?

The 2026 reevaluation did not prove that GFMs are fake [11]. It exposed that papers had been comparing different adaptation budgets, datasets, definitions of zero-shot inference, and baseline strength. Under one stronger protocol, most non-PFN methods failed to beat tuned GraphSAGE, GCN, GAT, and related models.

A foundation model deserves a harder comparison because it spends more resources before the downstream task begins. The relevant question is not merely:

\[ \text{Does GFM accuracy} > \text{one default GCN accuracy}? \]

It is closer to:

\[ \frac{ ext{quality across unseen tasks}} { ext{pretraining cost}+ ext{adaptation cost}+ ext{inference cost}} > \frac{ ext{quality of strong task-specific development}} { ext{training and tuning cost}}. \]

That ratio changes by application. In a research benchmark with one fixed dataset, training a good GNN may be easier. In an industrial platform receiving hundreds of new graph tasks, a pretrained model that works immediately may save enormous engineering time even if each inference is slower. Foundation models are partly an economic claim about reuse.

My test for whether a GFM is actually foundational

I do not think the field needs one police-approved definition. But every paper calling itself a GFM should report a clear scope card. I would want six things.

1. State the pretraining universe

What kinds of graphs were used? How many datasets, domains, node types, relation types, feature schemas, and task-generating processes? “Large-scale graph data” is not enough. One billion samples from one connected industrial universe can be deeper but less diverse than ten million samples from many unrelated graph families.

2. State exactly what is unseen

Are test nodes unseen? Test graphs? Feature columns? Class counts? Domains? Task types? Relation vocabularies? Architectures? The word unseen should be followed by a noun. Otherwise it is doing the same marketing job as foundation.

3. Separate probing, few-shot, fine-tuning and zero-shot

A frozen encoder with a trained linear probe is not zero-shot, but it is a valid and useful evaluation. In-context prediction using target labels as demonstrations is not supervision-free, but it may require no gradient updates. Full fine-tuning can still demonstrate good transfer, but it should not be presented as immediate adaptation. These regimes answer different questions.

4. Compare against serious target-specific baselines

Tune the GNN. Give it the same feature information. Report the search budget. Include simple methods such as label propagation or linear models when appropriate. A foundation model should win because pretraining transfers knowledge, not because the baseline was prevented from learning.

5. Count all the costs

Report pretraining compute, target adaptation time, hyperparameter search, inference latency, memory, and ensembling. A model that saves six hours of tuning but adds twenty minutes to every inference may be fantastic for one workflow and terrible for another.

6. Test negative transfer and failure boundaries

Give the model graphs from a domain where its assumptions break. Change homophily, feature noise, graph density, class imbalance, useful receptive field, and causal relationship between topology and labels. A foundation model should not only perform well when pretraining helps. It should reveal when its foundation is the wrong foundation.

I would summarise these into a completely unofficial score:

\[ \text{Foundation value} \propto \frac{ ext{breadth}\times\text{adaptation efficiency} \times\text{robustness}\times\text{baseline advantage}} { ext{pretraining}+ ext{adaptation}+ ext{inference cost}}. \]

This is not a benchmark metric. It is a sanity check. A model with enormous breadth but no advantage is not useful. A model with great accuracy but expensive retraining on every target is not behaving foundationally. A model with excellent average transfer but catastrophic negative transfer needs a reliable routing or uncertainty mechanism.

The most promising direction may be a layered system

After reading this literature, I no longer expect the graph GPT moment to be one gigantic homogeneous model that consumes every graph identically. Graphs are too varied. The more plausible system has layers.

At the bottom is a flexible graph interface. It handles arbitrary feature dimensions, missing text, multiple node and edge types, and changing graph sizes. Covariance-based feature operators such as All-In are one recent attempt: they build representations invariant in distribution to feature permutations and robust to dimensional mismatch [14]. PFN-style tokenization is another. Text encoders can be used when semantics are available, but they should not be mandatory.

Above that sits a vocabulary of structural operators: local smoothing, high-pass filters, long-range propagation, motifs, computation trees, paths, subgraphs, temporal transitions, and heterogeneous relations. Instead of fixing one architecture, a router chooses or composes the useful operators for the target problem.

Above that is dataset-level inference. Given labeled examples, the model infers what the columns, labels, and structural correlations mean. This is where PFNs are exciting. The task is not represented by a permanent output head; it is represented by context.

Language can then provide a task interface. It describes instructions, label semantics, domain constraints, and explanations. It should not be forced to encode every adjacency list itself. Graph structure and language can co-train while retaining separate strengths.

Finally, retrieval can bring relevant graph datasets, motifs, experts, or synthetic priors into context. When a new fraud graph arrives, the model should not rely equally on molecule and road experience. It should retrieve structurally and semantically related problems, adapt its operator mixture, and express uncertainty when no useful precedent exists.

What would this mean for the kinds of graphs I care about?

Take recommendation. A user-item graph is often bipartite, temporal, heterogeneous, and highly non-stationary. A GFM pretrained across many marketplaces could learn reusable ideas about exposure, popularity, long-tail items, repeated interaction, and two-sided matching. But moving from movie recommendation to dating or job matching changes the meaning of acceptance and the cost of a bad recommendation. Structural transfer helps; objective transfer can be dangerous.

Take football. A possession graph and a molecular graph may share local motifs, but nobody should expect a chemistry-pretrained label head to predict the next pass. The transferable part might be much lower-level: temporal interaction patterns, spatial neighborhoods, role-conditioned edges, bottlenecks, and long-range dependency operators. A graph foundation model for sport would probably be domain-specific, pretrained across leagues, teams, event providers, tracking schemas, and tasks such as next-event prediction, receiver prediction, possession value, and tactical classification.

That would still be a real foundation model. It would replace dozens of separately trained sports graph models with one adaptable backbone. The fact that it cannot classify proteins is irrelevant. Nobody rejects a language model because it cannot directly simulate fluid dynamics from a mesh.

Are graphs missing a GPT moment, or are we asking for the wrong moment?

GPT benefited from a remarkable fact: an enormous fraction of human tasks can be represented as sequences of tokens. Translation, summarisation, question answering, code, dialogue, classification, and even tool instructions all fit through one interface. The next-token objective is not identical to every downstream task, but it is close enough to absorb broad competence.

Graphs do not have one equally dominant task. Link prediction is not node regression. Molecular energy prediction is not community detection. A graph may be the input, the output, a memory, a constraint, or a changing environment. We may never get one objective as unreasonably effective as next-token prediction.

That does not mean graph foundation models fail. It may mean their success will look different. Instead of one universal graph model, we may get several foundation layers:

A molecular foundation model that learns physical and chemical structure. A knowledge-graph foundation model that learns transferable relational reasoning. A recommender foundation model that learns interaction dynamics. A general node-property PFN that adapts across arbitrary tables and topologies. A graph-language model that handles semantically described graphs. And an industrial heterogeneous-graph model pretrained over a company’s entire data universe.

My verdict on the current models

PRODIGY, OFA, and GOFA are foundational in how they unify tasks and use demonstrations, prompts, or language to adapt [4–6]. Their scope is strongest on graphs that can be placed into a meaningful common semantic interface.

GraphAny and AnyGraph are foundational in fully inductive node classification and feature-space adaptation [7,8]. They show that a learned graph inference strategy can survive changing dimensions and labels. Their weakness is that broad dataset transfer does not automatically imply broad computational transfer.

GFT is foundational in its attempt to define a reusable structural vocabulary [9]. Whether computation trees carry stable predictive meaning across the full diversity of graphs is still an open question, but the vocabulary problem is exactly the right problem.

GraphPFN is, to me, the strongest clean evidence for a general node-property foundation model right now [10,11]. It learns over synthetic graph tasks, adapts through context, beats tuned GNNs in a fair comparison, and handles changing feature and label spaces. It is slower at inference and scoped to node prediction, but the behaviour is genuinely foundational.

GraphBFF is the strongest evidence that scale can create reusable industrial graph representations and predictable graph scaling laws [12]. Its private data and bounded industrial universe make universal conclusions difficult, but a foundation model does not become fake because the foundation is built for a real ecosystem rather than a public benchmark.

Closing note

So, are graph foundation models actually foundation models?

Some of them, yes. But the honest sentence needs a few extra words. Foundation model for what graph universe, what tasks, what adaptation regime, and what kinds of change?

What we do not yet have is a model that can move from a molecule to a road network to a football possession, accept new features and labels, infer a task from a few examples, choose the right graph computation, and beat a tuned specialist at reasonable cost. That is the graph GPT fantasy. Current systems each solve a piece of it.

The field is progressing fastest when it stops copying the surface details of language models and attacks the graph-specific obstacles directly: no shared vocabulary, unstable feature spaces, changing labels, structural distribution shift, negative transfer, and architecture mismatch. PFNs treat the dataset as context. GFT searches for structural tokens. GraphAny learns feature- and label-invariant inference. GraphBFF tests whether scale behaves predictably. GOBLIN asks the backbone itself to adapt.

Until then, I am happy to keep the name, with one condition: every time we say “graph foundation model,” we should also say where the foundation ends.

References and links

1. Bommasani, R., Hudson, D. A., Adeli, E., et al. (2021). On the Opportunities and Risks of Foundation Models. arXiv:2108.07258.
2. Mao, H., Chen, Z., Tang, W., et al. (2024). Position: Graph Foundation Models Are Already Here. OpenReview.
3. Wang, Z., Liu, Z., Ma, T., et al. (2025). Graph Foundation Models: A Comprehensive Survey. arXiv:2505.15116.
4. Huang, Q., Ren, H., Chen, P., et al. (2023). PRODIGY: Enabling In-context Learning Over Graphs. NeurIPS 2023. OpenReview.
5. Liu, H., Feng, J., Kong, L., et al. (2024). One For All: Towards Training One Graph Model For All Classification Tasks. ICLR 2024. OpenReview.
6. Kong, L., Feng, J., Liu, H., et al. (2025). GOFA: A Generative One-For-All Model for Joint Graph Language Modeling. ICLR 2025. OpenReview.
7. Zhao, J., Mostafa, H., Galkin, M., Bronstein, M., Zhu, Z., & Tang, J. (2024/2025). Fully-Inductive Node Classification on Arbitrary Graphs / GraphAny. arXiv:2405.20445.
8. Xia, L., & Huang, C. (2024). AnyGraph: Graph Foundation Model in the Wild. arXiv:2408.10700.
9. Wang, Z., Zhang, Z., Chawla, N. V., Zhang, C., & Ye, Y. (2024). GFT: Graph Foundation Model with Transferable Tree Vocabulary. NeurIPS 2024. arXiv:2411.06070.
10. Eremeev, D., Platonov, O., Bazhenov, G., Babenko, A., & Prokhorenkova, L. (2025). GraphPFN: A Prior-Data Fitted Graph Foundation Model. arXiv:2509.21489.
11. Platonov, O., Bazhenov, G., Eremeev, D., & Prokhorenkova, L. (2026). A Fair Evaluation of Graph Foundation Models for Node Property Prediction. arXiv:2606.24509.
12. Bechler-Speicher, M., Gottlieb, Y., Isakov, A., et al. (2026). Billion-Scale Graph Foundation Models. arXiv:2602.04768.
13. Gutteridge, B., et al. (2026). Can Graph Foundation Models Generalize Over Architecture? arXiv:2603.22984.
14. Paolino, R., et al. (2026). Bridging Input Feature Spaces Towards Graph Foundation Models. arXiv:2605.04834.
15. Galkin, M., Yuan, X., Mostafa, H., Tang, J., & Zhu, Z. (2024). Towards Foundation Models for Knowledge Graph Reasoning. ICLR 2024. OpenReview.
16. Wang, Y., Fan, W., Wang, S., & Ma, Y. (2025). Towards Graph Foundation Models: A Transferability Perspective. arXiv:2503.09363.