NVIDIA Kumo Tabular: A Zero-Training Tabular Predictor That Has Never Seen Real Data

What happened

NVIDIA released Kumo Tabular, a 28M-to-215M-parameter Transformer that predicts labels or values for new rows from a table of labeled examples in one forward pass. No training, no feature engineering, no tuning. Weights are on Hugging Face, the inference library is open-source on GitHub, and the model carries an OpenMDW-1.1 license.

Context

Kumo Tabular extends the TabPFN and TabICL lineage of in-context tabular learners, which ask whether a small Transformer can replace the train-and-deploy cycle for structured data. Earlier models in that family proved the core idea: feed labeled rows as context, predict on query rows. What they left open was scale, missing-value handling, and regression uncertainty. Kumo Tabular is part of NVIDIA's Kumo Structured collection and shipped on 29 September 2026 with both weights and code.

How it works

The architecture is built around the geometry of a table. A group of cells is packed into one token; numerical and categorical values are encoded with Fourier features using separate learned weights per type, and missing values receive a dedicated encoding path rather than an imputation step.

Attention runs in two passes: column attention via induced self-attention (linear cost in rows), then row attention with rotary position encodings to keep columns distinct. Four [CLS] tokens per row are compressed through attention, making the final readout cost independent of column count.

A third in-context layer handles the actual prediction. Context rows attend to each other; query rows attend only to context. Because context never sees query, the context KV cache is computed once and reused for follow-up predictions. Query rows use Test-GQA to shrink the per-prediction KV read. For regression, the output head emits 999 quantiles, giving a point estimate and an uncertainty interval. A length-aware attention temperature, scaled by the log of the number of keys with a per-head learned coefficient, keeps attention sharp when the inference table outgrows the pretraining tables.

Pretraining is entirely synthetic. Tables are sampled from a procedural Structural Causal Model generator, not a trained network, yielding an unbounded supply of new causal graphs, mixed missing-value patterns, many-level categorical columns, and heavy-tailed regression targets.

Our read

The "ranks first on four benchmarks" line deserves a second look. Kumo Tabular is pretrained exclusively on tables from a procedural SCM sampler. It has never ingested a row of real-world data. That is the strongest selling point and the most important caveat in the same breath. Its inductive biases are shaped entirely by the causal graphs that sampler produces. If your tables look structurally similar to those graphs, the fit is good. If your data has domain-specific encodings or dependency structures the sampler does not generate, the benchmark ranking tells you less than the headline implies.

The release also does not emphasize that this is an in-context model, not a fine-tuning model. You do not train it on your data. You supply labeled rows and it predicts. Your labeled context set is your entire domain adaptation. A 200-row sample of your specific table is doing the work a fine-tuned model would do over 200,000 rows. For most small-studio tables that is enough; for tables where the signal lives in cross-column interactions a short context cannot convey, it is not.

The 28M-to-215M range is deliberately small. The smallest model runs on a laptop GPU. That is a deployment choice: run it next to your data, not behind a hosted API.

What this changes

For a ComfyUI video pipeline, nothing changes on Monday. Kumo Tabular has no node, no latent interface, no integration point in a render workflow.

Where it does land: the analytics side. If you track render times, GPU utilization, asset reuse rates, or campaign CTR in a spreadsheet or small database, the 28M model can sit on a local GPU and classify or regress on that table without a training step. The 999-quantile regression output gives you an uncertainty band, not just a point. The open-source library means you script it in Python, pull weights from Hugging Face, and run. No API key, no per-token billing. The tradeoff: your labeled context must be representative, because the model will not learn from your data the way a fine-tuned model would.

License

Kumo Tabular is released under the OpenMDW-1.1 license, which the source states permits commercial use. The full terms (attribution, redistribution, modification, field-of-use restrictions) are not documented in the source material. Check the license text on the Hugging Face model card before shipping anything built on these weights.

Key takeaways

• Kumo Tabular is a 28M-to-215M-parameter in-context learner: feed it labeled rows, get a prediction, no training step.
• Pretraining is entirely synthetic via a procedural SCM sampler; the model has never seen real-world data.
• The architecture targets efficient single-pass inference: two-pass attention, [CLS] compression, context KV caching, Test-GQA.
• Commercial use is permitted under OpenMDW-1.1, but full terms are not documented in the source; check the model card before building.
• For a small studio, the practical entry point is local analytics on production-metric tables, not video pipeline integration.

Sources

1. NVIDIA Kumo Tabular Sets a New Accuracy-Efficiency Frontier for Tabular Prediction — tier 1