On October 21, 2026, NVIDIA introduced Kumo Relational, a pretrained model that makes predictions directly from related database tables: which customers will churn, how much they will order, and which transaction looks like fraud. There is no need to train a separate model for each task: Kumo Relational takes up to 10,000 historical examples from the database itself as context and returns a prediction in a single pass. According to the developers, it outperformed supervised models on 41 tasks across 15 databases. For business, this is a chance to test a forecasting idea faster, but not a reason to skip validating it on your own data.
Prepared by AIrassvet October 22, 2026 for executives, CFOs, and CIOs deciding whether to launch forecasting on CRM, accounting system, or e-commerce data. This analysis is based on NVIDIA’s post on the Hugging Face blog, the KumoRFM-2 research paper, the model card, and the documentation. We did not run our own model tests: all performance figures were obtained by the developers on public benchmarks.
Contents
- At a Glance
- What’s Included and What’s Not
- What Happened on October 21
- How Kumo Relational Works
- What the Developers’ Tests Showed
- How This Differs from a Typical ML Project
- Limitations and Open Questions
- What a Company Should Do Now
- Frequently Asked Questions
- Primary Sources and Method
At a Glance
- What was released: Kumo Relational is NVIDIA’s relational foundation model. It reads multiple linked tables (customers, orders, products) with awareness of keys and timestamps, and predicts churn, demand, fraud, and related objects for recommendations.
- Key difference: there is no task-specific training stage and no manual feature engineering. The prediction is expressed as a query in PQL, and the model learns on the fly from examples in the database history.
- Claimed result: on 41 tasks across 15 databases, the model outperformed trained models, including gradient boosting on expert-built features. These are the developers’ results, not an independent validation.
- How to get it: the code is open under Apache 2.0, the weights are available on Hugging Face under the OpenMDW 1.1 license, and there is also an NVIDIA NIM service option. Running it requires an NVIDIA GPU.
- What to do: pick one forecasting task that already has a baseline method, and compare the model against it on a held-out period from your own history.
What’s Included and What’s Not
Included in this review: what NVIDIA released on October 21, how the model works, what results were claimed, how the approach differs from a classic ML project, its limitations, and how a company can test it on its own data.
Not included: step-by-step installation of the library and NIM, the full PQL syntax, a legal assessment of the OpenMDW license, and a comparison with all tabular foundation models. For that, use NVIDIA documentation and consult a lawyer.
What Happened on October 21
On October 21, 2026, the Kumo team at NVIDIA published an article on the Hugging Face blog NVIDIA Kumo Relational Outperforms Supervised Machine Learning on Relational Data, No Training Required. In the post, NVIDIA provides links to everything needed to get started:
- model weights in the nvidia/Kumo-Relationalrepository;
- the open-source structured-data-models library to run it on your own GPU;
- the structured-data-models-client client for working with the model deployed as an NVIDIA NIM service;
- documentation, which lists the task types: classification, regression, horizon forecasting of numeric values, and link prediction (recommendations).
The scientific basis was described earlier in the paper KumoRFM-2: Scaling Foundation Models for Relational Learning, submitted to arXiv on April 14, 2026. The model card explicitly states that Kumo Relational is based on KumoRFM-2.
The news matters not because of another benchmark number, but because of a shift in approach. Large language models have already replaced separate models for each text task. NVIDIA says the same shift is now starting for tabular and relational data, which power sales, inventory, and finance.
How Kumo Relational Works
Kumo Relational is a pretrained model for linked tables that makes predictions from examples passed along with the query instead of training a separate model for each task. In machine learning terms, this is in-context learning, like language models that are shown a few examples in the prompt.
According to the developers, the process looks like this:
- Connect the database. The model works with the tables as they are: with primary and foreign keys and timestamps. There is no need to flatten everything into a single table with aggregates such as “average order value over 30 days.”
- PQL query. The task is described declaratively—what to predict, not how. Example from the documentation:
PREDICT COUNT(orders.*, 0, 30, days) FOR EACH users.user_id— how many orders each user will place in the next 30 days. - Context collection. The system “walks through” the database history: it takes the state of the data on past dates, calculates what happened after them, and builds up to 10,000 examples with known answers. The model is shown only data up to the selected date, preventing future information from leaking into training.
- Prediction. The model first parses each table (relationships between columns and rows), then passes information through the table relationships and matches the current object with examples. The answer is produced in a single pass, with no training steps.
If maximum accuracy is needed, the model can be fine-tuned on specific data and tasks. According to the developers, this mode is intended for cases with very large training datasets.
What the Developers’ Tests Showed
All figures below are taken from the NVIDIA publication and the KumoRFM-2 paper. They were obtained by the authors themselves on public datasets that, according to them, were not used during pretraining.
| What was compared | Result according to the developers |
|---|---|
| 41 tasks across 15 databases (RelBench V1 and V2, SAP SALT, 4DBInfer) | Kumo Relational outperforms the strongest trained models in classification and regression |
| RelBench V1 classification versus gradient boosting on expert-engineered features | On average, nearly 4 AUROC points higher |
| Enterprise benchmark SAP SALT versus XGBoost on prepared features | 7 MRR points higher without fine-tuning and 13 points higher after fine-tuning |
| SAP SALT versus AutoGluon ensembles | 8% higher MRR without fine-tuning and 16% higher after fine-tuning |
| RelArena-α leaderboard, speed | About 17 seconds median time per 1,000 predictions; the most accurate system delivers a comparable result about 430 times slower |
| Robustness | Works with context equal to 0.2% of the training data and remains stable when up to 75% of the links between tables are removed |
AUROC and MRR are standard quality metrics: the first shows how well the model separates, for example, customers who are leaving from those who are staying, and the second shows how high up in the ranked list the correct answer appears.
Important caveat: public benchmarks are curated research datasets from e-commerce, healthcare, enterprise, social, and academic systems. In a company’s data from 1C, CRM systems, and Excel exports, there may be key mismatches, missing dates, and manual edits that benchmarks may not have. So the table answers the question “is it worth trying,” not “will it work for us.”
How this differs from a traditional ML project
A classic churn or demand forecasting project is built as a standalone development effort: an analyst brings the data together in one table, an engineer designs features, the model is trained, tuned, deployed, and then maintained. The cycle repeats for each new task. More on this approach in articles about customer churn prediction and AI-powered demand forecasting.
| Stage | Classic approach | Kumo Relational |
|---|---|---|
| Data preparation | Combine tables into one and calculate aggregates | Describe the tables, keys, and dates |
| Features | Designed and tested by an engineer | The model identifies significant columns and relationships on its own |
| Training | A separate model for each task | Not required; fine-tuning is optional |
| New task | New project | New PQL request |
| Hardware requirements | A CPU is often enough | An NVIDIA GPU (CUDA) is required |
| Quality check | Required | Required |
The last row of the table is the key one. The model saves weeks on feature engineering and training, but it does not eliminate data work: tables must be linked by keys, events must have dates, and the history must be long enough to build examples from it. We covered how to prepare such data in our article on preparing data for AI implementation.
NVIDIA also highlights work with AI agents: the model can be called as a tool, and the agent gets not only text but also a prediction—for example, a list of customers at high risk of churn who should be called.
Limitations and open questions
The developers themselves note several limitations, and they should be considered before a pilot:
- Data type. The model works best where there are meaningful relationships and time dynamics, such as customer behavior history. For a static reference table, the advantage is not obvious.
- Very large datasets. If there is a very large amount of training data, a specialized trained model may slightly outperform context-based prediction: in tests, context was limited to 10,000 examples. Fine-tuning is provided for this case.
- Depth of relationships. The useful signal should be within a few links of the target object. The developers recommend starting with a narrow query across a few tables and expanding the graph gradually.
- Hardware. The example launch in the model card uses a GPU (
device="cuda"). The required amount of GPU memory is not specified on the documentation overview page and should be clarified for your own data volume. - Licensing. The code is distributed under Apache 2.0, the weights under OpenMDW 1.1, and the model itself was fine-tuned from TabICLv2 weights under the BSD-3-Clause license. The OpenMDW terms should be reviewed with legal counsel before commercial use, as with any open model; we covered the general principles in the FAQ on open LLM licenses.
- Mismatch in the data description. The blog says the model was pre-trained on fully synthetic relational data, while the abstract of the KumoRFM-2 paper says synthetic and real data. This is not critical for risk assessment, but it shows that marketing and scientific wording should be checked against each other.
- Independent verification. As of October 22, 2026, all results cited here are the authors’ data. We did not find third-party measurements on enterprise data.
What a company should do now
Kumo Relational lowers the entry barrier to forecasting, but the decision should be based on results from your own data. A practical order of actions:
- Choose one task with a clear cost of error. For example, churn for a subscription business, 30-day demand for a product category, or identifying suspicious returns. It helps if you already have a baseline method in place—a rule, an Excel model, or gradient boosting.
- Check the data. You need related tables with keys (customer — order — product) and event dates over a period long enough for several business cycles. If the keys differ between 1C and CRM, they will need to be matched first.
- Define the metric and acceptance criteria before testing. For example, the share of churned customers among the top 10% highest-risk cases, or the weekly demand forecast error. Choose the metric based on the business decision that will be made from the forecast.
- Run a retrospective test. Hold out the last period of history, build a forecast as of its start date, and compare the model with the current method using the same metric. That is the test that will show whether the approach works on your data.
- Assess the infrastructure and the license. The model can be run on your own servers with an NVIDIA GPU, so the data never leaves the company environment. At the same time, legal should review the OpenMDW 1.1 terms.
- Decide what to do next. If the model is no worse than the current method, the next step is to embed the forecast into the process: a retention list in CRM, purchasing recommendations, an operations review queue.
The general principle behind implementing predictive analytics is described in the article “Predictive Analytics: What It Is and How to Use It in Business”.
Frequently Asked Questions
Do you need to train Kumo Relational on your own data?
No, the base mode works without training: the model takes up to 10,000 historical examples from your database as context and immediately produces a forecast. Fine-tuning is possible and, according to the developers, improves accuracy, but it is an additional step for cases where maximum accuracy is needed or there is a very large amount of data.
What tasks can be solved with Kumo Relational?
The documentation mentions classification (will the customer leave, is the transaction fraudulent), regression (the amount of the next purchase), forecasting numeric values over a horizon (30-day demand), and predicting links for recommendations. The model works best on data with event history over time and relationships between tables.
Can the model be run on your own servers?
Yes, the weights are open on Hugging Face, and the structured-data-models library downloads them on first launch and runs the forecast on your NVIDIA GPU. Another option is to deploy the model as an NVIDIA NIM service and access it through a client. In both cases, the data can remain inside the company environment.
Will Kumo Relational replace an in-house ML team?
No. The model removes some of the work around feature engineering and training, but someone still has to prepare the related data, define the task, choose the metric, run a retrospective test, and embed the forecast into the workflow. These steps determine the business value of a forecast more than the choice of algorithm.
Original sources and methodology
- NVIDIA. NVIDIA Kumo Relational Outperforms Supervised Machine Learning on Relational Data, No Training Required — Hugging Face blog, October 21, 2026.
- Hudovernik, López, Kocijan, and coauthors. KumoRFM-2: Scaling Foundation Models for Relational Learning, arXiv:2604.12596, April 2026.
- Model card for nvidia/Kumo-Relational on Hugging Face — weight license, base model TabICLv2, and launch example.
- NVIDIA documentation: Kumo Relational overview — task types and deployment options.
- Code: structured-data-models and structured-data-models-client.
We checked the availability and content of the sources on October 22, 2026. The benchmark results belong to the developers and were obtained under their conditions; AIrassvet did not conduct its own testing of the model.
How AIrassvet helps validate a predictive model on company data
A new model is worth exploring when it is clear what decision will be made based on its forecast and what it will be compared against. Among the areas listed on the AIrassvet website, there are several that address this task:
- ML forecasting and predictive analytics: forecasting customer churn, demand, and inventory levels, and comparing a new model with the current method;
- process auditing and data preparation: combining tables from the accounting system and CRM into a linked structure with keys and dates;
- deploying models on the customer's servers, testing and launching them so the forecast becomes part of the workflow.
The first step is to choose one forecasting process and document the current result, data sources, constraints, and acceptance criteria.
Bottom line: a no-training forecast is worth testing, not taking on faith
Kumo Relational shows that forecasting across related tables can become a query, not a separate project: no manual features, no task-specific training, open weights, and deployment on your own server. According to the developers, this approach already outperforms trained models on public benchmarks.
For a company, the practical takeaway is simple: pick one forecasting task, prepare the related data, and compare the model with the current method on a holdout period from your own history. If the result holds up, the forecast can be built into the process; if not, you spend days validating it, not months.
