NVIDIA Kumo Relational: 4 AUROC points over XGBoost, no training

Most enterprise prediction still runs on gradient-boosted trees fed by weeks of hand-built features. Nvidia's pitch is a foundation model that reads the database itself and predicts in a single pass — and it says that model now beats the tuned pipelines it replaces.

Nvidia published Kumo Relational on Wednesday: a pretrained foundation model that makes predictions directly against a relational database, with no task-specific training, no feature engineering, and no flattening of tables into one wide row. You connect a database, describe what you want to predict in a small declarative query language, and the model returns a churn probability, a demand number, or a fraud score in one forward pass. The weights are on Hugging Face under the OpenMDW 1.1 licence, the library that runs them is Apache 2.0, and the model is also available as an Nvidia NIM microservice, per Nvidia's announcement.

That framing matters because the alternative is genuinely expensive. A real business database is users joined to orders joined to products, all moving through time. Getting a prediction out of it today means deciding by hand which 30-day aggregates to compute, writing those features, training a model per task, and maintaining the pipeline when the schema changes. Every new question — who will churn, which invoice will go unpaid, which shipment will be late — is a new project rather than a new query.

The numbers Nvidia is claiming

The company evaluated Kumo Relational on 41 tasks across 15 relational databases drawn from RelBench V1 and V2, SAP SALT, and 4DBInfer, none of which appeared in pre-training. It reports beating the strongest supervised baselines in both classification and regression, including relational deep-learning models and expert-engineered gradient-boosted ensembles, according to the paper.

The headline comparison is against the tool most data teams actually use. On RelBench V1 classification tasks, Kumo Relational comes in nearly 4 AUROC points above gradient-boosted trees trained on expert-engineered features. On the SAP SALT enterprise benchmark it beats engineered XGBoost by 7 MRR points out of the box and by 13 points after fine-tuning, and it clears large AutoGluon ensembles by 8% in mean reciprocal rank — 16% once fine-tuned.

The efficiency claim is the more interesting one. On the RelArena-α leaderboard, which plots accuracy against inference time, the model sits on the Pareto front at Elo 1,842 and roughly 17 seconds per 1,000 samples. The highest-scoring entry, rt-plurel, reaches Elo 1,878 — about 2% better — at roughly 7,300 seconds, or some 430 times slower. For a scoring job that has to run nightly across millions of accounts, that gap is the difference between a batch window and a batch problem.

Scale is handled by a custom graph engine that serves databases with more than 500 billion rows through memory-mapped I/O at up to 5 GB per second, either in memory or through warehouse connectors.

How a model predicts without training

The mechanism is in-context learning, the same trick that makes a language model useful on the first prompt. At inference time Kumo Relational gathers up to 10,000 historical examples as context — each one a small subgraph around an entity at a point in time, paired with what actually happened next — and reasons over them alongside the entity it has been asked about.

Three stages do the work. A lightweight network reads each table on its own, alternating attention across a column's values with attention across a row's features, which filters noise before it propagates. A larger network then pushes those row embeddings across the primary-key and foreign-key graph, interleaved with attention across the context examples, which is where a user's profile gets connected to their transaction history. Because the second stage operates on row embeddings rather than on every cell, the cost stays linear-ish instead of going quadratic, which is what lets the context and the subgraph both get large.

Queries are written in Predictive Query Language, a declarative interface where you state the prediction rather than the procedure. For temporal tasks the system replays historical database states, serving the model only data from before the anchor timestamp and computing targets from events after it, which is how it avoids the leakage that quietly inflates most in-house churn models.

Pre-training happened entirely on synthetic relational data. Nvidia's generator builds on PluRel, a method that extends single-table synthetic data to full relational schemas — inventing a schema, wiring foreign keys so rows cluster the way real data clusters, and filling columns from structural causal models with temporal trends. The PluRel work showed pre-training loss falling on a power law as synthetic databases are added, with the gains carrying to real ones. Several Kumo team members co-authored that paper, so the pipeline and the model were designed together.

Where the claim gets thin

Two limits are worth taking seriously. First, in-context learning has a ceiling: the benchmarks used at most 10,000 context examples, and Nvidia concedes that on tasks with very large training sets a task-specific supervised model may still edge it out. Fine-tuning is the answer offered, but fine-tuning is exactly the project-shaped work the model was supposed to eliminate. Second, predictive signal has to be reachable within a few hops of the entity, so a sprawling schema needs a focused query rather than one heroic join.

The bigger caveat is that these are the authors' own evaluations on academic benchmarks. RelBench, SAP SALT and 4DBInfer are the right test sets, and none was seen in pre-training, but no independent group has reproduced the 4-AUROC result on a messy production warehouse with duplicated customers, null-heavy columns, and a schema nobody has documented since 2021. Accuracy on clean benchmark graphs is not the hard part of enterprise prediction; data plumbing is. Nvidia's answer to that is the connector layer and the query language, which is a claim about engineering rather than about model quality, and it is the claim most likely to be tested in the next six months.

There is also a lineage worth naming: the weights fine-tune TabICLv2, an earlier tabular foundation model released under a BSD-3-Clause licence, which is preserved in the model card's third-party notices. Kumo Relational is a relational extension of a tabular idea, not a from-scratch architecture.

Why Nvidia is giving this away

Nvidia bought Kumo AI in June for a reported $400 million, Forbes reported at the time, bringing the relational foundation model work in-house along with founders Vanja Josifovski, Hema Raghavan and Jure Leskovec. Open weights under a permissive-ish licence and a free library look generous until you notice what inference costs: every prediction here is a GPU forward pass over a graph, on hardware Nvidia sells. Replacing a CPU-bound XGBoost pipeline with a GPU-native foundation model is a very good business to be in if you make the GPUs.

The timing fits a pattern. Kumo Tabular and Kumo Forecast shipped from the same team this week, forming a small family of structured-data models — one for flat tables, one for time series, one for relational graphs. That is a stack, not a one-off paper.

What to watch

Independent replication on a real warehouse schema, and whether the warehouse vendors bundle it. Databricks and Snowflake both sell feature-engineering pipelines as part of their value proposition, and a model that makes those pipelines optional is either a partner or a threat depending on which quarter you ask. Watch the NIM pricing too: an open-weight model that is cheap to download and expensive to serve is a very specific kind of free.

Would you trust a foundation model's churn predictions over your own feature pipeline? Write to us via our contact page.