In September 2026, NVIDIA released Kumo Tabular, a foundation model for classification and regression with strong published benchmark results and compact checkpoints licensed for commercial use (1). Seven weeks earlier, our comparison of tabular foundation models for browser use had identified TabICLv2 as the only viable choice we found for Carla (2). Kumo changed that landscape.
We wanted to bring it into Carla, where predictions run inside Google Sheets on the user’s own hardware. Exporting the model to ONNX Runtime WebGPU was the first step. The monolithic graph recomputed the same labeled rows for every query batch, and larger tables exhausted the memory available to the browser’s GPU process.
We addressed both problems with GPU-resident context caches and a tiled WebGPU execution engine. Kumo Tabular Small now processes more than 30,000 context rows in packaged Chromium on a 16 GB Apple M2 Pro. Query batches within a prediction call reuse the prepared context. Kumo is the next model coming to Carla’s local model zoo.
What does Kumo Tabular predict?
NVIDIA Kumo Tabular uses labeled rows from one table as context for classification or regression. Carla is bringing the Small classifier and regressor to Google Sheets. The classifier returns class probabilities. The regressor returns 999 quantiles, which Carla can use for a point prediction and uncertainty intervals (1).
NVIDIA describes the architectural reason context caching works:
“Because the context never looks at the queries, its keys and values are computed once and can be reused for follow-up predictions.” (1)
Kumo first combines information within columns and rows, then applies in-context attention to labeled and query rows. The query cannot change the labeled context representation. That gives Carla a reusable boundary between preparation and prediction (1).
This is a single-table predictor. It is distinct from NVIDIA’s relational, forecasting, and anomaly models. When Kumo arrives in Carla, the user will select a target and feature columns in Google Sheets, choose Kumo Small, and score new rows locally. The extension’s worker runs the model through ONNX Runtime WebGPU. A WebAssembly fallback covers smaller contexts when WebGPU is unavailable.
What did we have to port?
Running a checkpoint outside Python requires more than translating its neural network. Carla’s port has three layers:
- Model behavior. We reproduced Kumo’s preprocessing, feature treatment, randomized ensemble plans, and output handling in Rust and WebAssembly. A numeric column with only two distinct values must be treated as categorical, as in NVIDIA’s recipe. We also had to preserve the feature order for high-cardinality categories. Both details changed final predictions before we aligned the recipes.
- Browser execution. We exported the Small classifier and regressor to ONNX and ran them through ONNX Runtime WebGPU. The regression head returns 999 quantiles per query row; the classification path returns class scores.
- Runtime optimization. We split preparation from querying, kept the resulting cache on the GPU, and staged row and attention work in tiles sized for browser memory.
That first layer is why checking only ONNX graph outputs would have missed important errors. We check final probabilities and quantiles after preprocessing and ensemble aggregation.
Why split the model before tiling it?
Consider a sheet with 3,000 labeled customers and hundreds of new rows to score. A monolithic graph encodes the 3,000 labeled rows again for each query batch. The repeated work dominates the prediction call.
We split execution into prepare and query stages. Prepare encodes the labeled table and builds the attention keys and values. Query reuses those tensors for new rows. The split export records 33 reusable tensors, including imputation statistics and column and in-context learning attention caches. ONNX Runtime’s WebGPU I/O binding keeps output tensors in GPU buffers between stages, so the browser does not need to copy the full context back to JavaScript for each query batch (3).
Three measurements tell different parts of the performance story:
| Test | What it demonstrates |
|---|---|
| Split-cache probe in Node/Metal | Reusing a context across separate single-row queries |
| Installed Chrome extension | Complete prediction calls, including context preparation |
| Full-context packaged Chromium | Bounded-memory execution on large tables |
In a Node/Metal WebGPU probe on an Apple M2 Pro, one warm classifier query with 256 context rows and 57 features took 62 ms with the cache versus 201 ms with the monolithic graph. That is about 3.2× faster after preparation. Regression took 62 ms versus 196 ms. Preparing the context took 254–262 ms once. These are medians from a small number of warm repetitions, with one query row and one model member.
The preparation cost changes the interpretation. For one 256-row classifier query, 254 ms of preparation plus 62 ms of querying costs more than the 201 ms monolithic call. At 3,067 rows, preparation plus the first cached query took about 2,233 ms, almost the same as the 2,263 ms monolithic call. Reuse is the payoff: each later query in this split-cache probe draws on the prepared context. These figures isolate the caching mechanism; they do not represent the complete four-member Carla workflow.
Dataset runs gave a second check on the same idea. Eight separate Breast W queries took 2.61 seconds with the split path versus 3.55 seconds in an earlier monolithic run. Eight Airfoil regression queries took 2.67 seconds versus 5.07 seconds. These pairs came from separate runs. The Airfoil results differed by at most 3.1e-5 across all 7,992 output quantiles.
How does the tiled WebGPU engine control memory?
Caching reduces repeated computation, but a full-context attention matrix can still overwhelm a browser GPU process. The attention memory problem is well established: the FlashAttention paper argues that compute alone does not explain performance. Its authors write:
“A missing principle is making attention algorithms IO-aware.” (4)
FlashAttention uses fused GPU kernels and an on-chip tiling algorithm. Carla uses staged ONNX graphs and explicit GPU buffers. The shared lesson is to design around data movement and temporary allocations; our engine is not a FlashAttention implementation (3,4).
Kumo Small uses eight FP32 attention heads. A single attention-score tensor for T query rows over N context rows needs roughly T × N × 8 × 4 bytes. At 30,000 context rows and a 1,024-row tile, that is about 0.92 GiB for one score tensor. Several in-flight tiles can multiply the pressure.
Our staged engine divides the work into smaller graphs and moves the intermediate tensors between them as GPU buffers:
- Encode rows in 512-row tiles. The engine writes each tile into a bounded output buffer, then advances through four row-encoder layers.
- Size attention tiles from a byte budget. It limits one FP32 attention-score tensor to 256 MiB. At 30,000 context rows, the chosen in-context learning tile is 256 rows.
- Finish GPU work before releasing a tile. The worker waits for each submitted tile before disposing its temporary buffers. It keeps only one ensemble member’s cache resident at a time.
- Check the workload before allocating. A preflight estimate covers row buffers, the active context cache, and fixed graph headroom. It rejects an estimate above 4 GiB. This is a workspace check, not a 4 GiB ceiling on total GPU memory including model weights and driver allocations. The default context cap is 35,000 rows; feature count and query batch size have their own budgets. Contexts above 3,000 require staged WebGPU.
These choices keep allocation size predictable as a table grows. They let Kumo run on a laptop with 16 GB of unified memory while retaining a GPU cache for query batches in the active prediction call. NVIDIA pretrained Kumo Tabular with contexts up to 60,000 rows (5). Our 32,561-row result makes part of that existing model capacity accessible in a constrained browser; it does not extend the model’s trained context range.
What ran on the 16 GB laptop?
The large-context tests used FP32 tiled WebGPU in packaged Chromium, with four ensemble members on an Apple M2 Pro with 16 GB unified memory. The reported times cover each prediction call, including recipe fitting, per-member context preparation, and query inference. They exclude predictor session initialization. The datasets have different query counts, so their times are not a head-to-head speed ranking.
| Workload | Context rows | Queries | Runtime |
|---|---|---|---|
| House Sales regression | 14,408 | 8 | 73.1 s |
| Bank Marketing classification | 30,140 | 512 | 416.5 s |
| Adult classification | 32,561 | 512 | 362.6 s |
These are full-context, four-member runs on a consumer laptop. House Sales matched the Node regression output across eight rows × 999 quantiles. Adult matched the Node probabilities. Bank Marketing matched classification decisions at the 0.5 threshold. The large-table runs take minutes. Caching avoids repeated context work across query batches; tiling makes these memory-constrained workloads complete locally.
For interactive scale, we also tested the installed Chrome extension with synthetic two-feature tables, one query row, and four ensemble members. At 256 context rows, first and repeat calls took 161/154 ms for classification and 154/143 ms for regression. At 1,000 rows, repeat calls took about 431–433 ms. At 3,000 rows, repeat calls took about 1.9 seconds. Each call includes recipe fitting, context preparation, and query inference. The predictor session stays open, but the cache is rebuilt for each call and released afterward. Here, “repeat” means a second complete call at the same context size, not a persistent-cache hit. These figures exclude browser launch and model download; they cannot be combined with the 57-feature, one-member split-cache probe into a single speedup ratio.
Does the port preserve model quality?
The matched evaluation used persisted splits and four ensemble members for Kumo and TabICLv2. NVIDIA’s published Kumo example uses eight, so our quality and timing results describe Carla’s four-member configuration (5). Both the Kumo reference on PyTorch MPS and its ONNX/WebGPU port completed 384 splits across 14 binary or regression datasets. That run compares task metrics such as ROC AUC and RMSE. It is not a strict pointwise parity test: MPS and WebGPU use different random generators for ensemble plans. These are Carla’s own measurements, separate from NVIDIA’s published evaluations and the wider TabArena benchmark (1,6).
For numerical parity, we compared every positive-class probability produced by PyTorch CPU and tiled Node/Metal WebGPU on the first full split of Bank Marketing and Adult, using identical four-member ensemble plans. Maximum absolute differences were 8.4 × 10⁻⁵ and 7.7 × 10⁻⁵, respectively, with no disagreements at the 0.5 classification threshold. The packaged Chromium results above provide a separate browser check.
For example, Kumo ONNX/WebGPU reached 0.8044 ROC AUC on Credit G versus TabICLv2 PyTorch’s 0.7984. On Titanic, TabICLv2 led 0.8771 to 0.8724. On Airfoil Self Noise, Kumo’s RMSE was 1.01 versus TabICLv2’s 1.12. The results show why a model zoo matters: users can compare predictors on the kind of table they have. Our tabular benchmark pages provide more dataset-level context.
NVIDIA’s published Small checkpoints are about 110 MB for classification and 114 MB for regression. NVIDIA released them under OpenMDW-1.1, which it describes as permitting commercial use (1). That combination of model quality, local runtime, checkpoint size, and licensing meets the browser-deployment criteria we used in our earlier comparison.
What’s next for Carla?
Kumo Tabular Small is the next addition to Carla’s local model zoo, joining TabICLv2 for classification and regression. Small tables support interactive predictions. Large contexts can take minutes, but run locally on the tested laptop without a prediction server. The broader lesson is that bringing a foundation model into the browser takes more than exporting weights. Faithful preprocessing, reusable computation, and predictable memory use are all parts of the runtime.
Our structured data foundation model map starts with the user’s question and the shape of the data. Growing Carla’s model zoo gives users another choice within the same task. They can compare predictors on tabular benchmarks, then weigh prediction quality and execution cost for their own table and device. Carla can suggest a model while leaving the choice and its assumptions visible.
Install Carla to use its current predictors in Google Sheets. Kumo Tabular Small is coming next.
