@@ -69,6 +69,7 @@ A simple model that wins is a successful research result. A shared model valid f
 | [Research plan](docs/research-plan.md) | Hypotheses, comparisons, evaluation, and stop conditions |
 | [Data contract](docs/data-contract.md) | What to collect, label, connect, and keep out |
 | [Random Forest demo](docs/random-forest-demo.md) | A small CPU-only classifier, historical base-rate comparison, and temporal checks on synthetic data |
+| [TabPFN-3 comparison](docs/tabpfn-comparison.md) | An optional GPU experiment using the same rows and a pinned pretrained classifier |
 | [Application integration](docs/application-integration.md) | How apps contribute to the Organisation Core |
 | [First 90 days](docs/first-90-days.md) | A bounded starting project and collaboration questions |
 | [Reading list](docs/reading-list.md) | Intellectual lineage and the limits of the evidence |
 
@@ -0,0 +1,178 @@
+"""Optional TabPFN-3 GPU comparison using the forest demo's exact synthetic split.
+
+Requires a separately downloaded, hash-verified checkpoint. Does not serve a model.
+"""
+
+import argparse
+from hashlib import file_digest
+from importlib.metadata import version
+import json
+from pathlib import Path
+import platform
+from time import perf_counter
+
+from .forest_demo import SETTLED, feature_matrix, generate_rows, run_demo, temporal_split
+
+
+MODEL_REPO = "Prior-Labs/tabpfn_3"
+MODEL_REVISION = "24a16a89d245878b846555110985634aa2e656d7"
+MODEL_FILENAME = "tabpfn-v3-classifier-v3_default.ckpt"
+MODEL_SHA256 = "d0d865d54dfbc524f5703104be90620182dca7e5fb2c16de72e9959ea18f3988"
+MODEL_LICENCE = "https://huggingface.co/Prior-Labs/tabpfn_3/blob/" + MODEL_REVISION + "/LICENSE"
+
+
+def verify_checkpoint(path, expected_sha256):
+    if len(expected_sha256) != 64 or any(c not in "0123456789abcdef" for c in expected_sha256):
+        raise ValueError("checkpoint SHA-256 must be 64 lowercase hexadecimal characters")
+    with Path(path).open("rb") as stream:
+        actual = file_digest(stream, "sha256").hexdigest()
+    if actual != expected_sha256:
+        raise ValueError("checkpoint hash mismatch; refusing to load model")
+    return actual
+
+
+def predict_independently(estimator, rows):
+    """A future test row must not enter an earlier row's preprocessing/context."""
+    import numpy as np
+
+    classes = list(estimator.classes_)
+    if set(classes) != {0, 1}:
+        raise ValueError("expected classes 0=not_met and 1=met")
+    positive_column = classes.index(1)
+    predictions = []
+    for row in rows:
+        output = np.asarray(estimator.predict_proba(np.asarray([row], dtype=float)))
+        if output.shape != (1, 2) or not np.isfinite(output).all():
+            raise ValueError("invalid probability response")
+        if (output < 0).any() or (output > 1).any() or not np.allclose(output.sum(axis=1), 1):
+            raise ValueError("invalid probability distribution")
+        predictions.append(float(output[0, positive_column]))
+    return np.asarray(predictions)
+
+
+def comparison(checkpoint, expected_sha256, samples=300, seed=42, gpu_memory_gib=4):
+    checkpoint = Path(checkpoint).resolve()
+    if expected_sha256 != MODEL_SHA256:
+        raise ValueError("this adapter pins one checkpoint; update its provenance before changing weights")
+    checkpoint_hash = verify_checkpoint(checkpoint, expected_sha256)
+    if checkpoint.name != MODEL_FILENAME:
+        raise ValueError("use the explicitly documented TabPFN-3 checkpoint filename")
+    if not 0 < gpu_memory_gib <= 8:
+        raise ValueError("GPU allocation budget must be greater than 0 and at most 8 GiB")
+
+    import torch
+    from sklearn.metrics import accuracy_score, brier_score_loss, log_loss
+    from tabpfn import TabPFNClassifier
+
+    if not torch.cuda.is_available():
+        raise ValueError("this experiment requires a working CUDA GPU; no silent CPU fallback")
+    properties = torch.cuda.get_device_properties(0)
+    budget_bytes = int(gpu_memory_gib * 1024**3)
+    torch.cuda.set_per_process_memory_fraction(min(1.0, budget_bytes / properties.total_memory), 0)
+    torch.set_num_threads(2)
+    torch.manual_seed(seed)
+    torch.cuda.reset_peak_memory_stats(0)
+
+    baseline_start = perf_counter()
+    report = run_demo(samples, seed)
+    baseline_seconds = perf_counter() - baseline_start
+    rows = generate_rows(samples, seed)
+    train, test, excluded = temporal_split(rows, report["training_cutoff"], report["test_start"], report["evaluation_as_of"])
+    if [r["initiative_id"] for r in train] != report["training_initiatives"]:
+        raise ValueError("training split differs from baseline")
+    if [r["initiative_id"] for r in test] != [r["initiative_id"] for r in report["test_predictions"]]:
+        raise ValueError("test split differs from baseline")
+    if excluded != report["counts"]["excluded"]:
+        raise ValueError("exclusion policy differs from baseline")
+
+    import numpy as np
+
+    x_train, x_test = feature_matrix(train), feature_matrix(test)
+    y_train = np.asarray([SETTLED[r["label_status"]] for r in train])
+    y_test = np.asarray([SETTLED[r["label_status"]] for r in test])
+    estimator = TabPFNClassifier(
+        model_path=checkpoint, device="cuda", random_state=seed,
+        n_estimators=4, auto_scale_n_estimators=False, n_preprocessing_jobs=1,
+        fit_mode="fit_preprocessors", softmax_temperature=0.9,
+    )
+    torch.cuda.synchronize()
+    start = perf_counter()
+    estimator.fit(np.asarray(x_train, dtype=float), y_train)
+    torch.cuda.synchronize()
+    fit_seconds = perf_counter() - start
+    start = perf_counter()
+    predicted = predict_independently(estimator, x_test)
+    torch.cuda.synchronize()
+    predict_seconds = perf_counter() - start
+    report["metrics"]["tabpfn_3"] = {
+        "brier_score": float(brier_score_loss(y_test, predicted)),
+        "log_loss": float(log_loss(y_test, predicted, labels=[0, 1])),
+        "accuracy_at_0_5": float(accuracy_score(y_test, predicted >= 0.5)),
+    }
+    for row, probability in zip(report["test_predictions"], predicted):
+        row["tabpfn_3"] = float(probability)
+    report["environment"].update({p: version(p) for p in ("tabpfn", "torch", "huggingface-hub")})
+    report["environment"].update({"python": platform.python_version(), "architecture": platform.machine(),
+                                   "gpu": properties.name, "cuda_runtime": torch.version.cuda})
+    report["candidate"] = {
+        "name": "TabPFN-3", "repository": MODEL_REPO, "revision": MODEL_REVISION,
+        "filename": checkpoint.name, "sha256": checkpoint_hash, "licence": MODEL_LICENCE,
+        "n_estimators": 4, "random_state": seed, "device": "cuda", "n_preprocessing_jobs": 1,
+        "auto_scale_n_estimators": False, "fit_mode": "fit_preprocessors", "softmax_temperature": 0.9,
+        "prediction_protocol": "one_test_row_per_call_with_fixed_training_context",
+        "gpu_allocator_budget_gib": gpu_memory_gib,
+        "peak_torch_allocated_bytes": torch.cuda.max_memory_allocated(0),
+        "peak_torch_reserved_bytes": torch.cuda.max_memory_reserved(0),
+    }
+    report["timing_seconds"] = {
+        "complete_baseline_demo": baseline_seconds,
+        "tabpfn_fit_including_model_loading": fit_seconds,
+        "tabpfn_predict_all_test_rows_individually": predict_seconds,
+    }
+    report["implementation_sha256"] = {}
+    for name in ("forest_demo.py", "tabpfn_demo.py"):
+        with Path(__file__).with_name(name).open("rb") as stream:
+            report["implementation_sha256"][name] = file_digest(stream, "sha256").hexdigest()
+    report["limitations"].extend([
+        "One pretrained checkpoint, one synthetic generator and seed; no claim of model superiority or organisational validity.",
+        "TabPFN has external pretraining; this comparison does not isolate architecture from pretraining.",
+        "GPU timing is from a shared machine and single-row prediction; not a controlled hardware speed benchmark.",
+        "CUDA seeds do not guarantee bitwise reproducibility across platforms or library versions.",
+        "Allocator budget is not a hard bound on all process or unified-memory use.",
+        "TabPFN-3 weights and outputs have their own non-commercial licence; the repository MIT licence does not replace it.",
+    ])
+    return report
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--checkpoint", type=Path, required=True)
+    parser.add_argument("--checkpoint-sha256", default=MODEL_SHA256)
+    parser.add_argument("--samples", type=int, default=300)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--gpu-memory-gib", type=float, default=4)
+    parser.add_argument("--output", type=Path, required=True)
+    args = parser.parse_args()
+    try:
+        if args.output.exists():
+            raise ValueError("output already exists; choose a new report filename")
+        report = comparison(args.checkpoint, args.checkpoint_sha256, args.samples, args.seed, args.gpu_memory_gib)
+        args.output.parent.mkdir(parents=True, exist_ok=True)
+        with args.output.open("x") as stream:
+            json.dump(report, stream, indent=2, allow_nan=False)
+            stream.write("\n")
+    except ModuleNotFoundError as error:
+        parser.exit(1, f"Missing optional dependency: {error.name}. See docs/tabpfn-comparison.md.\n")
+    except (ValueError, OSError) as error:
+        parser.exit(1, f"error: {error}\n")
+    print("SYNTHETIC GPU COMPARISON — not evidence of organisational prediction quality")
+    print(f"Train: {report['counts']['train']}; test: {report['counts']['test']}; generator seed: {report['seed']}")
+    print("Model                     Brier (lower)  Log loss (lower)  Accuracy @ 0.5")
+    for name, metrics in report["metrics"].items():
+        print(f"{name:25} {metrics['brier_score']:.4f}         {metrics['log_loss']:.4f}            {metrics['accuracy_at_0_5']:.4f}")
+    print(f"TabPFN-3: checkpoint {report['candidate']['sha256']}")
+    print(f"Report: {args.output}")
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,76 @@
+# TabPFN-3 GPU comparison
+
+This optional adapter compares a pretrained TabPFN-3 classifier with the Random Forest and historical base rate on the **same fictional data, temporal split, feature allowlist, and scoring targets**. It does not change the generator, label the discussion cases, or introduce real organisational data.
+
+## What is pinned
+
+| Component | Selection |
+| --- | --- |
+| TabPFN package | `8.5.0` |
+| PyTorch | `2.11.0`, official CUDA 13.0 build for the GPU experiment |
+| Model repository | `Prior-Labs/tabpfn_3` |
+| Model revision | `24a16a89d245878b846555110985634aa2e656d7` |
+| Checkpoint | `tabpfn-v3-classifier-v3_default.ckpt` |
+| Checkpoint SHA-256 | `d0d865d54dfbc524f5703104be90620182dca7e5fb2c16de72e9959ea18f3988` |
+| Candidate ensemble | Four estimators; automatic ensemble scaling disabled |
+| Test protocol | One test row per prediction call, fixed historical training context |
+
+The adapter verifies the checkpoint hash before loading it. It requires CUDA and does not silently fall back to another model or device. A future checkpoint comparison must update provenance explicitly.
+
+## Environment and model access
+
+The GPU setup uses Linux ARM64, Python 3.12, and an NVIDIA GB10. The pinned tabular dependencies also support this Python version. Create an isolated environment on the GPU machine; keep its existing inference service separate.
+
+```sh
+python3.12 -m venv .venv
+.venv/bin/python -m pip install torch==2.11.0 --index-url https://download.pytorch.org/whl/cu130
+.venv/bin/python -m pip install -r requirements-tabpfn.txt
+.venv/bin/python -m pip check
+```
+
+The [upstream package](https://github.com/PriorLabs/TabPFN) documents local inference. The model weights and outputs have a [separate non-commercial licence](https://huggingface.co/Prior-Labs/tabpfn_3/blob/24a16a89d245878b846555110985634aa2e656d7/LICENSE). The repository's MIT licence does not grant production rights for TabPFN. This example is a non-commercial synthetic evaluation; it does not distribute weights, distil their outputs into another model, or deploy a service.
+
+After reviewing the applicable model terms, download the fixed revision:
+
+```sh
+.venv/bin/python - <<'PY'
+from huggingface_hub import hf_hub_download
+from com_jepa.tabpfn_demo import MODEL_REPO, MODEL_REVISION, MODEL_FILENAME
+for filename in ('LICENSE', MODEL_FILENAME):
+    hf_hub_download(
+        repo_id=MODEL_REPO, revision=MODEL_REVISION, filename=filename,
+        local_dir='artifacts/tabpfn-3',
+    )
+PY
+```
+
+At initial inspection this revision was publicly downloadable without authentication. If access requirements change, use the publisher's authorised access process. The adapter never accepts a licence, logs into an account, or downloads an unspecified replacement model.
+
+## Run the experiment
+
+```sh
+.venv/bin/python -m unittest discover -s tests -v
+.venv/bin/python -m com_jepa validate examples/fictional-trajectory.jsonl
+.venv/bin/python -m com_jepa.tabpfn_demo \
+  --checkpoint artifacts/tabpfn-3/tabpfn-v3-classifier-v3_default.ckpt \
+  --output artifacts/tabpfn-comparison.json
+.venv/bin/python -m pip freeze > artifacts/tabpfn-environment.txt
+```
+
+The output file must be new. The model and reports stay in ignored `artifacts/`. To initiate an already prepared run from another machine, use SSH to the experiment checkout and invoke the same module. Host aliases and paths are operator configuration, not embedded in the adapter.
+
+The default PyTorch allocator budget is 4 GiB, adjustable with `--gpu-memory-gib` up to 8 GiB. This is not a hard bound on all process or unified-memory use. Check available memory and other workloads before running. The adapter does not stop, replace, or reconfigure an existing model service, and no GPU runner is added to CI.
+
+## What is compared
+
+The adapter first runs the original forest demonstration, then reconstructs and verifies identical training/test identities and exclusions. The pretrained candidate gets only the selected training features and labels. It processes each test row separately; it never receives future test rows or any test labels as context. Four feature values and the fixed historical examples are its entire task input.
+
+TabPFN uses external pretraining, so equal task data does not imply equal total training information or compute. This is a practical estimator comparison, not an experiment isolating model architecture from pretraining. It is also not a JEPA experiment or a test of organisational transfer.
+
+The JSON report extends the baseline report with candidate metrics, per-row probabilities, checkpoint provenance, code hashes, device/library versions, timing, and peak PyTorch memory. `fit` includes checkpoint loading and preparation of the training context; it is not fine-tuning the neural weights. Prediction time covers individual calls and must not be advertised as maximum batched throughput. The machine may be sharing its GPU with another workload.
+
+GPU timings and floating-point outputs need not be bitwise reproducible across hardware and versions. Preserve the environment capture alongside the report. A single generator/seed cannot establish broad model superiority, even if one model scores better on this run. Probability calibration, uncertainty intervals, multiple reviewed generators, and real-data evaluation remain separate work.
+
+## Testing boundaries
+
+Unit tests verify checkpoint rejection, positive-class mapping, probability validity, and one-row-per-call isolation without downloading a model. The existing temporal and missing-label tests still apply. A real checkpoint execution is a separate, explicitly invoked GPU experiment, not a stubbed test result.
@@ -0,0 +1,4 @@
+# Install CUDA PyTorch from its official index first; see the comparison guide.
+-r requirements-ml.txt
+torch==2.11.0
+tabpfn==8.5.0
@@ -0,0 +1,53 @@
+from hashlib import sha256
+from importlib.util import find_spec
+from pathlib import Path
+import tempfile
+import unittest
+
+from com_jepa.tabpfn_demo import predict_independently, verify_checkpoint
+
+
+class CheckpointTests(unittest.TestCase):
+    def test_changed_checkpoint_is_rejected_before_loading(self):
+        with tempfile.TemporaryDirectory() as directory:
+            path = Path(directory) / "checkpoint.ckpt"
+            path.write_bytes(b"fictional checkpoint for hash test")
+            expected = sha256(path.read_bytes()).hexdigest()
+            self.assertEqual(verify_checkpoint(path, expected), expected)
+            path.write_bytes(b"changed")
+            with self.assertRaisesRegex(ValueError, "hash mismatch"):
+                verify_checkpoint(path, expected)
+            with self.assertRaisesRegex(ValueError, "64 lowercase"):
+                verify_checkpoint(path, "invalid")
+
+
+@unittest.skipUnless(find_spec("numpy"), "optional ML adapter tests: install requirements-ml.txt")
+class PredictionIsolationTests(unittest.TestCase):
+    def test_each_call_sees_one_row_and_positive_class_is_looked_up(self):
+        class Estimator:
+            classes_ = [1, 0]
+
+            def __init__(self):
+                self.seen = []
+
+            def predict_proba(self, rows):
+                self.seen.append(rows.tolist())
+                return [[float(rows[0][0]), 1 - float(rows[0][0])]]
+
+        estimator = Estimator()
+        self.assertEqual(predict_independently(estimator, [[0.2], [0.8]]).tolist(), [0.2, 0.8])
+        self.assertEqual(estimator.seen, [[[0.2]], [[0.8]]])
+
+    def test_invalid_probabilities_fail_instead_of_becoming_metrics(self):
+        class Estimator:
+            classes_ = [0, 1]
+
+            def predict_proba(self, rows):
+                return [[0.4, 0.8]]
+
+        with self.assertRaisesRegex(ValueError, "distribution"):
+            predict_independently(Estimator(), [[0.2]])
+
+
+if __name__ == "__main__":
+    unittest.main()