NVIDIA's Kumo Tabular Brings In-Context Learning to Spreadsheets: Predict From a Table in One Pass, No Training Required

A pretrained model for spreadsheets

NVIDIA released Kumo Tabular on September 29, 2026, an open, pretrained foundation model for tabular data, and published a technical article on Hugging Face describing what it does and how it was built. The claim at the center of the release is unusual for this corner of machine learning: a model that can read a spreadsheet-style table with labeled rows and predict outcomes for new rows in a single forward pass, without any training, tuning, or feature engineering for the task at hand.

The release states the core idea plainly. According to the NVIDIA technical article: "Given a table of labeled rows, it predicts the labels of new rows in a single forward pass, with no training, no tuning, and no feature engineering, for both classification and regression."

Attribution for the quotation: NVIDIA authors including Jingang Qu, Jure Leskovec, and Matthias Fey, in the article "NVIDIA Kumo Tabular Sets a New Accuracy-Efficiency Frontier for Tabular Prediction," published on Hugging Face on September 29, 2026.

For two decades, predicting outcomes from tables has meant building a model for each task. This release argues that the same in-context learning that made large language models flexible can now be applied to the tables that businesses, clinics, and analysts actually work with. Whether it holds up outside vendor-run benchmarks is the open question this article examines.

Why tabular prediction has been different

Tabular data means rows and columns: customer records, transactions, sensor logs, claims, orders. Predicting churn, loan default, demand, or price from such tables is among the most common machine learning tasks in industry.

Since the early 2000s, the dominant tool has been gradient-boosted trees. These work well, but each new question requires a full modeling lifecycle: collecting labels, engineering features, searching hyperparameters, validating, and deploying. A tree model knows nothing about tables in general; it learns each task from scratch.

Large language models demonstrated a different way of working. Given a few examples in the prompt, a pretrained model can solve a new task without updating any weights. This is called in-context learning. The Kumo Tabular release applies the same idea to tables: a model pretrained on millions of artificial tables reads a labeled table as its context and predicts the labels of new rows directly, the way a language model answers a question from examples in its prompt.

In practical terms, a user provides a table with some rows already labeled (for example, customers known to have churned or not churned) and the rows they want predictions for. The model returns class probabilities for classification or numeric predictions for regression in one pass.

How it works, in plain terms

Kumo Tabular is a Transformer, the same architectural family behind modern language models, but built around the structure of a table. It uses column, row, and in-context attention, drawing on techniques introduced in the earlier research systems TabICL and TabPFN.

In simplified terms, the model does three things to produce a prediction. First, it learns what each value means within its column: whether a 42 is typical or extreme for that column's distribution. Second, it learns how the columns of a row interact. Third, it relates the context rows with known labels to the query rows with unknown labels.

A key scaling trick is a length-aware attention temperature. Attention that stays sharp over a few hundred rows can blur over tens of thousands, so the model scales each query by a temperature that grows with the logarithm of the number of keys, with a coefficient learned separately for each attention head. The stated result is attention that stays sharp as tables grow longer or wider.

Missing values need no imputation and are treated specially by the cell embedding stage. The model supports up to 10 classes in a single forward pass for classification, which the accompanying open-source library extends to any number of classes using error-correcting output codes. For regression, a head produces 999 quantiles, from which a point prediction and an uncertainty estimate follow.

Trained entirely on synthetic tables

Perhaps the most surprising fact about Kumo Tabular is that it was pretrained entirely on artificial tables, not real-world data. Each training table is generated by sampling from a Structural Causal Model: a random causal graph links hidden variables, evaluated through randomly drawn functions such as linear maps, small neural networks, trees, or Gaussian processes. Some nodes become numerical or categorical columns, one becomes the prediction target, and the rest remain hidden, mimicking the unmeasured causes behind real data.

The generator injects realistic imperfections: values missing in several patterns, coarsened features that can make duplicate rows disagree on their labels, categorical columns with many levels, and heavy-tailed regression targets. A quick tree-ensemble check discards any generated table without a learnable signal. Because the generator is a procedural sampler rather than a trained model, it can produce an endless supply of tables.

Training ran in three stages with progressively longer context lengths, from tables of 1,024 rows up to 60,000 rows, with up to 100 columns. According to the article, the Small, Medium, and Large variants saw roughly 35, 71, and 137 million artificial tables respectively. Classification and regression are trained as separate models. NVIDIA states its training recipe and data generators will be released soon; that release has not yet happened as of this writing.

Sizes, license, and availability

The released models come in three sizes, from 28 million to 215 million parameters, which is small by the standards of large language models. The weights are published on Hugging Face under the OpenMDW 1.1 license, which the release describes as permitting commercial use, and the code runs through NVIDIA's open-source structured-data-models library, which downloads the weights on first use.

The model page on Hugging Face confirms the license designation, stating: "Kumo Tabular weights are released under OpenMDW 1.1."

Attribution for the quotation: the NVIDIA Kumo Tabular model card on Hugging Face (nvidia/Kumo-Tabular), retrieved October 4, 2026. The license terms themselves are published at openmdw.ai, which this outlet could not directly retrieve; the commercial-use characterization here follows NVIDIA's own description and should be confirmed against the license text before commercial adoption.

Benchmarks: strong numbers, vendor-run

NVIDIA reports that all three model sizes, run with default settings against the full TabArena leaderboard, rank first overall with an ELO of 1950, while running 17 times faster than LimiX-2 in what NVIDIA describes as a uniform single RTX 6000 Pro evaluation setup. The release also reports first place on BeyondArena (ELO 1418, Improvability score 7.78 percent), the top overall ranking on TALENT across classification accuracy, log-loss, and regression RMSE, and first and second places on ScoringBench for the Large and Medium variants.

These numbers matter, with one large caveat: every one of these benchmarks was run by NVIDIA itself as part of its release evaluation. TabArena, TALENT, and ScoringBench are externally maintained benchmarks with public repositories, which makes the results more meaningful than a fully self-graded test, but the specific runs, configurations, and comparisons come from the vendor. Independent replications have not yet been published as far as this article could verify.

The speed figure deserves the same treatment. Seventeen times faster than LimiX-2 is measured in NVIDIA's own uniform hardware setup, and the underlying leaderboard results are public, but the comparison was assembled by the company announcing the win. This is normal practice for model releases, and it is also exactly the situation where readers should wait for third-party confirmation.

What is unverified

NVIDIA states limitations candidly in the release, and they are worth taking seriously. The model works on numerical and categorical columns only; text, images, or timestamps must first be turned into features using built-in preprocessing recipes. A single forward pass covers up to 10 classes natively.

More importantly, the release warns: "Accuracy may degrade on tables far beyond the training ranges or when the query rows come from a different distribution than the context rows, so, as with any predictive model, validate accuracy and calibration on your own held-out data before deployment."

Attribution for the quotation: NVIDIA, "NVIDIA Kumo Tabular Sets a New Accuracy-Efficiency Frontier for Tabular Prediction," Hugging Face, September 29, 2026, Limitations section.

Two additional uncertainties follow from the architecture itself. First, in-context predictions depend only on the context rows and the row being scored, which is efficient but means a prediction can shift if the provided labeled examples change; the quality of the supplied context matters. Second, because the model was pretrained only on artificial tables, its behavior on unusual real-world domains, such as highly regulated or idiosyncratic data, is an empirical question that benchmarks built on public datasets may not fully answer.

What this could change for non-specialists

If the claims hold under independent testing, the practical consequence is a change in who can build predictive tools. Today, a small clinic wanting to predict patient no-shows, or a small business predicting churn, generally needs someone to run the full tree-modeling lifecycle or hire outside help. A model that takes a labeled spreadsheet and returns predictions in one pass compresses that lifecycle dramatically.

It will not remove the hard parts entirely. Someone still needs to collect good labels, choose sensible columns, check for data leakage, and validate accuracy on held-out data, which NVIDIA explicitly recommends. Domain expertise remains essential, and a prediction pipeline is only as good as the table behind it.

But the barrier shifts from machine-learning engineering to data preparation, which many more organizations already do. The small parameter counts, 28 to 215 million, and the released open weights mean the model can run on a single consumer-class GPU. The OpenMDW 1.1 license, if its commercial terms are confirmed against the license text, would let businesses build on it without negotiating a separate agreement.

This is an opinion framed by the evidence: tabular prediction has been the most resistant of the major machine-learning categories to the foundation-model approach, precisely because per-task tree models were already so effective. If in-context learning closes the accuracy gap while removing the per-task lifecycle, the accessibility argument in this release's favor is real, and the coming months of independent replications on the public TabArena and TALENT leaderboards will show whether it survives contact with users outside NVIDIA.