Get Started with Agents

The fastest way to train a model with Kumo Engine is to describe your prediction problem to the coding agent you already use. The kumo-data-science skill teaches the agent the Kumo Engine Python API. You name your data, the outcome to predict, and the time window. The agent inspects your tables, confirms the graph and the task with you, and writes one notebook that trains a task-specific Kumo Engine model on your data and makes predictions.

This workflow trains your own model. To make predictions with a pretrained model and no training, use Structured Data Models instead. Without the skill, an agent answers from general knowledge and usually gets the Kumo Engine API wrong.

Fastest Way to Get Started

Requirements

You need three things:

A supported agent: Claude Code, Codex, Snowflake Cortex Code, or Databricks Genie Code. Other agents that read skill directories can use the generic package.
An environment that runs Kumo Engine: a Linux machine, a Mac with Apple silicon, Windows through WSL2, a Snowflake notebook on GPU Container Runtime, or a Databricks GPU notebook. The agent writes the notebook. Your environment runs it. Check Kumo Engine Prerequisites for supported runtimes and GPU Sizing for capacity.
Read access to your data: a local folder of CSV or Parquet files, Amazon S3, Google Cloud Storage, BigQuery, Snowflake, or Databricks. The agent reads table names, columns, and types before it writes code. It never changes your source data.

You install the skill from a download attached to the kumo-engine release, one package per agent host. The skill runs wherever your agent runs, including a Mac. Only the notebooks it writes need an environment that runs Kumo Engine.

Get Started with Cortex Code or Genie Code

Use this path when your data lives in Snowflake or Databricks and you want the agent inside that platform.

Snowflake Cortex Code

Databricks Genie Code

Snowsight workspace. Download the Cortex Code package and unzip it. Open the workspace where you will do your Kumo work, open Cortex Code settings, choose Skills, then Upload Skill Folder(s), and select the kumo-data-science folder. The skill is visible to Cortex Code in that workspace only.

Download CoCo skill

Direct link: https://github.com/NVIDIA/kumo-engine/releases/download/kumo-engine-v1.0.1/kumo-data-science-coco.zip

Cortex Code CLI or desktop app. Install the skill into your user skills directory, ~/.snowflake/cortex/skills/:

mkdir -p ~/.snowflake/cortex/skills
curl -fsSL https://github.com/NVIDIA/kumo-engine/releases/download/kumo-engine-v1.0.1/kumo-data-science-coco.zip -o /tmp/kumo-data-science-coco.zip
unzip -oq /tmp/kumo-data-science-coco.zip -d ~/.snowflake/cortex/skills

If Claude Code is also installed on the same machine, Cortex Code loads the copy in ~/.claude/skills/ first. To give Cortex Code its own copy, unzip into your project’s ./.cortex/skills/ instead.

Get Started with Claude Code or Codex

Use this path when your agent runs in a terminal or editor beside you. The agent writes code for any of the six Kumo connectors, so your data can be local or in a warehouse.

Paste these commands into a terminal to install the skill. They work on Linux and macOS and need no Python package:

Claude Code

Codex

mkdir -p ~/.claude/skills
curl -fsSL https://github.com/NVIDIA/kumo-engine/releases/download/kumo-engine-v1.0.1/kumo-data-science-generic.zip -o /tmp/kumo-data-science.zip
unzip -oq /tmp/kumo-data-science.zip -d ~/.claude/skills

Run them again to upgrade. Start a new agent session to load the skill.

Agent	User skills directory	Project skills directory
Claude Code	`~/.claude/skills/`	`./.claude/skills/`
Codex	`~/.agents/skills/`	`./.agents/skills/`
Genie Code CLI (`genie-cli`)	`~/.agents/skills/`	`./.agents/skills/`

To install by hand, download the generic skill and unzip it into a directory in the table above. On a Mac with Apple silicon, follow macOS Setup to run locally. On Windows, install the skill and run your workflow inside WSL2. The same download works for any other agent that reads skill directories.

Download skill

Direct link: https://github.com/NVIDIA/kumo-engine/releases/download/kumo-engine-v1.0.1/kumo-data-science-generic.zip

Check the Skill Is Loaded

Start a new chat and ask:

Load the kumo-data-science skill and quote its SKILL-BUILD line.

The agent quotes a SKILL-BUILD: line from the skill. A vague answer or an invented version means the agent did not load the skill. Check the install location and start a new chat.

After you upgrade kumo-engine, download the skill from the matching release and install it again.

Quick Example: Predict Repeat Customers

This example uses AdventureWorks, Microsoft’s public sample of a bicycle retailer: customers, orders, order lines, and products. You ask the agent to train a Kumo Engine model that predicts which customers will order again in the next 90 days.

Get the data

Download the Linux examples bundle and run its two preparation scripts. They download AdventureWorks from Microsoft, verify the checksums, and write four CSV files.

For Cortex Code or Genie Code, load the four CSV files as tables in a schema you can read, for example KUMO_DEMO.ADVENTUREWORKS.

Ask your agent

Paste one of these prompts into a new chat. Each one names the data, the entity, the outcome, and the window, which is everything the skill needs.

Claude Code or Codex

Cortex Code or Genie Code

Train a Kumo model on the AdventureWorks CSV files
in ./adventureworks-inputs. For each customer, predict
whether they place at least one order in the next 90 days.

Confirm the graph

The agent reads the tables and replies with the primary keys, time columns, and links it inferred, each marked as inferred. Correct any line, or reply Confirmed.

Confirm the task

The agent restates the task: the entity (customers), the outcome (at least one order), the window (90 days), and the task type (binary classification). Reply Confirmed.

Run the notebook

The agent writes one notebook that builds the graph, trains the model, and predicts for every customer. It does not run anything until you ask. Ask it to run the notebook, or open it and run it yourself.

You get evaluation metrics for the trained model and a probability for each customer. To compare with a hand written version of the same task, see Predict a Yes or No Outcome on Linux.

After the first model, keep going in the same chat. Ask the agent to explain the predictions, diagnose a training run, tune the model, or save it and score new data later.

For AI Agents

These docs publish a machine-readable index for agents, in the same spirit as robots.txt:

llms.txt lists every page with a short summary.
llms-full.txt contains the full text of the docs.

To set up an agent that does not have the skill yet, paste this into its chat:

Install the Kumo Engine agent skill for yourself.
Download
https://github.com/NVIDIA/kumo-engine/releases/download/kumo-engine-v1.0.1/kumo-data-science-generic.zip
and unzip it into your skills directory.
Use https://docs.nvidia.com/sdgm/llms.txt as the reference for Kumo Engine.
Then tell me the SKILL-BUILD line of the kumo-data-science skill.

Next Steps

Write the Request Yourself

Learn how predictive queries express the entity, outcome, and window your agent asks for.

Set Up Your Kumo Environment

Choose a Linux, Snowflake, or Databricks deployment to run the notebooks your agent writes.