Why Tabular Foundation Models Excel on Relational Data They Have Never Seen

W HY TABULAR F OUNDATION M ODELS E XCEL ON R ELATIONAL DATA T HEY H AVE N EVER S EEN Linjie Xu, Yiqun Hu, Jixiang He, & David Wipf∗ University of Hong Kong, Shanghai X-Lab

arXiv:2611.02936v2 [cs.AI] 3 Nov 2026

A BSTRACT Given a relational database (RDB) storing heterogeneous tabular information, how can we predict missing (or future) values in some target column of interest? As candidate targets are numerous in enterprise settings, it is preferable to avoid learning a new model from scratch each time there is a new prediction task. Frozen foundation models (FMs) based on in-context learning (ICL) and RDB-specific pre-training provide a viable solution, but the ideal design still remains largely unresolved. Perhaps unexpectedly, preliminary evidence has recently shown that existing single-table FMs (aka TFMs), when combined with suitable parameter-free relational encoders, can be quite competitive in practice despite zero exposure to RDB pre-training or relational data of any kind. In this work we first empirically confirm this phenomenon with a more diverse array of experiments. We then turn to our main contribution, namely, surfacing multiple complementary explanations for why TFMs behave so effectively. These explanations ultimately hinge on innate synergies whereby parameter-free encoders map relational effects to fixedlength embeddings that loosely mimic distributions for which TFMs were originally designed; in so doing, desirable single-table properties transfer to relational settings (e.g., convergent posterior predictive distributions). Collectively, our analysis forges new pathways for improving RDB FMs, particularly when we prioritize interpretability and inevitable integration within agentic systems.

1

I NTRODUCTION

Relational databases (RDBs), housing collections of interrelated tables, are indispensable across enterprise applications and e-commerce platforms (Garcia-Molina et al., 2009). From a machine learning standpoint, the information stored within just a single RDB often contains countless possibilities for predictive modeling, covering targets such as customer retention, user churn, or click-through rates (Dave et al., 2014; Motl & Schulte, 2015; Ni et al., 2019; Zykov et al., 2022). Of course retraining a new model from scratch to address each new predictive task of interest may be prohibitively laborious or expensive, which motivates a new class of foundation models (FMs) specifically tailored for RDBs. Among others, these vary from LLM-based approaches that digest serialized RDB content (Wydmuch et al., 2024), to specialized Transformers pre-trained based on in-context learning (ICL) (Fey et al., 2025; Hudovernik et al., 2026; Ranjan et al., 2026c; Wang et al., 2026b), the common theme in each case being a frozen architecture capable of making predictions involving arbitrary unseen RDBs. As a robust and scalable alternative, it has recently been demonstrated that single-table FMs (aka TFMs), when combined with suitable parameter-free subgraph encoders for capturing multi-table relational context, can perform well without requiring any RDB-specific pre-training (Grinsztajn et al., 2026; Hayler et al., 2026; Xu et al., 2026). After presenting background RDB context in Section 2, our work herein centers around confirming and explaining this unexpected performance via: • Comprehensive demonstration. We provide thorough empirical comparison of wide-varying RDB foundation models across diverse benchmarking tasks. These results from Section 3 solidify the surprising effectiveness of TFMs repurposed for relational data. • Explanatory theory. In Sections 4–7, we elucidate multiple complementary factors that help explain this phenomenon and broader merits of TFMs. Specifically, we show that TFM-based approaches: (i) naturally handle varying degrees of relational context, forming a continuum from ∗

Correspondence to linjiexu@hkushxlab.com and davidwipf@gmail.com.

1

single-tables to rich RDB schemas; (ii) transfer desirable asymptotic properties to RDB use cases, helping to compensate for mismatches between pre-training prior and practical deployment distributions; (iii) are not notably limited by expressivity concerns, even with parameter-free encoders and no prior RDB exposure, and (iv) integrate particularly well with agentic systems.

2

BASICS OF RDB F OUNDATION M ODELS

The goal of an RDB foundation model is to retain applicability across unseen RDBs, ideally with no retraining for each new predictive task. Beyond direct LLM-prompting approaches (Wydmuch et al., 2024), we now discuss recent pipelines designed to natively handle RDB/tabular data. 2.1

P REDICTIVE M ODELING WITH R ELATIONAL C ONTEXT

Suppose we have training data {xi , yi }ni=1 = {X, y} composed of instance feature rows xi ∈ X d along with associated instance labels yi ∈ Y for all i. The objective is to learn a parameterized model fθ that achieves fθ (xtest ) ≈ ytest at any test point {xtest , ytest }, where in practice ytest is unknown. RDB predictive modeling generalizes this canonical ML scenario by integrating an additional set of k nk ×dk auxiliary data tables T = {T k }K denotes the k-th table associated with a k=1 , where T ∈ T given entity type. Each table row corresponds with a single instance of that entity (e.g., a purchased item), while columns reflect heterogeneous instance attributes (e.g., product information). Note that w.l.o.g., we also assume T 1 = X. Lastly, an RDB also includes a set of relations R expressed as primary key (PK), foreign key (FK) pairs (Garcia-Molina et al., 2009); these may be absorbed into the constituent tables of T as additional columns when convenient. Both supervised methods and FMs leverage these auxiliary tables for making predictions. 2.2

C OMPUTING RDB E MBEDDINGS

To make use of relational context for predictive tasks, the basic strategy is to first convert a given labeled RDB D := {T , R, y} to a heterogeneous graph G. This typically involves treating each table T k as a node type and each row i within a given T k as a node with features tki (Cvitkovic, 2020; Dwivedi et al., 2025; Fey et al., 2023; Zhang et al., 2023a;b). Directed edges can then be formed using each PK-FK pair within R. We next sample H-hop subgraphs or ego-networks GH (xi ) from G that are centered at each target row xi within X. Importantly, sampling for temporal RDBs should exclude nodes with time-stamps later than xi . These subgraphs form the input to an RDB encoder gϕ , instantiated as some form of graph neural network or Transformer architecture with (optional) parameters ϕ. This facilitates computation of fixed-length embeddings z i = gϕ [GH (xi )] ∈ Rdz . 2.3 C OMBINING WITH RDB P REDICTION H EADS Schema-agnostic models. Provided the encoder gϕ is designed to digest a broad spectrum of input RDB schema using a shared representational form, then it is possible to train a single composite  
model qθ y | z test ) ≡ qθ y | gϕ GH (xtest ) to assign high probability to labels y = ytest (or y ≈ ytest for regression tasks) across a range of real-world RDBs (Ranjan et al., 2026a; Wang et al., 2025; Wu et al., 2025). Here xtest can be viewed as an additional unlabeled row(s) appended to X. Such models can in principle be applied to new unseen RDBs without further training. Pre-trained ICL-based models. A limitation of the schema-agnostic models from above is that the effective context available for making predictions is merely the subgraph GH (xtest ), which in isolation may not contain sufficient information pertaining to broader labeling patterns across a vast RDB. In-context learning (ICL) provides a natural workaround by granting the prediction head diverse samples of multiple analogous subgraphs extracted from each new RDB of interest. Specifically, ICL-based architectures derive predictions from the revised distribution qθ y | z test , Sn ), with Sn = {z i , yi }ni=1 , z = gϕ [GH (x)], where z test and each z i are obtained by passing unlabeled and labeled rows of X through the shared encoder gϕ . It is also possible to apply gϕ to revised tabular embeddings U k ← T k rather than original tables (Hudovernik et al., 2026). The prediction head qθ is implemented via various Transformer architectures that grant flexibility over n and dz . Finally, model pre-training is conducted using large volumes of synthetically-generated data, possibly combined with real-world RDBs (Chen et al., 2026; Fey et al., 2025; Hudovernik et al., 2026; Kothapalli et al., 2026; Ranjan et al., 2026b;c). 2

(a) SALT — multi-class classification

(b) RelBench v2 — binary classification

(c) RelBench v2 — regression RDBLearn

RDBLearn

RDBLearn

RelAgent TabPFN-Rel-OSS

TabPFN-Rel-OSS

KumoRFM-1

KumoRFM-2

KumoRFM-2 KumoRFM-2

GraphSAGE GraphSAGE

KumoRFM-1

GraphSAGE

Global Median

KumoRFM-1

Entity Median LightGBM

LightGBM

0.00

0.25

0.50

0.75

1.00

0.25

0.50

TabPFN-Rel-OSS GNN KumoRFM-2 KumoRFM-1 RDB-PFN RandGNN Griffin XGBoost

0.50

0.75

1.00

Supervised FM – Closed-source FM – Open-source Baseline / Median TFM-based

RelAgent TabPFN-Rel RT-J+fine-tuning RelGNN TabPFN-Rel-OSS GraphSAGE RelGT RDBLearn KumoRFM-2 KumoRFM-1 RDBPFN RandGNN RT-J RT-P LLM-B RT LLM-A RelLLM Griffin LightGBM

RelAgent RDBLearn

0.25

0.75

0.00

(e) RelBench v1/RelArena-® — binary classification

(d) 4DBInfer — binary classification

0.00

LightGBM

0.00

1.00

0.00

0.25

0.50

0.75

1.00

0.25

0.50

0.75

1.00

(f) RelBench v1/RelArena-® — regression

RelAgent RT-J+fine-tuning KumoRFM-2 TabPFN-Rel RelGT RelGNN TabPFN-Rel-OSS RDBLearn GraphSAGE KumoRFM-1 RT-J LightGBM RandGNN Global Median Entity Median RT Griffin

0.00

0.25

0.50

0.75

1.00

Normalized Avg. Rank (lower is better # )

Figure 1: A TFM-based approach outperforms other RDB FMs on each benchmark. Retrofitting TFMs with a relational encoder. Given the growing range of single-table FMs (Hollmann et al., 2025; Jingang et al., 2025; Qu et al., 2026; Zhang et al., 2025b;a), it is natural to consider combining with a parameter-free encoder gpf , for flattening RDB neighborhoods into fixedlength tabular features, such that the entire pipeline requires no RDB-specific training/pre-training (Grinsztajn et al., 2026; Hayler et al., 2026; Xu et al., 2026) (a conversion akin to U k ← T k , as adopted by the pre-trained ICL-based model from Hudovernik et al. (2026) described above, may be optionally considered as an additional pre-processing step, but we do not pursue this possibility further). Herein we aim to confirm and explain the effectiveness of these simple approaches relative to more complex alternatives.

3

M ORE E MPIRICAL E VIDENCE THAT TFM S E XCEL ON RDB S

Models. For TFM-based approaches, we adopt RDBLearn (Xu et al., 2026) and TabPFN-Rel (Hayler et al., 2026) based on analogous principles; TabPFN-Rel has both open- and closed-source versions (the latter including proprietary text handling and unknown RDB-related modifications). For RDB-native FMs, we include a variety of both open-source and closed-source options with published results based on author-specific tuning. Note that most models only provide results on a subset of available benchmarks. Lastly, we cover a handful of supervised baselines that represent either SOTA performance or classical methodology as a reference point. Appendix E includes all baseline model descriptions as well as further details of how results were obtained. Results. We compare across a suite of six diverse benchmarks from Appendix E, each composed of multiple RDB predictive tasks. We remark that it is routine to only report results on RelBenchv1 datasets/tasks (Jäger et al., 2026; Hayler et al., 2026; Kothapalli et al., 2026; Ranjan et al., 2026a;c), which are also equivalent to recent RelArena-α task designations at the time of this writing (Hayler et al., 2026). But this poses greater risk of overfitting to limited benchmarking data, e.g., settings/architectures suitable for RelBench-v1 need not always translate to stronger performance elsewhere. For the expanded benchmark set considered here, results are shown in Figure 1 and Appendix E.4, where TFM-based approaches achieve the best performance among all FMs, including even several variants that may involve pre-training with RDBs structured similarly to the benchmarks. We stress that RDBLearn and TabPFN-Rel-OSS were run directly from open-source repositories for all benchmarks with no task-specific pipeline adjustments and zero exposure to RDB data of any kind at any stage, i.e., no chance for any implicit test-set alignment on public benchmarks. Why are TFMs so competitive on RDBs? It is initially reasonable to assume that pre-training RDB-specific FMs using actual RDB data (real or synthetic) is essential for achieving strong inferencetime performance on unseen relational data. So how can TFMs paired with some gpf possibly perform well, as we have confirmed in Figure 1. The high-level argument from Xu et al. (2026) is that prior to 3

seeing ICL samples, a data-agnostic encoder is incapable of adjudicating column roles, which may vary from dataset to dataset (or even task to task within a given RDB). This phenomenon advantages RDB encoders that only compress vertically within high-dimensional columns (where shared units facilitate interpretable aggregation), not horizontally across columns, where relevance is largely indeterminate without adequate label information. Conditioned on this restriction to vertical (intracolumn) compression, Xu et al. (2026) detail how gpf can result in minimal loss of expressiveness, while naturally pairing with existing TFMs to form a complete RDB pipeline. While promising as an analytical starting point, there remains considerable ambiguity regarding the rationale and surprising empirical efficacy of this simple recipe. In the remainder of this work we take several disambiguating steps, beginning with a discussion of the blurry line between single tables and RDBs, where TFMs already work well on the former.

4

S INGLE TABLES AND RDB S ON A C ONTINUUM

Inducing RDBs from single tables. Conventionally, TFMs and benchmarking (i.e., single-table regimes) are treated separately from their RDB counterparts. But as we now examine, infinitesimal adjustments to an initial single-table setup facilitate gradual transitioning to multi-table relational scenarios, making any strict partitioning somewhat arbitrary. Concretely, beginning with a singletable scenario, meaning K = 1 and features T 1 = X, we can trivially transform these data into two or more tables with arbitrarily-small, labeled cross-row relational dependencies as follows: 1. Select any categorical column of T 1 ; w.l.o.g. assume B categories. If no categorical columns exist, then we simply chose a numerical column and quantize into B bins. 2. Form a new auxiliary table T 2 with a single length-B column, where elements are the unique categories obtained from step 1 above. Treat the lone column within T 2 as a PK, and the original categorical column within T 1 as an FK. 3. To induce more complex schema, we may optionally repeat steps 1–2 using other T 1 columns. 4. Form subgraphs GH (x) seeded at any row x; provided H ≥ 2, these neighborhoods will include multiple nodes associated with different rows of X. This is because the first hop reaches an induced T k (k > 1), while any second hop returns to T 1 . In doing so, cross-row relational dependencies are introduced via the edges within GH (x) (Gan et al., 2024). 5. Define the label generation function 
 y = ψ (1 − τ )f1 (x, ε1 ) + τ f2 GH (x)\x, ε2 , (1) where τ ∈ [0, 1] represents a continuation parameter and {ε1 , ε2 } ∈ R2 are exogenous noise factors. Meanwhile, f1 and f2 are functions mapping their respective domains to a shared r-dimensional embedding space Rr , after which ψ : Rr → Y converts to the final label space. Continuum perspective. Any possible conditional distribution p (y|GH (x)) can in principle be obtained by generating data via step 5, subject to mild regularity conditions (Peters et al., 2017)[Proposition 4.1]; likewise for special cases p(y|x) (when τ = 0) and p (y|GH (x)\x) (when τ = 1). Hence given any set of tabular features, we can always generate a continuum of rich label distributions with varying degree of relational dependency, ranging from the canonical single-table regime (τ = 0) to an interconnected multi-table structure (τ ̸= 0). We emphasize that our point here is not to replicate the most likely real-world processes by which RDBs are generated, nor discount the countless other ways single tables can be normalized into RDB-like schema. Instead, we are merely demonstrating that there is no unambiguous line between single tables and multi-table relational data, as relational effects can diversely form a continuum from non-existence to prominence. Plausibility of TFMs on RDBs. TFMs by original design excel handling τ = 0 cases, and some real-world RDBs likely approximate this regime (Akhter et al., 2026). Furthermore, if they are equipped with a suitably powerful encoder gpf , such as the encoding strategy endorsed by Xu et al. (2026), then larger τ cases are also within reach as evidenced by Figure 1. Hence, TFMs are reasonable candidates for navigating relational continuums, providing a strong initial plausibility argument for their usage on RDBs. Conversely, if an alternative RDB FM does not work well on single-tables, what about performance on RDBs that are minimally different from single tables, and so on? Again, these considerations motivate RDB FMs that explicitly handle a broad relational spectrum as TFMs already do. In Appendix A.1 we closely examine limitations of adopting interpolation/ensembling 4

1.0

0.9

0.8

0.6 0.5

0.6 0.4 0.2 0.0

OOM

0.4

rs ppe

sho

t s ane nk_mk ba

l

elec hote

kick kickst

0.2

lend spark

OOM

0.7

TabPFN-v3 RDBLearn KumoRFM-2 RT-J

OOM

R 2 ( better)

0.8

OOM

ROC-AUC ( better)

1.0

t r s s k v k e e e ous climat coffe coo deli worke ercede st_sale erban permi sb m

ca_h

Figure 2: Classification/Regression performance on RDBs induced from single-table temporal data. between single-table FMs and RDB FMs as a simplistic workaround, proving a pessimistic bound (Proposition A.3) that occurs even with very minor modeling constraints. See also Appendix A.2 for broader benchmarking implications of the continuum perspective. Empirical implications. We empirically probe implications of the continuum perspective, particularly the behavior of RDB FMs operating near single-table regimes. For this purpose, we first collect a set of tabular datasets (originally single table), whereby train/test splits are temporal as in typical RDB scenarios; see Appendix F for all setup details. We then induce RDBs using steps 1–4 from above; however, we retain the original dataset labels to maintain real-world authenticity. Note that these datasets, designed to test non-IID temporal shifts, may already exhibit small degrees of cross-row dependency even without artificially inducing such dependencies via (1). We compare TFM-based RDBLearn against the top RDB FMs (non-TFM-based) KumoRFM-2 (Hudovernik et al., 2026) and RT-J (Ranjan et al., 2026b;c) in Figure 2 and Appendix F. We also include TabPFN-v3 (Grinsztajn et al., 2026) as a non-relational baseline (also shared as the RDBLearn base model). Overall, RDBLearn shows the best performance among RDB FMs, demonstrating the ability to mostly discard distracting relational effects that are not necessary for making predictions. Meanwhile, although RT-J struggles with some of these tasks, KumoRFM-2 performs significantly better (excluding four OOM cases). This is perhaps not surprising given that KumoRFM-2 pre-training explicitly transitions from single tables to relational data over an undisclosed multi-stage process (Hudovernik et al., 2026). Moreover, inspection of the KumoRFM-2 implementation reveals heavy reliance on the TabICL-v2 TFM architecture (Qu et al., 2026). Pure TFM-based methods like RDBLearn and TabPFN-Rel simply take these observations one step further by dispensing with potentially-complex RDB-specific pre-training altogether. Either way, it is our view that Figure 2-style benchmarking represents an informative hurdle for RDB FMs to pass. It is also worth noting that on three regression tasks, RDB FMs actually surpass the performance of the non-relational baseline, and the RDBLearn average regression performance modestly exceeds TabPFN-v3 (see Appendix F).

5

L OCALITY C ONSIDERATIONS FAVOR TFM U SAGE

We now turn to an RDB generative process that facilitates the study of locality-based necessary conditions for removing bias. We then find that TFMs, with uniformly drawn ICL samples produced by a suitable gpf , allow us to approximately satisfy these conditions with RDB data. 5.1

N ECESSARY C ONDITIONS FOR U NBIASED RDB FM S

Definition 5.1. (continual RDB generation) Let P denote a set of RDB distribution sequences ρ := {pn }∞ n=m , while Dn ∼ pn is an RDB associated with ρ for any n > m ≥ 0. We stipulate that all such Dn include a table T 1 composed of labeled rows {xi , yi }ni=0 . These labels are assumed to
follow the conditional p yi |GH (xi ) that does not vary across n, but may vary with different ρ ∈ P
(in contrast, we do not prevent the marginal p GH (xi ) from varying across n and ρ). We treat {GH (x0 ), y0 } ≡ {GH (xtest ), ytest } as a test sample that remains fixed across n. By design, Definition 5.1 allows us to consider distributions of RDBs whereby the overall size and number of ICL samples is growing indefinitely (these may extend into the past if timestamps are involved), but with a fixed evaluation point {GH (xtest ), ytest } (akin to typical IID tabular cases). And 5

even if real-world RDBs are not generated in exactly this way, with modest assumptions, the same RDB distribution can often be defined/generated in either a forward or backward fashion. Hence we preserve flexibility with this construction while facilitating asymptotic analyses as follows. Consider a scenario where, as n becomes large, a given RDB FM achieves two desirable conditions: (i) the variance of the predicted label vanishes, and (ii) the bias relative to the true label distribution, conditioned on an encoder output, tends to zero. Mathematically, these conditions manifest as

 qθ ytest | {z i , yi }ni=1 , z test − EDn ∼pn qθ ytest | {z i , yi }ni=1 , z test → 0 (variance)

 n p ytest | z test − EDn ∼pn qθ ytest | {z i , yi }i=1 , z test → 0 (bias) (2)
almost surely as as n → ∞. We are assuming here that z = gϕ GH (x) and that {pn }∞ n=m represents a sequence
of RDB distributions adhering to the generative process from Definition 5.1; likewise for p ytest |z test which does not vary with n. Building on the rich conceptual framework from Nagler (2023), originally designed to analyze IID scenarios over single tables, we now examine necessary conditions on a given {qθ , gϕ } for achieving (2), noting that gpf is a special case of gϕ . Proposition 5.2. Given an RDB FM defined by some
{qθ , gϕ }, and
every ρ ∈ P adhering to Definition 5.1, assume (2) holds and that p yi |GH (xi ) = p yi |z i ∀i = 0, . . . , n. Then for any ρ̌ ∈ P (and associated label generator p̌) there exists a sequence εn → 0 such that almost surely

n→∞ qθ ytest | {z i , yi }ni=1 , z test − qθ ytest | {ž i , y̌i }ni=1 , z test −−−−→ 0, (3) where samples {z i
, yi }ni=1 are extracted from Dn ∼ pn , samples {ž i , y̌i }ni=1 from Ďn ∼ p̌n , and
p y | z = p̌ y | z if ∥z − z test ∥ ≤ εn . Intuitively, this result merely indicates that if we wish to obtain unbiased estimates of the label across broad distributional settings within P (as required by RDB foundation models in particular), then the output of our decoder function qθ should depend only on ICL samples with encoder representations z i that are close to the test representation z test . Note that {z i , yi }ni=1 = {z i , yi }z i ∈Ωn ∪ {z i , yi }z i ̸∈Ωn with Ωn = {z : ∥z − z test ∥ ≤ εn },

(4)

while {ž i , y̌i }ni=1 decomposes analogously. When n grows large, elements of the sets {z i , yi }z i ∈Ωn and {ž i , y̌i }ž i ∈Ωn become indistinguishable as Ωn collapses around z test , hence they may influence the output of qθ without conflicting with (3). In contrast, remaining samples not in Ωn must have negligible influence for (3) to hold. This dependency on locality allows the FM to differentiate RDBs that have similar behavior around any given test point, but increasing separation elsewhere. We next discuss the implications for RDB FM design types, particularly those based on TFMs. 5.2

NATURAL A LIGNMENT WITH S INGLE -TABLE FM S .

Uniform ICL sampling. When choosing ICL samples, we would like at least some associated with encoder representations {z i }ni=1 that are reasonably close to the test point representation z test , as required for unbiased estimation per Proposition 5.2. In the absence of domain-specific knowledge or strong a priori assumptions such as homophily,1 we may not know in advance where these close samples will be located in a given RDB. And yet FM architectures should ideally address wideranging conditions with a shared data-agnostic strategy. Along these lines, uniform sampling (from rows of X with historical timestamps) is reasonable for approximating the full RDB context across generic new tasks, leading to at least some coverage of any new z test with select elements of {z i }ni=1 .2 Moreover, in a sufficiently large RDB these uniform samples may even behave roughly as though they were IID, mirroring the single-table distributions for which TFMs were originally pre-trained. This alignment can play a critical role in achieving more robust performance as the number of ICL samples grows, which we will investigate next through the lens of posterior predictive distributions (PPDs) (Müller et al., 2021). The PPD serves a critical role, representing the target distribution that ICL-based TFMs attempt to approximate during pre-training (Hollmann et al., 2022). 1 In the context of heterogeneous graphs or subgraphs defining RDB relations, homophily refers to the tendency of neighboring nodes of the same node type (not necessarily 1-hop neighbors) to share the same label, while heterophily represents the converse. 2 By uniform sampling, we do not exclude temporal bias. For example, if we wish to prioritize recency, we can still uniformly sample across all RDB neighborhoods satisfying a time difference constraint.

6

Leveraging Single-Table PPDs. Given some RDB D drawn from ground-truth distribution pgt , suppose we extract samples {GH (xi ), yi }ni=1 and test point {GH (xtest ), ytest } = {GH (x0 ), y0 } satisfying n
Y


pgt {GH (xi ), yi }ni=0 ≈ pgt GH (xi ), yi and pgt yi |GH (xi ) ≈ pgt yi |z i ) ∀i.

(5)

i=0

These may be reasonable approximations if (i) uniform sampling is conducted over a sufficiently large RDB, and (ii) the embeddings z i adequately reflect the dominant sources of discriminative information within H-hop neighborhoods. Granting the assumptions from (5) hold as n grows large, we may directly borrow an existing prior µ over single-table distributions q ∈ Q satisfying mild regularity conditions (Nagler, 2023). We then form a PPD that converges towards the ground-truth as Z


n→∞

pppd ytest |z test , Sn = q ytest |z test dµ q|Sn −−−−→ p̂ ytest |z test ≈ pgt ytest |z test , (6) where p̂ is the KL-optimal approximation of pgt in Q. This drift towards the ground-truth pgt is essential for the following reason. While the distribution of pre-training data for TFMs may loosely resemble trends in real-world tables, there is certainly no exact correspondence. However, a perfect match with the prior is not required to achieve strong performance, provided that: (i) the prior assigns at least some nonzero probability mass to a p̂ reasonably near pgt , and (ii) we have collected
enough uniformly-distributed ICL samples such that the true PPD narrows as p ppd ytest |z test , Sn ≈
p̂ ytest |z test . Originally motivated from single-tables (Nagler, 2023), this phenomenon may at least partially explain the observed empirical success generalizing to RDBs, whereby conditions mirroring the single-table case have been explicitly engineered through uniform sampling and encoders gpf that do not mix across columns, preserving column identity and roles akin to typical tabular regimes (Xu et al., 2026). The latter plausibly increases the chances that condition (i) from above is roughly satisfied in regions around z test . In so doing we effectively align RDB neighborhoods with attributes of input data previously applied to successful TFMs, transferring similar efficacy. 5.3

L IMITATIONS OF A LTERNATIVE P OSSIBILITIES

Bias from non-uniform sampling. The distance between local RDB neighborhoods, as arbitrated by encoder representations {z i }ni=1 , determines the notion of locality upon which Proposition 5.2 is based. But it is nonetheless useful to contrast this notion with distinct options adopted by other types of RDB FMs. For example, the latest SOTA relational Transformer instantiation RT-J (Ranjan et al., 2026b;c), based on RDB-specific pre-training with real-world RDB data, involves forming ICL samples as the set of target rows in T 1 that are most frequently visited over the course of a large number of fixed-length random walks seeded from xtest . In this way we collect samples that are close to xtest in the sense of graph distance, but not necessarily in terms of encoder representation. For networks dominated by homophily effects, meaning nearby nodes in the graph have similar labels, this likely works well. But more broadly, within an RDB influenced by heterophily relationships, disconnected regions, or other spurious network effects, similar samples/nodes drawn from random walks may not be similar in terms of encoder representations, in which case the necessary conditions of Proposition 5.2 would not hold. This may also partially explain the performance of RT-J in Figure 2, where the infused relational structure is minimally related to the labels by experimental design. Implications for the PPD. The distinction between uniform and non-uniform sampling also influences the PPD upon which ICL-based FMs depend. For example, regardless of whether the measure µ reflects a single-table or a full RDB pre-training prior, if random-walk sampling is adopted to obtain Sn , then the core IID assumption from (5) used to establish (6) will no longer generally hold. Consequently, increasing the number of ICL samples need not approximate a desirable
asymptotic regime, and the resulting PPD may bear little resemblance to the target pgt ytest |z test . See Appendix C.2 for a simple example whereby random-walks stall around the test node, failing to capture samples that lie elsewhere in the RDB as required to produce a meaningful PPD (the core issue is that G is disconnected). Hence instead of having n approximately IID samples from some pgt (GH (x), y) (as with uniform sampling matched with a single-table prior µ), with random walk sampling we instead have just one sample
from a much more complex, entangled joint distribution pgt {GH (x0 ), y0 , }, . . . , {GH (xn ), yn } . This dramatically increases the necessity of an accurate RDB-specific pre-training data prior to resolve ambiguity in the resulting PPD, as (6) need not hold any longer, even approximately. But such priors raise a new issue. 7

Dilemma of RDB-specific pre-training priors. Now suppose that µ is no longer simply a prior over distributions of single-tables with IID rows (as assumed by TFMs), but instead over distributions of full RDBs as adopted by multiple RDB FMs (Chen et al., 2026; Fey et al., 2025; Hudovernik et al., 2026; Ranjan et al., 2026b). But designing an accurate prior of this type is more challenging than in the single-table case, simply because of all the new relational dependencies introduced over multiple tables. This implies that misspecifications may actually be greater relative to real-world RDBs, and yet we cannot necessarily compensate with a larger n (as in TFM cases) since this need no longer induce an IID regime or the equivalent of (6). These observations suggest that, outside of specific domains where developing targeted pre-training priors may be more feasible, generic TFM-based pipelines still hold some sway. Plausibly, loose IID approximations with even modest compensatory effects as n grows large might often generalize better in new domains than highly-complex,
entangled priors that do not factorize over ICL sample sets {GH (x0 ), y0 , }, . . . , {GH (xn ), yn } .

6

A DEQUATE E NCODER E XPRESSIVITY EVEN WITH N O PARAMETERS

We next address possible expressivity limitations associated with gpf usage, the key ingredient which allows TFMs to avoid any RDB-specific training or pre-training. A natural presumption here is that parameter-free encoders place a potentially-burdensome restriction on the types of RDB neighborhood representations available for constructing ICL samples. We analyze this concern through a case study involving interaction terms, where we find that the added expressivity of parameterized encoders gϕ need not provide an unequivocal advantage over the much simpler gpf adopted by TFMs. Interaction terms as a case study. Prior work has noted that parameter-free encoders that process RDB columns individually (as mentioned in Section 3 and adopted by RDBLearn/TabPFN-Rel) are incapable of handling interaction terms between columns in auxiliary tables. Along these lines, consider the following representative example of this ostensible limitation discussed by Hudovernik et al. (2026); Huang et al. (2026). Suppose we are given an RDB with only two tables: A labeled target table T 1 = y and a child table T 2 = [a, b] composed of two binary feature columns a and b. A PK associated with each row of T 1 is linked by FKs to one or more rows of T 2 , where Ri denotes the set of rows within T 2 that have FKs pointing to the PK associated with row i in T 1 . Ground-truth labels are then constructed to satisfy yi = max [aj ∧ bj ] ∀i. j∈Ri

(7)

Clearly the element-wise interactions aj ∧ bj determine the label, and so the argument goes, excluding such interactions is disproportionately problematic within any gpf that encodes columns separately as advocated by Xu et al. (2026). We provide three counter-points to this concern: All lossy encoding involves negative counter-examples. The labels computed via (7) involve a binary function over a 2|Ri |-dimensional input space, giving 22|Ri | = 4|Ri | possible input configurations. But this is just one possible function sharing this input range. Assuming no permutation |Ri | invariance across rows, there are 2(4 ) distinct binary functions expressible over the same input space. Without external knowledge mandating which function is correct, an encoder that fails to losslessly preserve the entire input range will make it impossible to guarantee that a subsequent decoder can determine the correct labeling rule; a single missing bit can flip any labeling rule leading to errors within an arbitrary downstream classifier. More broadly, all lossy encoding, whether parameterized or not, opens up a set of inevitable counterexamples, whereby learning the correct function is infeasible; see Xu et al. (2026)[Proposition 4.2] as one representative scenario. This remains true even if task-specific labels are included within GH (x); more on this in Appendix B. Consequently, the primary differentiating consideration is not whether counter-examples exist; rather, what matters is the relative frequency with which encoder-specific counter-examples appear in real-world RDBs.3 In general, functional expressivity is likely more critical in supervised scenarios, where trainable degrees-of-freedom can be mapped to task-specific encoders that mitigate task-specific counter-examples (e.g., a particular set of interaction terms). But for ICL-based FMs restricted to a fixed data-agnostic form, other factors such as interpretability or sample complexity may matter more than parameterized expressivity per se. 3

This is admittedly difficult to quantify, as we usually only have reported results on final predictive accuracy.

8

Arbitrary interactions challenge any fixed encoder. Even if we restrict label generation to functions of interaction terms similar to (7), parameterized encoders still do not have a clear-cut advantage in real-world settings. This is because real-world auxiliary tables often have many columns. Excluding all higher-order interactions, there will still exist a quadratically expanding number of candidate interaction terms as the number of columns grow. Without knowing in advance which are important, lossy encoder compression, parameterized or not, will create the potential for prediction errors (i.e., there will always be cases where needed interaction signal depends on missing information). Appendix B analyzes how historical labels within GH (x) cannot generally resolve this ambiguity under certain settings. Parameter-free encoders can (sometimes) handle interactions. For arguments sake, the presumption thus far in this section has been that a column-wise parameter-free gpf cannot represent interaction terms. But actually, this is not strictly true for the following two reasons. First, models like RDBLearn or TabPFN-Rel can directly handle interactions between compressed representations of individual columns; these representations form additional columns within Z ∈ Rn×dz , and TFMs can readily handle interactions between the constituent ICL features. Secondly, with enough aggregations of a suitable type, lossless compression is possible to enable interactions, at least in principle. For continuous aggregators (Corso et al., 2020), the required cardinality is equal to the number of real-valued elements being aggregated (not surprising), noting that these aggregators need not be permutation invariant (e.g., they could be time-dependent, involve symmetry-breaking projections, etc., for resolving ordered column values). But if arbitrary discontinuities are allowed (which is admittedly not practically feasible to implement), even just a single aggregation is technically capable of reconstructing the full set (Rubio-Madrigal & Burkholz, 2026); this conclusion follows from the Kolmogorov-Arnold representation theorem (Schmidt-Hieber, 2021). Interaction experiments. We conduct multiple tests to explore the impact of interaction terms; see Appendix G for full details. For the first, we generalize the setup of (7) to include 4 different interaction types involving columns {a, b} in T 2 ; we then compare TFM-based RDBLearn against the top non-TFM-based RDB FMs, KumoRFM-2 and RT-J. Figure 3 (left) shows the prediction results as the width of T 2 is increased by adding uninformative columns. These distracting columns follow the same distribution as a and b, and models do not know in advance which columns are useful, raising estimation difficulty. Overall, we observe that RT-J does not work well in these settings, likely because the implicit graph is disconnected, which can disrupt the collection of suitable ICL samples (see Section 5.3). Meanwhile, RDBLearn is consistently competitive with KumoRFM-2, and actually displays more stable performance across table width. This occurs because the aggregated features from gpf can be combined by the subsequent TFM, at times forming usable approximations despite not explicitly computing most interaction terms (see further details in Appendix G). Although we do not pursue further here, expanding the aggregation set within gpf can in principle reduce RDBLearn prediction errors beyond what is shown. For the second test, we begin with the rel-trial dataset (Robinson et al., 2024) and compute new ground-truth labels via interactions between sets of auxiliary table columns. Results are shown in Figure 3 (right) across 9 different column interaction pairs (x-axis) used for generating labels. While these tasks are challenging for all methods, RDBLearn generally outperforms the others (agentic results included on this bar plot are addressed in Section 7).

7

TFM S F ORM NATURAL PARTNERING WITH AGENTIC S YSTEMS

Feature discrimination in three stages. RDB predictive modeling depends heavily on the ability to differentiate, on a task-specific basis, informative versus non-informative features, relational or otherwise. There are (at least) three candidate stages where such feature screening may plausibly take place: symbolically prior to any FM application, via reasoning agents with access to task-dependent meta-data or domain expertise (stage 1); locally at the RDB encoder level using whatever context is available within GH (x) (stage 2); and globally at the decoder level in a purely data-driven manner, using the full range of labeled ICL samples (stage 3). It is our assertion that TFM-based models are particularly adept at utilizing all three stages as complements, particularly because their gpf can reduce potential interference between stages. In support of this conjecture, we offer the following: Stage 2 as a conduit from the symbolic to the data-driven. Given the previously stated capabilities of stages 1 and 3, a plausible role for stage 2 becomes relatively transparent: Make sure any features 9

Figure 3: Left: Prediction quality over synthetic RDBs formed via 4 different interaction types in child table T 2 . Colors denote models; line styles distinguish the 4 RDB versions. Results are shown as the width of T 2 increases by padding with uninformative columns. Right: Performance on quasi-synthetic data, whereby new ground-truth labels are generated via interactions between different column pairs (x-axis) within the real-world RDB rel-trial. Solid/dark bars show original results, while shaded/light bars represent revised performance after explicitly appending needed interaction terms to the appropriate table. The latter simulates a practical agentic scenario described in Section 7. that stage 1 judges to have potential are organized, to the extent possible, so as to align with the distribution of single-table features for which the subsequent stage 3 ICL decoder has been optimized. Among other things, this entails that if a particular set of features are designated as possibly useful by stage 1, they are not mixed together; some may be valuable, others ultimately not, but that is for stage 3 to decide in a data-driven manner (per results from Xu et al. (2026), this task is often easier when column-wise axis-alignment is maintained). Most notably, a so-called “golden feature” with designated predictive value by a stage 1 agent should be passed directly through stage 2 without alteration or attenuation. For example, this feature could be a specific interaction term whose a priori importance would be otherwise indeterminate without domain knowledge from stage 1. Or alternatively, various aggregations over temporal windows might be incorporated to reflect known recency biases. Of course numerous other pragmatic possibilities exist as well, which can be iteratively explored by an agentic system, with robust and scalable validation facilitated by TFMs. TFMs innately honor stage 1–3 roles. When we adopt TFMs, equipped with an appropriate gpf , any designated golden feature from stage 1 can simply be appended to others in stage 2 without deviating from the original tabular setting under which stage 3 pre-training was conducted. But this need not be the case for existing RDB FMs with parameterized gϕ . For the latter, there is no guarantee that any input dimension/feature, golden or not, will be preserved within the output embedding. Moreover, if we simply append such features to the encoder output (bypassing the parameterized encoder itself), we then introduce potential mismatch from the original RDB-specific pre-training regime of these architectures. There is also the larger related issue of interpretability. An agent can directly reason over the SQL-based aggregations used to form gpf and offer suggestions regarding what useful factors might be missing. In contrast gϕ is much more opaque since the output embeddings result from stacked Transformer layers, e.g., there is no obvious way for an agent to tell if a valuable interaction term is attenuated or absent altogether. Empirical corroboration. Consider the hypothetical scenario whereby an agent (stage 1) with domain knowledge materializes a golden feature; namely, an interaction term which determines the downstream label is added as a new column (see Appendix G). Figure 3 (right) results show that RDBLearn leverages this information to consistency boost performance in line with the three-stage perspective from above. RT-J and KumoRFM-2 experience more modest gains, and in certain cases do not capitalize at all on the provided golden feature (e.g., p-val×onesided, p-val×disp-sd cases from the figure), suggesting that the respective pipelines have somehow attenuated or underutilized this golden feature. We further explore real-world implications in Appendix H, whereby RDBLearn with a single coding-agent prompt can match the performance of a SOTA multi-agent system (Huang et al., 2026) that trains numerous models supervised on a per-task basis. Moving forward, we also emphasize that a default expectation should be that any agentic system built on top of tabular base models will likely exceed the benchmark performance of pipelines such as RDBLearn and TabPFNRel-OSS. This is because as public open-source projects, their design choices represent an observable starting point with known performance upon which to calibrate any additional enhancements, albeit at the cost of significant leakage concerns discussed in Appendix D. 10

8

TAKE -H OME M ESSAGE

Despite never seeing relational data (real or synthetic) during their pre-training stage, empirical results indicate that TFMs paired with a simple gpf are competitive with the best alternative RDB FM architectures. Although our core analyses provide multiple complementary rationales for this phenomenon, we readily concede that advancements in the field may plausibly shift the balance moving forward, hopefully catalyzed in part by our findings herein.

R EFERENCES Kazi F Akhter, Bharath Ajendla, and Manar D Samad. A fair benchmarking of deep relational database learning models. arXiv preprint arXiv:2607.03659, 2026. Tianlang Chen, Charilaos Kanatsoulis, and Jure Leskovec. RelGNN: Composite message passing for relational deep learning. arXiv preprint arXiv:2502.06784, 2025. Zhikai Chen, Junyu Yin, Jialiang Gu, Siheng Xiong, Xiaoze Liu, Ruowang Zhang, Keren Zhou, and Kai Guo. OpenRFM: Dissecting relational in-context learning. arXiv preprint arXiv:2606.04320, 2026. Gabriele Corso, Luca Cavalleri, Dominique Beaini, Pietro Liò, and Petar Veličković. Principal neighbourhood aggregation for graph nets. Advances in Neural Information Processing Systems, 33:13260–13271, 2020. Milan Cvitkovic. Supervised learning on relational databases with graph neural networks. arXiv preprint arXiv:2002.02046, 2020. Amit Daniely and Eran Malach. Learning parities with neural networks. Advances in Neural Information Processing Systems, 33:20356–20365, 2020. DM Dave, B Todd, and Will Cukierski. Acquire valued shoppers challenge, 2014. URL https: //kaggle.com/competitions/acquire-valued-shoppers-challenge. Vijay Prakash Dwivedi, Sri Jaladi, Yangyi Shen, Federico López, Charilaos I Kanatsoulis, Rishi Puri, Matthias Fey, and Jure Leskovec. Relational graph transformer. arXiv preprint arXiv:2505.10960, 2025. Moonjung Eo, Min-Kook Suh, Hye-Seung Cho, Jiwon Kim, Seoyoon Kim, Sangjun Nam, and Soonyoung Lee. EXAONE Tabular 1.0: Technical Report. arXiv preprint arXiv:2608.25774, 2026. Nick Erickson, Lennart Purucker, Andrej Tschalzev, David Holzmüller, Prateek Desai, David Salinas, and Frank Hutter. TabArena: A living benchmark for machine learning on tabular data. Advances in Neural Information Processing Systems, 38, 2026. Matthias Fey, Weihua Hu, Kexin Huang, Jan Eric Lenssen, Rishabh Ranjan, Joshua Robinson, Rex Ying, Jiaxuan You, and Jure Leskovec. Relational deep learning: Graph representation learning on relational databases. arXiv preprint arXiv:2312.04615, 2023. Matthias Fey, Vid Kocijan, Federico Lopez, J Lenssen, and Jure Leskovec. KumoRFM: A foundation model for in-context learning on relational data. Online Tech Report, 2025. Quan Gan, Minjie Wang, David Wipf, and Christos Faloutsos. Graph machine learning meets multi-table relational data. In Proceedings of the 30th ACM SIGKDD Conference on Knowledge Discovery and Data Mining, pp. 6502–6512, 2024. Hector Garcia-Molina, Jeffrey D. Ullman, and Jennifer Widom. Database Systems: The Complete Book. Prentice Hall, 2009. Léo Grinsztajn, Klemens Flöge, Oscar Key, Felix Birkel, Philipp Jund, Brendan Roof, Mihir Manium, Shi Bin Hoo, Magnus Bühler, Anurag Garg, Dominik Safaric, Jake Robertson, Benjamin Jäger, Simone Alessi, Adrian Hayler, Vladyslav Moroshan, Lennart Purucker, Philipp Singer, Alan Arazi, Julien Siems, Jan Hendrik Metzen, Georg Grab, Nick Erickson, Siyuan Guo, Eliott Kalfon, Simon 11

Bing, David Salinas, Clara Cornu, Lilly Charlotte Wehrhahn, Diana Kriuchkova, Kursat Kaya, Lydia Sidhoum, Marie Salmon, Jerry Chen, Madelon Hulsebos, Yann LeCun, Samuel Müller, Bernhard Schölkopf, Sauraj Gambhir, Noah Hollmann, and Frank Hutter. TabPFN-3: Technical report. arXiv preprint arXiv:2605.13986, 2026. Prince Grover, Julia Xu, Justin Tittelfitz, Anqi Cheng, Zheng Li, Jakub Zablocki, Jianbo Liu, and Hao Zhou. Fraud dataset benchmark and applications. arXiv preprint arXiv:2208.14417, 2022. Justin Gu, Rishabh Ranjan, Charilaos Kanatsoulis, Haiming Tang, Martin Jurkovic, Valter Hudovernik, Mark Znidar, Pranshu Chaturvedi, Parth Shroff, Fengyu Li, et al. RelBench v2: A large-scale benchmark and repository for relational data. arXiv preprint arXiv:2602.12606, 2026. Sungwon Han, Jinsung Yoon, Sercan O Arik, and Tomas Pfister. Large language models can automatically engineer features for few-shot tabular learning. arXiv preprint arXiv:2404.09491, 2024. Adrian Hayler, Klemens Flöge, Alan Arazi, Rishabh Ranjan, Jure Leskovec, Felix Birkel, Brendan Roof, Anurag Garg, Kristina Collins, Lydia Sidhoum, et al. Advancing open and reproducible relational learning: RelArena-α, TabPFN-Rel and RPI. arXiv preprint arXiv:2608.16319, 2026. Noah Hollmann, Samuel Müller, Katharina Eggensperger, and Frank Hutter. TabPFN: A Transformer that solves small tabular classification problems in a second. arXiv preprint arXiv:2207.01848, 2022. Noah Hollmann, Samuel Müller, Lennart Purucker, Arjun Krishnakumar, Max Körfer, Shi Bin Hoo, Robin Tibor Schirrmeister, and Frank Hutter. Accurate predictions on small data with a tabular foundation model. Nature, 637(8045):319–326, 2025. Xingyue Huang, Louis Tichelman, Jinwoo Kim, Krzysztof Olejniczak, and İsmail İlkan Ceylan. RelAgent: LLM agents as data scientists for relational learning. arXiv preprint arXiv:2605.07840, 2026. Valter Hudovernik, Federico López, Vid Kocijan, Akihiro Nitta, Jan Eric Lenssen, Jure Leskovec, and Matthias Fey. KumoRFM-2: Scaling foundation models for relational learning. arXiv preprint arXiv:2604.12596, 2026. Benjamin Jäger, Nick Erickson, Léo Grinsztajn, Felix Birkel, Klemens Flöge, Oscar Key, Kürşat Kaya, Jonas Kübler, Adèle Frankel, Tobias Schröder, Anurag Garg, Jan Hendrik Metzen, David Salinas, Simon Bing, Kristina Collins, Tuana Çelik, Vahid Balazadeh, Lydia Sidhoum, Tomás Pereda, Brendan Roof, Andrej Tschalzev, Siyuan Guo, Philipp Singer, Lennart Purucker, Jake Robertson, Marie Salmon, Philipp Jund, Jerry Chen, Diana Kriuchkova, Arthur Cahu, Eliott Kalfon, Adrian Hayler, Georg Grab, Vitor Monteiro, Lilly Wehrhahn, Dominik Safaric, Clara Cornu, Alan Arazi, Rylee Grace, Simone Alessi, Mihir Manium, Bernhard Schölkopf, Yann LeCun, Madelon Hulsebos, Sauraj Gambhir, Noah Hollmann, and Frank Hutter. TabPFN-3.5: Technical report. arXiv preprint arXiv:2609.17895, 2026. QU Jingang, David Holzmüller, Gaël Varoquaux, and Marine Le Morvan. TabICL: A tabular foundation model for in-context learning on large data. In International Conference on Machine Learning, 2025. Kyungho Kim, Geon Lee, Juyeon Kim, Dongwon Choi, Shinhwan Kang, and Kijung Shin. ReFuGe: Feature generation for prediction tasks on relational databases with LLM agents. In Proceedings of the ACM Web Conference, pp. 8501–8504, 2026. Tassilo Klein, Clemens Biehl, Margarida Costa, Andre Sres, Jonas Kolk, and Johannes Hoffart. SALT: Sales autocompletion linked business tables dataset. In NeurIPS 2024 Third Table Representation Learning Workshop, 2024. Vignesh Kothapalli, Rishabh Ranjan, Valter Hudovernik, Vijay Prakash Dwivedi, Johannes Hoffart, Carlos Guestrin, and Jure Leskovec. PluRel: Synthetic data unlocks scaling laws for relational foundation models. arXiv preprint arXiv:2602.04029, 2026. Jan Motl and Oliver Schulte. The CTU Prague relational learning repository. arXiv preprint arXiv:1511.03086, 2015. 12

Samuel Müller, Noah Hollmann, Sebastian Pineda Arango, Josif Grabocka, and Frank Hutter. Transformers can do Bayesian inference. arXiv preprint arXiv:2112.10510, 2021. Thomas Nagler. Statistical foundations of prior-data fitted networks. In International Conference on Machine Learning, pp. 25660–25676. PMLR, 2023. Jianmo Ni, Jiacheng Li, and Julian McAuley. Justifying recommendations using distantly-labeled reviews and fine-grained aspects. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing, pp. 188–197, 2019. Jonas Peters, Dominik Janzing, and Bernhard Schölkopf. Elements of Causal Inference: Foundations and Learning Algorithms. MIT Press, Cambridge, MA, USA, 2017. Lennart Purucker, Andrej Tschalzev, Nick Erickson, Gioia Blayer, David HolzmÃ1/4ller, Alan Arazi, Alexander Pfefferle, Mustafa Tajjar, Gaà Varoquaux, Frank Hutter, et al. Beyond iid: How general are tabular foundation models, really? arXiv preprint arXiv:2606.30410, 2026. Jingang Qu, David Holzmüller, Gaël Varoquaux, and Marine Le Morvan. TabICLv2: A better, faster, scalable, and open tabular foundation model. arXiv preprint arXiv:2602.11139, 2026. Rishabh Ranjan, Valter Hudovernik, Mark Znidar, Charilaos Kanatsoulis, Roshan Upendra, Mahmoud Mohammadi, Joe Meyer, Tom Palczewski, Carlos Guestrin, and Jure Leskovec. Relational Transformer: Toward zero-shot foundation models for relational data. International Conference on Learning Representations, 2026a. Rishabh Ranjan, Vignesh Kothapalli, Harshvardhan Agarwal, Charilaos Kanatsoulis, Roshan Upendra, Tom Palczewski, Carlos Guestrin, and Jure Leskovec. RT-J: Large-scale pretraining of relational transformers for context-efficient predictions. arXiv preprint arXiv:2610.17867, 2026b. Rishabh Ranjan, Vignesh Kothapalli, Harshvardhan Agarwal, Charilaos Kanatsoulis, Roshan Upendra, Tom Palczewski, Carlos Guestrin, and Jure Leskovec. Large-scale pretraining unlocks few-shot prediction for relational data. In Workshop on Graph Foundation Models: A New Era for Graph Machine Learning, 2026c. Joshua Robinson, Rishabh Ranjan, Weihua Hu, Kexin Huang, Jiaqi Han, Alejandro Dobles, Matthias Fey, Jan Eric Lenssen, Yiwen Yuan, Zecheng Zhang, et al. RelBench: A benchmark for deep learning on relational databases. Advances in Neural Information Processing Systems, 37:21330– 21341, 2024. Celia Rubio-Madrigal and Rebekka Burkholz. Fixed aggregation features can rival gnns. arXiv preprint arXiv:2601.19449, 2026. Johannes Schmidt-Hieber. The Kolmogorov–Arnold representation theorem revisited. Neural networks, 137:119–126, 2021. Yefan Tao, Xiyuan Zhang, Xinyi Liu, Boran Han, Danielle Maddix, Haoyang Fang, Zhen Han, Jiading Gai, Xuanqing Liu, Michael Bohlke-Schneider, et al. Mitra-v2 technical report. arXiv preprint arXiv:2609.04540, 2026. Gemma Team, Aishwarya Kamath, Johan Ferret, Shreya Pathak, Nino Vieillard, Ramona Merhej, Sarah Perrin, Tatiana Matejovicova, Alexandre Ramé, Morgane Rivière, et al. Gemma 3 Technical Report. arXiv preprint arXiv:2503.19786, 2025. Joaquin Vanschoren, Jan N Van Rijn, Bernd Bischl, and Luis Torgo. Openml: networked science in machine learning. ACM SIGKDD Explorations Newsletter, 15(2):49–60, 2014. Minjie Wang, Quan Gan, David Wipf, Zhenkun Cai, Ning Li, Jianheng Tang, Yanlin Zhang, Zizhao Zhang, Zunyao Mao, Yakun Song, Yanbo Wang, Jiahang Li, Han Zhang, Guang Yang, Xiao Qin, Chuan Lei, Muhan Zhang, Weinan Zhang, Christos Faloutsos, and Zheng Zhang. 4DBInfer: A 4D benchmarking toolbox for graph-centric predictive modeling on RDBs. Advances in Neural Information Processing Systems, 37:27236–27273, 2024. 13

Penghui Wang, Wei Liu, Hong Wang, Chengyue Huang, Yuxi Sun, Zirui Wang, Hongming Huang, Quan Wang, Chunxiao Liu, et al. Xiaomi-TabLDM: A tabular foundation model technical report. arXiv preprint arXiv:2609.03880, 2026a. Yanbo Wang, Xiyuan Wang, Quan Gan, Minjie Wang, Qibin Yang, David Wipf, and Muhan Zhang. Griffin: Towards a graph-centric relational database foundation model. In International Conference on Machine Learning, 2025. Yanbo Wang, Jiaxuan You, Chuan Shi, and Muhan Zhang. Relational in-context learning via synthetic pre-training with structural prior. In International Conference on Machine Learning, 2026b. Yangkun Wang, Jiarui Jin, Weinan Zhang, Yongyi Yang, Jiuhai Chen, Quan Gan, Yong Yu, Zheng Zhang, Zengfeng Huang, and David Wipf. Why propagate alone? Parallel use of labels and features on graphs. International Conference on Learning Representations, 2022. Fang Wu, Vijay Prakash Dwivedi, and Jure Leskovec. Large language models are good relational learners. In Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), 2025. Marek Wydmuch, Łukasz Borchmann, and Filip Graliński. Tackling prediction tasks in relational databases with LLMs. arXiv preprint arXiv:2411.11829, 2024. Linjie Xu and David Wipf. Parameter-free encoders remain viable for RDB foundation models. ICML Workshop on Foundation Models for Structured Data, 2026. Linjie Xu, Yanlin Zhang, Quan Gan, Minjie Wang, and David Wipf. No need to train your RDB foundation model. International Conference on Machine Learning, 2026. Han Zhang, Quan Gan, David Wipf, and Weinan Zhang. GFS: Graph-based feature synthesis for prediction over relational databases. arXiv preprint arXiv:2312.02037, 2023a. Xingxuan Zhang, Gang Ren, Han Yu, Hao Yuan, Hui Wang, Jiansheng Li, Jiayun Wu, Lang Mo, Li Mao, Mingchao Hao, et al. Limix: Unleashing structured-data modeling capability for generalist intelligence. arXiv preprint arXiv:2509.03505, 2025a. Xingxuan Zhang, Gang Ren, Hao Yuan, Hao Zou, Hongze Tan, Hui Wang, Jianhao Song, Jiansheng Li, Jiayao Zhang, Jinghan Zhang, et al. LimiX-2: A contextual mechanism network towards general structured-data intelligence. arXiv preprint arXiv:2609.17488, 2026. Xiyuan Zhang, Danielle C Maddix, Junming Yin, Nick Erickson, Abdul Fatir Ansari, Boran Han, Shuai Zhang, Leman Akoglu, Christos Faloutsos, Michael W Mahoney, et al. Mitra: Mixed synthetic priors for enhancing tabular foundation models. arXiv preprint arXiv:2510.21204, 2025b. Yanlin Zhang, Ning Li, Quan Gan, Weinan Zhang, David Wipf, and Minjie Wang. Elf-Gym: Evaluating large language models generated features for tabular prediction. In Proceedings of the 33rd ACM International Conference on Information and Knowledge Management, pp. 5420–5424, 2024. Zizhao Zhang, Yi Yang, Lutong Zou, He Wen, Tao Feng, and Jiaxuan You. Rdbench: ML benchmark for relational databases. arXiv preprint arXiv:2310.16837, 2023b. Roman Zykov, Noskov Artem, and Anokhin Alexander. Retailrocket recommender system dataset, 2022. URL https://www.kaggle.com/dsv/4471234.

14

A

F URTHER A NALYSIS OF THE C ONTINUUM P ERSPECTIVE FROM S ECTION 4

In this section we demonstrate that simple ensembling or interpolation strategies, designed to combine canonical TFMs (without gpf ) and RDB-native FMs, may struggle to handle data along a continuum between single-tables and RDBs. Later, we discuss further benchmarking implications of the continuum perspective. A.1

E NSEMBLING D IFFERENT FM T YPES C ANNOT R ESOLVE THE C ONTINUUM

One candidate workaround for navigating varying relational effects on a continuum would be to invoke both a typical RDB FM and a single-table FM, and then simply use the validation set to either pick the best one or form some type of ensemble. To analyze this possibility, we define predictions from tabular and RDB FMs respectively as
tab ŷtest := fθtab {z i , yi }ni=1 , z test s.t. z = x (8)

rdb rdb n ŷtest := fθ {z i , yi }i=1 , z test s.t. z = gϕ GH (x) for an arbitrary input RDB. The TFM from (8) only has access to T 1 information, or any tables that can be trivially joined to T 1 without a true encoder gpf (i.e., by design we are assuming standard single-table operational mode here, not a TFM equipped with gpf for handling rich relational effects). To formalize things further, we require precise specifications of a suitable RDB generation process. We must also introduce some form of practical constraint on the RDB FM encoder; otherwise, it is trivially a superset of the TFM listed in (8). We present these definitions first, before proceeding to the main result of this section. Definition A.1. We define Dτ as an RDB induced by a single table via the following generation process pτ , where continuation parameter τ ∈ [0, 1] mitigates the significance of cross-table relational cat real d factors. First, we draw tabular rows xi = [xreal i ; xi ] from some p(xi ), where xi ∈ R represent cat κ numerical features, xi ∈ C are categorical features with |C| ≤ B and i = 0, . . . , N . We assume that the marginal p (xreal ) is an absolutely continuous distribution satisfying p (xreal ) ≤ pmax for all xreal ∈ Rd . We treat each categorical column as an FK pointing to a new auxiliary table T k (with k ∈ {2, . . . , κ + 1}) composed of a single PK column (the elements of which correspond with the unique categories in the referring FK column). And finally, we generate labels by first uniformly d′ e real sampling d′ < d indices from {1, . . . , d} to form the reduced numerical features x i ∈ R . We then compute labels as 
 yi = ψ (1 − τ )f1 (e xreal ∈ Y, ∀i = 0, . . . , N, (9) i ) + τ f2 GH (xi )\xi where f1 and f2 are continuous functions mapping their respective domains to a shared r-dimensional embedding space Rr , after which ψ : Rr → Y converts to the label space.4 We reserve {GH (xi ), yi }ni=1 for ICL, with n < N ,5 while treating sample i = 0 as {GH (xtest ) , ytest }. Definition A.2. We define a space of minimally constrained RDB encoders ḡ, elements of which
produce fixed-length embeddings as z = gϕ GH (x) ∈ Rdz . Furthermore, we impose that 
 n inf inf EDτ ∼pτ ∥xreal (10) test − η {z i , yi }i=1 , z test ∥ > 0, gϕ ∈ḡ η

with expectation over the generation process from Definition A.1 and η : Rdz ×(n+1) × Y n → Rd as an arbitrary continuous mapping. The intuitive implication of Definition A.2 is simply that xreal test , which may be high-dimensional, cannot be completely reconstructed (in expectation) using all of the encoded information available to an ICL-based decoder qθ (namely {z i , yi }ni=1 and z test ), regardless of which gϕ is chosen. This is nominally a reasonable restriction to impose given that typical RDB encoders must ultimately 4 For reference, GH (x)\x represents all H-hop neighborhood information available at the timestamp associated with x (following the newly-generated PK-FK pairs), but excluding the seed row features x. 5 This is effectively equivalent to uniform sampling given the original construction with IID rows.

15

compress into fixed-length embeddings, and such compression may apply to an original feature row x, particularly so for any high-dimensional numerical values. Moreover, (10) does not rule out complete reconstruction of d − 1 elements of xreal test , indicating minimal enforced compression. Given these definitions, we now analyze the limitation of ensembling: Proposition A.3. For any ε ∈ (0, 1) and C > 0 there will always exist fixed mappings {Ψ′ , f1′ , f2′ } such that the following simultaneously hold: h i tab min EDτ ∼pτ ytest − ŷtest =0 τ =0 fθtab

min

fθrdb , gϕ ∈ḡ

min

fθtab , fθrdb , gϕ ∈ḡ, α∈[0,1]

h EDτ ∼pτ

h EDτ ∼pτ

rdb ytest − ŷtest

tab rdb ytest − α ŷtest + (1 − α)ŷtest

i

i

=0

τ =1

≥C

∀ τ ∈ [ε, 1 − ε],

(11)

where Dτ ∼ pτ indicates an RDB sampled according to Definition A.1 with {Ψ, f1 , f2 } = {Ψ′ , f1′ , f2′ } and n > d′ , and ḡ denotes any RDB encoder satisfying the conditions of Definition A.2. Even though we are optimizing separately for each τ , this relatively straightforward result shows that any additive combination of the two FMs (as produced by typical ensembling) can perform arbitrarily badly. This is despite the fact that for the purely tabular regime (τ = 0), the TFM exhibits ideal behavior, while for the purely relational case (i.e., τ = 1 implying no dependence on the original target row features) the RDB FM performs perfectly. Admittedly, we can always try training a more complex combining function to address this scenario, but then we are diverging from the targeted FM regime to supervised learning. In contrast, if we pre-train our original FMs to consistently handle such cases, then in principle we should arrive at a model the operates effectively on both single and multiple tables. But of course this is the main point we are advocating for in the first place; namely, RDB FMs should work on single tables or single-table adjacent regimes as well. A.2

B ENCHMARKING I MPLICATIONS OF THE C ONTINUUM P ERSPECTIVE

If there were always a clear-cut distinction between single tables and RDBs, then benchmarking would be straightforward: simply partition into separate domains and evaluate accordingly, RDB FMs tested only on RDBs (e.g., RelArena, RelBench, 4DBInfer, etc.) and TFMs only on single tables (e.g., TabArena). But in light of the continuum described in Section 4, is such strict partitioning unequivocally warranted? For example, consider breaking out of this mold by applying an RDB FM to a suite of traditional tabular benchmarks. If performance is competitive relative to frontier TFMs that specialize on single tables, then our confidence in the robustness of this RDB FM justifiable grows. But now suppose instead that performance is notably lagging. It is tempting to simply discount such cases as the magisteria of single-table FMs and move on; however, the continuum perspective complicates any such immediate dismissal. After all, if an RDB FM does not work well on single-tables, what about performance on RDBs along a continuum that are minimally different from single tables? More broadly, it is reasonable to question how large is the multi-table relational neighborhood around any single-table benchmark within which unsatisfactory predictions are likely to be produced. Or conversely, we may ask how large along any continuum must this neighborhood grow before the RDB FM capabilities begin to outshine TFM alternatives by exploiting relational effects. It is precisely these factors that (at least partially) motivate RDB FMs based on TFMs that already perform well on single tables.

B

I MPLICATIONS OF E NCODER L ABEL U SAGE

Two counter-points challenge the efficacy of the parameter-free encoders gpf upon which TFMs applied to RDBs are based. Both involve the use of observable labels as inputs to a trainable gϕ , and the potential benefits of doing. We analyze these scenarios next, providing new insights that further inform foundational questions of RDB FM development. 16

B.1

L ABELS AS E XTRA D ISCRIMINATIVE F EATURES

Per previously-stated definitions, an RDB neighborhood subgraph GH (x) may include nodes associated with other rows of T 1 ≡ X, provided these rows are reachable within H PK-FK hops and have an earlier time-stamp to avoid temporal leakage. As these rows have associated labels, it is natural to consider including them as extra node features to improve downstream predictability. We adopt ∗ GH (x) to reference the resulting subgraph with these labels concatenated as additional node features; ∗ we are assuming here that any labels included within GH (x) have time-stamps earlier than x. In more traditional supervised learning regimes involving graphs, this is a common practice for improving node classification accuracy (Wang et al., 2022) (akin to a trainable form of label propagation). More recently, analogous ideas have been applied to RDB foundation models, whereby trainable encoders are explicitly designed to process past labels of similar entities within an RDB neighborhood (Chen et al., 2026; Hudovernik et al., 2026; Ranjan et al., 2026a). But to what degree can we actually rely on such neighborhood labels as predictive features, specifically ∗ in the context of trainable RDB foundation model encoders gϕ applied to GH (xtest ) evaluated at an ∗ unlabeled test row of interest xtest . To begin, for an arbitrary RDB we define Gtest as an augmented version of G, with xtest appended to X, known labels associated with X included as candidate node ∗ (xtest ) denote features, but restricted to entities with timestamps earlier than xtest . We also let GeH ∗ ∗ Gtest \GH (xtest ), meaning all RDB context outside of the label-infused H-hop ego-network centered at test point xtest . And lastly, we adopt yH (xtest ) to indicate the set of all past labels present within ∗ GH (xtest ); this of course does not include the unknown label ytest associated with xtest itself. We then have the following: ∗ Proposition B.1. Given any ego-network GH (xtest ) with |yH (xtest )| > 0, distributions over remaining
∗ ∗ e RDB content p GH (xtest ), ytest |GH (xtest ) will always exist such that: ∗ 1. (Foundation model setting) ytest is a deterministic function of Gtest , and yet any possible fixed encoder gϕ and prediction head qθ perform no better than chance estimating ytest in the sense that

h h h h  ∗ 
ii
ii ∗ ∗ E KL p(ytest |Gtest ) || qθ ytest | gϕ GH (xtest ) ≥ E KL p(ytest |Gtest ) || Unif ytest , (12)
∗ ∗ with outer expectations over p GeH (xtest )|GH (xtest ) . ∗ 2. (Supervised setting) Given {GH (xi ), yi }ni=1 and ytest extracted from any single draw
e∗ test ), ytest |G ∗ (xtest ) , there exists a draw-specific fθ = qθ ◦ gpf satisfying yi = from H  ∗   ∗p GH (x  (xtest ) , where gpf is a parameter-free mapping from fθ GH (xi ) for all i and ytest = fθ GH ∗ any GH (xtest ) to Rm and qθ is a ReLU network with finite width and depth. ∗ Intuition behind Proposition B.1. Neighborhood labels within GH (x) can be highly discriminative ∗ in a supervised setting, where training specifically on samples {GH (xi ), yi }ni=1 extracted from a single RDB predictive task facilitates learning a task-specific discriminative function fθ applicable ∗ to test points GH (xtest ) (part 2). And yet it is not generally possible to determine a stable predictive role for these labels within an encoder that must remain varying datasets/tasks facing a  ∗ fixed across 
foundation model architecture of the form qθ y | gϕ GH (xtest ) (part 1). Given this implication of Proposition B.1, why then are existing schema-agnostic foundation models like the original relational Transformer (RT) model from Ranjan et al. (2026a) capable of making successful predictions? A simple plausible hypothesis is that, within the handful of real-world RDBs available for pretraining RT models, homophily relationships dominate, so simply adopting the majority label of local neighbors can be a highly discriminative feature. Empirical results from Ranjan et al. (2026a)[Table 1] support this conclusion, namely, the similar performance of a basic entity mean predictor explicitly predicated on homophily (66.7 avg AUROC) relative to RT (69.7 avg AUROC).

Implications for ICL-based models. ICL provides one pathway for diversifying label usage effectively beyond the homophily-dominant regimes mentioned above; however, this remains true whether or not a parameter-free encoder gpf is adopted. This is because even without trainable parameters, encoder representations can include diverse label aggregations that are sensitive to both homophily and heterophily relationships; the subsequent ICL-prediction head then sorts which are 17

relevant for any given task. Note that canonical aggregators can trivially handle the parity check example constructed within the proof of Proposition B.1 (see Appendix I). Hence given evidence available thus far, the use of labels as discriminative features does not by itself provide a compelling reason to favor trainable parameterized RDB encoders gϕ within ICL-based models. And so TFMs equipped with gpf ultimately remain viable independently of whether or not such labels are available. B.2

L ABELS FOR A DJUDICATING F EATURE I MPORTANCE

Analysis from Xu et al. (2026) indicates that uninformative feature columns within RDBs cannot generally be filtered out using a dataset-agnostic encoder, which reduces the motivation for including trainable encoder parameters. However, this calculus may change if the encoder is provided with local ∗ neighborhood labels (as in GH (x)). The latter provide task-specific information, which may plausibly facilitate feature-column differentiation on a task-by-task basis as required by RDB foundation ∗ models. But is such differentiation generally possible even when GH (x) is switched to GH (x)? The answer is negative in the following sense: Proposition B.2. Given any representative RDB ego-network GH (xtest ) constructed from non-empty ∗ tabular feature columns and |yH (xtest )| > 0, there will always exist distributions over GeH (xtest ) and yH (xtest ) ∪ ytest such that: 1. Each label in yH (xtest ) ∪ ytest is a shared deterministic function of some support set S of tabular column features and independent of all remaining columns. 2. Encoder input labels yH (xtest ) provide
no information about
the unknown generating support ∗ set S in the sense that p S|GH (xtest ) = p S|GH (xtest ) . Implications for ICL-based models. While not strictly ruling out any benefit of trainable encoders, Proposition B.2 does mute confidence in their ability to robustly screen uninformative columns through the use of local neighborhood labels as additional inputs. This plausibly suggests that, at least for RDBs with large numbers of feature columns (many of which are likely uninformative), trainable encoders may be unnecessary, especially given that parameter-free encoders are already structured to naturally handle column-wise feature screening (Xu et al., 2026). Therefore, consistent with our conclusions from Appendix B.1, TFMs with an appropriate gpf need not fall behind, even when considering encoder label usage for assessing task-specific feature importance. We also remark in closing that the RDB FM architecture described in Hudovernik et al. (2026) involves first converting each RDB table T k into revised embeddings U k dependent on task-specific labels, prior to formation of GH and subsequent presentation to gθ (this conversion is accomplished with an additional module akin to a traditional TFM applied on single tables). While certainly an innovative idea, and one that can be applied within purely TFM-based pipelines like RDBLearn as well, the extent to which uninformative columns can be resolved at this early stage may still have limitations (e.g., the counter-example used to prove Proposition B.2 would disallow filtering uninformative columns using the signal within a given U k alone). However, further treatment of these possibilities lies beyond the scope of this work.

C

A DDITIONAL ICL S AMPLING C ONSIDERATIONS

C.1

E VALUATING S AMPLE C OMPLEXITY

We remark that Ranjan et al. (2026b;c) emphasize the impressive sample efficiency of RT-J relative to TFM-based RDBLearn, ostensibly requiring many fewer labeled ICL samples to achieve competitive performance. But there are two key factors that merit consideration when interpreting the empirical comparisons upon which this claim is based: Different notions of sample complexity. ICL samples in Ranjan et al. (2026b;c) are only counted per test instance, as opposed to counting the total number of unique samples required across an entire test set, i.e., the union of unique samples extracted over all test instances associated with a given task. This distinction is critical, since RDBLearn is designed to adopt a fixed ICL batch that is shared over all test instances, while RT-J requires a new batch for each separate inference point. Obviously then, 18

the cardinality of the fixed RDBLearn set will generally be larger than what RT-J adopts for just a single test instance. But if we compute the average number of unique ICL samples needed per test instance, RDBLearn may operate using far fewer depending on the RDB task. Hence RDBLearn can potentially be more sample efficient relative to RT-J per this alternative metric as the number of test points grows larger. This distinction impacts not only the required number of labeled observations, but also execution costs, since RDBLearn need only extract ICL samples and construct a fixed TFM KV cache once per task, regardless of how many test points exist. Model alignment. The actual per-instance empirical ICL sample complexity results reported in Ranjan et al. (2026b;c) are not directly based on an RDBLearn specification from either Xu et al. (2026) or Xu & Wipf (2026). Instead, the RDBLearn pipeline is restricted to the TFM base model TabICL-v2 and paired with much smaller per-instance ICL sample batches originally prepared for RT-J (via random-walks combined with BFS local searches). Notably, RT-J pretraining is explicitly aligned with this particular ICL-sampling regime, while RDBLearn is nominally designed for larger fixed ICL sets (per motivations from Section 5). Even so, our central point here is not to discount the prior comparisons between RT-J and RDBLearn from Ranjan et al. (2026b;c), which certainly convey a useful complementary perspective, particularly if the goal is quantifying minimal sample complexity costs for a single test point executing from scratch. Rather, we are simply advocating that additional factors provide important balance, especially when weighing diverse tasks involving a multiplicity of test points. C.2

D EGENERACY E XAMPLE FROM R ANDOM WALK S AMPLING

Assume data drawn according to Definition A.1, with original feature table T 1 = X and corresponding labels y, as well as induced auxiliary table T 2 ∈ C B composed of a single PK column. The latter is assumed to correspond with a categorical column in T 1 that we treat as an FK column pointing to the PKs in T 2 . Granting this simplified setup, we observe that any random walk originating at an arbitrary row i of T 1 will at most reach |Ri | rows of T 1 . Here Ri denotes the set of rows within T 1 that share the same FK value as row i. There is no mechanism for longer random walks to eventually extend across the entire RDB; each must stall within Ri because ultimately the underlying graph G extracted from the RDB is not fully connected. The graph underlying the experiments shown in Figure 3 exhibits an analogous phenomenon. The only difference is that the FK column switches from (implicitly) T 1 to (explicitly) T 2 in this example, while the corresponding G remains disconnected. This might help explain why the RT-J model does not happen to work as well within the particular context of the Figure 3 experiments (note that RDBLearn would also not perform well here if forced to adopt the same RW sampling procedure). That being said, if the RT-J context budget is not filled by random-walk accessible rows, a fallback involving hybrid uniform sampling akin to RDBLearn could represent a potential workaround.

D

L ANGUAGE M ODEL AGENT U SAGE

A growing body of evidence suggests that LLM agents can play a useful role in tabular model development (Han et al., 2024; Huang et al., 2026; Kim et al., 2026; Zhang et al., 2024). That being said, their usage in the specific context of RDB predictive modeling involves notable caveats from a benchmarking perspective. One in particular relates to potential leakage issues that may obscure the degree to which we can plausibly extrapolate benchmarking results to expected performance within new siloed industry settings. This concern stems from the fact that existing public benchmarks are scarce, largely because of privacy concerns with real-world data. And yet predictive solutions addressing the few RDB datasets that do exist, often involving feature engineering and human expertise, are readily visible to frontier LLM agents during their pre-training process or during inference-time retrieval. Hence agent-based solutions may simply lean on problem-specific prior human knowledge to a degree that may not be possible on less-familiar or esoteric tasks within private RDB repositories. Of course this is not meant to discourage LLM-based RDB frameworks, and certainly TFMs equipped with gpf (e.g., RDBLearn, TabPFN-Rel-OSS, etc.) are a natural fit for agentic enhancements, the topic of Section 7. We only advocate that some caution is warranted when interpreting results, especially when extrapolating to new domains. While similar concerns have certainly been raised with other data modalities, we would argue that the situation is more acute in RDB regimes with only limited, relatively well-known benchmarking sources that are susceptible to memorized solutions. 19

E

E XPERIMENT D ETAILS AND F ULL R ESULTS B EHIND F IGURE 1

E.1

D ESCRIPTION OF TFM- BASED A PPROACHES

For TFM-based pipelines we adopt RDBLearn (version 1.1 from Xu & Wipf (2026)) and TabPFNRel (version from Hayler et al. (2026)); we use TabPFN-Rel-OSS to refer to the open-source release of TabPFN-Rel.6 Since our goal is to examine TFM-based approaches on a wider task set than original papers considered, we ran both RDBLearn and TabPFN-Rel-OSS out of the box ourselves from the respective public repos using default configurations.7 Both methods were run on a single Nvidia RTX 5090 (32G) GPU. For RDBLearn, we encountered OOM errors in some tasks when the TFM was LimiX or TabFM. These sweep cases were simply skipped, so RDBlearn just selects from the remaining healthy cases. Meanwhile, we found that TabPFN-Rel-OSS did not execute on the multi-class SALT benchmark in our environment; hence this is our only exclusion in terms of reported results.8 In terms of architecture, RDBLearn and TabPFN-Rel-OSS are conceptually the same, with a shared gpf implementation, but differing primarily in which tabular base models are chosen and details of how ICL sample sets are constructed. For example, TabPFN-Rel-OSS includes validation samples in the final chosen ICL set as in Hudovernik et al. (2026), and also oversamples ICL instances with more recent past timestamps; the latter is consistent with benefits of recency featurization bias explored by Huang et al. (2026). Neither RDBLearn nor TabPFN-Rel-OSS include text-column handling (text columns are simply ignored), unlike the closed-source TabPFN-Rel version (see below) which includes a proprietary module for this purpose. We also remark that new crops of advanced single-table FMs are constantly being released; recent examples that appeared as we were finalizing this draft include TabPFN-v3.5 (Jäger et al., 2026), EXAONE (Eo et al., 2026), LimiX-2 (Zhang et al., 2026), Mitra-v2 (Tao et al., 2026), and XiaomiTabLDM (Wang et al., 2026a). These approaches can readily be combined with an encoder gpf to further boost performance relative to alternative RDB FM formulations. However, we do not rerun all experiments using these options, since our central goal herein is not to surface the best possible TFM configuration within RDB operational settings. The latter represents a moving target, and remains somewhat orthogonal to our primary objective, which the results from Figure 1 already adequately achieve. E.2

D ESCRIPTION OF OTHER BASELINE M ODELS

To compare against the TFM-based approaches from above, we present evaluations across a wide range of alternative RDB predictive architectures, including both foundation models and more traditional supervised learning approaches. We emphasize though that results are not presently available for all models on all datasets. For example, it is frequent practice to only report results on RelBench-v1 datasets and tasks, or to only report results on some tasks within a given benchmark. Closed-Source Foundation Models. We include the original industry model KumoRFM-1 (Fey et al., 2025) as well as the more recent version KumoRFM-2 (Hudovernik et al., 2026) that incorporates task-specific labels within the encoder and constituent table embeddings.9 We also compare with OpenRFM (Chen et al., 2026); while this model is presumably intended to be open-sourced at some point, the full code is not available at the time of this writing. For all of these closed-source approaches we rely on posted performance results from original authors for evaluation purposes, with one exception. We follow Grinsztajn et al. (2026), who have independently reevaluated KumoRFM-2 performance via API calls for certain datasets using author-provided benchmarking scripts. 6

Improved configurations of both RDBLearn and TabPFN-Rel are possible, but lie outside of our scope. An exception is TabPFN-Rel-OSS on RelBench-v1 tasks, whereby existing results were pulled directly from Hayler et al. (2026) rather than running ourselves. 8 TabPFN-Rel-OSS presently does not support class cardinalities that exceed the base TFM capability, and SALT tasks happen to exceed this limit for now. 9 KumoRFM-2 has generally been treated as a closed-source model and we maintain this designation here given that all KumoRFM-2 results in Figure 1 are based on private API calls. Moreover, the KumoRFM-2 pre-training regime and extent of real-world RDB exposure remain undisclosed. 7

20

Open-Source Foundation Model Baselines. Open-source baselines include the schema-agnostic Griffin (Wang et al., 2025), RelLLM (Wu et al., 2025), and RT (relational transformer) (Ranjan et al., 2026a) models, as well as an updated RT version enhanced with PluRel synthetic pretraining data (Kothapalli et al., 2026), denoted RT-P. On the open-source ICL-based side we include results with RT-J, also based on the RT architecture but with modifications such as random-walk sampling to collect ICL sets (as discussed in Section 5.3 of the main text) and pretraining with a large collection of real-world RDBs called The Join (Ranjan et al., 2026b); see also Appendix C.1 for additional perspective on RT-J sampling considerations and prior comparisons with RDBLearn. Furthermore, we compare results from RDB-PFN (Wang et al., 2026b), with synthetic RDB pre-training, and RandGNN (Xu et al., 2026), which combines a random-weight GNN encoder with a TFM-based model. RandGNN represents a form of ablation w.r.t. RDBLearn and TabPFN-Rel-OSS, in that it explicitly mixes cross-column information in a manner at odds with the theoretical considerations upon which these models are based. And finally, for pure language model baselines, we evaluate LLM-A (Team et al., 2025) (as tested in Ranjan et al. (2026a)) and LLM-B (Wydmuch et al., 2024); both approaches are predicated on serialized RDB neighborhood representations and/or ICL samples. Although the underlying LLMs are not open-source, we still treat these approaches as open-source given that the prompts used to reproduce results are publicly available and no hidden fine-tuning steps are involved. Task-Specific Supervised Models. While our emphasis is on RDB foundation models, it is still useful to contextualize FM performance results w.r.t. methods benefitting from per-task supervised training. On this front, largely following prior work, we include the more classical standards LightGBM, XGBoost, and GraphSage as evaluated in Hudovernik et al. (2026). Meanwhile, for recent SOTA supervised architectures we select RelGNN (Chen et al., 2025), RelGT (Dwivedi et al., 2025), RelAgent (Huang et al., 2026), and RT-J+fine-tuning; the latter introduces task-specific fine-tuning of the pre-trained RT-J architecture mentioned previously to achieve SOTA performance on RelArena-α (Hayler et al., 2026). E.3

RDB B ENCHMARKS

In producing Figure 1, we evaluate RDB predictive modeling approaches over a diverse suite of benchmarks, including regression and binary classification tasks from both RelBench-v1 (Robinson et al., 2024) and RelBench-v2 (Gu et al., 2026). Note that RelBench-v1 datasets and tasks are also equivalent to the recently-posted RelArena-α benchmarking platform (Hayler et al., 2026) patterned after TabArena (Erickson et al., 2026). The primary difference is that RelArena-α enforces more rigid/standardized submission protocols that some published work on RelBench-v1 may not satisfy. That being said, RDBLearn and TabPFN-Rel-OSS already adhere to these guidelines, and it is only to the advantage of other models with which we compare if they do not. This means our results in Figure 1 are actually conservative in showcasing the abilities of TFM-based approaches to RDB predictive modeling. Beyond the above, we test over five 4DBInfer (Wang et al., 2024) binary classification datasets that have been used in several recent works (Huang et al., 2026; Hudovernik et al., 2026), as well as the multi-class predictive tasks from the SALT repository (Klein et al., 2024) as adopted by Hudovernik et al. (2026). Standard train/dev/test splits are used for all experiments. Note that for RelBench-v1, we omit only rel-f1 and rel-event datasets because of potential leakage issues mentioned in prior work, and we do not have results for all baseline models on these datasets.

21

E.4

E XTENDED E MPIRICAL R ESULTS

In this section we provide the full set of experimental results upon which the final rankings shown in Figure 1 from the main text are based. The TFM-based methods (along with their attendant gpf ) achieve the best overall performance among RDB FMs. This follows by comparing numbers for RDBLearn, TabPFN-Rel-OSS, and TabPFN-Rel versus other RDB FMs in the tables below. Surprisingly, these frameworks even exceed the results produced by many per-task supervised models. Table 1: Results on 4DBInfer binary classification tasks (AUC↑). Bold = best per column, underline = second best.

Method

AB churn

OB ctr

RR cvr

SE upvote

SE churn

Avg AUROC ↑

Avg Rank ↓

Supervised XGBoost GNN RelAgent

50.00 75.71 79.44

50.00 62.39 62.63

50.00 84.70 86.35

49.68 88.61 89.45

50.84 85.58 89.03

50.10 79.40 81.38

9.6 4.6 2.0

61.11 61.97 52.59

84.36 84.36 78.12

88.92 88.50 85.60

87.87 87.92 85.50

79.57 79.96 75.04

5.1 4.9 7.2

52.22 49.29 63.68 63.76

39.92 66.21 88.92 89.06

71.66 61.06 88.59 87.86

72.18 77.41 89.14 88.69

57.86 66.28 81.51 81.62

8.8 7.6 2.6 2.6

Foundation model Closed-Source KumoRFM-1 75.59 77.06 KumoRFM-2 RDB-PFN 73.38 Open-source Griffin 53.32 77.42 RandGNN TabPFN-Rel-OSS 77.21 RDBLearn 78.71

Table 2: Results on the SALT benchmark (MRR↑). Bold = best per column; underline = second best. salt-item

Avg MRR

Avg Rank

Group

Payment Terms

Shipping Condition

↑

↓

salt-sales

Method

Plant

Shipping Point

Supervised GraphSAGE LightGBM

0.99 0.61

0.98 0.28

0.69 0.73

0.62 0.73

1 0.99

0.16 0.02

0.37 0.10

0.57 0.51

0.67 0.50

3.88 4.75

Foundation model Closed-Source KumoRFM-1 0.99 KumoRFM-2 0.99 Open-source RDBLearn 1

0.99 0.98

0.79 0.78

0.81 0.81

1 1

0.38 0.61

0.38 0.61

0.78 0.79

0.77 0.82

2.56 2.56

0.99

0.82

0.91

1

0.69

0.79

0.84

0.88

1.25

Incoterm

Incoterm

Office

22

Table 3: Results on Relbench v2 binary classification tasks (AUROC↑). Bold = best per column; underline = second best. mimic

ratebeer

arxiv

Avg AUROC

Avg Rank

Method

stay

beer-churn

user-churn

dormant

citation

↑

↓

Supervised LightGBM GraphSAGE Rel-Agent†

51.81 55.01 –

76.21 78.67 84.70

83.92 94.27 97.43

75.79 80.51 83.33

71.21 82.50 82.61

71.79 78.19 –

5.80 3.60 –

56.33 55.28 – –

75.06 83.84 79.60 80.90

91.38 97.43 – –

77.10 80.65 77.50 79.10

80.62 81.71 81.00 81.00

76.10 79.78 – –

4.40 3.00 – –

53.10 55.36

80.15 85.15

98.28 98.48

82.32 81.85

82.69 82.37

79.31 80.64

2.40 1.80

Foundation model Closed-Source KumoRFM-1 KumoRFM-2 OpenRFM (TabICL)† OpenRFM (TabPFN)† Open-source TabPFN-Rel-OSS RDBLearn †

RelAgent and OpenRFM are excluded when calculating average AUROC and rank because results are missing in some cases (RelAgent: no mimic-stay; OpenRFM: no mimic-stay or ratebeer user-churn). Note also that public code is not available to produce results for the missing tasks at the time of this writing.

23

Table 4: Results on Relbench v1 binary classification tasks (AUROC↑). Bold = best per column, underline = second best. avito

trial

amazon

stack

hm

Avg AUROC

Avg Rank

Method

click

visit

out

user

item

eng

badge

churn

↑

↓

Supervised LightGBM GraphSAGE RelGT RelGNN RelAgent RT-J+fine-tuning

53.60 65.90 68.30 68.23 68.36 66.81

53.05 66.20 66.78 66.18 67.79 66.89

70.09 68.60 68.61 71.24 71.86 69.57

52.22 70.42 70.39 70.99 70.78 71.46

62.54 82.81 82.55 82.64 82.84 83.16

63.39 90.59 90.53 90.75 90.41 90.65

63.43 88.86 86.32 88.98 88.42 89.21

55.21 69.88 69.27 70.93 71.07 70.49

59.19 75.41 75.34 76.24 76.44 76.03

18.88 6.38 6.81 4.12 3.50 4.00

64.85 67.42 67.42 67.52 62.30 63.90

64.11 69.41 69.41 66.80 64.60 64.60

70.79 72.03 72.03 76.47 60.80 63.40

67.29 69.10 67.71 70.86 – –

79.93 82.17 80.18 82.80 – –

87.09 89.40 88.69 90.60 88.50 88.40

80.00 87.15 85.40 88.04 86.30 86.40

67.71 69.27 67.81 70.52 68.60 68.90

72.72 75.74 74.83 76.70 – –

11.56 6.62 7.69 3.88 – –

59.80 61.32 62.28 45.90 59.50 51.39 47.90 64.46 61.58 61.45 67.55

62.70 60.28 56.17 60.70 61.80 64.09 63.40 65.82 64.15 66.88 66.71

57.40 55.72 59.02 51.00 51.80 64.43 51.80 64.50 55.98 73.06 72.71

58.10 60.56 60.07 62.30 64.00 67.20 65.00 65.92 65.87 70.24 69.33

62.10 71.96 64.10 69.00 70.90 78.61 72.50 79.59 77.73 82.79 82.25

78.00 81.01 69.46 77.50 75.70 86.76 86.20 88.04 85.14 90.58 89.92

80.00 71.13 62.12 73.50 80.10 81.11 82.00 84.52 83.14 86.35 85.23

59.80 64.34 55.95 60.20 62.80 65.66 66.00 67.21 66.54 70.57 68.27

64.74 65.79 61.15 62.51 65.83 69.91 66.85 72.51 70.02 75.24 75.25

17.69 17.12 18.25 18.62 17.19 14.25 15.69 11.75 13.75 6.00 7.25

Foundation model Closed-Source KumoRFM-1 KumoRFM-2 (orig.)* KumoRFM-2 (repro.)* TabPFN-Rel OpenRFM (TabICL)† OpenRFM (TabPFN)† Open-source LLM-A LLM-B RelLLM Griffin RT RT-J RT-P RDBPFN RandGNN TabPFN-Rel-OSS RDBLearn ∗

Results are drawn from both the original KumoRFM-2 paper (Hudovernik et al., 2026), as well as an independent reproduction from Grinsztajn et al. (2026) using KumoRFM-2 API calls for some datasets. (The latter relies on official benchmarking scripts for setting the various KumoRFM-2 hyperparameters that may vary from task to task. For datasets with no available scripts, avito and trial, the reproduction value is set to the original.) † OpenRFM is excluded when calculating average AUROC and rank because results are not available for all datasets, and public code is not available to produce results for the missing tasks.

24

Table 5: Results on Relbench-v1 regression tasks (MAE↓). Bold = best per column; underline = second best. avito

∗

trial

amazon

stack

hm

Geo Mean

Avg Rank

Method

ctr

adverse

success

user

item

votes

sales

↓

↓

Base Global Median Entity Median

0.043 0.046

57.533 57.930

0.462 0.441

16.783 17.423

64.234 66.436

0.068 0.069

0.076 0.078

1.303 1.329

14.57 15.57

Supervised LightGBM GraphSAGE RelGT RelGNN RelAgent RT-J+fine-tuning

0.041 0.041 0.035 0.037 0.033 0.0345

44.011 44.473 43.992 44.461 37.194 34.9

0.425 0.400 0.326 0.301 0.386 0.364

16.783 14.313 14.267 14.230 13.949 13.97

60.569 50.053 48.922 48.767 41.765 42.49

0.068 0.065 0.065 0.065 0.064 0.0653

0.076 0.056 0.054 0.054 0.035 0.0375

1.220 1.096 1.030 1.027 0.934 0.937

12.50 8.93 6.57 6.64 2.57 3.86

Foundation Model Closed-Source KumoRFM-1 KumoRFM-2 (orig.)* KumoRFM-2 (repro.)* TabPFN-Rel

0.035 0.034 0.033 0.0311

58.231 43.293 41.974 39.8

0.417 0.433 0.433 0.413

16.161 13.921 14.627 14.4

55.254 46.992 45.352 46.8

0.065 0.064 0.065 0.0679

0.040 0.034 0.043 0.0605

1.102 0.986 1.015 1.051

9.50 4.86 6.21 6.36

Open-source Griffin RT RT-J RandGNN TabPFN-Rel-OSS RDBLearn

0.050 0.058 0.0402 0.038 0.0314 0.033

78.232 73.999 55.377 53.370 42.6 43.565

0.463 0.455 0.4265 0.434 0.386 0.378

35.590 18.802 16.757 17.580 14.4 14.504

53.214 57.996 46.151 66.130 47.8 47.038

0.092 0.110 0.0752 0.071 0.068 0.067

0.151 0.089 0.0501 0.065 0.0614 0.063

1.737 1.543 1.156 1.248 1.058 1.066

16.86 16.71 10.57 14.00 7.29 7.43

See comment from Table 4.

25

F

S ETUP D ETAILS AND F ULL E MPIRICAL R ESULTS FOR F IGURE 2

Setup. For our initial source of single tables, we select binary classification and regression tasks from BeyondArena (Purucker et al., 2026), Fraud Dataset Benchmark (FDB) (Grover et al., 2022), and OpenML (Vanschoren et al., 2014). The origins of specific tasks are listed in Table 6. To better align with realistic RDBs, we consider tasks that have temporal splits, e.g., the “Temporal” category within BeyondArena. Large datasets (home credit default stability) and datasets without categorical columns (maps router eta) are excluded. To induce RDBs from these tables, we select at most 5 categorical columns as FKs following steps 1–4 of the procedure described in Section 4. As mentioned in the main text, we retain the original dataset labels as opposed to synthetically generating new ones. This allows us to probe RDB FM behavior in regimes where relational structure exists, but is not strictly necessary for making accurate predictions. Extended results. In Table 6 we present the full results that contributed to Figure 2, including performance from TabPFN-v3 (Grinsztajn et al., 2026) applied only on the original single-table data as a reference point, RDBLearn (Xu et al., 2026), KumoRFM-2 (Hudovernik et al., 2026), and RT-J (Ranjan et al., 2026b). Because BeyondArena has no validation set, and to standardize comparisons, we simply execute RDBLearn under the fixed setting of hop H = 2 along with just a single TFM selected as TabPFN-v3. For KumoRFM-2, we also use the same default hop value H = 2 and leave the inference-time configuration unchanged. RT-J uses the default inference configuration as well. Regarding hardware, we ran each method on a single GPU. TabPFN-v3, RDBLearn, and RT-J were run on a single Nvidia RTX 5090 (32G). Although the dataset scale is the same, KumoRFM-2 requires more GPU memory. To fulfill this requirement, we ran KumoRFM-2 on a single Nvidia L20 (48G). However, there were still four tasks raising OOM errors, noted in Table 6 and Figure 2.

Table 6: Full results corresponding to Figure 2, where we examine RDBs induced from single tables. Classification reports ROC-AUC (↑); regression reports R2 (↑). Best result per row in bold; second best underlined. Avg (excluding OOM) represents mean performance computed only over tasks/rows where every method reports a value; Avg (all) includes all tasks (KumoRFM-2 omitted due to OOM entries). Task

Origin

TabPFN-v3

RDBLearn

KumoRFM-2

RT-J

0.6245 0.8620 0.8856 0.9542 0.8059 0.8220 0.9101 0.6767 0.9809

0.6098 0.8260 0.8555 0.9098 0.7265 0.7840 0.9061 0.6573 0.9722

OOM OOM 0.8568 0.8752 0.6645 0.7611 0.8354 0.6311 0.9079

0.5797 0.5000 0.3762 0.6176 0.5755 0.5949 0.6860 0.5628 0.6103

0.8622 0.8358

0.8302 0.8052

0.7903 —

0.5748 0.5670

0.9351 0.8339 0.3390 0.4549 0.4375 0.3686 0.5519 0.8161 0.6283 0.0610

0.9345 0.8293 0.3515 0.4505 0.3435 0.5094 0.5446 0.8244 0.5978 0.1751

0.9091 0.7879 0.0928 0.3617 0.4034 0.3011 OOM 0.5957 OOM 0.1669

0.0026 0.7575 0.0769 0.3211 0.2797 −0.1818 0.0000 0.3062 0.0149 0.2714

0.5308 0.5426

0.5523 0.5561

0.4523 —

0.2292 0.1849

Classification (ROC-AUC ↑) acquire valued shoppers challenge anes voting 2026 bank marketing temporal month electricity temporal hotel booking demand kick kickstarter lending club sparknov temporal

BeyondArena BeyondArena OpenML OpenML BeyondArena BeyondArena BeyondArena BeyondArena FDB

Avg (excluding OOM) Avg (all) Regression (R2 ↑) california house prices 2020 climate model weather forecasting coffee rating prediction cooking time delivery eta garments worker productivity mercedes benz greener manufacturing rossmann store sales sberbank housing market forecasting sf permit time

BeyondArena BeyondArena BeyondArena BeyondArena BeyondArena BeyondArena BeyondArena BeyondArena BeyondArena BeyondArena

Avg (excluding OOM) Avg (all)

26

G

D ETAILS OF I NTERACTION E XPERIMENTS

This section describes the detailed setup for experimenting with the interaction terms discussed in Sections 6 and 7, particularly as they relate to Figure 3. G.1

S ETUP B EHIND F IGURE 3 ( LEFT )

Data generation. Each synthetic RDB contains two tables, a target/parent T 1 and a child T 2 . Table T 1 contains two columns (PK and a label) and 4000 rows (3200 for training and 800 for testing). Each row of T 1 is linked to l rows of T 2 via PK-FK pairs, where T 2 is composed of a single FK column as well as two signal columns {a, b} mixed within a variable number of uninformative columns. We set l ∼ Uniform{2, . . . , 20}. Signal columns are synthesized with Bernoulli(0.3) for binary variants or N (0, 1) for Gaussian ones, alongside d2 − 2 additional columns drawn IID from the same respective family, for total widths d2 ∈ {8, 16, 32, 64, 96} for T 2 instantiations. Label synthesis. We incorporate 4 labeling functions to cover both linear and nonlinear relationships. For each row in the task table where PK= i, let Ri = {j ∈ T 2 where FKj = i}. Labels are generated by aggregating the row-level interaction with different the aggregation functions: • mean: yi = meanj∈Ri aj bj ; • thresholded count: yi = countj∈Ri (aj bj > 1) ; L • parity: yi = j∈Ri (aj ∧ bj ) ; • prod agg: yi = meanRi (a) · meanRi (b). We remark that prod agg is favorable to RDBLearn since gpf already computes this form of interaction between aggregations, as mentioned in Section 6. Meanwhile, the other aggregation choices are not favorable to RDBLearn since they are not computed by any single aggregation (although combinations thereof may approximate them). For different labeling rules, we experimented with different data column distributions as follows: • parity, mean, and prod agg with binary columns; • count(ab > 1) with Gaussian columns. Together these selections give us the four tasks listed in Figure 3 (left). Experiment models. We compare TFM-based RDBLearn against the top non-TFM-based RDB FMs, KumoRFM-2 (Hudovernik et al., 2026) and RT-J (Ranjan et al., 2026b), all in-context with no task-specific training or fine-tuning. RDBLearn simply uses H = 2 to match the KumoRFM-2 default setting, run from a local deployment of the published model. RT-J uses the public zero-shot checkpoint for FM operational mode (i.e., no fine-tuning). For both KumoRFM-2 and RT-J we first validated our implementation pipeline by reproducing performance numbers from the respective published papers. G.2

Q UASI -R EAL W ORLD RDB U SED IN F IGURE 3 ( RIGHT )

We adopt the rel-trial RDB (Robinson et al., 2024) for the quasi-real world interaction experiment. We do not modify the actual schema; instead, for each trial we pick two numerical or categorical columns {a, b} co-located in one child table of the task entity, and define each task label as the temporallyvalid mean of the row-level product aj bj over the linked child rows, computed strictly over rows dated before the task timestamp. The same per-row cutoff column is consumed by all three models, so no model can access post-cutoff rows during labeling or inference. Column pairs touching value columns whose measurement unit varies across rows (param value and the confidence-interval limits, whose unit depends on a sibling code column) are excluded a priori and outcome-blind, leaving nine child-table pairs. These pairs form the x-axis labels of Figure 3 (right). We repeat the above experiment, this time explicitly adding an additional child-table column formed from this so-called “golden feature” interaction term. This is meant to reflect a hypothetical scenario 27

whereby an informed agent has supplied this product term as an additional useful feature. We then explore the degree to which each RDB FM can effectively utilize this column to improve predictive performance in Figure 3 (right).

H

D ETAILS OF R EAL -W ORLD AGENTIC E XPERIMENT

Following the pointer at the end of Section 7, this experiment represents a preliminary proof-ofconcept, not an exhaustive exploration of possibilities. And certainly there are more principled ways of incorporating agents within a TFM-based paradigm than what we have done. We also stress one additional point upfront: Even as agents are often able to generate useful predictive features, this typically requires extensive domain knowledge and/or meta-data associated with a given RDB (this may also introduce new pathways for leakage and/or memorization that could artificially inflate performance; see Appendix D). In contrast, TFM-based models like RDBLearn and TabPFN-Rel can in principle operate out of the box in new domains without such knowledge, providing greater flexibility and privacy. H.1

E XPERIMENT SETUP

TFM-based methods leverage agent-friendly SQL-based RDB harnesses, where SQL queries are automatically generated to aggregate features from RDBs. These queries are agent-readable and provide an alternative entry point for understanding the predictive modeling task and core RDB structure. Based on this observation, we prompt Cursor Grok 4.5 under the default Cursor 3.6.31 harness. We provide a single prompt together with the raw training set and the corresponding features generated by the RDBLearn encoder gpf . Note that we do not allow the agent to iterate (e.g., by using a loop). Therefore, the feature generation is a single forward pass. This is substantially different from the SOTA RelAgent (Huang et al., 2026), which trains numerous fully-supervised models (on a per-task basis) across multiple iterations of a multi-agent system. For our experiments, the prompt for all tasks is the same except for the task name. As a representative example, the rel-trial prompt is as follows: Prompt for Cursor Grok 4.5 to generate RDB features If you look into what the rel-trial/study outcome tasks are, understand what the goal is, then look into DFS-depth 4 (including hop 1-4) SQLs. Can you analyze what features are useless and what new useful feature column you can add to the flattened table by SQL?” H.2

L EAKAGE C HECK

For our experiment, only the training set is exposed to the agent. To investigate whether there is data leakage, we manually look into the trace and prompt the agent to self-check. As a result, two features for rel-event tasks were found aggregating future (the same week) data. They are sql hist ignore rate and sql hist repeat rate, which calculate past-week label statistics. Although the target predictive entity is excluded from the calculation, when this predictive entity correlates with a mid-week date, same-week future label information can still be included. (For reference, performance results in Table 7 below exclude these two features.) Beyond this, inspecting every tool call in the agent trace, we did not observe any behavior that would indicate retrieval/access of validation or testing set information. H.3

R ESULTS

Table 7 presents the performance comparison between the agent-feature-enhanced RDBLearn (based on TabPFN-v3.5 (Jäger et al., 2026)) and a SOTA multi-agent system, RelAgent (Huang et al., 2026). We note that even without domain knowledge and metadata information, RDBLearn already outperforms RelAgent (Qwen3-32B). And when enhanced with agent-generated features, its performance is significantly boosted to be on-par with RelAgent (GPT-5.2). Critically though, all RelAgent versions are fully-supervised, training many per-task models, whereas RDBLearn remains a training-free FM enhanced with just a single batch of agent-generated features and no iterations. 28

Table 7: RDBLearn+Agent results on RelBench-v1 binary classification tasks (AUROC↑). Bold = best per column, underline = second best. We emphasize that RelAgent is fully-supervised, training numerous models per task, while RDBLearn is an FM. Dataset

Task

RelAgent (GPT-5.2)

RelAgent (Qwen3-32B)

RDBLearn

RDBLearn+Agent

rel-amazon

item-churn user-churn

0.8284 0.7078

0.7992 0.6922

0.8270 0.6973

0.8273 0.6968

rel-avito

user-clicks user-visits

0.6836 0.6779

0.6510 0.6462

0.7050 0.6714

0.6994 0.6661

rel-event

user-ignore user-repeat

0.8725 0.7820

0.7591 0.7473

0.7446 0.7646

0.7873 0.7753

rel-f1

driver-dnf driver-top3

0.7834 0.8523

0.5767 0.5804

0.7263 0.7975

0.8351 0.9204

rel-hm

user-churn

0.7107

0.7062

0.6895

0.6953

rel-stack

user-badge user-engagement

0.8842 0.9041

0.6530 0.8911

0.8678 0.9051

0.8514 0.8982

rel-trial

study-outcome

0.7186

0.7136

0.7265

0.7569

0.7838

0.7013

0.7602

0.7841

AVG (12 tasks)

I

T ECHNICAL P ROOFS

I.1

P ROOF OF P ROPOSITION 5.2

Generalizing from Nagler (2023), the proof here is relatively straightforward once the RDBdependent setup is specified through Definition 5.1, the assumption that (2) holds, and that

p yi |GH (xi ) = p yi |z i ∀i = 0, . . . , n. The first and third assumption alone imply that a given label yi is independent of others when conditioned on the corresponding encoder outputs, i.e., p(yi , yj |z i , z j ) = p(yi |z i )p(yj |z j ) ∀i, j. Hence we may
also infer that for any labeled sample, the conditional p(y|z), as opposed to merely p y|GH (x) , is stable across n, even while encoder representations z need not be. Now consider any sequence pairs p, p̌ ∈ P, along with their associated label generators p(y|z) and p̌(y|z) respectively, satisfying p(y|z) = p̌(y|z) whenever ∥z test − z∥ < ϵ for any fixed ϵ > 0. For all such pairs, we have from (2) (bias part) that 
 p(ytest |z test ) − EDn ∼pn qθ ytest | {z i , yi }ni=1 , z test (13)   
 − p̌(ytest |z test ) − EDn ∼p̌n qθ ytest | {z i , yi }ni=1 , z test 
 
 EĎn ∼p̌n qθ ytest | {ž i , y̌i }ni=1 , z test − EDn ∼pn qθ ytest | {z i , yi }ni=1 , z test → 0 as n → ∞, where {z test , ytest } is treated as a fixed evaluation point. Combining with (2) (variance part) we then may conclude that

qθ ytest | {ž i , y̌i }ni=1 , z test − qθ ytest | {z i , yi }ni=1 , z test → 0. (14) From standard diagonalization arguments, the same holds true for some ϵn → 0 since no assumptions were placed on the original ϵ, therefore (3) is established. ■

I.2

P ROOF OF P ROPOSITION A.3

We show this result through an interpretable counter-example. Note that there is nothing particularly special about the configuration we introduce for this purpose; rather it merely represents a simplified case sufficient for illustration purposes and completing the proof. As we will see, the core ingredient is the existence of at least some degree of nonlinear interaction between relational effects within GH (x) and the original tabular features x. Basic Setup. For any ε ∈ (0, 1) and C > 0 we define mappings f1′ : Rd → R2 , f2′ : GH → R2 , and Ψ′ : R2 → R as           u1 β 0 0 e real ω⊤ x ′ ′ f1 : = + , f2 : = , (15) 0 0 u2 π (GH (x)\x) 0 29

Ψ′ : y = wv1 sign[v2 ] + v1 + v2 , ′

where ω ∈ Rd , β ∈ R, and w ∈ R are constants in general position, and π : GH → R. For the latter, we choose π such that under pτ we have 
 
 Prob π GH (xtest )\xtest > 0 = Prob π GH (xtest )\xtest < 0 = 0.5. (16) Additionally, underpinning (15) we use GH to denote the relational neighborhood space of GH (x)\x, while {v1 , v2 } and {u1 , u2 } are the variables adopted to express the relevant input and output spaces, respectively. Combining these specifications with (9) we arrive at the label generation function y = w(1 − τ )τ u1 sign[u2 ] + (1 − τ )u1 + τ u2 ,

(17)

where we observe nonlinear coupling between features derived from x (expressed through u1 ) and GH (x)\x (expressed through u2 ). Handling Equalities in (11). To establish the first equality of (11), we observe that by construction e real + β when τ = 0. However, we may infer that y = ω⊤ x h i h
i tab tab e real min ED0 ∼p0 ytest − ŷtest = min ED0 ∼p0 ω ⊤ x {xi , yi }ni=1 , xtest = 0, test + β − fθ fθtab ∈F

fθtab ∈F

(18) where p0 follows Definition A.1 with τ = 0. Given the assumption that n > d′ , the equality with zero in (18) occurs by straightforward extension of Xu et al. (2026)[Proposition 4.2], which is not operationally effected by padding xtest and each xi with additional categorical elements. Meanwhile,
the second equality in (11) stems from the fact that y = π GH (x)\x and our encoder constraint set ḡ allows for modeling an arbitrary function π over the relational neighborhood excluding x. Hence when τ = 1 we trivially have that h i rdb min ED1 ∼p1 ytest − ŷtest (19) fθrdb ∈F , gϕ ∈ḡ

≡

min

h

fθrdb ∈F , gϕ ∈ḡ

ED1 ∼p1

i π GH (xtest )\xtest − fθrdb {z i , yi }ni=1 , z test = 0.

Handling the Inequality in (11). Lastly, we handle the third line of (11), namely, the inequality that results for τ values bounded away from zero and one. We establish this bound via several steps tab tab as follows. We also remark upfront that α can be absorbed into the specifications of ŷtest and ŷtest without loss of generality. First, because of the constraint gϕ ∈ ḡ, the encoder cannot reliable reconstruct xreal test ; at most we can guarantee reconstruction of d − 1 coordinates per Definition A.2. Moreover, it is not possible to reconstruct the missing coordinate from the others with a continuous mapping from F, as doing so would violate the assumption from Definition A.1 that any p(xreal ) is bounded from above (i.e., if we could reconstruct this coordinate with a continuous mapping, it would imply that the data lies on a low-dimensional manifold within Rd , which by necessity would have infinite density). Given these considerations, we can again invoke Xu et al. (2026)[Proposition 4.2] to infer that there will be non-negligible error (in expectation over the generation process) for any attempt to predict u1,test from available context {z i , yi }ni=1 and z test . Intuitively, this is because the support pattern for real e real extracting x test from xtest varies uniformly across random draws from pτ , and so in expectation there will always be cases where needed information is missing. From this we may conclude that   rdb inf EDτ ∼pτ u1,test − ŷtest ≥ δ (20) fθrdb ∈F , gϕ ∈ḡ

for any τ ∈ [ε, 1 − ε] and some δ > 0. But this will also remain true when conditioning on the corresponding u2,test . This is because u2,test is merely a function of other rows within X, and conditioning on any or all rows (or functions thereof), excluding the current xtest , will not remove the prediction error, since these rows are generated IID by Definition A.1. And so we have that   rdb inf EDτ ∼pτ u1,test − ŷtest u2,test ≥ λ ≥ δ ′ (21) fθrdb ∈F , gϕ ∈ḡ

30

for some possibly new δ ′ > 0; an analogous error term is bounded away from zero when conditioning on the event u2,test < 0. And therefore from the tower rule of conditional expectations, we also have     rdb inf EDτ ∼pτ u1,test sign u2,test − ŷtest ≥ δ ′′ > 0, (22) fθrdb , gϕ ∈ḡ

a lower bound that becomes w(1 − τ )τ δ ′′ once we reintroduce scale factors. If we choose w = C (1−ε)εδ ′′ , then C(1 − τ )τ w(1 − τ )τ δ ′′ = ≥ C ∀τ ∈ [ε, (1 − ε)]. (23) (1 − ε)ε tab Finally, the remaining factors (1 − τ )u1,test , τ u2,test , and ŷtest from within the last expectation of (11) cannot appreciably improve the lower bound of C. Note that the factor τ u2,test can be absorbed into rdb ŷtest without loss of generality; they share the same input range while the former is a pre-specified function and the latter is arbitrary. tab tab Analogously, w.l.o.g. (1 − τ )u1,test can be absorbed into ŷtest . But the flexibility from ŷtest itself is inconsequential to altering the bound. This is because u1,test ⊥⊥ u2,test , given that xreal ⊥ ⊥ GH (x)\x test per Definition A.1, and so reducing the error approximating the interaction term u1,test sign[u2,test ] tab is not possible without access to u2,test (noting that u2,test has a median of zero). And ŷtest cannot generally reproduce u2,test , since the latter will depend (in expectation at least) on IID context rows outside of the ICL set mitigated through choice of the function π. ■

I.3

P ROOF OF P ROPOSITION B.1

High-Level Intuition. To illustrate the gist of this result, assume that the ground-truth label ytest for ∗ any xtest is given by a parity check on available labels in GH (xtest ). This labeling rule is impossible ′ to determine from yH (xtest ) alone, since for any node x associated with a label y ′ ∈ yH (xtest ), the corresponding set yH (x′ ) need not be fully observed, i.e., the overlap between yH (x′ ) (with a known label for x′ ) and yH (xtest ) (with an unknown label for xtest ) is only partial. Hence the parity rule is not identifiable, as even a single missing label can flip the result. This disrupts inductive inference from ∗ the information available within GH (xtest ), which is all a fixed FM encoder has access too. In contrast, if per-dataset training is allowed over RDB instances formed via a given parity-based labeling rule, it is straightforward to learn the associated mapping on a dataset-by-dataset or task-by-task basis. We remark that, although the proof below relies on parity checks for illustrative convenience, the underlying phenomena is emblematic of quite broad scenarios where diverse heterophilic (as opposed to homophilic) relationships are dominant. Basic Setup. The basic proof follows from the construction of a suitable joint distribution over ∗ ∗ context GeH (xtest ) and test label ytest . Meanwhile, by assumption we have that GH (xtest ) is fixed and given. To begin, we introduce a latent indicator variable z ∈ {0, 1} that selects among two determin∗ istic generative processes for {GeH (xtest ), ytest }. In this way, all randomness in the joint distribution ∗ ∗ e p(GH (xtest ), ytest | GH (xtest )) will ultimately reduce to randomness from p(z). We emphasize that this is not meant to exclude broader sources of randomness that naturally describe RDB content; instead, we are merely distilling down to a minimal design case that nonetheless still allows us to establish the proposition. Other latent sources of variation associated with real-world RDBs then become largely orthogonal to our result and need not be explicitly specified. Label Assumptions. We assume that all labels are binary, namely, y ∈ {0, 1}. While generalization to broader label domains Y is feasible, it introduces superfluous complexity given that the binary case is already sufficient for establishing the proof. For any yH (x) ̸= ∅, where yH (x) indicates the set of ∗ all past labels present within GH (x) for some arbitrary x, we define conditional label generation via a parity function and its negative given by   X   π yH (x) ; z = 1 :=  y  mod 2 y∈yH (x)     π yH (x) ; z = 0 := ¬π yH (x); z = 1 , (24) both of which output a label y ∈ {0, 1}. 31

∗ Context Assumptions. We specify a function h GH (xtest ); z for context generation. To ensure no e∗ conflicting labels, for z = 1 we define this h such  that GH(xtest ) has label assignments consistent with both yH (xtest ) and the label assignment rule π · ; z = 1 from (24). This will always be achievable ∗ by introducing new appropriately-labeled neighbors to specific nodes of GH (xtest ) associated with elements of yH (xtest ). To establish this possibility, assume an arbitrary trial arrangement of node features, edges, and ∗ ∗ labels within GeH (xtest ), but following the typing of GH (xtest ) for consistency. Then consider any y ′ ∈ yH (xtest ) with corresponding x′ extracted from the associated row of X ≡ T K (per original definitions For consistency with the labeling rule (24) with z = 1, we require that  in the main text).  y ′ = π yH (x′ ) ; z = 1 , which may not initially be the case since labeling assignments were thus far assumed arbitrary. However, for any node where this is not the case, we can add a single additional ∗ labeled neighbor to GeH (xtest ), with an earlier time-stamp and a label selected to flip the parity check, such that we obtain the necessary equality. Such a neighbor can be added in multiple ways given that H ≥ 2 (note that if H = 1 then |yH (xtest )| = 0, i.e., no labels within one hop, which is not allowed by assumption). First, assume H = 2, if some table T k exists with at least two FK columns pointing to the PK column associated with T K ≡ X, we can trivially add such a neighbor by adding a new labeled row to T K and a new row to T k that links the former to x′ ∈ T K . Meanwhile, if such a T k does not exist, we can ∗ (xtest ). Moreover, when supplied with an earlier time-stamp, the added simply add such a table to GeH labeled node/row need not introduce any additional constraints vis-à-vis (24). With regard to the latter, if x′′ indicates the added node, we can directly enforce yH (x′′ ) = ∅ as no nodes with earlier time-steps exist, and so y ′′ can be selected free of any constraint from (24), which would only apply if yH (x′′ ) ̸= ∅. Lastly, because this added label will by design be two hops from x′ and three or more hops from any other labeled rows, it will not introduce new conflicts per (24) if H = 2. For H > 2 an analogous procedure can be applied pushing the new labeled node to H hops away from x′ so as to achieve the same effect. In an analogous manner we can also define h when z = 0, handling label consistency via the introduction of neighboring nodes to adjust parity accordingly. Again, we are granted this flexibility ∗ by assumption, since only GH (xtest ) is fixed and given. Finalizing Part 1. Per stated above and the appropriate counting measure, it R the assumptions ∗ ∗ directly follows that p (ytest |Gtest ) log p (ytest |Gtest ) dytest = that ytest is a n 0 trivially establishing o ∗ ∗ ∗ ∗ deterministic function of Gtest . Furthermore, given Gtest = Ge (xtest ), G (xtest ) by definition, we H

H

also have that h h  ∗ 
ii ∗ Ep(Ge∗ (xtest )|G ∗ (xtest )) KL p(ytest |Gtest ) || qθ ytest | gϕ GH (xtest ) H H Z  Z ∗ p (ytest |Gtest ) ∗ ∗ ∗ ∗  ∗ 
dytest dGeH = p GeH (xtest )|GH (xtest ) p (ytest |Gtest ) log (xtest ) qθ ytest | gϕ GH (xtest ) Z  Z    ∗ 
∗ ∗ ∗ ∗ ∗ = − p GeH (xtest )|GH (xtest ) p ytest |GeH (xtest ), GH (xtest ) log qθ ytest | gϕ GH (xtest ) dytest dGeH (xtest ) Z Z    ∗ 
∗ ∗ ∗ =− p GeH (xtest ), ytest |GH (xtest ) log qθ ytest | gϕ GH (xtest ) dytest dGeH (xtest ) (25)   ∗ ∗ for any fixed gϕ and qθ . By construction, p GeH (xtest ), ytest |GH (xtest ) ̸= 0 at only two points (0)

(1)

associated with z = 0 and z = 1. Let ytest and ytest denote the value of ytest at these two points. ∗ Moreover, if we assume that z is drawn uniformly over {0, 1}, we have GH (xtest ) ⊥⊥ z and so we may conclude from (25) that h h  ∗ 
ii Ep(Ge∗ (xtest )|G ∗ (xtest )) KL p(ytest |Gtest ) || qθ ytest | gϕ GH (xtest ) H H  ∗ 
 ∗ 
(0) (1) = −p(z = 0) log qθ ytest | gϕ GH (xtest ) − p(z = 1) log qθ ytest | gϕ GH (xtest ) ≥ H[z] = log 2.

(26)  ∗ 
This lower bound is achievable iff qθ ytest | gϕ GH (xtest ) is a uniform distribution over {0, 1}. 32

Finalizing Part 2. Assume that some parameter-free encoder gpf computes the element-wise sum of yH (x); other arbitrary features may be computed as well, but they are are ultimately treated as spurious features in what follows. Given this setup, the prediction head qθ need only learn to differentiate even and odd sums associated with yH (x), while ignoring all other feature columns. For example, if z = 1 governs the generative process, then odd values of any sum over yH (x) will be mapped to 1, even values to 0. Such functions can be directly represented by ReLU networks, and while not a requirement for this proof, are even efficiently learnable with additional assumptions (Daniely & Malach, 2020). ■

I.4

P ROOF OF P ROPOSITION B.2

High-Level Intuition. The proof follows through modifications applied to the original parity setup from Appendix I.3. For illustrative simplicity, assume a single informative binary RDB feature column, whereby ground-truth labels are a deterministic function, akin to a parity check, on the values ∗ of all features from this column contained within GH (xtest ). All other RDB columns are also binary ∗ but uninformative. Inclusion of yH (xtest ) within GH (xtest ) does not allow for differentiating which column is informative, for analogous reasons to those presented in establishing Proposition B.1. In brief, for any node x′ associated with a label y ′ ∈ yH (xtest ), the corresponding set yH (x′ ) and its associated features need not be fully observed, and so a parity function on any column can produce an arbitrary distribution of yH (xtest ). Consequently, the parity rule is not identifiable regardless of whether yH (xtest ) is present or not as an encoder input. Note that this line of reasoning is not restricted to binary feature columns, as we can quantize continuous or categorical columns into binary ones in forming deterministic labeling functions for analysis purposes. We now turn to the actual proof. Basic Setup. As in the proof of Proposition B.1, all randomness is encapsulated by a binary latent variable z that selects between two deterministic generative processes, now over ∗ ∗ {GeH (xtest ), yH (xtest ), ytest }, i.e., only GH (xtest ) as opposed to GH (xtest ) is assumed fixed/given. When granted GH (x) for some arbitrary x, we specify the conditional label generation functions   X  
  π GH (x) ; z = 1 :=  β tkij  mod 2 (1) {i,j,k}∈SH (x)   X
    β tkij  mod 2, (27) π GH (x) ; z = 0 :=  (0) {i,j,k}∈SH (x) (1)

(0)

where SH (x) and SH (x), associated with z = 1 and z = 0 respectively, represent distinct support sets over RDB column elements reachable within H hops from x following PK-FK pairs. In this way (1) (0) any {i, j, k} ∈ SH (x) (or analogously, within SH (x)) indicates the i-th element within a specific RDB column tk:j , namely column j in table k. Meanwhile β denotes a mapping from each table element to a binary value (this discretization is by no means necessary, but it facilitates a simplified exposition that is sufficient for establishing the core result). These values are then subsequently combined via the stated parity functions in (27) to produce binary labels y ∈ {0, 1}. Establishing Part 1. By adopting (27) as the label generating function, we trivially achieve the conditions of part 1 in Proposition B.2. Specifically, with all randomness deferred to z, which explicitly fixes the support set, all labels default to a deterministic function of the chosen support set, (0) (1) either SH (x) or SH (x) for any x. Establishing Part 2. If we stipulate that z is drawn uniformly over {0, 1} independently of GH (xtest ), then we have     (0) (1) p S = SH (xtest ) | GH (xtest ) = p S = SH (xtest ) | GH (xtest ) = 12 . (28) ∗ However, by design we also have the flexibility to select the distribution over GeH (xtest ) such that yH (xtest ) is invariant to z, even while ytest still depends on z through (27) applied at xtest . To see this,

33

note that each y ′ ∈ yH (xtest ) is computed as π[GH (x′ ); z], where x′ is the target table feature row associated with y ′ . Hence we only need enforce     π GH (x′ ); z = 1 = π GH (x′ ); z = 0 for each y ′ ∈ yH (xtest ). (29) But this will always be possible per the following: Suppose the equality from (29) does not initially (1) (0) hold. We may add an additional element to either SH (x′ ) or SH (x′ ) (but not both) such that the corresponding tuple produces β(tkij ) = 1 to flip the parity and induce equality. This is achievable ∗ (xtest ), at a location H without disrupting equality elsewhere by placing the added element within GeH ′ hops from x and greater than H hops from other elements of yH (xtest ). This placement mirrors an analogous placement strategy applied in Appendix I.3, only here labeled nodes are not required. Lastly, if (29) holds, then


∗ p S|GH (xtest ) = p S|GH (xtest ), yH (xtest ) = p S|GH (xtest ) ,

(30) ■

completing the demonstration of part 2.

34

Related documents

• <b>Prediction Without Training: Google TabFM and the Rise of Tabular Foundation Models</b>#420118
• Recall or Relearn? A Mixture of In-Context Experts for Recurring Concept Drift#1467909
• Towards Universal Tabular Embeddings: A Benchmark Across Data Tasks#925140
• Towards Universal Tabular Embeddings: A Benchmark Across Data Tasks#920906
• Tabular Foundation Models for Credit Risk Prediction: A Dedicated Review and Empirical Comparison#1447160