I Built an AI That Scores Sensitive Data Entirely Offline - No Cloud, No Data Leaks

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

Airgap is a desktop-style web dashboard that turns a spreadsheet into risk scores, with no cloud, no training run and no data scientist. You drop in a CSV or Excel file, pick one of three jobs, and TabPFN (Prior Labs' tabular foundation model) scores every row on your own GPU. A local LLM then writes the one-page summary. Nothing leaves the machine.

The problem

Small teams sit on small, sensitive tables: a few hundred to a few thousand rows. The tools that would help them either need a data scientist to tune a model, or they send the data to a cloud service they are not allowed to use.

Who would pay

The buyer is whoever holds the table and cannot upload it. My hypothesis for the side hustle: one person installs Airgap on a clinic, plant or lender's own machine and charges per site or per seat. This is untested. I have not sold it yet, and the licensing note in "Why Open Innovation Matters" applies before anyone charges for it.

The three modes

Decision support, not a decision-maker. Scores should never replace a clinician, an engineer or a credit committee. The dashboard says so, and so do the generated summaries.

Demo

What the demo shows: loading real hospital data, pressing Score it, and getting scored rows, tiers, drivers and a written summary, all on a laptop RTX 4090 with the network unplugged.

Real result: hospital readmission

Real data: Diabetes 130-US Hospitals (UCI, CC BY 4.0), 8,000 rows and 47 columns. 7,800 rows have a known outcome. 200 have a blank outcome and are scored as "new patients".

I am showing this number on purpose. Readmission is a noisy outcome, and an AUC around 0.67 is realistic for it. A dashboard that reported 0.99 on this data would be hiding a leak. Known rows are always scored out-of-fold, so a patient's own outcome never helps score that patient.

The strongest driver, number of prior inpatient visits, is also the best-known predictor for this dataset, which is a useful sanity check. The model drivers show influence on the score, not causation. For example, "A1C result missing" mostly reflects who gets tested.

Code

https://github.com/YuvrajSHAD/Airgap

airgap/
├── server.py            FastAPI app, job queue (one analysis at a time keeps the GPU predictable)
├── app/
│   ├── engine.py        TabPFN wrapper: picks CUDA when torch sees it, exposes GPU name to the UI
│   ├── analysis.py      CSV -> features -> cross-validation -> final fit -> explanations
│   ├── narrative.py     local LLM summary with a number guardrail + template fallback
│   └── samples.py       synthetic demo data
├── static/index.html    the whole UI: one file, loads nothing from the internet
├── prepare_datasets.py  downloads and cleans the four real datasets
├── check_gpu.py         times a real TabPFN run on the GPU and caches the weights
├── install.bat          CUDA build of PyTorch, dependencies, GPU check
└── run.bat              starts the server offline

Run it (Windows, NVIDIA GPU): run install.bat once while online, then run.bat. After the first weight download, it starts in offline mode.

How I Built It

Stack: TabPFN (3.5 weights) · PyTorch with CUDA 12.8 · FastAPI · pandas and scikit-learn · Ollama running qwen3:8b · a single static HTML page.

1. TabPFN does all the scoring. There is no model to train and no hyperparameters. Your known rows are the context, and TabPFN predicts from them in one forward pass. Classification gives calibrated probabilities. Regression gives a prediction plus an 80% interval, which powers the yield mode's "outside the expected range" flag.

2. Honest accuracy by default. Rows with a known outcome are scored by 5-fold cross-validation (3-fold for very large files). Rows with a blank outcome are scored from everything known. The dashboard's accuracy numbers come from the first group, so they are not flattered by memorization.

3. Explanations by occlusion. For the 10 columns most related to the outcome, I swap in a typical value and watch the score move. The columns that move it most are listed per record, with an up or down arrow.

4. A local LLM that is not allowed to invent numbers. qwen3:8b writes the summary through Ollama from a small JSON of facts. Every number in its text is checked against the results. If the model cites a figure that was not in the facts, the summary is rejected and a built-in template is used instead. The page tells you which one you got and why.

5. Cleaning real data without cheating. prepare_datasets.py drops columns that give away the answer (for example, the five failure-type columns in the machine dataset), removes patients who died or went to hospice (they cannot be readmitted), keeps the best-filled sensors without looking at the outcome, and blanks the outcome on the last rows so the "new rows" path is exercised.

Three things that broke (and what they taught me)

• "It uses my CPU, not my 4090." pip install torch on Windows gives the CPU-only build, and pip happily treated an existing CPU build as "already satisfied". The fix was a forced reinstall of the CUDA 12.8 build. No CUDA Toolkit is needed, only the NVIDIA driver. The top bar now shows the GPU name, or a red "CPU only".
• TabPFN's browser licence login crashed inside a .bat file on Windows. The scripts now read an API key from a local file and turn the browser flow off.
• The LLM summary silently fell back to the template. My model-name check matched on a prefix, so a different model of the same family counted as "installed". Now the check is exact, and the page states the reason whenever the LLM is not used.

Honest limits

• TabPFN is slower per run than a gradient-boosting model. Its value is near-best accuracy with zero tuning, not speed.
• My timing on the 8,000-row file is 269 s. Smaller tables, which are the intended use, are much faster. In my GPU check, a 1,500-train / 500-test fit and predict took 1.34 s once warm.
• Results come from cross-validation on public datasets, so they show how the model does on held-out rows from the same source. I have not tested on data from a different hospital, plant or lender, so a new site’s numbers could differ.

Why Does Open Innovation Matter?

Because the whole product is a promise: your data never leaves your computer. A closed API cannot make that promise.

• Open weights make the air gap real. TabPFN's weights sit on the local disk. After a one-time download, Airgap runs with the network off, and telemetry is disabled. A hosted prediction API would mean uploading patient records, plant telemetry or loan histories.
• Zero cost per prediction. Score ten rows or ten thousand and nothing is metered.
• Swappable parts. The summary model is one setting (LLM_MODEL). Any Ollama model works, and the guardrail keeps whichever one honest.
• Inspectable. A clinic's IT team can read the code, see that nothing phones home, and decide for themselves.

A caveat I want to be upfront about: TabPFN's weights are open-weight under Prior Labs' licence. The free licence is non-commercial, so selling Airgap would need a commercial licence from Prior Labs. This is a hackathon prototype, and checking that licence is the first step of the side hustle.

Prize Categories

• Best Use of TabPFN. TabPFN is the engine for all three modes and the only thing producing scores: classification probabilities, regression with 80% intervals, categorical and missing-value handling without preprocessing, and a CUDA path on a local RTX 4090. It runs on real public datasets with honest out-of-fold evaluation. The local LLM only narrates results, and its text is checked against them. Note: TabPFN is the core of a dashboard, not an MCP-driven prediction agent.