Why the LLM Playbook Stops Working with TFMs

Summary

Heading

Author

Aziz Fouché

Tabular foundation models (TFMs) and large language models (LLMs) may look like close relatives. Both are transformers, both do in-context learning, both replace per-task fitting with a single pretrained model that conditions on a prompt. It is tempting to assume the LLM playbook carries over: scale the model, scale the data, expect predictable returns. Working on TFMs, we keep running into places where that assumption fails. This post is an attempt to lay out where the two paradigms diverge, which LLM intuitions survive, and where we think the open problems actually are.

1. How TFM pretraining differs from classical ML

Reminder: the pretraining framework

A TFM is a single pretrained network that, given any labeled table \((X, y)\) as context and an unlabeled query row \(x_{\text{test}}\), returns a label prediction \(y_{\text{test}}\) in one forward pass, with no retraining. This is the main selling point of the technology: you hand it the whole training set and query as a prompt and it answers directly, with performance equal to or exceeding canonical machine learning algorithms.

Classical supervised learning that we were taught in college has two levels. Any problem starts with a latent data-generating distribution \(p\), and we observe a dataset \(X \sim p\) sampled from it. The basis of machine learning is then to fit a model on that dataset \(X\), and hope it generalizes to new unseen samples drawn from \(p\) in a way that makes it useful. What matters here is that the prior \(p\) is fixed, unknown, and singular: it is the latent "ground truth" our ML framework is doing its best to approximate, and if it does, we win.

A TFM adds a third level on top. Instead of one latent prior, we posit during training a distribution over synthetic priors, \(\mathcal{P}\), and generate synthetic data through a double sampling process: we first draw a prior \(p \sim \mathcal{P}\), then draw a dataset \(X \sim p\). A TFM is a backbone trained to perform classification or regression over tens of millions of such synthetic priors and datasets, and the consequences are threefold:

- \(\mathcal{P}\) is not discovered in nature; it is a synthetic distribution designed by practitioners, which they hope will be useful in enabling the model to transfer to real use-cases.
- No single \(p\) is privileged as the ground truth. The model must fit a (possibly infinite) number of synthetic priors at a fixed parameter budget.
- We can draw an infinite number of fresh datasets for any prior \(p\), which means that, in the classical sense, we theoretically never need to worry about overfitting.

(*Top*) Classical machine learning models are fit to approximate a prior distribution from which a dataset is observed; large language models (LLMs) operate under this paradigm. (*Bottom*) Prior-fitted networks are a different kind of models, which are trained to fit *millions* of synthetic prior distributions; tabular foundation models (TFMs) are leveraging this approach to perform in context learning.

i

This formulation resembles meta-learning [1], or learning to learn, which has been formalising "distributions over tasks" since the 1990s. PFNs sit squarely in that lineage, and what is surprising is how little traffic there is between the two communities. The downstream tasks are different enough that results rarely cross over, but meta-learning has already spent two decades on the question we are now hitting: how much does the choice of task distribution determine what transfers?

That last point is worth a caveat, because it is easy to over-read. Infinite fresh draws do remove overfitting in the classical sense; there is no train/test gap within \(\mathcal{P}\) since we never run out of new datasets. But "no overfitting" is not "no risk." The model can fit \(\mathcal{P}\) faithfully and still fail on real-life problems, simply because \(\mathcal{P}\) is the wrong distribution: a meta-prior we designed that does not cover the use cases we care about. This is not a generalization failure but a specification one. The risk moves from "did we overfit this dataset?" to "did we design a prior that transfers?" and, as we will see, that second question is the one that actually governs TFM performance.

i

Other fields have a name for this. In robotics it is the sim-to-real gap: a policy that is optimal in simulation and useless on hardware, not because it was underfit but because the simulator was the wrong distribution. The response there is instructive, as the winning move has usually been not to make the simulator more faithful but to randomise it aggressively, so that reality falls somewhere inside the training distribution.

A prior-data fitted network (PFN), the design underneath Seldon and most current TFMs, is pretrained differently. Given a prior \(p(\mathcal{D})\) from which datasets can be sampled, a TFM is trained so that a single forward pass on a training set plus a test input predicts the held-out label. Instead of a fixed corpus, the prior is a data-generating process we design and sample from at will, typically a distribution over structural causal models (SCMs). A TFM is therefore not fitting one dataset; it is learning an inference procedure that maps a context table to a predictive distribution, amortized (the model's inference cost is mostly paid at pretraining time) over a whole distribution of synthetic tasks [2].

Comparing the LLM and TFM frameworks

An LLM is pretrained by next-token prediction on a corpus of natural language. There is effectively one prior \(p\) here: the distribution of human text. It is a single, fixed, empirical object, but an extraordinarily rich one, rich enough that models with trillions of parameters keep extracting signal from it and scaling laws hold across many orders of magnitude. The recipe worked for LLMs until now because with enough data, the latent prior has been deep enough to absorb any amount of capacity we threw at it.

Large language models (LLMs) are typically pretrained to perform next token prediction over a very large text data corpus.

Tabular foundation models (TFMs) are generally pretrained to perform classification or regression over a wide variety of tabular problems generated from a synthetic data prior.

Placed against the two-level and three-level picture above, the contrast sharpens. The LLM prior is the fixed \(p\) of classical learning, except unusually rich. The TFM prior is the \(\mathcal{P}\) one level up, and its richness is bounded by what we can design rather than by what the world produced. That single substitution is what risks making many of the intuitions we developed while building LLMs unreliable on TFMs.

2. Model scaling is the intuition that breaks first

The central LLM result of the past five years is that loss falls predictably with model size, data, and compute [3]. For TFMs, only much smaller regimes have been explored; the picture is not as clear, and there is reason to think the bottleneck is the prior rather than the architecture.

The most direct evidence comes from TabICLv2 [4]. When the authors paired their new architecture with the older TabICLv1 [5] prior, pretraining failed outright: performance stayed below the baseline and validation loss degraded in the second half of training. They read this as the architecture requiring higher prior diversity to generalize, and connect it explicitly to the observation that scaling laws can break down with weak synthetic data generators. Capacity and prior richness have to move together, and in their ablations the prior produced the largest single effect on downstream performance, larger than the architectural changes.

This reframes the scaling question for tables. In the LLM setting, the corpus is a given, and the engineering lever is the model. For TFMs, the prior is also an engineering lever, making TFM model makers responsible for creating both the data and the model on top of it. As of today, TFMs remain small in comparison to LLM standards: the widely used models sit in the tens of millions of parameters, and even if recent larger efforts are around a billion, there are no published scaling laws for now demonstrating that pushing to that point pays off (and it’s still orders of magnitude below frontier LLMs). Whether tabular priors can be made rich enough to reward LLM-scale capacity is open, and it is a question many in the field are working to answer.

There is a hard part underneath this that deserves to be named. Prior design is largely done with thin experimental feedback: fine-grained ablations on the prior are impractical, they require costly pretrainings, they often yield noisy results, and they tend to overfit the validation datasets. So prior development is often guided by general design principles rather than rigorously measured improvement. That is a real methodological gap: the practitioners are tuning an utterly important component of the system with the weakest feedback loop.

3. Are our current priors as rich as we'd like them to be?

A distribution over SCMs looks combinatorially enormous. You can vary graph structure, mechanisms, noise, cardinalities, and get what seems like unlimited diversity. The question is whether that nominal diversity translates into diversity in the space that matters: the space of inference problems the model actually has to distinguish.

Recent evidence suggests it may not. A study ensembling six modern TFMs [6] found the diversity across them to be mostly nominal: no single model wins on every dataset, yet their predictions are too correlated for any combiner to exploit, and the best ensemble bought a fraction of a percent in accuracy at hundreds of times the compute, and the gain was uncorrelated with how far apart the models scored. This does not contradict the large gains from ensembling many configurations of a single TFM: those perturb the input encoding around one posterior, whereas combining across priors needs the posteriors themselves to differ. The redundancy is striking, and it's tempting to explain it structurally. PFN-style ICL approximates Bayesian model averaging at inference [2], so priors that overlap in inference-problem space should produce similar posteriors, and a combiner has little left to exploit. If different teams designing different priors and architectures land on nearly the same posterior, the effective richness of these priors may be smaller than the generative description implies.

*Theoretical prior richness* describes the set of all posterior distributions a prior can produce, given its set of generative algorithms. *Empirical prior richness* is the effective set of posterior distributions it will likely represent given the number of datasets generated and the distribution of hyperparameters.

This is the sharpest contrast with LLMs. The text prior basically comes for free from the world that produced it, while gathering the data corpus is expensive; generating tabular data is almost free, but the tabular prior is something we author, and its richness is bounded not only by our imagination but by what we can actually realize from the generator. On paper, an SCM prior is unbounded, with enough free parameters to write down any dataset. In practice it is a grey box of coupled, poorly-calibrated knobs (graph samplers, mechanism families, noise and post-processing choices) that interact unpredictably, so pushing variety in one place can quietly collapse it in another. We hope diversity comes out, but we cannot easily confirm how much, because the natural check (ablate a prior parameter, pretrain a model, measure the downstream effect) is impractical at the granularity that matters.

This also ties the diversity question to scaling. Lacking a direct instrument for prior diversity, model scaling is one of the few proxies we have: capacity that keeps paying off suggests there is variety worth resolving, while an early plateau is consistent with a generator emitting far less effective diversity than its parameterization implies. It is an uncomfortable proxy, confounded with architecture and optimization, but it is what we have. The open problem is therefore twofold: which axes to expand the prior along, and how to build an evaluation loop that tells us whether a given change increased usable diversity at all. We have a weak grip on the first and almost none on the second.

Lastly, it brings the natural question of the “yield” of the diversity we add: how much of it will cost model capacity without transferring at all into downstream performance, because it lands too far from real tabular data? And how to measure it? This looks like a deep but crucial research question the field has yet to answer.

4. Resemblance-is-transfer?

There is a natural strategy for making a TFM work on a target domain: make the synthetic data resemble the target, matching marginals, correlations, missingness, feature types, and so on. Call this the resemblance-is-transfer hypothesis. It is plausible and worth stating as a hypothesis rather than dismissing, because the evidence cuts both ways.

In favor, continued pretraining on real tables helps, and prior mismatch has measurable cost. TabDPT [7] shows that large-scale pretraining on real data can be competitive, and Real-TabPFN [8] shows continued real-data pretraining can improve TabPFNv2. Deploying TabPFNv2 on a dirty medical dataset is framed not as a data-quality problem but as a prior-mismatch one: the model assumes near-clean, roughly Gaussian, low-missingness inputs, and violating that column by column degrades accuracy and calibration.

Against it, two things. First, priors with no real-world semantics still transfer broadly. TabPFN's [9] datasets are built from randomly constructed SCMs with no real-world semantics, yet it beats strong per-task-tuned baselines on small tables, indicating SCM structure is an effective prior for a substantial fraction of real tables. What transferred there was structure, not appearance. Second, and more pointed: the approach that should work best if the resemblance-transfer connection holds is fine tuning on the target data distribution, but even that does not reliably beat the generic prior. A dedicated study [11] finds fine-tuning TabPFNv2 reaches state-of-the-art on IID data but underperforms under temporal shift, and works by sharpening the retrieval logic (the query-key dot products that weight in-context samples) rather than by learning new features. On the shift-heavy TabReD datasets, it is less stable than the state of the art, and on at least one dataset fine-tuning even degrades performance. If perfect resemblance to the target buys unreliable and sometimes negative gains, anything short of that is a weak lever.

There is a notable observation that might explain why fine-tuning TFMs does not yield the expected result. In a sense, fine-tuning collapses the TFM training back down a level: instead of optimizing over \(p \sim \mathcal{P}\) (the TFM training recipe that is proven to work), it optimizes over a single \(X \sim p\), the target dataset and its latent prior. That is a return to the classical two-level contract, forfeiting the amortization that made the model work in the first place, and there is for now no guarantee that the trade pays off.

Surface resemblance, SCM similarity, and "inducing the target's inference problem" all sound like they should predict transfer, yet each can be satisfied while transfer fails, or violated while it succeeds. We do not currently have a validated proxy for transfer at all. Until we find a better one, the only signal we should trust is the blunt one: downstream performance on real targets.

5. What are the leads?

If the binding constraint is prior richness measured with a broken instrument, the useful work is building the instrument. Three directions look tractable.

• First, we should treat evaluation on real data as an ongoing research effort. Downstream performance on real tables is the signal we should trust, and any static benchmark gets saturated at roughly the speed the field iterates. Open benchmarks have driven progress in most fields; what keeps them useful is renewal. Keeping the signal honest means continuously defining, releasing, and refreshing benchmarks, and broadening them across domains as models start to saturate the current set, so the goalpost moves as models improve. This is notably the motivation behind Neuralk's work on TabBench V1 and V2 [10], an open evaluation suite for tabular models built around real industry use cases, which we expand and update over time.
• Then, every prior-side signal (validation loss, ablations, the scaling behavior above) is measured on \(\mathcal{P}\), and is only as meaningful as the link between loss on \(\mathcal{P}\) and performance on real tables. That link is assumed more often than checked, and it can break: fine-tuning sharpens the fit to a target yet does not reliably improve transfer [9]. So the correlation between \(\mathcal{P}\)-loss improvement and real-task performance is itself something to always track and maintain high. If the link is weak, repairing it should be the top priority, since this is the glue that underpins the entire transfer learning paradigm.
• Finally, we can use scaling as a rough bottleneck diagnostic. If adding capacity against a fixed prior keeps paying off on downstream tasks, the prior is not yet the limiting factor; if returns flatten despite adding more model capacity, then the prior is a strong candidate for the bottleneck. Scaling the prior can take several forms: if modern TFMs scale the prior through multi-stage curriculum learning with increasing dataset scale, we could also think about adding more variety of intrinsic complexity in the generation process (more random functions, more complex causal structure and data transformations, etc.), though the ablations are more difficult to conduct when doing so.

None of these measures transfer directly; that proxy is still open. What they do is give us quantities we can compare where we currently rely on intuition, which is a precondition for scaling priors with any confidence.

So, where does this leave us?

For TFMs, prior richness and model capacity are coupled constraints, and which one binds is an empirical question to ask at each scale rather than settle once. What makes that hard is that we cannot yet easily measure whether a given prior change helped, which leaves downstream performance on real targets as the only signal we fully trust, and makes building better priors, and better instruments for evaluating them, a central task rather than a side quest. The open question underneath everything is whether tabular priors can be made rich enough to reward LLM-scale capacity, or whether the heterogeneity of tables sets a structurally lower ceiling. We do not know, and much of the field is quietly betting on one answer. The LLM playbook got us this far by suggesting the moves worth trying. It stops being a reliable guide exactly once we realize that for TFMs, the ground truth prior is not given but is our responsibility to design. And that shift is precisely where a number of problems that will shape the future of TFMs live!