Before swapping XGBoost for NVIDIA's Kumo Relational, run it on one prediction you already know the answer to

An XGBoost model (a machine-learning library that chains many decision trees) that predicts which customers will not buy again in the next 30 days usually runs on summary columns someone wrote by hand, such as “average order value over 30 days”. On October 21, 2026, NVIDIA published a post on Hugging Face (a platform for sharing AI models) introducing Kumo Relational, a model the company says can predict straight from a multi-table database with no task-specific training, and beat pipelines (chains of steps that build columns, train and run a model) of that kind. The sensible way to treat that number is to run it on one live prediction your team already owns, in the four steps below, before anyone talks about replacing anything.

What NVIDIA says about Kumo Relational

According to NVIDIA, Kumo Relational is a foundation model (a model trained once in advance and then reused for many tasks) for relational data, meaning data that sits in several tables joined by foreign keys: customers link to orders, orders link to products. The company writes that the model was pre-trained entirely on synthetic relational data. At prediction time it reads up to 10,000 historical examples as context and returns a result in a single pass. This is called in-context learning: the model looks at examples at the moment of prediction instead of being retrained for each problem. You state the task in PQL (Predictive Query Language), for example PREDICT COUNT(orders.*, 0, 30, days) FOR EACH users.user_id, the line in NVIDIA’s own sample, which predicts each customer’s order count over the next 30 days.

The results NVIDIA reports were measured across 41 tasks on 15 databases, none of which the model saw during pre-training:

• On the classification tasks of RelBench V1 (a shared benchmark for machine learning on relational data), Kumo Relational beats gradient-boosted trees (decision trees built one after another) on expert-engineered features by nearly 4 AUROC points on average. AUROC measures how well a model ranks people who will leave above people who will stay: 0.5 is a coin flip, 1 is a perfect ranking.
• On SAP SALT (SAP’s enterprise-data benchmark), the model beats XGBoost on engineered features by 7 MRR points out of the box and by 13 points after fine-tuning. MRR (mean reciprocal rank) scores 1/k when the right answer sits at position k in a list of suggestions.
• On the RelArena-α leaderboard, NVIDIA says Kumo Relational takes about 17 seconds per 1,000 samples, while the highest-scoring entry, rt-plurel, scores slightly higher (1,878 against 1,842) but takes about 7,300 seconds, roughly 430 times slower.

The code is under the Apache 2.0 license and the model weights under the OpenMDW License Agreement, version 1.1. It runs on NVIDIA’s structured-data-models library, which needs a GPU (a graphics processor, the chip used to run AI models), or as an NVIDIA NIM (NVIDIA’s packaging of a model to run as a separate service you call). These are results published by NVIDIA and the paper’s authors; the post does not say anyone has reproduced them independently.

What the company itself lists as limits

In the same post NVIDIA writes that the model works best on data with meaningful relationships and change over time, such as user behavior. On tasks with very large training sets, a model trained for that one task may still edge ahead, because in the company’s measurements the model read at most 10,000 examples. The predictive signal also has to be reachable within a limited number of table joins, so the company advises starting with a focused query over a few relevant tables and expanding gradually. These three points shape steps 1 and 4 below.

Four steps on your own prediction

The customers and orders tables in this example store are an illustration built for this article, and the four steps have not been run on any system.

1. Pick a live prediction that already has real outcomes. You need a problem your team already has a model for and whose true answer is known, for example “will the customer buy within 30 days after date T”. Choose a cutoff date T far enough back that more than 30 days of outcomes exist after it. Start with two tables, customers and orders.

2. Write the PQL query for exactly that problem. For the example above you can use NVIDIA’s sample line shown earlier. Build the context examples only from time before T.

3. Run it on the same customers your current model predicted. Use the same cutoff T and the same customer set. NVIDIA describes two ways to run it:

   • Through NVIDIA NIM: install the client with pip install 'structured-data-models-client[relational]', pass the users and orders tables as pandas DataFrames (tables of data in Python) together with the PQL from step 2, then call client.predict(...). According to the post, the client gathers the context examples and related tables itself and sends the request to the NIM; you put your own NIM address in sdm_client.SDMClient(url=...).
   • Directly on a machine with a GPU: pip install structured-data-models, then sdm.models.KumoRelational(device="cuda"). Here you supply the context-example tables and the customers to predict yourself, so before running, filter every table so that no row carries a timestamp after T.

   NVIDIA says its tooling keeps only pre-cutoff data to prevent leakage of future data, but if you join tables yourself you have to check that on your own. The output is one predicted value per user_id in the set you asked about; join it to the true outcomes on user_id to compute the metric in step 4. NVIDIA’s sample notebook: relational.ipynb.

4. Compare with the current model using the metric your team already uses. Record two numbers, the old model’s metric and Kumo Relational’s on the same customers, plus run time and GPU cost. Before running, decide what gap your team would consider worth changing the pipeline for. If Kumo Relational only matches or falls below the current model, or the result looks unusually good, first go back to step 3 and look for any row after T that slipped in. If your tables hold millions of training rows, try the fine-tuned version NVIDIA mentions, or keep the old pipeline. If the predictive signal sits many joins away, widen the tables you feed in gradually and run again.

Sources

1. NVIDIA, “NVIDIA Kumo Relational Outperforms Supervised Machine Learning on Relational Data, No Training Required” (Hugging Face Blog, October 21, 2026): the post introducing the model, its results on RelBench, SAP SALT and RelArena-α, the limits the company lists, how to run it and the licenses.
2. NVIDIA, quickstart notebook relational.ipynb (GitHub): the sample notebook that runs Kumo Relational through structured-data-models-client, linked from the Hugging Face post.