NVIDIA Kumo Relational Outperforms Supervised Machine Learning on Relational Data Without Task-Specific Training

NVIDIA Kumo Relational Outperforms Supervised Machine Learning on Relational Data Without Task-Specific Training

Published October 21, 2026

TL;DR

NVIDIA Kumo Relational is a pre-trained relational foundation model that makes predictions directly from enterprise databases. Given a predictive query, it uses up to 10,000 historical examples as context and predicts outcomes such as customer churn, demand, or fraud in a single forward pass.

The model requires no task-specific training, feature engineering, or table flattening. Across 41 tasks on 15 databases, Kumo Relational outperformed supervised relational deep-learning models and expert-engineered gradient-boosted-tree pipelines. On the SAP SALT enterprise benchmark, it exceeded AutoGluon ensembles by 8% in mean reciprocal rank (MRR).

Kumo Relational scales to databases containing more than 500 billion rows. It can be used through NVIDIA's open-source, GPU-native structured-data-models library or deployed as an NVIDIA NIM.

• Research paper: arXiv:2604.12596
• Documentation: NVIDIA structured data models documentation

The Shift Toward Structured-Data Foundation Models

Foundation models have changed how language and vision systems are developed. Previously, production natural-language processing often required a separate model and pipeline for each task, along with steps such as tokenization, lemmatization, and n-gram generation. Large language models reduced that complexity by improving accuracy, simplifying deployment, and supporting agent-based applications.

A similar change is emerging for structured data. Relational databases support many business decisions, but predictive modeling over them often requires weeks of feature engineering, task-specific training, and pipeline tuning. Structured-data foundation models address these challenges in three ways:

Accuracy

As drop-in replacements, structured-data foundation models can outperform existing production pipelines, particularly XGBoost systems. On RelBench V1 classification tasks, Kumo Relational exceeded gradient-boosted trees trained on expert-engineered features by nearly 4 AUROC points on average.

On SAP SALT, it outperformed XGBoost using engineered features by 7 MRR points without fine-tuning, and by 13 MRR points after fine-tuning.

Simpler development

A single pre-trained model can replace separate pipelines for individual prediction tasks. Instead of starting a new machine-learning project, a team can describe a prediction as a query.

Predictive agents

Large language models allow agents to read, write, and reason. Structured-data foundation models allow them to anticipate future events, such as which customers may churn, and act on those predictions. Kumo Relational can be called by agents through its Predictive Query Language (PQL) interface.

Kumo Relational applies this approach to relational data. A database can be connected, a prediction can be specified, and the model can return results in a single forward pass without task-specific training.

How Kumo Relational Works

Many structured-data foundation models operate on one flat table. Real-world data is usually stored in relational databases, where users connect to orders, products, transactions, and other entities that change over time.

Flattening these relationships into a single row requires manual aggregations, such as calculating a user's average order value over the previous 30 days. This process can discard structural information and requires substantial engineering work.

Kumo Relational operates directly on a database while preserving its tables, foreign keys, and timestamps. The model is pre-trained on synthetic relational data designed to reflect real-world datasets. It adapts to new tasks through in-context learning, processing up to 10,000 examples during inference.

Each context example contains a local subgraph around an entity at a particular point in time, together with its known target. Examples might indicate that a user churned or that a product sold 142 units.

The model must perform three types of reasoning:

1. Understand values within individual tables.
2. Connect records across tables.
3. Relate context examples with known targets to the entity being predicted.

Automatic context generation

Tasks are expressed in the Predictive Query Language (PQL), a declarative interface for describing what should be predicted rather than how to calculate it.

For temporal tasks, Kumo Relational replays historical database states. It samples entity-centered subgraphs up to an anchor timestamp and calculates each target from events occurring after that timestamp. The model receives only data available before the anchor timestamp, preventing data leakage.

Reasoning within tables

A lightweight network processes each table independently. It alternates between:

• Column attention, which relates values within a column.
• Row attention, which relates features within a row.

This enables the model to identify the columns and rows most relevant to the current prediction and filter noise before information is propagated.

Reasoning across tables

A larger network distributes row embeddings through the relational structure using graph attention over primary-key and foreign-key relationships. Cross-sample attention is interleaved across the context examples.

This enables relational reasoning, such as connecting a user's profile with transaction history. Because the process operates on row embeddings instead of every cell in every table, it avoids quadratic costs and can scale to larger contexts and deeper subgraphs.

How Kumo Relational Was Built

Kumo Relational was pre-trained entirely on synthetic relational data generated to represent real-world databases and a broad range of predictive queries. Training progressed from individual tables to increasingly complex relational structures.

Public relational databases suitable for pre-training are limited, so synthetic data provides the necessary scale. The data generator builds on PluRel, developed by Kothapalli et al. and published at ICML 2026. Members of the Kumo team contributed to PluRel and co-authored the original paper.

PluRel generates databases in three stages:

1. It creates a schema.
2. It generates foreign-key links between rows, including clustering patterns found in real data.
3. It generates column values using Structural Causal Models with temporal trends and cross-table dependencies.

The generation process is lightweight, making the supply of pre-training data effectively unlimited. The PluRel paper reports that pre-training loss follows a power law as synthetic databases are added, with improvements transferring to real databases.

Through pre-training, Kumo Relational learns to filter, correlate, and aggregate information across tables rather than depending on fixed, manually designed aggregations. Fine-tuning is also available for cases where maximum accuracy on a particular dataset and task is required.

Performance

The evaluation covered 41 benchmarks across 15 relational databases from RelBench V1 and V2, SAP SALT, and 4DBInfer. The datasets represented e-commerce, medical, enterprise, social, and academic domains, and none were included in pre-training.

Kumo Relational outperformed the strongest supervised models in both classification and regression. The comparison included relational deep-learning models and tabular ensembles based on expert-engineered features.

On the RelArena-α leaderboard, which compares relational models and systems on RelBench V1, Kumo Relational was on the accuracy-efficiency Pareto front without task-specific training. It reached an Elo score of 1,842 with a median inference time of approximately 17 seconds per 1,000 samples.

The highest-scoring entry, rt-plurel, reached an Elo score of 1,878 but required approximately 7,300 seconds per 1,000 samples, making Kumo Relational roughly 430 times faster at similar accuracy.

On the SAP SALT enterprise benchmark, Kumo Relational:

• Exceeded large AutoGluon ensembles by 8% in MRR.
• Outperformed recent tabular foundation models by approximately 25%.
• Extended its lead over AutoGluon to 16% after fine-tuning.

The model also performed under challenging conditions. It remained effective with as little as 0.2% of the training data provided as context, stayed stable after up to 75% of foreign-key links were removed, and showed little degradation after many noisy columns were added.

Limitations

Kumo Relational performs best when data contains meaningful relationships and temporal dynamics, such as user behavior over time.

For tasks with very large training sets, task-specific supervised models may still outperform in-context predictions. The benchmarks used no more than 10,000 context examples, and fine-tuning is intended for cases where more task-specific adaptation is needed.

Predictive signals must also be reachable within a limited number of relational hops. A focused query over a small number of relevant tables is recommended initially, with the graph expanded as necessary.

Using the Model

Kumo Relational supports in-context learning over databases in memory, through database and warehouse connectors, or through a custom graph engine. The graph engine supports more than 500 billion rows through memory-mapped I/O at speeds of up to 5 GB/s.

The model is available in NVIDIA's GPU-native structured-data-models library. The library downloads model weights from the Hugging Face Hub on first use, allowing the model to run in a GPU-backed notebook.

A direct library call can provide context examples, prediction entities, and related tables:

## 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=...,
)

The library repository includes complete RelBench and SAP SALT pipelines, including methods for sampling tables related to each entity.

Kumo Relational can also run as a separate service through an NVIDIA NIM. The open-source structured-data-models-client can send PQL queries and related table data to the service:

## 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 repository provides example notebooks for running the model against a local NIM and on Databricks.

Availability and Licensing

NVIDIA Kumo Relational is distributed through the following resources:

• Research paper: arXiv:2604.12596
• Documentation: NVIDIA structured data models documentation
• Code: structured-data-models on GitHub
• PyPI package: structured-data-models
• Client code: structured-data-models-client
• Client package: structured-data-models-client on PyPI
• Model weights: NVIDIA Kumo-Relational on Hugging Face
• Quickstart notebook: Relational example notebook
• Related research: Predictive Query Language, PluRel, and Kumo Tabular

The code is released under the Apache 2.0 license. The model weights are released under the OpenMDW License Agreement, version 1.1.