NVIDIA Kumo Relational Outperforms Supervised Machine Learning on Relational Data, No Training Required

What it claims

Kumo Relational is a pre-trained relational foundation model from NVIDIA. It predicts on multi-table databases in one forward pass, using up to 10,000 in-context examples and no task-specific training. Beyond the headline results, the page gives specific margins. On RelBench V1 classification it beats gradient-boosted trees on expert-engineered features by nearly 4 AUROC points on average. On SAP SALT it beats XGBoost on engineered features by 7 MRR points out of the box and by 13 points after fine-tuning. The authors argue these results justify replacing production XGBoost pipelines; that is NVIDIA's position, not an independent finding.

How it works

Tasks are written in Predictive Query Language (PQL), a declarative language that states what to predict. For temporal tasks the system replays historical database states. It samples entity-centric subgraphs up to an anchor timestamp, computes targets from events after it, and shows the model only data from before it. This is meant to prevent leakage.

The model reasons in two stages. A lightweight network processes each table on its own, alternating column attention and row attention, with context targets injected. A larger network then runs graph attention over primary-key/foreign-key links, interleaved with cross-sample attention across context examples. This stage works on row embeddings, not on every cell, which the authors say avoids quadratic cost and allows larger contexts and deeper subgraphs.

Pre-training uses only synthetic relational data, staged from single tables up to complex schemas. The generator builds on PluRel (Kothapalli et al., ICML 2026), co-authored by Kumo team members. PluRel creates a schema, then clustered foreign-key links, then column values from Structural Causal Models with temporal trends and cross-table dependencies. The PluRel paper reports that pre-training loss follows a power law as synthetic databases are added. The model can also be fine-tuned on a specific dataset and task.

Evidence

The evaluation covers 41 tasks on 15 databases from RelBench V1 and V2, SAP SALT and 4DBInfer. None of these datasets were seen in pre-training. On the RelArena-α leaderboard (RelBench V1), Kumo Relational scores Elo 1,842 at about 17 seconds median inference per 1,000 samples. The top entry, rt-plurel, scores Elo 1,878 at about 7,300 seconds, roughly 430 times slower. On SAP SALT it beats AutoGluon ensembles by 8% MRR (16% after fine-tuning) and recent tabular foundation models by about 25%. The page also reports these results:

• It works with as little as 0.2% of the training data as context.
• It stays stable with up to 75% of foreign-key links removed.
• It barely degrades when many noisy columns are added.

How to use it

The code is Apache 2.0. The weights (nvidia/Kumo-Relational on Hugging Face) are under the OpenMDW License Agreement v1.1, not Apache, so check that licence separately. The open-source structured-data-models library is GPU-native and fetches the weights on first use. Its graph engine handles 500B+ rows via memory-mapped I/O at up to 5 GB/s. In-process use:

# pip install structured-data-models
import sdm
model = sdm.models.KumoRelational(device="cuda")
pred = model(
    # In-context training table (fkeys/timestamps/targets):
    x_context=...,
    y_context=...,
    # Prediction examples (fkeys/timestamps):
    x_query=...,
    # Multi-table information for context/prediction entities:
    related_context_tables=...,
    related_query_tables=...,
)

In this mode you sample each entity's related tables yourself. The library's RelBench and SAP SALT examples show how. The alternative is to deploy the model as an NVIDIA NIM and use the client, which takes PQL and gathers the context itself:

# pip install 'structured-data-models-client[relational]'
import sdm_client
client = sdm_client.SDMClient(url="http://localhost:8001")  # NIM URL
query = sdm_client.PredictiveQuery(
    # Prediction task in Predictive Query Language (PQL):
    "PREDICT COUNT(orders.*, 0, 30, days) FOR EACH users.user_id",
    # Multi-table data as pandas DataFrames (keys/links inferred):
    {"users": ..., "orders": ...},
)
pred = client.predict(
    # Context examples and related tables for the entities to predict:
    query.materialize(indices=[1, 2, 3]),
    model=sdm_client.KumoRelational(),
)

The client ships example notebooks for a local NIM and for Databricks.

Limits

The authors say the model does best on data with meaningful relationships and temporal dynamics. With very large training sets, task-specific supervised models may still beat in-context prediction, since benchmarks capped context at 10,000 examples. Fine-tuning is the stated remedy for that case. Predictive signal must be reachable within a limited number of hops, so the authors advise starting with a few relevant tables and expanding the graph from there. All results are self-reported by NVIDIA, and the page gives no model size or pre-training compute.