TabICLv2 vs TabPFN-3 vs TabPFN-2.6 vs TabFM vs EXAONE: which tabular foundation model can run in the browser?

In-context learning (ICL) has expanded to tabular data. Recent benchmarks show that tabular foundation models (TFMs) can outperform traditional gradient-boosted decision trees such as XGBoost and LightGBM on a range of tabular datasets. They deliver zero-shot classification and regression without hyperparameter tuning or dataset-specific training (1,2).

For teams building client-side AI tools (such as browser extensions, spreadsheet add-ons, or edge applications), running models locally is the target architecture. Local execution protects data privacy, eliminates API token costs, and enables offline operation (3).

Looking past paper benchmarks reveals an operational problem: published TFMs face significant computational, memory, or licensing constraints when deployed in the browser.

Below, we evaluate four major contenders (TabICLv2, TabPFN-3, Google’s TabFM, and LG AI Research’s EXAONE-Tabular, released on July 31st, 2026) on weight size, compute overhead, and licensing to explain why TabICLv2 fits on-device browser applications. We omit the original TabICL model from detailed benchmark evaluation because TabICLv2 fully supersedes it with faster inference, lower memory overhead, and key-value caching support (2,4,5).

How do the major tabular foundation models compare?

Before examining benchmark figures, we summarize the model specifications, licensing models, and browser execution feasibility:

Methodology note: Weight sizes refer to published downloadable model artifacts (.safetensors / .ckpt). Latency figures come from cited server-side GPU benchmarks and should not be interpreted as in-browser WebGPU latency. Browser feasibility reflects Carla’s engineering assessment based on artifact size, licensing, and runtime requirements.

What do benchmark trade-offs look like in practice?

Selecting a model architecture requires evaluating empirical benchmark data. The TabArena benchmark suite (covering 19 diverse datasets) highlights trade-offs between predictive accuracy and runtime resource consumption (1,6):

• Google TabFM leads raw accuracy benchmarks on specific tasks. It achieves high zero-shot predictive scores by scaling architecture depth to 24 transformer blocks, using alternating row and column attention, and setting embedding dimensions to 256 (7).
• LG EXAONE-Tabular (released July 31st, 2026) ranks 2nd overall on TabArena with an Elo score of 1755, excelling in categorical prediction tasks (8).
• TabPFN-3 (specifically TabPFN-3-Plus) outperforms AutoGluon ensembling on medium datasets while running in less time (9,10).
• TabICLv2 sits slightly behind scaled-up TabFM checkpoints in raw accuracy, but surpasses original TabICL checkpoints and tuned reference models without local hyperparameter tuning (4,5).

TabICLv2 does not win the raw TabArena accuracy leaderboard. That isn’t the optimization target for Carla.

Our optimization target is the best combination of predictive quality, inference latency, model footprint, licensing, and browser compatibility.

How high is the compute and latency overhead?

Independent benchmarks from AIMultiple show that TabFM requires 40x to 58x the computational resources of TabICLv2 or TabPFN-3 (1).

While TabICLv2 evaluates a fold in ~3.0 seconds, TabFM averages 173.6 seconds per fold on server GPUs. JAX backends used by TabFM introduce cold-start compilation delays up to 20 minutes and consume substantial GPU VRAM (1,7).

Waiting nearly three minutes for a prediction fold renders in-browser execution non-viable. The cited benchmark reports substantially lower inference time for TabICLv2 than tuned reference models like RealTabPFN-2.5 (2,4).

How do model weight sizes impact browser memory?

Downloading model weights creates an initial friction point for client-side machine learning. For Carla, we target model artifacts under ~150 MB for rapid initial download and local persistence in WebGPU browser environments.

• TabICLv2 uses a ~110 MB weight footprint. The browser fetches weights on initial run and caches them in CacheStorage or IndexedDB. Subsequent model loads execute from local cache (7).
• EXAONE-Tabular splits weights across specialized checkpoints; 3 classification checkpoints weighing ~83.3 MB each (~250 MB total) and 8 regression checkpoints weighing ~84.5 MB each (~676 MB total) (8). Fetching the full checkpoint suite requires up to 676 MB, which exceeds TabICLv2’s single ~110 MB unified footprint.
• TabPFN-3 relies on specialized checkpoints (such as tabpfn-v3-regressor-v3_20260506_timeseries.ckpt) that weigh 233 MB each. While a 233 MB payload can download over fast connections, it doubles TabICLv2’s footprint and delays initial load times (10).
• TabFM weight files hosted under google/tabfm-1.0.0-pytorch total 6.56 GB for classification (classification/model.safetensors) and 6.59 GB for regression (regression/model.safetensors). Allocating 6.5 GB of model parameters inside a browser tab exceeds browser memory limits (11,12).

What are the licensing constraints for commercial deployment?

Even if hardware and latency bottlenecks were solved for TabFM, EXAONE-Tabular, or TabPFN-3, licensing terms prevent commercial deployment.

• TabFM licensing. Google released the inference source code under the Apache-2.0 license. The pre-trained model weights on Hugging Face use the TabFM Non-Commercial License v1.0. Commercial deployment falls outside the scope of Google’s published non-commercial license (11,13).
• EXAONE-Tabular licensing. LG AI Research released EXAONE-Tabular on July 31st, 2026 under the restrictive EXAONE Non-Commercial License (8). Commercial deployment falls outside the scope of LG’s published non-commercial license.
• TabPFN-3 licensing. Prior Labs released TabPFN-3 under the TABPFN-3.0 license, restricting usage to research and non-commercial evaluation (9,10).
• TabICLv2: the permissively licensed option. INRIA SODA released inference code, pre-training scripts, and model weights under open licenses, using BSD-3-Clause for the minimal nanotabicl implementation (2,4).

What about TabPFN-2.6 and RealTabPFN-2.5?

A technically informed reader looking at the TabArena leaderboard might ask: if Carla optimizes for browser footprint, why not use TabPFN-2.6?

Why not TabPFN-2.6? TabPFN-2.6 is perhaps the closest technical alternative to TabICLv2 for browser deployment. Its published model artifact is roughly 95 MB (with its default regressor checkpoint weighing just 51.6 MB), making its weight footprint comparable to—and even slightly smaller than—TabICLv2 (14). It also ranks ahead of TabICLv2 at #4 on TabArena.

The deciding factor for Carla is licensing: the published TabPFN-2.6 license permits research and non-commercial evaluation but explicitly prohibits commercial and production use of the model and its outputs without a separate commercial enterprise license from Prior Labs (9,14). For a commercial product distributing local inference to end users inside a browser extension, TabICLv2 (BSD-3-Clause) provides a self-hosted, permissively licensed path forward.

RealTabPFN-2.5 as a reference baseline RealTabPFN-2.5 is useful as a reference because it represents a tuned and ensembled TabPFN-based approach rather than a single default checkpoint. It ranks #5 on the TabArena leaderboard, immediately ahead of TabICLv2. Its published licensing terms likewise do not provide the commercial production rights Carla requires.

Why Carla HQ chose TabICLv2 for Google Sheets

At Carla HQ, we built local AI infrastructure inside Google Sheets using a Chrome extension. We designed around three requirements: local data privacy, low inference latency, and zero per-token API costs (3).

Selecting TabICLv2 satisfies these constraints:

• Client-side data privacy. TabICLv2’s 110 MB weights execute locally via WebGPU. Spreadsheet data stays on the user’s device (2,3).
• KV caching. TabICLv2 supports Key-Value (KV) caching across table contexts (2).

The important distinction is not simply whether a model can technically execute in a browser. Carla needs a model that can repeatedly answer predictions against the same table context. Key-value (KV) caching makes this interaction model practical because the table context does not need to be recomputed for every prediction.

• Zero server compute costs. Running inference on local user hardware via WebGPU eliminates GPU server clusters and per-token API fees (3).

Conclusion

Google’s TabFM, Prior Labs’ TabPFN-3 and TabPFN-2.6, and LG’s EXAONE-Tabular report high raw accuracy on academic benchmarks, but their published licenses do not permit the commercial production deployment Carla requires. TabFM and EXAONE-Tabular additionally impose substantially larger model footprints (1,8,10,13,14).

For Carla’s particular constraints, TabICLv2 is the practical choice for local, on-device tabular AI.

Join the private beta

Carla is currently in private beta. If you want to run local, privacy-preserving tabular AI predictions directly inside Google Sheets, join our waitlist for early access.

Join the Carla private beta to get early access, or explore our documentation to see how Carla keeps your tabular data private.

Daniel Münch

Carla HQ Founder

Software engineer and applied mathematician with 15+ years of experience building production software across biomedical imaging, HRTech, PropTech, and FinTech domains.