NVIDIA's Kumo Tabular Skips Training and Reads Your Table Instead

Classification on a table has always meant the same loop: split your data, fit a model (XGBoost, LightGBM, a plain scikit-learn classifier), tune it, evaluate it, retrain when the data shifts. NVIDIA's Kumo Tabular, released September 23, skips the fitting step for a new dataset entirely. You hand it a table and it predicts.

How the prediction actually happens

You give it one table: some rows with a known label (the context) and some rows without one (the query). Every row shares the same columns. In a single forward pass, the model returns class probabilities for the query rows if you're classifying. If you're predicting a number instead, it returns numeric predictions with quantiles. There's no training step on your data at all. Each query row attends only to the labeled context rows you gave it in that same request.

Under the hood it's a three-stage transformer. Each cell becomes a token built from Fourier features of its value. A missing cell gets filled with the context column's mean plus a learned marker saying it was missing. From there the encoder alternates column attention and row attention. In column attention, each column attends across its rows through a fixed set of inducing points. That's what keeps the cost scaling linearly with row count instead of quadratically. Row attention works the other way: each row attends across its own columns, using rotary position encoding to track column order. Every row then gets summarized into four learned tokens. A final in-context-learning stage takes it from there: the unlabeled query rows attend to the labeled context rows and the model produces its prediction.

It never saw a real dataset

The part that stood out to me most is the training data: none of it is real. NVIDIA pretrained the three model sizes (roughly 28M, 62M and 215M parameters) purely on synthetic tables generated from structural causal models, somewhere between 35 and 137 million tables depending on size. Those training tables went up to 60,000 rows and 100 columns, with 2 to 10 classes. No customer data, no scraped datasets, nothing that could leak a real record into a prediction. The approach traces back to TabPFN and TabICL. Both trained a transformer purely on synthetic tabular priors like this. The idea is that the model learns the general shape of a classification problem instead of memorizing a specific one.

Where the limits are

NVIDIA evaluated the released model on TabArena, TALENT and BeyondArena, benchmarks that were kept out of training. Its own documentation doesn't publish the resulting scores though, so I can't tell you where it lands against a tuned gradient-boosted baseline. NVIDIA's own caveat is that accuracy drops once your query data diverges meaningfully from the context rows you supplied. That tracks: the model has no memory of your actual distribution beyond what you hand it in that one request. It's also limited to a single table: there's no support for joining in a related table the way you'd join a transactions table to a customers table in a real pipeline. One independent reviewer who tested it ahead of the public release put it plainly: pilot it against your own holdout set before you trust it. Don't treat it as a drop-in replacement for CatBoost, LightGBM or TabPFN in anything already in production.

What I'd actually use this for

What makes this useful is skipping the fitting step, not the accuracy. Say you just received a new dataset and don't yet know whether a real model is worth building on it. Handing Kumo Tabular your labeled rows as context and getting a prediction back in one call beats standing up a training pipeline you might throw away within the hour. I wouldn't put it in front of a stable production classification problem that already has a well-tuned gradient-boosted model behind it. Retraining that model when your data drifts is a known cost you've already budgeted for. A model fit to your actual distribution is still a safer bet than one that's never seen a real row.