The transformation that large language models brought to text — collapsing task-specific, laboriously engineered pipelines into a single pre-trained model — arrived Wednesday for enterprise relational databases. NVIDIA published Kumo Relational on Hugging Face, open-sourcing the first few-shot foundation model to beat fully supervised machine learning across a broad relational benchmark suite. The model outperforms XGBoost — the decade-long gold standard for tabular machine learning — on 41 benchmark tasks across 15 relational databases, without a single custom feature built by a data scientist.

The release is the commercial product of NVIDIA's reported $400 million Kumo AI deal in June 2026, a startup co-founded by Jure Leskovec — a Stanford professor whose published research on graph neural networks, including the widely used node2vec and GraphSAGE algorithms, laid much of the architectural groundwork for what Kumo Relational now runs at production scale. Leskovec has been serving at NVIDIA as a Distinguished Research Scientist since joining the company alongside the acquisition.

The mechanism powering the model is the same one that made LLMs generalize across language tasks: in-context learning. Rather than training a new model for each prediction problem, Kumo Relational accepts up to 10,000 historical database records as context examples in a single forward pass and returns predictions without updating its weights. What took weeks of feature engineering and a full training pipeline now takes a declarative query.

Relational Data's Missing Foundation Model

Every large enterprise runs its operations on multi-table relational databases — orders linked to customers, transactions linked to products, medical records linked to patient histories. Making predictions from this data has long required a labor-intensive preprocessing step: flattening interconnected tables into a single wide table and handcrafting columns like "average order value over 30 days" or "total purchases in the last quarter" before training any model.

That flattening destroys information. Sequential patterns across tables, the timing of a customer's repeated interactions, the graph structure of which products co-appear in which orders — all of it gets compressed into aggregate statistics that no longer carry their original relational signal. And for every new predictive task, the process starts over. Enterprise ML teams have responded rationally: they restrict machine learning investment to the highest-priority use cases, leaving the organizational majority of potentially valuable predictions — at every business unit, for every product line, for every customer segment — unaddressed.

Kumo Relational is designed to change that calculus. The model is the first few-shot relational foundation model to surpass supervised machine learning across a broad benchmark suite, according to NVIDIA's published evaluations, with results corroborated across five independent benchmark families covering e-commerce, medical, enterprise, social, and academic relational databases.

How Kumo Relational Works: Native Graph Attention Over Tables

The model's core innovation is what NVIDIA calls the Relational Graph Transformer — a three-stage architecture described in the underlying research paper submitted to arXiv in April 2026 — that operates natively on multi-table data rather than first converting it to a flat representation.

The first stage automatically generates context. For temporal prediction tasks, the model replays historical database states, samples entity-centric subgraphs up to an anchor timestamp, and computes each target label from events that occur after that point. This design prevents data leakage — a well-documented failure mode in time-series tabular work where information about future events accidentally influences training through improperly constructed examples.

The second stage, within-table reasoning, uses a lightweight network that alternates column attention — relating values within a column — and row attention, relating features within a row. This stage learns which columns and rows are actually relevant to the current prediction and filters noise before propagating any signal forward.

The third and architecturally distinctive stage distributes row embeddings across the relational structure using graph attention over primary-key and foreign-key relationships, interleaved with cross-sample attention across context examples. By operating on row-level embeddings rather than individual cell values, the system avoids the quadratic scaling problem that would otherwise make large-table attention computationally intractable. NVIDIA reports the model scales to 500 billion database rows.

This work has a direct technical lineage. Graph attention networks, introduced by Veličković et al. in 2018, established the principle of learned weighted aggregation over a node's neighbors. Leskovec's own GraphSAGE paper from 2017 introduced scalable inductive learning on graph structures that the broader GNN field built on. The Relational Graph Transformer extends that lineage into a domain — corporate relational databases — that prior GNN research mostly bypassed. A database's foreign-key relationships are, structurally, a graph; the insight is that a model designed to reason over graphs is the natural architecture for a database, not an afterthought retrofitted to one.

The pre-training strategy is equally important. Real multi-table relational databases are rarely publicly available in sufficient quantity to train a foundation model, so NVIDIA used PluRel — a synthetic database generator from ICML 2026 — which constructs realistic multi-table databases complete with foreign-key link clustering, temporal trends, and cross-table causal dependencies. The PluRel paper demonstrates that pre-training loss follows a power law as synthetic databases are added, with gains transferring to real databases. That power-law scaling is the economic mechanism behind zero-marginal-training-cost inference: pre-training happened once, on synthetic data, and every prediction task after that is a query.

How the LLM Playbook Is Now Running on Enterprise Databases

The architectural parallel to large language models is not a marketing metaphor — it is the specific mechanism. LLMs generalize across language tasks because they use GPT-3's in-context learning: given examples in the prompt, the model adapts its outputs without updating its weights. The same mechanism is operating here, transposed to structured tabular data.

Before LLMs, production NLP required a dedicated model per task, each fed by its own preprocessing pipeline of tokenization, lemmatization, and n-gram feature extraction. A single pre-trained transformer rendered that entire stack largely obsolete, as it could be prompted with examples of any task and generalize. The parallel to enterprise relational data is direct: before Kumo Relational, every prediction task required its own feature-engineering sprint, training run, and deployment pipeline. The economic argument for that model — that only the highest-priority use cases justify the investment — weakens considerably when a single pre-trained model can be queried against any relational database in a declarative syntax.

The second-order implication concerns agentic AI systems. LLMs have given software agents the ability to read, write, and reason over text. Structured data foundation models give those agents the ability to anticipate outcomes from enterprise databases — predicting which customer will churn, which order will be delayed, which transaction is fraudulent — and act on those predictions automatically. Kumo Relational's Predictive Query Language is explicitly designed to be callable by agents: a query expressing a prediction target and the relevant tables triggers the model's full pipeline, including context sampling and cross-table reasoning, without any additional code. That makes it a candidate component in the agentic enterprise stacks that major cloud and software vendors are currently assembling.

What the Benchmarks Show: XGBoost Falls Across 41 Tasks

NVIDIA evaluated Kumo Relational on 41 tasks spanning 15 relational databases drawn from RelBench V1, RelBench V2, SAP SALT, 4DBInfer, and RelArena-α. None of the evaluation data appeared in the model's pre-training set.

The headline result: on RelBench V1 classification tasks, Kumo Relational beats gradient-boosted tree pipelines trained on expert-engineered features by nearly four AUROC points on average. XGBoost, which has dominated tabular ML competitions and enterprise deployments for a decade, is surpassed out of the box — without any custom feature construction.

On the SAP SALT benchmark — built from real enterprise resource planning data — Kumo Relational surpasses large AutoGluon ensembles by 8% in mean reciprocal rank without fine-tuning, extending that margin to 16% with fine-tuning on task-specific data. Compared to other tabular foundation models on SAP SALT, the margin is approximately 25%. Compared to XGBoost on engineered features on the same benchmark, Kumo Relational beats it by 7 MRR points out of the box and 13 MRR points after fine-tuning.

On RelArena-α — an independent benchmark from the same research community that produced RelBench — Kumo Relational sits on the accuracy-efficiency Pareto front. The only model with a higher raw Elo score (rt-plurel) runs approximately 430 times slower, at roughly 7,300 seconds of median inference time per 1,000 samples versus about 17 seconds for Kumo Relational.

The model also demonstrated robustness under conditions designed to simulate real-world data quality problems. Performance held with as little as 0.2% of available context data, remained stable when up to 75% of foreign-key links were removed, and degraded only modestly under high noise column counts.

Where Does Kumo Relational Break Down?

NVIDIA's own documentation is specific about limitations. The model performs best on data with meaningful relationships and temporal dynamics — behavioral sequences, transactional histories, and patterns where relational structure carries genuine predictive signal. On tasks with very large labeled training sets, task-specific supervised models may still outperform in-context predictions, which are capped at 10,000 context examples in benchmarking. Fine-tuning the foundation model is the recommended path for those cases.

The context cap is a structural constraint: in-context learning with 10,000 examples is powerful, but a supervised model trained on millions of examples remains a different class of system for tasks where that data volume is available. Predictive signals must also be reachable within a limited number of relational hops from the query entity. NVIDIA recommends starting with a focused query over a few highly relevant tables and expanding the relational graph incrementally rather than loading an entire enterprise schema.

These are honest constraints, not dealbreakers for most enterprise prediction use cases. The typical target — churn, demand forecasting, fraud detection, recommendation — involves relatively small labeled sets in the thousands to tens of thousands, high feature engineering cost, and a relational structure that is exactly what this model is designed for.

A Competitive Field Closing Fast

Kumo Relational enters a research landscape that has compressed dramatically in the past year. Prior Labs, the company behind TabPFN-3, developed TabPFN-Rel — an approach that applies TabPFN's single-table prediction to relational data via automated SQL joins, without native graph attention — and contributed the RelArena-α evaluation framework to the community. Prior Labs argues that flattening-based baselines have been systematically undertuned and that their approach is more competitive than previous benchmark results suggested. TabPFN-Rel currently holds the top position on RelArena-α by raw accuracy score, though at substantially higher inference time than Kumo Relational.

The debate between native relational architectures and well-tuned flattening approaches mirrors a broader question the field has not settled: how much of a database's predictive signal lives in its relational structure versus in aggregate features derivable from that structure. Kumo Relational's benchmark results make the case for native architecture, but Prior Labs' position — that automated flattening, done well, is competitive — will likely generate continued research activity.

Michael Stonebraker, the Turing Award-winning MIT database systems researcher, has argued that enterprise AI faces structural challenges the benchmark community underestimates: schema corruption in real production databases, domain-specific business concepts that pre-trained models cannot learn without fine-tuning, deep joins across four or five tables that exceed what evaluation benchmarks typically test, and access control requirements that constrain available training data. Stonebraker's sharpest critiques apply to LLM-based Text-to-SQL approaches; Kumo Relational's native relational architecture — which keeps tables as tables rather than converting them to language — is more consistent with his view that the relational model should be the foundation. Whether production deployments validate benchmark results at scale remains an open question.

Availability, Licensing, and Deployment

Kumo Relational is available through multiple access paths as of today. The structured-data-models Python library, published under the Apache 2.0 license, is available on GitHub under Apache and supports in-memory inference, database and warehouse connectors, and a custom graph engine with memory-mapped input/output at up to 5 GB/s for databases exceeding 500 billion rows.

Model weights are published on Hugging Face under the OpenMDW License Agreement (version 1.1), which permits commercial use with NVIDIA restrictions. Enterprise deployments can use the NVIDIA NIM inference microservice containerized as a standalone service and accessible via a companion Python client, supporting classification, regression, forecasting, and temporal link prediction.

Prediction tasks are expressed through PQL without writing any preprocessing code. A query predicting 30-day order counts for each user requires only the prediction window, the relevant tables, and the entity identifier — context sampling, temporal leakage prevention, and cross-table reasoning are handled automatically. Cloud notebooks cover end-to-end pipelines on Databricks and against a local NIM, along with complete benchmark reproductions.

Organizations with data residency requirements should note that both the Python library and NIM options support fully on-premise deployment: data does not leave the customer's infrastructure during inference.

Frequently Asked Questions

What is a relational foundation model, and how is it different from standard tabular ML?

A relational foundation model is a pre-trained neural network that operates directly on multi-table relational data — the linked tables of a typical enterprise database — without first converting them to a flat single-table format. Standard tabular ML approaches, including XGBoost and AutoGluon, require a preprocessing step called feature engineering: flattening multiple linked tables into one wide table and manually constructing aggregate columns that summarize the relational signals. A relational foundation model skips that step entirely, reasoning over the table relationships via graph attention and producing predictions from historical context examples in a single forward pass. The practical difference for enterprise data science teams is measured in weeks of labor eliminated per prediction task, with no task-specific training required.

How does Kumo Relational compare to TabPFN and other tabular foundation models?

The primary architectural difference is native multi-table support. TabPFN-3 and TabPFN-Rel — the leading competing family, from Prior Labs — operate on a single flat table; handling multi-table relational data requires automated SQL joins that Prior Labs provides as an external preprocessing step. Kumo Relational uses graph attention directly over primary-key and foreign-key relationships, reasoning across tables without flattening. On the SAP SALT enterprise benchmark, Kumo Relational beat rival foundation models by approximately 25% in mean reciprocal rank without fine-tuning. The RelArena-α leaderboard shows the nearest competitor by raw accuracy score running approximately 430 times slower. The competitive picture is evolving rapidly — Prior Labs argues that well-tuned flattening approaches have been systematically underestimated, and that debate is likely to drive continued advances in the field.

Can Kumo Relational replace XGBoost pipelines for large enterprise datasets?

For datasets with large labeled training sets — millions of examples — task-specific supervised models including XGBoost pipelines remain competitive, and NVIDIA's documentation recommends fine-tuning the foundation model for those cases rather than relying solely on zero-shot in-context predictions, which are capped at 10,000 historical context examples. Where Kumo Relational shows the clearest advantage is in use cases with smaller labeled sets (thousands to tens of thousands of examples), high feature engineering cost, and meaningful relational structure across multiple linked tables — which describes the majority of enterprise ML use cases that currently go unaddressed because the engineering overhead is too high. On RelBench V1 classification tasks, it beat XGBoost by four AUROC points on average without any custom feature construction.

Is Kumo Relational fully open source, and can companies use it commercially?

The structured-data-models Python inference library is open source under the Apache 2.0 license. The model weights are published on Hugging Face under the OpenMDW License Agreement version 1.1, which permits commercial use subject to NVIDIA's terms — this is a source-available commercial license rather than a fully open-source one. Enterprise users deploying via NVIDIA NIM are subject to NVIDIA's enterprise licensing terms. Organizations with strict data residency requirements should note that both the Python library and NIM options support fully on-premise deployment: data does not leave the customer's infrastructure during inference, which addresses a common enterprise compliance concern for cloud-hosted AI services.