Google's TabFM: What Data Scientists Should Know About This New Foundation Model

Is this the end of Machine learning as we know it?

Jul 28, 2026

Think about the last few ML models you trained…

They probably followed the same pattern: You had a dataset, you cleaned it, you built features, you picked an algorithm, you tuned it, you trained it on your data, and only then could you start getting predictions.

And when a new dataset showed up, you did all of it again from scratch.

That’s been the reality of ML for as long as most of us have been working in this field.

On June 30, 2026, Google Research released something that is changing this completely. It’s called TabFM, and it’s a foundation model for tabular data classification and regression.

It’s zero-shot, which means you don’t train it on your own data. You just point it at your dataset, and it returns predictions. No feature engineering or hyperparameter tuning. In six lines of code, you get a baseline that competes with (and often beats) heavily tuned gradient-boosted models.

And by the way, this isn’t just a research release. It’s on GitHub, it’s on Hugging Face, it’s on PyPI, and a BigQuery integration is already available. If you work with tabular data, you don’t want to skip this breakdown.

Let’s get into it!

Here’s what we’ll cover

What TabFM actually is (and how it works)
What this means for you as a data scientist
What you should consider before you build on it
Code breakdown to try it out
Where I think this is headed (my take on the bigger shift)

What TabFM actually is

TabFM is a foundation model, in the same way an LLM is.

Just like ChatGPT was trained on huge amounts of text so it can generate a response to a prompt it has never seen before, TabFM was trained on hundreds of millions of synthetic prediction problems so it can make predictions on a dataset it has never seen before. It learned how features relate to targets across an enormous variety of these problems, which is what lets it recognize the pattern in yours.

Concretely, TabFM handles both classification and regression. You give it your training rows and your query rows in one call. It reads them together, figures out the pattern, and returns predictions in a single forward pass. No weight updates. No tuning.

This is what people mean when they say in-context learning: the model learns the task from the examples in the input, without needing to be retrained.

A few concrete things worth knowing:

The code is Apache-2.0 and open on GitHub. Weights are on Hugging Face
It ships with a scikit-learn compatible API (.fit() and .predict()), so it should fit into your existing workflow
Google is integrating it into BigQuery via an AI.PREDICT SQL command, which will bring warehouse-native inference without a training pipeline.
On the TabArena benchmark (38 classification datasets, 13 regression datasets, sample sizes from 700 to 150,000 rows), it goes head-to-head with heavily tuned tree-based models

Performance at a glance by “Elo“ aggregation. Snapshot from July 26, 2027

What this means for you as a data scientist

Let’s zoom out and think about how this changes our day-to-day…

Baselines get much faster: The whole “spend a week getting to a working baseline” phase of a project might shrink to a single afternoon. You import TabFM, pass your data, and see how it does. If the zero-shot performance is already good, you have your baseline. If not, you know quickly that this problem needs more custom work.
Exploration gets cheaper: New dataset, new problem, unclear signal? Instead of committing to a full modeling loop, you can run TabFM to see if the data has any predictive signal at all. That’s a huge time saver for triage.
Foundation models are coming for everything tabular: TabFM is part of a bigger wave. Google already released TimesFM for time-series forecasting a while back, and the same pattern is playing out there. TabPFN and TabICL are strong open-source alternatives on the tabular side. Netflix has been publicly building foundation models for their recommendation systems. I think we should expect more of these to land over the next 12 to 24 months.

What you should consider (before you get too excited)

A few things worth knowing before you build anything on this:

The license: the code is Apache-2.0, but the model weights are released under a non-commercial license. You can experiment, evaluate, and prototype freely, but you can’t drop TabFM into a commercial product today.
Model limits: TabFM handles classification with up to 10 output classes, and it's optimized for tables with up to 500 features and around 150,000 rows. If your problem exceeds those, you'll need a different tool.
Inference cost: because in-context learning means passing your training set as context on every prediction call, inference is more expensive than a compiled tree-based model. Fine for batch and exploration, less so for high-throughput serving.
Not a full XGBoost replacement (yet): production tabular ML often needs calibration, interpretability, and speed guarantees that TabFM doesn’t obviously give you today.

Getting started (in just a few lines of code)

The scikit-learn API makes it really easy to try out:

import numpy as np
import pandas as pd
from tabfm import TabFMClassifier
from tabfm import tabfm_v1_0_0_pytorch as tabfm_v1_0_0

# Load the pretrained model
model = tabfm_v1_0_0.load()

# Wrap in the sklearn-compatible classifier
clf = TabFMClassifier(model=model)

# Your data (mixed numeric and categorical, no special encoding needed)
X_train = pd.DataFrame({
    "age": [25, 45, 35, 50],
    "job": ["engineer", "manager", "engineer", "manager"],
    "income": [80000, 120000, 90000, 130000]
})
y_train = np.array(["low_risk", "high_risk", "low_risk", "high_risk"])

X_test = pd.DataFrame({
    "age": [30, 48],
    "job": ["engineer", "manager"],
    "income": [85000, 125000]
})

# No training. Just fit (which stores context) and predict.
clf.fit(X_train, y_train)
predictions = clf.predict(X_test)

That’s it!

One thing worth remembering: .fit() here doesn’t train anything. It just stores your training data as context, and .predict() runs a single forward pass. So it borrows from the methods we are all used to, but works in a slightly different way.

A few things I recommend:

First-pass baseline: Before you invest hours in XGBoost tuning, try TabFM. If it already gets you close to the metric you need, you might be done, or at least you’ll know exactly how much room for improvement is left.
Comparison benchmark: Run TabFM alongside your current production model. If it’s competitive, that’s a signal about how much of the value in your model comes from the model itself vs your feature engineering.

Where I think this is headed

Before we wrap up, I want to leave you with this…

TabFM as a tool is genuinely exciting, but I think it’s worth stepping back and thinking about where this fits in the bigger picture. After all, this newsletter is called Future Proof Data Science for a reason.

The mechanical parts of our job have been getting automated for a while now.

Even before AI and agents, AutoML was already taking over things like hyperparameter search and model selection. Foundation models like TabFM push this further by removing the training step entirely. On the other side, AI is also automating parts of our workflow that used to eat up hours, like exploratory analysis, data cleaning, and writing SQL. All of that used to be work; A lot of it is now assisted, and some of it is close to fully automated.

That’s not a bad thing, but it does change what our job actually is and what will start mattering more over the next few years:

Judgment: Framing the right problem, understanding the business context, and knowing whether a result is trustworthy enough to act on. None of that gets automated.
Deploying and operating these systems in production: Whether it's a model, an analytics pipeline, or a dashboard, the gap between "it works in my notebook" and "it's running reliably where people can use it" is where a lot of the actual value lives. That gap is going to get more valuable, not less, as the modeling and analysis parts get easier.

Anyways, I hope you found this breakdown useful. Go install TabFM. Try it on a dataset and see what happens.

A couple of other great resources:

📚 Want to learn what it takes to deploy ML models? Check out my free mini-course on MLOps for Data Scientists.
🎥 Want to follow along on YouTube? I just launched a channel for data scientists. Don’t forget to subscribe to not miss any videos.

Thank you for reading! And stay tuned for next week’s article in the Engineering Skills for Data Scientists series.

- Andres Vourakis

Before you go, please hit the like ❤️ button at the bottom of this email to help support me. It truly makes a difference!

Future Proof Data Science

Discussion about this post

Ready for more?