Kumo Tabular Is a Tabular Foundation Model You Can Ship Commercially. Its First Place Is Self-Reported.

A tabular foundation model does for a spreadsheet what in-context learning does for a prompt: give it labeled rows as context and it predicts the labels of new rows in one forward pass, with no training run and no hyperparameter search. NVIDIA released Kumo Tabular on 29 September, in three sizes from 28M to 215M parameters, pretrained only on synthetic tables drawn from structural causal models. The announcement says it ranks first on TabArena with an Elo of 1950 while running 17 times faster than LimiX-2, and first on BeyondArena at 1418.

The weights ship under OpenMDW-1.1. That is the part worth your attention, and it is not the part the headline is about.

The claim, stated fairly

NVIDIA ran all three sizes against the full TabArena pool on a single RTX 6000 Pro and published the benchmark harness alongside the model in its structured-data-models repository. The evaluation script folds the Kumo results into TabArena's own context and prints a leaderboard in the site's format. That makes it a claim anyone with the hardware can rerun, not a marketing number. The authors also list real limitations: numerical and categorical columns only, ten classes per forward pass with error-correcting output codes beyond that, and accuracy that may fall off on tables unlike the training distribution.

What the measurement covers, and what it leaves out

The leaderboard has no row for it. TabArena publishes its results as CSVs in its Hugging Face Space. The main pool, last updated on 28 September, has 82 entries and none of them is Kumo Tabular. The BeyondArena pool has none either. The top of TabArena today is LimiX-2 at 1965, then TabPFN-3.5 at 1887 and Causilo at 1807.

Do not read 1950 against 1965 as a contradiction. The Space's README says Elo is a pairwise rating over whoever competed, so each pool is its own evaluation, and a pool with Kumo in it produces different numbers for every entrant. The fair statement is narrower: first place is NVIDIA's run of TabArena's code, and TabArena has not yet admitted it. The leaderboard marks entries as verified, and Kumo is not one of them.

The benchmark settings are not the library defaults. The adapter in benchmark/tabular/model.py runs the small and medium models with 8 ensemble estimators and the large one with 16, under float16 autocast, with an experimental flag that re-types low-cardinality numeric columns as categorical. The 8-estimator setting for the two smaller sizes landed in a commit on 26 September, three days before launch. The library call behaves differently. KumoTabular defaults to the large size, and when num_estimators is left out on an ordinary two-dimensional table, the ensembling code builds exactly one estimator. The demo in the blog post leaves it out. The model card passes 8, which is half what the benchmark gave the large model it defaults to. None of this is hidden; it is in the repository. But the rank was earned by a configuration you have to set by hand.

The install line on the model card fails. The card says to pip install structured-data-models and then import sdm. The PyPI project of that name is a 1,082-byte placeholder uploaded on 14 September, version 0.0.0a0, whose only module is an empty structured_data_models package. There is no sdm in it, so the import fails. The repository README gives the working route: install from the main branch on GitHub.

What survives contact with production

Look at who holds the top three TabArena places: LimiX-2, TabPFN-3.5 and Causilo all carry non-commercial licenses, per the leaderboard's own license column. For a team shipping a scoring model inside a product, those rows are not options. The highest commercially licensed entry on the board today is Mitra-v2 at 1783 under Apache-2.0, and tuned-and-ensembled LightGBM and CatBoost sit at 1430 and 1418.

That is the comparison that matters, and it is where Kumo Tabular is genuinely new. OpenMDW-1.1 grants rights to the weights without restriction, places no conditions on outputs, and requires only that redistributions keep the license and notices; the grant ends if you sue claiming the model infringes a patent or copyright. The library code is Apache-2.0. If NVIDIA's rank holds up, no entry on the board today combines that position with terms like these.

Everything else still has to be proved on your data, starting with inference cost. TabArena's own timing column puts tuned CatBoost at 0.038 seconds of median prediction time per 1,000 rows, against 0.104 for Causilo and 9.028 for LimiX-2. The large Kumo classifier checkpoint alone is about 855 MB, and the labeled context is part of every forward pass unless you use the fit-and-predict path that caches its keys and values. That trade is the one From PoC to Production warns about. A leaderboard rank is the demo; latency, memory and monitoring are the bill. We made the same argument about forecasting when PatchTST-FM-r2 ranked second on GIFT-Eval and still regressed on a quarter of its configurations.

What you'd need to see before believing it applies to you

The central claim of this post: for any team that cannot use non-commercial weights, the bar Kumo Tabular has to clear is Mitra-v2, not LimiX-2, and NVIDIA's reported first place against the full TabArena pool says it does. This is wrong if TabArena admits a verified Kumo row and it lands at or below Mitra-v2 in the same pool. Check whether that row exists yet:

curl -sL https://huggingface.co/spaces/TabArena/leaderboard/resolve/main/data/entrants_models/imputation_no/splits_all/tasks_all/datasets_all/website_leaderboard.csv | grep -ci kumo

On 30 September it prints 0. Until it prints something else, run your own comparison:

• Install from GitHub, not PyPI: pip install git+https://github.com/NVIDIA/structured-data-models.git.
• Match the benchmark: pass num_estimators=16 for the large model or 8 for small and medium, and measure prediction time at that setting, not at one estimator.
• Baseline against the model you run today, tuned CatBoost or LightGBM, on a time-ordered holdout from your own data, not a random split.
• Count your classes. Above ten, you are on the error-correcting code path, and your accuracy and latency numbers need their own test.
• Ship it only if it beats your current model by a margin you set before looking, on both accuracy and calibration.

If you are weighing whether a tabular foundation model belongs in a churn or fraud pipeline at all, that is the evaluation our machine learning consulting work is built around.