NVIDIA releases Kumo Relational, a model that predicts straight from business databases

What NVIDIA released

NVIDIA has introduced Kumo Relational, a pre-trained model that makes predictions directly on a company's relational database instead of on one flattened spreadsheet. In a Hugging Face blog post published on 21 October 2026, the Kumo team at NVIDIA describes it as a relational foundation model: point it at a set of linked tables, state what you want to predict, and it returns predictions such as customer churn, product demand or fraud risk in a single forward pass, with no task-specific training, no feature engineering and no flattening of tables.

It is the multi-table sibling of Kumo Tabular, which NVIDIA released a week earlier for single tables, and it runs through the same open-source Structured Data Models library. The weights are on Hugging Face under the OpenMDW License Agreement 1.1, the library code is Apache-2.0, and NVIDIA also packages the model as a NIM inference service. The model card says Kumo Relational is based on KumoRFM-2, the relational model described in an April 2026 paper by Valter Hudovernik, Federico López, Jure Leskovec, Matthias Fey and colleagues, and that it fine-tunes pretrained TabICLv2 weights, which are BSD-3-Clause.

NVIDIA's headline claim is a strong one: that Kumo Relational is the first few-shot foundation model to beat supervised machine learning on common relational benchmarks, outperforming both purpose-built relational deep learning models and gradient-boosted tree pipelines built on expert-engineered features across 41 tasks on 15 databases. Those results come from NVIDIA's own paper and blog.

Why databases are hard for foundation models

Most business data does not live in a single table. A retailer has users linked to orders, orders linked to products, and all of it changing over time. To predict something like whether a customer will churn next month, data scientists usually flatten that structure by hand into one row per customer, writing aggregates such as average order value over the last 30 days. That work takes weeks per question, has to be repeated for each new prediction task, and throws away fine-grained signal in the process.

Tabular foundation models such as Kumo Tabular already remove the training step for a single flat table: the labelled rows act like examples in a prompt and the model predicts the rest. NVIDIA's argument is that stopping at one table leaves most of the hard work, the flattening, in place. Kumo Relational is meant to skip it and read the tables, foreign keys and timestamps as they are. NVIDIA pitches this as the same shift language models brought to text: one pre-trained model replacing a separate pipeline per task. The idea is already in commercial use; Santander named NVIDIA Kumo as part of the three-year AI deal it signed with NVIDIA this week, built around small specialised models.

NVIDIA also frames the model as a tool for AI agents. Language models let agents read, write and reason, the blog argues, while structured-data models let them anticipate what happens next, such as which customer will churn, and act on it. Kumo Relational exposes a declarative Predictive Query Language for that purpose, so an agent can ask a predictive question in one line rather than building a pipeline.

How Kumo Relational reads a database

A prediction starts with a query in Predictive Query Language, or PQL, which states what to predict rather than how. NVIDIA's example asks for the number of orders each user will place in the next 30 days. For time-based tasks the system replays the database as it stood at earlier moments: it samples a subgraph around each entity up to an anchor timestamp, computes the target from events after that timestamp, and only shows the model data from before it. NVIDIA says this prevents data leakage, a common way for predictive models to look better in testing than in production.

Each prediction draws on up to 10,000 such historical examples as context. The model then works in two stages. A lightweight network processes each table on its own, alternating column attention, which relates values within a column, and row attention, which relates features within a row, so irrelevant columns can be filtered out early. A larger network then passes the resulting row embeddings across the database using graph attention over primary-key and foreign-key links, interleaved with attention across the context examples. That is where a user's profile gets connected to their transaction history.

Because the cross-table stage operates on row embeddings rather than every cell of every table, NVIDIA says the design avoids quadratic cost and can handle large contexts and deeper subgraphs. The KumoRFM-2 paper adds that, unlike its predecessor, the model injects task information as early as possible, which the authors say helps it select relevant columns and cope with noisy data.

Trained on synthetic databases

Public relational databases with a variety of prediction tasks are rare, so NVIDIA says Kumo Relational was pre-trained on entirely synthetic relational data, in stages from single tables to increasingly complex structures. The generator builds on PluRel, an ICML 2026 method co-authored by members of the Kumo team, which creates a schema, then foreign-key links between rows that cluster as they do in real data, then column values from structural causal models with temporal trends and cross-table dependencies. NVIDIA says generation is cheap enough that pre-training data is effectively unlimited, and that the PluRel work found pre-training loss follows a power law as more synthetic databases are added.

There is one wrinkle worth noting. The KumoRFM-2 paper's abstract says that model was pre-trained on a large corpus of synthetic and real-world data, while NVIDIA's blog says Kumo Relational, which the model card describes as based on KumoRFM-2, was pre-trained entirely on synthetic data. AI Lookout has not seen a detailed explanation of the difference; it may reflect a separate training run for the open release. Teams that care about training-data provenance should check the model card and licence files directly. Where maximum accuracy matters, the model can also be fine-tuned on a specific dataset and task.

NVIDIA's benchmark claims

NVIDIA evaluated Kumo Relational on 41 benchmark tasks across 15 databases drawn from RelBench V1 and V2, SAP SALT and 4DBInfer, covering e-commerce, medical, enterprise, social and academic data. None of those datasets was seen in pre-training, according to the blog. On RelBench V1 classification tasks, NVIDIA reports that the model beats gradient-boosted trees trained on expert-engineered features by nearly 4 AUROC points on average.

On SAP SALT, an enterprise benchmark built from SAP sales data, NVIDIA says Kumo Relational beats XGBoost on engineered features by 7 mean-reciprocal-rank points out of the box and by 13 after fine-tuning. It reports an 8 percent MRR lead over large AutoGluon ensembles, rising to 16 percent with fine-tuning, and about 25 percent over recent tabular foundation models. On the RelArena-alpha leaderboard for RelBench V1, NVIDIA places the model on the accuracy-efficiency frontier at an Elo of 1,842 and about 17 seconds per 1,000 predictions. The highest-scoring entry, rt-plurel, reaches 1,878 Elo but takes about 7,300 seconds, roughly 430 times slower.

NVIDIA also reports robustness results: good performance with as little as 0.2 percent of the training data supplied as context, stable results when up to 75 percent of foreign-key links are removed, and little degradation when many noisy columns are added. AI Lookout did not run the model, and none of these numbers has been independently reproduced yet.

How to run it

There are two ways in. Developers can install the open-source structured-data-models library, which downloads the weights from Hugging Face on first use, and call the model from a GPU-backed notebook by passing context rows, query rows and their related tables. Or they can deploy Kumo Relational as an NVIDIA NIM and use the separate open-source client, which lets them write the prediction in PQL and pass tables as pandas DataFrames; the client gathers the context examples and related tables and sends the request. NVIDIA's NIM documentation lists classification, regression, forecasting and link prediction as supported prediction types, with data connectors for Snowflake, Databricks, DuckDB, SQLite and Amazon S3.

For scale, NVIDIA says the model can run in memory, through database and warehouse connectors, or through a custom graph engine that handles more than 500 billion rows using memory-mapped input and output at up to 5 GB per second. The library ships example pipelines for RelBench and SAP SALT and a quickstart notebook.

The release fills out a week of open structured-data and retrieval models from NVIDIA, after Kumo Tabular, a Kumo Forecast time-series model described in a separate Hugging Face post the same day, and the Nemotron 3.5 retrieval models. Together they amount to a push into predictive analytics on enterprise data, territory long held by gradient-boosted trees and AutoML tools.

Limits and open questions

NVIDIA lists the limits itself. Kumo Relational performs best on data with meaningful relationships and time dynamics, such as user behaviour over time. On tasks with very large training sets, a task-specific supervised model may still edge it out, since the benchmarks used at most 10,000 context examples; fine-tuning is the suggested remedy. Predictive signal also has to be reachable within a limited number of hops across the table graph, so NVIDIA recommends starting with a focused query over a few relevant tables.

The bigger questions are about evidence and governance. All the benchmark wins come from NVIDIA and the Kumo team, and relational leaderboards are young enough that results can shift quickly. Real enterprise databases are messier than benchmarks, with schema drift, missing keys and permissions that differ by table, and a model that reads raw tables needs the same access controls as any analyst. The OpenMDW terms, the inherited BSD-3-Clause notice and the separate NIM terms should be read before production use. Still, if the results hold up outside NVIDIA's tests, asking a database a predictive question could become as routine as running a SQL query.