Kumo Tabular: How NVIDIA Built a Foundation Model That Predicts on Any Table Without Training NVIDIA released Kumo Tabular in November 2026, a family of open-weight tabular foundation models that classify or regress on new datasets in a single forward pass without training, hyperparameter search, or feature engineering. Pretrained on millions of synthetic tables generated from Structural Causal Models (35 million for the Small variant, 137 million for the Large), the models use in-context learning over labeled rows and currently top eight major tabular benchmarks, including TabArena, TALENT, BeyondArena, and ScoringBench. The weights are available on Hugging Face and through NVIDIA's structured-data-models library under the OpenMDW-1.1 license. For most of machine learning's history, working with tabular data has meant the same ritual: clean the data, engineer features, pick a model, tune hyperparameters, train, evaluate, repeat. Gradient-boosted trees like XGBoost and LightGBM became the default because they handle this cycle well. But a new class of models is starting to challenge that assumption — and NVIDIA's Kumo Tabular https://arxiv.org/abs/2611.23001 , released in November 2026, is one of the most capable examples yet. Kumo Tabular is a family of open-weight tabular foundation models that can classify or regress on a new dataset in a single forward pass, with no training, no hyperparameter search, and no feature engineering required. It currently holds the top position on eight major tabular benchmarks, including TabArena, TALENT, BeyondArena, and ScoringBench. The core idea behind Kumo Tabular is in-context learning ICL — the same mechanism that lets large language models answer questions by reading examples in a prompt. Instead of text, Kumo Tabular reads labeled rows from a table as its "context" and uses them to predict labels for unlabeled query rows. This is a meaningful departure from the standard ML workflow. You don't fine-tune the model on your dataset. You don't touch its weights at all. You provide a table of labeled examples, and the model generalizes from them at inference time. For a practitioner, this means going from raw data to predictions in seconds rather than hours. The approach works because Kumo Tabular was pretrained on millions of synthetic tables generated from Structural Causal Models SCMs https://docs.nvidia.com/sdgm/about-nvidia-kumo/in-context-learning — procedurally constructed datasets that simulate realistic data imperfections: missing values, non-linear relationships, heavy-tailed targets, and varied causal structures. The Small variant trained on 35 million such tables; the Large on 137 million. By learning to recognize patterns across this enormous diversity of synthetic data, the model develops a general-purpose understanding of tabular structure that transfers to real-world datasets it has never seen. Kumo Tabular's architecture has three distinct components, each handling a different level of the tabular structure. Cell Embedding converts individual cell values into tokens using learned Fourier features — sines and cosines of learned frequencies applied to numerical values. Missing values are handled through dedicated learned embeddings, so no imputation step is needed before inference. Table Encoder compresses each row into a fixed-size embedding using alternating column-wise and row-wise attention layers. Column attention uses induced set attention, which scales linearly with the number of rows rather than quadratically — a critical property for large tables. Row attention then captures feature interactions across columns, using rotary positional encodings to distinguish between columns and four learnable CLS tokens as the final row readout. ICL Transformer operates on these row embeddings. Query rows the ones you want to predict attend only to labeled context rows; context rows attend to each other. This asymmetric attention pattern is what enables the model to generalize from labeled examples to unlabeled ones in a single pass. Two additional innovations improve efficiency at scale. Test-GQA Grouped Query Attention reduces the key-value cache size for query rows in the Medium and Large variants, cutting memory requirements during inference. Length-aware Attention Temperature dynamically scales attention sharpness as table size grows beyond the training range, preventing the attention distribution from flattening out on very large tables. Kumo Tabular comes in three sizes, all available on Hugging Face https://huggingface.co/nvidia/Kumo-Tabular and through NVIDIA's structured-data-models SDM library: The weights are released under the OpenMDW-1.1 license, and the pretraining and inference code is Apache 2.0. This matters in practice: several competing tabular foundation models, including TabPFN-3.5, carry non-commercial restrictions that limit production use. Kumo Tabular's licensing is commercially permissive. Using the model is straightforward via the SDM library: python from sdm import KumoTabular import pandas as pd model = KumoTabular.from pretrained "nvidia/Kumo-Tabular-L" predictions = model.predict context df=train df, query df=test df, target col="label" The model accepts a pandas.DataFrame directly and returns class probabilities or numeric predictions without any additional setup. The arxiv paper https://arxiv.org/abs/2611.23001 reports that Kumo Tabular-L currently ranks first on eight benchmarks: TabArena, TALENT, BeyondArena, ScoringBench, STRABLE, MulTaBench, RamanBench, and TabBench-Bio. On the accuracy-efficiency Pareto frontier, it outperforms both gradient-boosted baselines and other tabular foundation models in combined accuracy and runtime. Specific speed comparisons are notable: Kumo Tabular-L predicts 36× faster than LimiX-2 on TabArena and 1.7× faster than TabPFN-3.5 on BeyondArena. For a model that also eliminates the training step entirely, these inference-time advantages compound the overall time savings. The Databricks AI Runtime integration https://www.databricks.com/blog/tabular-foundation-models-databricks-ai-runtime published in November 2026 provides additional context on where tabular foundation models fit in production: they are most competitive as rapid baselines, for complex tasks where standard tuning is cost-prohibitive, or in settings where GPU infrastructure is already available and iteration speed matters more than raw throughput. Kumo Tabular doesn't make gradient-boosted trees obsolete. For large-scale, latency-sensitive, CPU-based production pipelines, XGBoost and LightGBM remain strong choices — they're mature, fast on CPU, and don't require GPU memory that scales with context size. Tabular foundation models are GPU-dependent, and inference memory grows with the number of labeled rows you provide as context. But the use case for ICL-based tabular models is real and growing. When you need a strong baseline quickly, when you're working with a new domain where feature engineering intuition is limited, or when you're running many experiments across diverse datasets, eliminating the training loop is a genuine advantage. The fact that Kumo Tabular achieves this while also topping eight benchmarks suggests the approach has moved well past proof-of-concept. The broader trend here — applying the pretraining-then-inference paradigm that transformed NLP and computer vision to structured data — is still early. Kumo Tabular is a concrete step toward making that transfer work at production quality. The model is available now on Hugging Face https://huggingface.co/nvidia/Kumo-Tabular and through NVIDIA's SDM library. The official documentation https://docs.nvidia.com/sdgm/structured-data-models/models/kumo-tabular covers installation, inference examples, and guidance on context size selection. For practitioners who want to understand the architecture and pretraining methodology in depth, the arxiv paper https://arxiv.org/abs/2611.23001 is the primary reference. If you've been waiting for tabular foundation models to reach a point where they're worth evaluating seriously against your existing pipelines, that point appears to have arrived.