NVIDIA Kumo Relational outperforms supervised machine learning on relational data without requiring training.
NVIDIA Kumo Relational is a pretrained model that predicts database outcomes in one pass using context examples, without task-specific training.
Key Takeaways
- NVIDIA Kumo Relational is a pre-trained relational foundation model that predicts outcomes like churn, demand, and fraud directly from databases without task-specific training or feature engineering.
- It uses up to 10,000 historical context examples at inference time and returns predictions in a single forward pass, enabling fast few-shot prediction on new database tasks.
- Kumo Relational works with native relational structures such as tables, foreign keys, and timestamps instead of flattening data, preserving complex relationships and reducing manual preprocessing.
- Across 41 tasks on 15 relational databases, it outperforms supervised models, including relational deep learning and expert-engineered XGBoost pipelines, and scales to databases with over 500 billion rows.
Meta description: NVIDIA Kumo Relational predicts database outcomes like churn, demand and fraud using up to 10,000 context examples, without task-specific training.
Tags: NVIDIA Kumo Relational, structured data foundation model, predictive database, relational deep learning, AutoGluon
Featured image: abstract friendly illustration of a relational database graph, GPU, and predictive query interface; no real people, no logos, no text.
This is for enterprise machine-learning teams, database developers, and agent builders: NVIDIA introduced Kumo Relational, a pre-trained relational foundation model that predicts outcomes such as churn, demand, or fraud directly from relational databases. It gathers up to 10,000 historical examples as context and returns predictions in a single forward pass, without task-specific training, feature engineering, or flattening tables. NVIDIA says the model is available today, with its paper at https://arxiv.org/abs/2604.12596 and documentation at https://docs.nvidia.com/sdgm/rfm/overview.
Why structured data now has a foundation-model path
Foundation models changed language and vision by replacing many task-specific pipelines with a single pre-trained system. Production natural language processing once meant a separate model for each task, supported by tokenization, lemmatization, and n-grams. LLMs displaced that stack because they outperformed many dedicated models, made deployment simpler, and let agents do more. NVIDIA frames Kumo Relational as the same shift for structured data: relational databases support important business decisions, yet traditional prediction still needs weeks of feature engineering, task-specific training, and tuned pipelines.
Kumo Relational is described as the first few-shot foundation model to outperform supervised machine learning on common relational benchmarks. Across 41 tasks on 15 databases, it beats supervised relational deep learning models and expert-engineered gradient-boosted tree pipelines. On the SAP SALT enterprise benchmark, it surpasses AutoGluon ensembles by 8% in mean reciprocal rank. It scales to databases with more than 500 billion rows and is usable by humans and agents through NVIDIA's open-source, GPU-native structured-data-models library or as an NVIDIA NIM.
The practical effect is that a new database prediction can become a query rather than a separate project. One pre-trained model replaces the separate pipelines that traditional ML teams used for individual tasks, so ML teams can take on use cases that earlier pipelines made too laborious at every level of an organization. LLMs let agents read, write, and reason; Kumo Relational gives them a way to anticipate outcomes, such as which customer will churn, and then act.
How it reads a relational database instead of one flat table
A lot of structured-data foundation models start from one flattened table. Enterprise data usually spreads across linked tables—users, orders, products, and timestamps—that evolve together. Collapsing those relationships into a single row through manual aggregation, such as average order value over the last 30 days, can remove fine-grained structural signals and require significant human effort.
Kumo Relational stays on the database structure, using tables, foreign keys, and timestamps rather than forcing rows into a flat form. It is pre-trained once on synthetic relational data designed to reflect real-world datasets, then adapts to each task through in-context learning, reading up to 10,000 context examples at inference time. Each context example pairs a local subgraph around an entity at a point in time with a known target, such as a user who churned or an item that sold 142 units.
The prediction path has three jobs: understand values inside each table, relate records across tables, and connect known context examples to the entity being predicted. For time-sensitive tasks, users write a predictive question in the Predictive Query Language, declaring what should be predicted rather than how. The system reconstructs past database states: the context subgraph is cut at an anchor timestamp, the target is derived from later events, and the model sees only the earlier data. That cuts off leakage.
Within a table, the model uses a lightweight network that switches between column attention and row attention, learning which columns and rows matter and suppressing noise before it spreads. Across tables, a larger network sends row embeddings along primary-key and foreign-key links using graph attention, while cross-sample attention compares the entity to known examples. This is where relational reasoning happens, such as linking a user's profile to transaction history. Because the cross-table stage uses row embeddings rather than every cell, the design avoids quadratic cost and can scale to large contexts and deeper subgraphs.
Benchmark evidence: accuracy, speed, and robustness
The paper evaluates Kumo Relational on 41 benchmarks across 15 relational databases from RelBench V1, RelBench V2, SAP SALT, and 4DBInfer. The datasets cover e-commerce, medical, enterprise, social, and academic domains, and none were seen during pre-training. The model outperforms the strongest supervised models in classification and regression, including relational deep learning models and expert-engineered tabular ensembles.
On RelBench V1 classification tasks, Kumo Relational outperforms gradient-boosted trees using expert-engineered features by nearly 4 points in area under the receiver operating characteristic curve on average. On SAP SALT, it beats XGBoost on engineered features by 7 points in mean reciprocal rank out of the box and by 13 points after fine-tuning. Those results position it as a possible replacement for production XGBoost pipelines.
On the RelArena-α leaderboard for RelBench V1, Kumo Relational sits on the accuracy-efficiency Pareto front out of the box. The leaderboard plots relative accuracy as Elo across tasks against median inference time per 1,000 samples on a logarithmic scale. Kumo Relational appears at about 17 seconds and Elo 1,842. The highest-scoring entry, rt-plurel, reaches Elo 1,878 at about 7,300 seconds, roughly 430 times slower. Every other foundation model, feature-engineering system, and supervised model scores lower and runs slower than Kumo Relational.
The SAP SALT results also show Kumo Relational surpassing large AutoGluon ensembles by 8% in mean reciprocal rank and recent tabular foundation models by about 25%; fine-tuning extends the lead over AutoGluon to 16%. The model remains useful with as little as 0.2% of training data used as context, stays stable when up to 75% of foreign-key links are removed, and barely degrades when many noisy columns are added.
Training data and what remains uncertain
Kumo Relational is pre-trained on entirely synthetic relational data with diverse predictive queries. Diverse public relational databases are rare, so synthetic generation fills the gap. Pre-training moves in stages, from single tables to increasingly complex relational structures.
The generator builds on PluRel, a method from Kothapalli and others presented at the International Conference on Machine Learning 2026, which extends single-table data generators to full relational databases. Members of the Kumo team helped develop PluRel and co-authored its original paper. PluRel creates a schema, foreign-key links between rows that cluster like real data, and column values from Structural Causal Models with temporal trends and cross-table dependencies.
Because generation is lightweight, pre-training data is effectively unlimited. The PluRel paper reports that pre-training loss follows a power law as synthetic databases are added, and that those gains transfer to real databases. Through this process, Kumo Relational learns to filter, correlate, and aggregate information across tables instead of relying on fixed aggregations. When maximum accuracy matters, it can also be fine-tuned on a specific dataset and task.
The limitations are narrow but practical. The model performs best when data has meaningful relationships and temporal dynamics, such as user behavior over time. On tasks with very large training sets, task-specific supervised models may still edge out in-context predictions that use at most 10,000 context examples in the benchmarks. Fine-tuning is intended for that case. Predictive signals also need to be reachable within a limited number of hops, so users should start with a focused query over a few relevant tables and expand the graph as needed.
Deployment, licensing, and who should use it or skip it
Kumo Relational runs in-context learning directly over databases: in memory, through database and warehouse connectors, or through a custom graph engine that handles more than 500 billion rows via memory-mapped input/output at up to 5 GB/s. It is available in NVIDIA's newly released GPU-native structured-data-models library, the same open-source library that powers Kumo Tabular. The library downloads weights from the Hugging Face Hub on first use, so users can load the model in a GPU-backed notebook and start making predictions on their own data. In the library, the prediction call passes context examples, the entities to predict, and their related tables to the model. The library's relational examples cover complete RelBench and SAP SALT pipelines, including how to sample each entity's related tables.
For a separate service, teams can deploy the model as an NVIDIA NIM and point the open-source structured-data-models-client at it from a notebook. The user writes the prediction in the Predictive Query Language, then the client gathers context examples and related tables before sending the request. Example notebooks show end-to-end runs against a local NVIDIA NIM and on Databricks. The model is available today through the paper, documentation, and a quickstart notebook.
NVIDIA says Trustworthy AI is a shared responsibility and has established policies and practices to enable development for a wide array of AI applications; when downloaded or used under its terms of service, developers should work with their supporting model team. The code is released under the Apache 2.0 license and the model weights under the OpenMDW License Agreement, version 1.1.
Who should use it: organizations with relational databases and time-varying entities that want many predictive tasks without building separate pipelines, plus agent builders that need a structured way to ask predictive questions. Who should skip it: problems that are only flat tables, workloads with very large training sets where task-specific supervised models may still win, and queries where the needed signals are too far apart in the graph to be reached within a limited number of hops.

Comments (0)