Google Research's TabFM Beats XGBoost on 51 Datasets Without Any Training

For decades, the default playbook for tabular ML has been the same: pick XGBoost or a random forest, spend days on feature engineering and hyperparameter tuning, and repeat for every new dataset. Google Research just shipped a model that skips all of that. TabFM is a foundation model for tabular classification and regression that produces predictions on a brand-new table in a single forward pass, with zero training required.

The problem with the old playbook

The lifecycle of deploying traditional models presents a significant bottleneck. Fitting an XGBoost model to a new dataset is not merely a matter of a single .fit() step; it invariably requires tedious manual effort. Data scientists must invest hours into hyperparameter optimization and domain-specific feature engineering just to get reliable signal from raw data. That cost multiplies across every new dataset, every new project, every new team.

Recent advances in large language models changed how we interact with novel tasks, demonstrating the remarkable power of zero-shot prediction through in-context learning (ICL). This technique lets a pretrained model learn a new task by providing examples and instructions in the input context, without updating any underlying model weights. TabFM applies that same idea to structured, tabular data.

How it actually works

Instead of undergoing a traditional training phase for each new task, TabFM takes the entire dataset , comprising both the historical training examples and the target testing rows , as a single unified prompt. The model learns to interpret the relationships between columns and rows directly from this context at inference time.

Tables are fundamentally different from text: they are two-dimensional and orderless. Swapping two rows or two columns does not change the meaning of the data, but standard transformers would treat that as a completely different input. TabFM synthesizes the strengths of architectures like TabPFN and TabICL into a novel hybrid design built around three mechanisms:

• Alternating row and column attention: The raw table is processed through a multilayer attention module that applies alternating attention across both columns (features) and rows (examples). By continuously attending across these two dimensions, the model learns rich representations that natively capture complex feature interactions and dependencies.
• Row compression: Following this contextualization, the rich, cross-attended information for each individual row is compressed into a single, dense vector representation.
• ICL Transformer: A dedicated Transformer operates on this sequence of compressed embeddings. Performing attention over these compressed row vectors , rather than the raw, uncompressed grid , drastically reduces the computation cost, ensuring the prediction step remains highly computationally efficient even for much larger datasets.

Trained entirely on synthetic data

One of the most interesting design choices here is the training data strategy. A major hurdle in tabular ML is that high-quality, diverse tabular datasets , especially the massive tables required to reflect true industrial data analysis , are critically scarce in the open-source space. Industrial tables often contain proprietary schemas and sensitive information, making them inaccessible for broad pre-training.

TabFM is trained entirely on hundreds of millions of synthetic datasets. These datasets are dynamically generated using structural causal models (SCMs) that incorporate a wide variety of random functions. SCMs are graph-based models that simulate cause-and-effect relationships between variables, letting the team generate arbitrarily large, diverse datasets that mimic the statistical structure of real-world tables without exposing any proprietary data.

Benchmark results that actually hold up

To rigorously test TabFM against existing state-of-the-art methods, Google evaluated it on TabArena, a living benchmark system that calculates Elo scores based on head-to-head win rates. This comprehensive evaluation spans 38 classification datasets and 13 regression datasets ranging in size from 700 to 150,000 samples.

Two configurations were tested:

• TabFM: The out-of-the-box capability of the model. Predictions are generated in a single forward pass, requiring no tuning or cross-validation.
• TabFM-Ensemble: This configuration pushes performance further by incorporating cross features and SVD features. The optimal weights for a 32-way ensemble are computed using a non-negative least squares solver. For classification tasks, this variant also incorporates Platt scaling as an additional calibration step. Platt scaling is a technique that converts raw model scores into well-calibrated probabilities.

Where it fits and where it does not

The zero-shot, no-tuning story is compelling, but it comes with caveats worth knowing. Prior benchmarks on similar tabular foundation models have shown that tree baselines complete full-batch inference in under 0.4s with zero VRAM, while some zero-shot foundation models incur significant latency and VRAM overhead. TabFM is best suited for situations where iteration speed and low engineering overhead matter more than raw inference throughput.

The sweet spots are clear:

• Rapid prototyping on new datasets with no labeled history
• Teams without dedicated ML engineers to tune gradient-boosted trees
• Pipelines where you need a strong baseline in minutes, not days
• BigQuery users who want ML predictions via SQL with no model management

Getting started today

TabFM is now available on Hugging Face and GitHub. The GitHub repo exposes a scikit-learn-compatible API, so the interface will feel immediately familiar. The model weights are downloaded automatically from Hugging Face on first use. Note that the Hugging Face model card lists a non-commercial license, so check the terms before using it in production.

from tabfm import tabfm_v1_0_0, TabFMClassifier
import pandas as pd, numpy as np
model = tabfm_v1_0_0.load()  # downloads weights automatically
clf = TabFMClassifier(model=model)
clf.fit(X_train, y_train)       # no gradient updates, just stores context
predictions = clf.predict(X_test)
probs = clf.predict_proba(X_test)

TabFM is being integrated directly into Google BigQuery. In the coming weeks, users will be able to perform advanced regression and classification using a simple AI.PREDICT SQL command in BigQuery , no ML expertise required. That BigQuery integration is the real distribution play here: it puts a competitive tabular model in front of every analyst who can write SQL, not just teams with ML infrastructure.

A shift in the default assumption

The broader significance of TabFM is what it says about the field. Tabular foundation models bridge the historical performance gap between deep learning and tree-based models on structured data, unlocking rapid adaptation to novel tables and schemas, efficient and calibration-aware predictions, and increasing flexibility for multi-modal reasoning. Google's TimesFM did this for time-series forecasting; TabFM is the same bet applied to the most common data format in enterprise ML. The assumption that gradient-boosted trees are always the right starting point for tabular data is worth revisiting.