Enterprises run on relational data — customers connect to orders, orders connect to products, and transactions connect to accounts. These relationships, and how they change over time, encode the strongest signals about what will happen next.
Today, NVIDIA announced the Agent Knowledge Foundation, which provides open models and libraries that help enterprise agents retrieve the right evidence, apply consistent business meaning, predict outcomes, and optimize actions. As part of that announcement, NVIDIA also announced Kumo, a new family of open models, libraries and tools for predictive AI across structured data.
Snowflake customers can leverage the NVIDIA Kumo Relational model and NVIDIA Kumo Engine, an open-source package for training graph neural networks at scale across an enterprise’s full relational graph. Snowflake customers can install the Kumo package and run it on Snowflake ML, using Snowflake Notebooks on Container Runtime, so data science teams can build predictive models from the relationships in their data, with training, scoring and data all staying inside Snowflake's security and governance perimeter.
Vanja Josifovski, VP of Graph Engineering at NVIDIA, says, "Enterprise data is inherently relational, and the most accurate predictions come from learning on that structure directly rather than discarding it. With NVIDIA Kumo, Snowflake customers can harness graph neural networks on their connected data — tables, keys and temporal patterns — using NVIDIA GPU acceleration, all without moving data outside their governed environment. This is what predictive AI on enterprise data should look like."
How it works
Kumo learns directly from relational structure and temporal patterns — tables, the keys that connect them and the timing of events — rather than requiring teams to flatten rich connections into a single wide table. This applies across core enterprise prediction tasks: customer churn, fraud detection, demand forecasting and product recommendation.
For example, here's a snippet showing how a team might train a model to predict which active customers will buy again in the next 90 days, using four Snowflake tables and a few lines of Python in a Snowflake Notebook:
import kumo.engine as kumo
# 1. Build the graph
graph = kumo.Graph(
tables={"Customer": customer, "Product": product, "SalesOrderHeader": orders, "SalesOrderDetail": lines},
edges=[
kumo.Edge(src_table="SalesOrderHeader", fkey="CustomerID", dst_table="Customer"),
kumo.Edge(src_table="SalesOrderDetail", fkey="SalesOrderID", dst_table="SalesOrderHeader"),
kumo.Edge(src_table="SalesOrderDetail", fkey="ProductID", dst_table="Product"),
],
)
# 2. Write the predictive query
pquery = kumo.PredictiveQuery(graph=graph, query="""
PREDICT COUNT(SalesOrderHeader.*, 0, 90, days) > 0
FOR EACH Customer.CustomerID
WHERE COUNT(SalesOrderHeader.*, -365, 0, days) > 0
""")
# 3. Fit
model_plan = pquery.suggest_model_plan()
trainer = kumo.Trainer(model_plan)
train_job = trainer.fit(
graph=graph,
train_table=pquery.generate_training_table(non_blocking=True),
)
# 4. Batch predict and write the scores back to Snowflake
pred_job = trainer.predict(
graph=graph,
prediction_table=pquery.generate_prediction_table(non_blocking=True),
output_types={"predictions"},
output_connector=conn,
output_table_name="CUSTOMER_REPURCHASE_90D"
)
Customers install the Kumo package into a Snowflake Notebook and run it on Snowflake infrastructure:
- Snowflake Notebooks provide the development surface for connecting to governed data, defining prediction targets and reviewing results.
- GPU compute pools provide NVIDIA GPU infrastructure through Snowflake's container runtime, governed by the same controls as other Snowflake resources.
- NVIDIA’s verified agent skills for Snowflake CoCo accelerate getting started: Teams describe a prediction task in natural language and receive a runnable notebook, from data connection through GPU training to writing predictions back to Snowflake.
This ease of use also puts graph-based predictive modeling in the hands of many more users, increasing impact across the organization. Because Kumo runs inside the customer's Snowflake account, data never has to leave it. Kumo reads from Snowflake tables, trains on Snowflake compute pools and writes predictions back to Snowflake tables. Teams can orchestrate those workloads with Snowflake ML capabilities such as ML Jobs, all under Snowflake's existing security perimeter.
Customers are already seeing results
Customers like Affirm, National Oilwell Varco (NOV), VideoAmp, and Yieldmo are already benefiting from NVIDIA Kumo on Snowflake ML.
Lynn Steffen, VP of Finance Business Operations at NOV, says, “NVIDIA Kumo didn't just speed up our data science work; it changed the pace we thought was possible. At NOV, we've put it to work across very different areas of our business, and each time it's accelerated how quickly we can turn data into action.
CoCo has pushed that even further in Snowflake by removing friction between the data and the work, letting us explore, build and iterate where the data already lives.”
Craig Simmons, VP of Product at Yieldmo, says, "Buyers shouldn't have to choose between precision and scale. Companion Audiences builds act-alike audiences designed to perform. It learns from what's already driving results, extends traditional targeting and helps uncover new audiences buyers wouldn't have found otherwise. Buyers set the similarity threshold, decide whether Companion leads or backs up the campaign, and, for managed service buyers, can train directly from conversion data with no seed spend. NVIDIA Kumo running with Snowflake ML is built with privacy in mind."
Get started
To get started, check out the guide or explore the Snowflake ML documentation.
