diff --git a/.gitignore b/.gitignore
index f2a6597..129ebf5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,11 +2,15 @@
 .cache/
 backbone_cache/
 backend_store/
+sklearn_cache/
+ituna_cache/
 checkpoints/
 data/
+data
 logs/
 optuna_studies/
 slurm_output/
+slurm_output
 wandb/*
 !wandb/*.py
 !wandb/*.sh
@@ -204,6 +208,7 @@ cython_debug/
 #  and can be added to the global gitignore or merged into this file. However, if you prefer,
 #  you could uncomment the following to ignore the entire vscode folder
 .vscode/
+.cursor/
 
 # Ruff stuff:
 .ruff_cache/
diff --git a/AUTHORS.md b/AUTHORS.md
index 58025dd..7f6be13 100644
--- a/AUTHORS.md
+++ b/AUTHORS.md
@@ -2,8 +2,8 @@
 
 ## v0.1.0 Development
 
-🐟<b>i</b><span style="color: #3C92ED;">Tuna</span> was initially developed and is being maintained by Tobias Schmidt ([&#64;TobiasSchmidtDE](https://github.com/TobiasSchmidtDE)) and Steffen Schneider ([&#64;stes](https://github.com/stes)) in the [Dynamical Inference Lab](https://dynamical-inference.ai/) at Helmholtz Munich. 
+🐟<b>i</b><span style="color: #3C92ED;">Tuna</span> was initially developed and is being maintained by Tobias Schmidt ([&#64;TobiasSchmidtDE](https://github.com/TobiasSchmidtDE)) and Steffen Schneider ([&#64;stes](https://github.com/stes)) in the [Dynamical Inference Lab](https://dynamical-inference.ai/) at Helmholtz Munich.
 
 Lilly May ([&#64;Lilly-May](https://github.com/Lilly-May)) contributed consistency metrics for sparse autoencoders (to be released soon).
 
-Paul Pommer ([&#64;ppommer](https://github.com/ppommer)) contributed demos for [piVAE](https://github.com/zhd96/pi-vae) and [FastSAE](https://github.com/dynamical-inference/fastsae) (to be released soon) and alpha-tested the package.
\ No newline at end of file
+Paul Pommer ([&#64;ppommer](https://github.com/ppommer)) contributed demos for [piVAE](https://github.com/zhd96/pi-vae) and [FastSAE](https://github.com/dynamical-inference/fastsae) (to be released soon) and alpha-tested the package.
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 5a0492e..96d7334 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -119,8 +119,8 @@ The documentation is built using [Jupyter Book](https://jupyterbook.org/) versio
 ### Local Build
 
 ```bash
-# Install jupyter-book (must be version <2)
-pip install "jupyter-book<2"
+# Install documentation dependencies (includes jupyter-book<2 and jupytext)
+pip install -e ".[docs]"
 
 # Build the docs from the project root
 jupyter-book build .
@@ -131,6 +131,29 @@ open _build/html/index.html   # macOS
 xdg-open _build/html/index.html  # Linux
 ```
 
+### Editing Notebooks (Jupytext, Recommended)
+
+We keep tutorial/demo notebooks paired as:
+
+- `*.ipynb` (rendered by Jupyter Book)
+- `*.py` in **percent** format (easy to diff/review)
+
+To edit a notebook:
+
+1. Edit the corresponding `*.py` percent file.
+2. Sync back to the `*.ipynb`:
+
+```bash
+jupytext --sync docs/tutorials/<notebook>.ipynb
+```
+
+To pair a new notebook (creates/updates the `*.py` alongside the `*.ipynb`):
+
+```bash
+jupytext --set-formats ipynb,py:percent docs/tutorials/new_notebook.ipynb
+jupytext --sync docs/tutorials/new_notebook.ipynb
+```
+
 ### Local Server
 
 To serve the docs locally with live preview:
@@ -161,7 +184,7 @@ Press Ctrl+C to stop.
 
 ```bash
 # Install required tools
-pip install "jupyter-book<2" ghp-import
+pip install -e ".[docs]"
 
 # Build and publish
 jupyter-book build .
diff --git a/README.md b/README.md
index 1c2ba7e..6e77a2f 100644
--- a/README.md
+++ b/README.md
@@ -91,6 +91,7 @@ Full documentation is available at **[dynamical-inference.github.io/ituna](https
 - **Quickstart notebook**: [`docs/tutorials/quickstart.ipynb`](docs/tutorials/quickstart.ipynb) - minimal working example
 - **Core concepts**: [`docs/tutorials/core.ipynb`](docs/tutorials/core.ipynb) - in-depth walkthrough
 - **Backends**: [`docs/tutorials/backends.ipynb`](docs/tutorials/backends.ipynb) - caching and distributed execution
+- **sklearn caching**: [`docs/guides/sklearn_caching.ipynb`](docs/guides/sklearn_caching.ipynb) - cache standalone sklearn estimators (`fit`/`transform`/`predict`/`score`)
 
 ## Backends
 
@@ -118,6 +119,10 @@ with config.config_context(
     BACKEND_KWARGS={"trigger_type": "auto", "num_workers": 4},
 ):
     ensemble.fit(X)
+
+# Advanced: route different operations to different backends
+# (e.g. distributed estimator fit + locally cached consistency transforms)
+# config.register_backend_route(method="fit", model_class=metrics.ConsistencyTransform, backend="disk_cache")
 ```
 
 ### CLI Commands
diff --git a/_config.yml b/_config.yml
index 8133483..3a6dc6c 100644
--- a/_config.yml
+++ b/_config.yml
@@ -11,6 +11,7 @@ repository:
 
 exclude_patterns:
   - .github/*
+  - .cursor/**
   - slurm/*
   - third_party/*
   - _build/*
diff --git a/_toc.yml b/_toc.yml
index e07012b..72ffff1 100644
--- a/_toc.yml
+++ b/_toc.yml
@@ -6,6 +6,9 @@ parts:
       - file: docs/tutorials/quickstart
       - file: docs/tutorials/core
       - file: docs/tutorials/backends
+  - caption: Guides
+    chapters:
+      - file: docs/guides/sklearn_caching
   - caption: Demos
     chapters:
       - file: docs/demos/cebra_best_practices
diff --git a/docs/demos/cebra_best_practices.ipynb b/docs/demos/cebra_best_practices.ipynb
index 8329440..c6c98d5 100644
--- a/docs/demos/cebra_best_practices.ipynb
+++ b/docs/demos/cebra_best_practices.ipynb
@@ -26,7 +26,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -39,6 +39,40 @@
     "from ituna import ConsistencyEnsemble, metrics"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 🐟<b>i</b><span style=\"color: #3C92ED;\">Tuna</span> Caching Magic\n",
+    "\n",
+    "Re-training models every time we re-run the notebook is annoying, especially if we train lots of models for consitency analysis. \n",
+    "\n",
+    "Therefore with 🐟<b>i</b><span style=\"color: #3C92ED;\">Tuna</span> we make it as easy as possible to automatically cache every model training. \n",
+    "\n",
+    "- For a full walkthrough of caching, distributed execution, and backend routing, see: `docs/tutorials/backends.ipynb`\n",
+    "- If you want to cache *standalone* sklearn estimators (outside `ConsistencyEnsemble`), see: `docs/guides/sklearn_caching.ipynb`\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'DEFAULT_BACKEND': 'disk_cache', 'BACKEND_KWARGS': {}, 'BACKEND_ROUTES': {}, 'CACHE_DIR': 'backend_store', 'FILE_LOCK_TIMEOUT': 30}\n"
+     ]
+    }
+   ],
+   "source": [
+    "ituna.config.set(\n",
+    "    DEFAULT_BACKEND=\"disk_cache\",\n",
+    ")\n",
+    "print(ituna.config.get_config())"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -52,7 +86,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 16,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -83,9 +117,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 17,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Neural data shape: (10178, 120)\n",
+      "Position labels shape: (10178, 3)\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/hgf_hmgu/hgf_sfs7789/miniconda3/envs/ituna-dev/lib/python3.12/pickle.py:1632: VisibleDeprecationWarning: dtype(): align should be passed as Python or NumPy boolean but got `align=0`. Did you mean to pass a tuple to create a subarray type? (Deprecated NumPy 2.4)\n",
+      "  stack[-1] = func(*args)\n"
+     ]
+    }
+   ],
    "source": [
     "# Load hippocampus dataset\n",
     "hippocampus = cebra.datasets.init(\"rat-hippocampus-single-achilles\")\n",
@@ -108,9 +159,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 18,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Train data: (8142, 120)\n",
+      "Validation data: (2036, 120)\n"
+     ]
+    }
+   ],
    "source": [
     "# Time-based split (80% train, 20% validation)\n",
     "split_idx = int(len(neural_data) * 0.8)\n",
@@ -136,9 +196,1012 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 19,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<style>#sk-container-id-2 {\n",
+       "  /* Definition of color scheme common for light and dark mode */\n",
+       "  --sklearn-color-text: #000;\n",
+       "  --sklearn-color-text-muted: #666;\n",
+       "  --sklearn-color-line: gray;\n",
+       "  /* Definition of color scheme for unfitted estimators */\n",
+       "  --sklearn-color-unfitted-level-0: #fff5e6;\n",
+       "  --sklearn-color-unfitted-level-1: #f6e4d2;\n",
+       "  --sklearn-color-unfitted-level-2: #ffe0b3;\n",
+       "  --sklearn-color-unfitted-level-3: chocolate;\n",
+       "  /* Definition of color scheme for fitted estimators */\n",
+       "  --sklearn-color-fitted-level-0: #f0f8ff;\n",
+       "  --sklearn-color-fitted-level-1: #d4ebff;\n",
+       "  --sklearn-color-fitted-level-2: #b3dbfd;\n",
+       "  --sklearn-color-fitted-level-3: cornflowerblue;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-2.light {\n",
+       "  /* Specific color for light theme */\n",
+       "  --sklearn-color-text-on-default-background: black;\n",
+       "  --sklearn-color-background: white;\n",
+       "  --sklearn-color-border-box: black;\n",
+       "  --sklearn-color-icon: #696969;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-2.dark {\n",
+       "  --sklearn-color-text-on-default-background: white;\n",
+       "  --sklearn-color-background: #111;\n",
+       "  --sklearn-color-border-box: white;\n",
+       "  --sklearn-color-icon: #878787;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-2 {\n",
+       "  color: var(--sklearn-color-text);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-2 pre {\n",
+       "  padding: 0;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-2 input.sk-hidden--visually {\n",
+       "  border: 0;\n",
+       "  clip: rect(1px 1px 1px 1px);\n",
+       "  clip: rect(1px, 1px, 1px, 1px);\n",
+       "  height: 1px;\n",
+       "  margin: -1px;\n",
+       "  overflow: hidden;\n",
+       "  padding: 0;\n",
+       "  position: absolute;\n",
+       "  width: 1px;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-2 div.sk-dashed-wrapped {\n",
+       "  border: 1px dashed var(--sklearn-color-line);\n",
+       "  margin: 0 0.4em 0.5em 0.4em;\n",
+       "  box-sizing: border-box;\n",
+       "  padding-bottom: 0.4em;\n",
+       "  background-color: var(--sklearn-color-background);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-2 div.sk-container {\n",
+       "  /* jupyter's `normalize.less` sets `[hidden] { display: none; }`\n",
+       "     but bootstrap.min.css set `[hidden] { display: none !important; }`\n",
+       "     so we also need the `!important` here to be able to override the\n",
+       "     default hidden behavior on the sphinx rendered scikit-learn.org.\n",
+       "     See: https://github.com/scikit-learn/scikit-learn/issues/21755 */\n",
+       "  display: inline-block !important;\n",
+       "  position: relative;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-2 div.sk-text-repr-fallback {\n",
+       "  display: none;\n",
+       "}\n",
+       "\n",
+       "div.sk-parallel-item,\n",
+       "div.sk-serial,\n",
+       "div.sk-item {\n",
+       "  /* draw centered vertical line to link estimators */\n",
+       "  background-image: linear-gradient(var(--sklearn-color-text-on-default-background), var(--sklearn-color-text-on-default-background));\n",
+       "  background-size: 2px 100%;\n",
+       "  background-repeat: no-repeat;\n",
+       "  background-position: center center;\n",
+       "}\n",
+       "\n",
+       "/* Parallel-specific style estimator block */\n",
+       "\n",
+       "#sk-container-id-2 div.sk-parallel-item::after {\n",
+       "  content: \"\";\n",
+       "  width: 100%;\n",
+       "  border-bottom: 2px solid var(--sklearn-color-text-on-default-background);\n",
+       "  flex-grow: 1;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-2 div.sk-parallel {\n",
+       "  display: flex;\n",
+       "  align-items: stretch;\n",
+       "  justify-content: center;\n",
+       "  background-color: var(--sklearn-color-background);\n",
+       "  position: relative;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-2 div.sk-parallel-item {\n",
+       "  display: flex;\n",
+       "  flex-direction: column;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-2 div.sk-parallel-item:first-child::after {\n",
+       "  align-self: flex-end;\n",
+       "  width: 50%;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-2 div.sk-parallel-item:last-child::after {\n",
+       "  align-self: flex-start;\n",
+       "  width: 50%;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-2 div.sk-parallel-item:only-child::after {\n",
+       "  width: 0;\n",
+       "}\n",
+       "\n",
+       "/* Serial-specific style estimator block */\n",
+       "\n",
+       "#sk-container-id-2 div.sk-serial {\n",
+       "  display: flex;\n",
+       "  flex-direction: column;\n",
+       "  align-items: center;\n",
+       "  background-color: var(--sklearn-color-background);\n",
+       "  padding-right: 1em;\n",
+       "  padding-left: 1em;\n",
+       "}\n",
+       "\n",
+       "\n",
+       "/* Toggleable style: style used for estimator/Pipeline/ColumnTransformer box that is\n",
+       "clickable and can be expanded/collapsed.\n",
+       "- Pipeline and ColumnTransformer use this feature and define the default style\n",
+       "- Estimators will overwrite some part of the style using the `sk-estimator` class\n",
+       "*/\n",
+       "\n",
+       "/* Pipeline and ColumnTransformer style (default) */\n",
+       "\n",
+       "#sk-container-id-2 div.sk-toggleable {\n",
+       "  /* Default theme specific background. It is overwritten whether we have a\n",
+       "  specific estimator or a Pipeline/ColumnTransformer */\n",
+       "  background-color: var(--sklearn-color-background);\n",
+       "}\n",
+       "\n",
+       "/* Toggleable label */\n",
+       "#sk-container-id-2 label.sk-toggleable__label {\n",
+       "  cursor: pointer;\n",
+       "  display: flex;\n",
+       "  width: 100%;\n",
+       "  margin-bottom: 0;\n",
+       "  padding: 0.5em;\n",
+       "  box-sizing: border-box;\n",
+       "  text-align: center;\n",
+       "  align-items: center;\n",
+       "  justify-content: center;\n",
+       "  gap: 0.5em;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-2 label.sk-toggleable__label .caption {\n",
+       "  font-size: 0.6rem;\n",
+       "  font-weight: lighter;\n",
+       "  color: var(--sklearn-color-text-muted);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-2 label.sk-toggleable__label-arrow:before {\n",
+       "  /* Arrow on the left of the label */\n",
+       "  content: \"▸\";\n",
+       "  float: left;\n",
+       "  margin-right: 0.25em;\n",
+       "  color: var(--sklearn-color-icon);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-2 label.sk-toggleable__label-arrow:hover:before {\n",
+       "  color: var(--sklearn-color-text);\n",
+       "}\n",
+       "\n",
+       "/* Toggleable content - dropdown */\n",
+       "\n",
+       "#sk-container-id-2 div.sk-toggleable__content {\n",
+       "  display: none;\n",
+       "  text-align: left;\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-2 div.sk-toggleable__content.fitted {\n",
+       "  /* fitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-0);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-2 div.sk-toggleable__content pre {\n",
+       "  margin: 0.2em;\n",
+       "  border-radius: 0.25em;\n",
+       "  color: var(--sklearn-color-text);\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-2 div.sk-toggleable__content.fitted pre {\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-0);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-2 input.sk-toggleable__control:checked~div.sk-toggleable__content {\n",
+       "  /* Expand drop-down */\n",
+       "  display: block;\n",
+       "  width: 100%;\n",
+       "  overflow: visible;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-2 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {\n",
+       "  content: \"▾\";\n",
+       "}\n",
+       "\n",
+       "/* Pipeline/ColumnTransformer-specific style */\n",
+       "\n",
+       "#sk-container-id-2 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
+       "  color: var(--sklearn-color-text);\n",
+       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-2 div.sk-label.fitted input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
+       "  background-color: var(--sklearn-color-fitted-level-2);\n",
+       "}\n",
+       "\n",
+       "/* Estimator-specific style */\n",
+       "\n",
+       "/* Colorize estimator box */\n",
+       "#sk-container-id-2 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-2 div.sk-estimator.fitted input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
+       "  /* fitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-2);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-2 div.sk-label label.sk-toggleable__label,\n",
+       "#sk-container-id-2 div.sk-label label {\n",
+       "  /* The background is the default theme color */\n",
+       "  color: var(--sklearn-color-text-on-default-background);\n",
+       "}\n",
+       "\n",
+       "/* On hover, darken the color of the background */\n",
+       "#sk-container-id-2 div.sk-label:hover label.sk-toggleable__label {\n",
+       "  color: var(--sklearn-color-text);\n",
+       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
+       "}\n",
+       "\n",
+       "/* Label box, darken color on hover, fitted */\n",
+       "#sk-container-id-2 div.sk-label.fitted:hover label.sk-toggleable__label.fitted {\n",
+       "  color: var(--sklearn-color-text);\n",
+       "  background-color: var(--sklearn-color-fitted-level-2);\n",
+       "}\n",
+       "\n",
+       "/* Estimator label */\n",
+       "\n",
+       "#sk-container-id-2 div.sk-label label {\n",
+       "  font-family: monospace;\n",
+       "  font-weight: bold;\n",
+       "  line-height: 1.2em;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-2 div.sk-label-container {\n",
+       "  text-align: center;\n",
+       "}\n",
+       "\n",
+       "/* Estimator-specific */\n",
+       "#sk-container-id-2 div.sk-estimator {\n",
+       "  font-family: monospace;\n",
+       "  border: 1px dotted var(--sklearn-color-border-box);\n",
+       "  border-radius: 0.25em;\n",
+       "  box-sizing: border-box;\n",
+       "  margin-bottom: 0.5em;\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-2 div.sk-estimator.fitted {\n",
+       "  /* fitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-0);\n",
+       "}\n",
+       "\n",
+       "/* on hover */\n",
+       "#sk-container-id-2 div.sk-estimator:hover {\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-2 div.sk-estimator.fitted:hover {\n",
+       "  /* fitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-2);\n",
+       "}\n",
+       "\n",
+       "/* Specification for estimator info (e.g. \"i\" and \"?\") */\n",
+       "\n",
+       "/* Common style for \"i\" and \"?\" */\n",
+       "\n",
+       ".sk-estimator-doc-link,\n",
+       "a:link.sk-estimator-doc-link,\n",
+       "a:visited.sk-estimator-doc-link {\n",
+       "  float: right;\n",
+       "  font-size: smaller;\n",
+       "  line-height: 1em;\n",
+       "  font-family: monospace;\n",
+       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
+       "  border-radius: 1em;\n",
+       "  height: 1em;\n",
+       "  width: 1em;\n",
+       "  text-decoration: none !important;\n",
+       "  margin-left: 0.5em;\n",
+       "  text-align: center;\n",
+       "  /* unfitted */\n",
+       "  border: var(--sklearn-color-unfitted-level-3) 1pt solid;\n",
+       "  color: var(--sklearn-color-unfitted-level-3);\n",
+       "}\n",
+       "\n",
+       ".sk-estimator-doc-link.fitted,\n",
+       "a:link.sk-estimator-doc-link.fitted,\n",
+       "a:visited.sk-estimator-doc-link.fitted {\n",
+       "  /* fitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-0);\n",
+       "  border: var(--sklearn-color-fitted-level-3) 1pt solid;\n",
+       "  color: var(--sklearn-color-fitted-level-3);\n",
+       "}\n",
+       "\n",
+       "/* On hover */\n",
+       "div.sk-estimator:hover .sk-estimator-doc-link:hover,\n",
+       ".sk-estimator-doc-link:hover,\n",
+       "div.sk-label-container:hover .sk-estimator-doc-link:hover,\n",
+       ".sk-estimator-doc-link:hover {\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-unfitted-level-3);\n",
+       "  border: var(--sklearn-color-fitted-level-0) 1pt solid;\n",
+       "  color: var(--sklearn-color-unfitted-level-0);\n",
+       "  text-decoration: none;\n",
+       "}\n",
+       "\n",
+       "div.sk-estimator.fitted:hover .sk-estimator-doc-link.fitted:hover,\n",
+       ".sk-estimator-doc-link.fitted:hover,\n",
+       "div.sk-label-container:hover .sk-estimator-doc-link.fitted:hover,\n",
+       ".sk-estimator-doc-link.fitted:hover {\n",
+       "  /* fitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-3);\n",
+       "  border: var(--sklearn-color-fitted-level-0) 1pt solid;\n",
+       "  color: var(--sklearn-color-fitted-level-0);\n",
+       "  text-decoration: none;\n",
+       "}\n",
+       "\n",
+       "/* Span, style for the box shown on hovering the info icon */\n",
+       ".sk-estimator-doc-link span {\n",
+       "  display: none;\n",
+       "  z-index: 9999;\n",
+       "  position: relative;\n",
+       "  font-weight: normal;\n",
+       "  right: .2ex;\n",
+       "  padding: .5ex;\n",
+       "  margin: .5ex;\n",
+       "  width: min-content;\n",
+       "  min-width: 20ex;\n",
+       "  max-width: 50ex;\n",
+       "  color: var(--sklearn-color-text);\n",
+       "  box-shadow: 2pt 2pt 4pt #999;\n",
+       "  /* unfitted */\n",
+       "  background: var(--sklearn-color-unfitted-level-0);\n",
+       "  border: .5pt solid var(--sklearn-color-unfitted-level-3);\n",
+       "}\n",
+       "\n",
+       ".sk-estimator-doc-link.fitted span {\n",
+       "  /* fitted */\n",
+       "  background: var(--sklearn-color-fitted-level-0);\n",
+       "  border: var(--sklearn-color-fitted-level-3);\n",
+       "}\n",
+       "\n",
+       ".sk-estimator-doc-link:hover span {\n",
+       "  display: block;\n",
+       "}\n",
+       "\n",
+       "/* \"?\"-specific style due to the `<a>` HTML tag */\n",
+       "\n",
+       "#sk-container-id-2 a.estimator_doc_link {\n",
+       "  float: right;\n",
+       "  font-size: 1rem;\n",
+       "  line-height: 1em;\n",
+       "  font-family: monospace;\n",
+       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
+       "  border-radius: 1rem;\n",
+       "  height: 1rem;\n",
+       "  width: 1rem;\n",
+       "  text-decoration: none;\n",
+       "  /* unfitted */\n",
+       "  color: var(--sklearn-color-unfitted-level-1);\n",
+       "  border: var(--sklearn-color-unfitted-level-1) 1pt solid;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-2 a.estimator_doc_link.fitted {\n",
+       "  /* fitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-0);\n",
+       "  border: var(--sklearn-color-fitted-level-1) 1pt solid;\n",
+       "  color: var(--sklearn-color-fitted-level-1);\n",
+       "}\n",
+       "\n",
+       "/* On hover */\n",
+       "#sk-container-id-2 a.estimator_doc_link:hover {\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-unfitted-level-3);\n",
+       "  color: var(--sklearn-color-background);\n",
+       "  text-decoration: none;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-2 a.estimator_doc_link.fitted:hover {\n",
+       "  /* fitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-3);\n",
+       "}\n",
+       "\n",
+       ".estimator-table {\n",
+       "    font-family: monospace;\n",
+       "}\n",
+       "\n",
+       ".estimator-table summary {\n",
+       "    padding: .5rem;\n",
+       "    cursor: pointer;\n",
+       "}\n",
+       "\n",
+       ".estimator-table summary::marker {\n",
+       "    font-size: 0.7rem;\n",
+       "}\n",
+       "\n",
+       ".estimator-table details[open] {\n",
+       "    padding-left: 0.1rem;\n",
+       "    padding-right: 0.1rem;\n",
+       "    padding-bottom: 0.3rem;\n",
+       "}\n",
+       "\n",
+       ".estimator-table .parameters-table {\n",
+       "    margin-left: auto !important;\n",
+       "    margin-right: auto !important;\n",
+       "    margin-top: 0;\n",
+       "}\n",
+       "\n",
+       ".estimator-table .parameters-table tr:nth-child(odd) {\n",
+       "    background-color: #fff;\n",
+       "}\n",
+       "\n",
+       ".estimator-table .parameters-table tr:nth-child(even) {\n",
+       "    background-color: #f6f6f6;\n",
+       "}\n",
+       "\n",
+       ".estimator-table .parameters-table tr:hover {\n",
+       "    background-color: #e0e0e0;\n",
+       "}\n",
+       "\n",
+       ".estimator-table table td {\n",
+       "    border: 1px solid rgba(106, 105, 104, 0.232);\n",
+       "}\n",
+       "\n",
+       "/*\n",
+       "    `table td`is set in notebook with right text-align.\n",
+       "    We need to overwrite it.\n",
+       "*/\n",
+       ".estimator-table table td.param {\n",
+       "    text-align: left;\n",
+       "    position: relative;\n",
+       "    padding: 0;\n",
+       "}\n",
+       "\n",
+       ".user-set td {\n",
+       "    color:rgb(255, 94, 0);\n",
+       "    text-align: left !important;\n",
+       "}\n",
+       "\n",
+       ".user-set td.value {\n",
+       "    color:rgb(255, 94, 0);\n",
+       "    background-color: transparent;\n",
+       "}\n",
+       "\n",
+       ".default td {\n",
+       "    color: black;\n",
+       "    text-align: left !important;\n",
+       "}\n",
+       "\n",
+       ".user-set td i,\n",
+       ".default td i {\n",
+       "    color: black;\n",
+       "}\n",
+       "\n",
+       "/*\n",
+       "    Styles for parameter documentation links\n",
+       "    We need styling for visited so jupyter doesn't overwrite it\n",
+       "*/\n",
+       "a.param-doc-link,\n",
+       "a.param-doc-link:link,\n",
+       "a.param-doc-link:visited {\n",
+       "    text-decoration: underline dashed;\n",
+       "    text-underline-offset: .3em;\n",
+       "    color: inherit;\n",
+       "    display: block;\n",
+       "    padding: .5em;\n",
+       "}\n",
+       "\n",
+       "/* \"hack\" to make the entire area of the cell containing the link clickable */\n",
+       "a.param-doc-link::before {\n",
+       "    position: absolute;\n",
+       "    content: \"\";\n",
+       "    inset: 0;\n",
+       "}\n",
+       "\n",
+       ".param-doc-description {\n",
+       "    display: none;\n",
+       "    position: absolute;\n",
+       "    z-index: 9999;\n",
+       "    left: 0;\n",
+       "    padding: .5ex;\n",
+       "    margin-left: 1.5em;\n",
+       "    color: var(--sklearn-color-text);\n",
+       "    box-shadow: .3em .3em .4em #999;\n",
+       "    width: max-content;\n",
+       "    text-align: left;\n",
+       "    max-height: 10em;\n",
+       "    overflow-y: auto;\n",
+       "\n",
+       "    /* unfitted */\n",
+       "    background: var(--sklearn-color-unfitted-level-0);\n",
+       "    border: thin solid var(--sklearn-color-unfitted-level-3);\n",
+       "}\n",
+       "\n",
+       "/* Fitted state for parameter tooltips */\n",
+       ".fitted .param-doc-description {\n",
+       "    /* fitted */\n",
+       "    background: var(--sklearn-color-fitted-level-0);\n",
+       "    border: thin solid var(--sklearn-color-fitted-level-3);\n",
+       "}\n",
+       "\n",
+       ".param-doc-link:hover .param-doc-description {\n",
+       "    display: block;\n",
+       "}\n",
+       "\n",
+       ".copy-paste-icon {\n",
+       "    background-image: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCA0NDggNTEyIj48IS0tIUZvbnQgQXdlc29tZSBGcmVlIDYuNy4yIGJ5IEBmb250YXdlc29tZSAtIGh0dHBzOi8vZm9udGF3ZXNvbWUuY29tIExpY2Vuc2UgLSBodHRwczovL2ZvbnRhd2Vzb21lLmNvbS9saWNlbnNlL2ZyZWUgQ29weXJpZ2h0IDIwMjUgRm9udGljb25zLCBJbmMuLS0+PHBhdGggZD0iTTIwOCAwTDMzMi4xIDBjMTIuNyAwIDI0LjkgNS4xIDMzLjkgMTQuMWw2Ny45IDY3LjljOSA5IDE0LjEgMjEuMiAxNC4xIDMzLjlMNDQ4IDMzNmMwIDI2LjUtMjEuNSA0OC00OCA0OGwtMTkyIDBjLTI2LjUgMC00OC0yMS41LTQ4LTQ4bDAtMjg4YzAtMjYuNSAyMS41LTQ4IDQ4LTQ4ek00OCAxMjhsODAgMCAwIDY0LTY0IDAgMCAyNTYgMTkyIDAgMC0zMiA2NCAwIDAgNDhjMCAyNi41LTIxLjUgNDgtNDggNDhMNDggNTEyYy0yNi41IDAtNDgtMjEuNS00OC00OEwwIDE3NmMwLTI2LjUgMjEuNS00OCA0OC00OHoiLz48L3N2Zz4=);\n",
+       "    background-repeat: no-repeat;\n",
+       "    background-size: 14px 14px;\n",
+       "    background-position: 0;\n",
+       "    display: inline-block;\n",
+       "    width: 14px;\n",
+       "    height: 14px;\n",
+       "    cursor: pointer;\n",
+       "}\n",
+       "</style><body><div id=\"sk-container-id-2\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>ConsistencyEnsemble(consistency_transform=PairwiseConsistency(include_diagonal=True,\n",
+       "                                                              indeterminacy=Linear()),\n",
+       "                    estimator=CEBRA(batch_size=512, conditional=&#x27;time&#x27;,\n",
+       "                                    max_iterations=500,\n",
+       "                                    model_architecture=&#x27;offset10-model&#x27;,\n",
+       "                                    output_dimension=3, temperature=1.12,\n",
+       "                                    time_offsets=10, verbose=True))</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item sk-dashed-wrapped\"><div class=\"sk-label-container\"><div class=\"sk-label fitted sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-7\" type=\"checkbox\" ><label for=\"sk-estimator-id-7\" class=\"sk-toggleable__label fitted sk-toggleable__label-arrow\"><div><div>ConsistencyEnsemble</div></div><div><span class=\"sk-estimator-doc-link fitted\">i<span>Fitted</span></span></div></label><div class=\"sk-toggleable__content fitted\" data-param-prefix=\"\">\n",
+       "        <div class=\"estimator-table\">\n",
+       "            <details>\n",
+       "                <summary>Parameters</summary>\n",
+       "                <table class=\"parameters-table\">\n",
+       "                  <tbody>\n",
+       "                    \n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('estimator',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">estimator</td>\n",
+       "            <td class=\"value\">CEBRA(batch_s... verbose=True)</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('consistency_transform',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">consistency_transform</td>\n",
+       "            <td class=\"value\">PairwiseConsi...nacy=Linear())</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('random_states',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">random_states</td>\n",
+       "            <td class=\"value\">5</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "                  </tbody>\n",
+       "                </table>\n",
+       "            </details>\n",
+       "        </div>\n",
+       "    </div></div></div><div class=\"sk-parallel\"><div class=\"sk-parallel-item\"><div class=\"sk-item\"><div class=\"sk-label-container\"><div class=\"sk-label fitted sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-8\" type=\"checkbox\" ><label for=\"sk-estimator-id-8\" class=\"sk-toggleable__label fitted sk-toggleable__label-arrow\"><div><div>consistency_transform: PairwiseConsistency</div></div></label><div class=\"sk-toggleable__content fitted\" data-param-prefix=\"consistency_transform__\"><pre>PairwiseConsistency(include_diagonal=True, indeterminacy=Linear())</pre></div></div></div><div class=\"sk-serial\"><div class=\"sk-item sk-dashed-wrapped\"><div class=\"sk-parallel\"><div class=\"sk-parallel-item\"><div class=\"sk-item\"><div class=\"sk-label-container\"><div class=\"sk-label fitted sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-9\" type=\"checkbox\" ><label for=\"sk-estimator-id-9\" class=\"sk-toggleable__label fitted sk-toggleable__label-arrow\"><div><div>indeterminacy: Linear</div></div></label><div class=\"sk-toggleable__content fitted\" data-param-prefix=\"consistency_transform__indeterminacy__\"><pre>Linear()</pre></div></div></div><div class=\"sk-serial\"><div class=\"sk-item\"><div class=\"sk-estimator fitted sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-10\" type=\"checkbox\" ><label for=\"sk-estimator-id-10\" class=\"sk-toggleable__label fitted sk-toggleable__label-arrow\"><div><div>Linear</div></div></label><div class=\"sk-toggleable__content fitted\" data-param-prefix=\"consistency_transform__indeterminacy__\">\n",
+       "        <div class=\"estimator-table\">\n",
+       "            <details>\n",
+       "                <summary>Parameters</summary>\n",
+       "                <table class=\"parameters-table\">\n",
+       "                  <tbody>\n",
+       "                    \n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('copy_X',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">copy_X</td>\n",
+       "            <td class=\"value\">True</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('n_jobs',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">n_jobs</td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('positive',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">positive</td>\n",
+       "            <td class=\"value\">False</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "                  </tbody>\n",
+       "                </table>\n",
+       "            </details>\n",
+       "        </div>\n",
+       "    </div></div></div></div></div></div></div></div></div></div></div><div class=\"sk-parallel-item\"><div class=\"sk-item\"><div class=\"sk-label-container\"><div class=\"sk-label fitted sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-11\" type=\"checkbox\" ><label for=\"sk-estimator-id-11\" class=\"sk-toggleable__label fitted sk-toggleable__label-arrow\"><div><div>estimator: CEBRA</div></div></label><div class=\"sk-toggleable__content fitted\" data-param-prefix=\"estimator__\"><pre>CEBRA(batch_size=512, conditional=&#x27;time&#x27;, max_iterations=500,\n",
+       "      model_architecture=&#x27;offset10-model&#x27;, output_dimension=3, temperature=1.12,\n",
+       "      time_offsets=10, verbose=True)</pre></div></div></div><div class=\"sk-serial\"><div class=\"sk-item\"><div class=\"sk-estimator fitted sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-12\" type=\"checkbox\" ><label for=\"sk-estimator-id-12\" class=\"sk-toggleable__label fitted sk-toggleable__label-arrow\"><div><div>CEBRA</div></div></label><div class=\"sk-toggleable__content fitted\" data-param-prefix=\"estimator__\">\n",
+       "        <div class=\"estimator-table\">\n",
+       "            <details>\n",
+       "                <summary>Parameters</summary>\n",
+       "                <table class=\"parameters-table\">\n",
+       "                  <tbody>\n",
+       "                    \n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('model_architecture',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">model_architecture</td>\n",
+       "            <td class=\"value\">&#x27;offset10-model&#x27;</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('device',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">device</td>\n",
+       "            <td class=\"value\">&#x27;cuda_if_available&#x27;</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('criterion',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">criterion</td>\n",
+       "            <td class=\"value\">&#x27;infonce&#x27;</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('distance',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">distance</td>\n",
+       "            <td class=\"value\">&#x27;cosine&#x27;</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('conditional',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">conditional</td>\n",
+       "            <td class=\"value\">&#x27;time&#x27;</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('temperature',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">temperature</td>\n",
+       "            <td class=\"value\">1.12</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('temperature_mode',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">temperature_mode</td>\n",
+       "            <td class=\"value\">&#x27;constant&#x27;</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('min_temperature',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">min_temperature</td>\n",
+       "            <td class=\"value\">0.1</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('time_offsets',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">time_offsets</td>\n",
+       "            <td class=\"value\">10</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('delta',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">delta</td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('max_iterations',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">max_iterations</td>\n",
+       "            <td class=\"value\">500</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('max_adapt_iterations',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">max_adapt_iterations</td>\n",
+       "            <td class=\"value\">500</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('batch_size',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">batch_size</td>\n",
+       "            <td class=\"value\">512</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('learning_rate',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">learning_rate</td>\n",
+       "            <td class=\"value\">0.0003</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('optimizer',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">optimizer</td>\n",
+       "            <td class=\"value\">&#x27;adam&#x27;</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('output_dimension',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">output_dimension</td>\n",
+       "            <td class=\"value\">3</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('verbose',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">verbose</td>\n",
+       "            <td class=\"value\">True</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('num_hidden_units',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">num_hidden_units</td>\n",
+       "            <td class=\"value\">32</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('pad_before_transform',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">pad_before_transform</td>\n",
+       "            <td class=\"value\">True</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('hybrid',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">hybrid</td>\n",
+       "            <td class=\"value\">False</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('optimizer_kwargs',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">optimizer_kwargs</td>\n",
+       "            <td class=\"value\">((&#x27;betas&#x27;, ...), ...)</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('masking_kwargs',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">masking_kwargs</td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "                  </tbody>\n",
+       "                </table>\n",
+       "            </details>\n",
+       "        </div>\n",
+       "    </div></div></div></div></div></div></div></div></div></div><script>function copyToClipboard(text, element) {\n",
+       "    // Get the parameter prefix from the closest toggleable content\n",
+       "    const toggleableContent = element.closest('.sk-toggleable__content');\n",
+       "    const paramPrefix = toggleableContent ? toggleableContent.dataset.paramPrefix : '';\n",
+       "    const fullParamName = paramPrefix ? `${paramPrefix}${text}` : text;\n",
+       "\n",
+       "    const originalStyle = element.style;\n",
+       "    const computedStyle = window.getComputedStyle(element);\n",
+       "    const originalWidth = computedStyle.width;\n",
+       "    const originalHTML = element.innerHTML.replace('Copied!', '');\n",
+       "\n",
+       "    navigator.clipboard.writeText(fullParamName)\n",
+       "        .then(() => {\n",
+       "            element.style.width = originalWidth;\n",
+       "            element.style.color = 'green';\n",
+       "            element.innerHTML = \"Copied!\";\n",
+       "\n",
+       "            setTimeout(() => {\n",
+       "                element.innerHTML = originalHTML;\n",
+       "                element.style = originalStyle;\n",
+       "            }, 2000);\n",
+       "        })\n",
+       "        .catch(err => {\n",
+       "            console.error('Failed to copy:', err);\n",
+       "            element.style.color = 'red';\n",
+       "            element.innerHTML = \"Failed!\";\n",
+       "            setTimeout(() => {\n",
+       "                element.innerHTML = originalHTML;\n",
+       "                element.style = originalStyle;\n",
+       "            }, 2000);\n",
+       "        });\n",
+       "    return false;\n",
+       "}\n",
+       "\n",
+       "document.querySelectorAll('.copy-paste-icon').forEach(function(element) {\n",
+       "    const toggleableContent = element.closest('.sk-toggleable__content');\n",
+       "    const paramPrefix = toggleableContent ? toggleableContent.dataset.paramPrefix : '';\n",
+       "    const paramName = element.parentElement.nextElementSibling\n",
+       "        .textContent.trim().split(' ')[0];\n",
+       "    const fullParamName = paramPrefix ? `${paramPrefix}${paramName}` : paramName;\n",
+       "\n",
+       "    element.setAttribute('title', fullParamName);\n",
+       "});\n",
+       "\n",
+       "\n",
+       "/**\n",
+       " * Adapted from Skrub\n",
+       " * https://github.com/skrub-data/skrub/blob/403466d1d5d4dc76a7ef569b3f8228db59a31dc3/skrub/_reporting/_data/templates/report.js#L789\n",
+       " * @returns \"light\" or \"dark\"\n",
+       " */\n",
+       "function detectTheme(element) {\n",
+       "    const body = document.querySelector('body');\n",
+       "\n",
+       "    // Check VSCode theme\n",
+       "    const themeKindAttr = body.getAttribute('data-vscode-theme-kind');\n",
+       "    const themeNameAttr = body.getAttribute('data-vscode-theme-name');\n",
+       "\n",
+       "    if (themeKindAttr && themeNameAttr) {\n",
+       "        const themeKind = themeKindAttr.toLowerCase();\n",
+       "        const themeName = themeNameAttr.toLowerCase();\n",
+       "\n",
+       "        if (themeKind.includes(\"dark\") || themeName.includes(\"dark\")) {\n",
+       "            return \"dark\";\n",
+       "        }\n",
+       "        if (themeKind.includes(\"light\") || themeName.includes(\"light\")) {\n",
+       "            return \"light\";\n",
+       "        }\n",
+       "    }\n",
+       "\n",
+       "    // Check Jupyter theme\n",
+       "    if (body.getAttribute('data-jp-theme-light') === 'false') {\n",
+       "        return 'dark';\n",
+       "    } else if (body.getAttribute('data-jp-theme-light') === 'true') {\n",
+       "        return 'light';\n",
+       "    }\n",
+       "\n",
+       "    // Guess based on a parent element's color\n",
+       "    const color = window.getComputedStyle(element.parentNode, null).getPropertyValue('color');\n",
+       "    const match = color.match(/^rgb\\s*\\(\\s*(\\d+)\\s*,\\s*(\\d+)\\s*,\\s*(\\d+)\\s*\\)\\s*$/i);\n",
+       "    if (match) {\n",
+       "        const [r, g, b] = [\n",
+       "            parseFloat(match[1]),\n",
+       "            parseFloat(match[2]),\n",
+       "            parseFloat(match[3])\n",
+       "        ];\n",
+       "\n",
+       "        // https://en.wikipedia.org/wiki/HSL_and_HSV#Lightness\n",
+       "        const luma = 0.299 * r + 0.587 * g + 0.114 * b;\n",
+       "\n",
+       "        if (luma > 180) {\n",
+       "            // If the text is very bright we have a dark theme\n",
+       "            return 'dark';\n",
+       "        }\n",
+       "        if (luma < 75) {\n",
+       "            // If the text is very dark we have a light theme\n",
+       "            return 'light';\n",
+       "        }\n",
+       "        // Otherwise fall back to the next heuristic.\n",
+       "    }\n",
+       "\n",
+       "    // Fallback to system preference\n",
+       "    return window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';\n",
+       "}\n",
+       "\n",
+       "\n",
+       "function forceTheme(elementId) {\n",
+       "    const estimatorElement = document.querySelector(`#${elementId}`);\n",
+       "    if (estimatorElement === null) {\n",
+       "        console.error(`Element with id ${elementId} not found.`);\n",
+       "    } else {\n",
+       "        const theme = detectTheme(estimatorElement);\n",
+       "        estimatorElement.classList.add(theme);\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "forceTheme('sk-container-id-2');</script></body>"
+      ],
+      "text/plain": [
+       "ConsistencyEnsemble(consistency_transform=PairwiseConsistency(include_diagonal=True,\n",
+       "                                                              indeterminacy=Linear()),\n",
+       "                    estimator=CEBRA(batch_size=512, conditional='time',\n",
+       "                                    max_iterations=500,\n",
+       "                                    model_architecture='offset10-model',\n",
+       "                                    output_dimension=3, temperature=1.12,\n",
+       "                                    time_offsets=10, verbose=True))"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "# Create ConsistencyEnsemble with Linear indeterminacy (for CEBRA)\n",
     "ensemble = ConsistencyEnsemble(\n",
@@ -157,9 +1220,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 20,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Train consistency score: 0.8917\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Validation consistency score: 0.8403\n"
+     ]
+    }
+   ],
    "source": [
     "# Evaluate consistency\n",
     "train_score = ensemble.score(train_data)\n",
@@ -181,9 +1259,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 21,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Train embedding shape: (8142, 3)\n",
+      "Validation embedding shape: (2036, 3)\n"
+     ]
+    }
+   ],
    "source": [
     "# Get aligned embeddings\n",
     "train_embeddings = ensemble.transform(train_data)\n",
@@ -195,9 +1282,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 22,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# Plot 3D embeddings\n",
     "fig = plt.figure(figsize=(12, 5))\n",
@@ -249,9 +1347,45 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 23,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Pairwise consistency scores:\n",
+      "  Model 0 -> Model 0: 1.0000\n",
+      "  Model 0 -> Model 1: 0.9734\n",
+      "  Model 0 -> Model 2: 0.8756\n",
+      "  Model 0 -> Model 3: 0.8968\n",
+      "  Model 0 -> Model 4: 0.8630\n",
+      "  Model 1 -> Model 0: 0.9736\n",
+      "  Model 1 -> Model 1: 1.0000\n",
+      "  Model 1 -> Model 2: 0.8831\n",
+      "  Model 1 -> Model 3: 0.8951\n",
+      "  Model 1 -> Model 4: 0.8750\n",
+      "  Model 2 -> Model 0: 0.7756\n",
+      "  Model 2 -> Model 1: 0.7755\n",
+      "  Model 2 -> Model 2: 1.0000\n",
+      "  Model 2 -> Model 3: 0.9021\n",
+      "  Model 2 -> Model 4: 0.9247\n",
+      "  Model 3 -> Model 0: 0.7586\n",
+      "  Model 3 -> Model 1: 0.7514\n",
+      "  Model 3 -> Model 2: 0.8814\n",
+      "  Model 3 -> Model 3: 1.0000\n",
+      "  Model 3 -> Model 4: 0.8524\n",
+      "  Model 4 -> Model 0: 0.8088\n",
+      "  Model 4 -> Model 1: 0.8042\n",
+      "  Model 4 -> Model 2: 0.9299\n",
+      "  Model 4 -> Model 3: 0.8925\n",
+      "  Model 4 -> Model 4: 1.0000\n",
+      "\n",
+      "Mean pairwise score: 0.8917\n",
+      "Std pairwise score: 0.0792\n"
+     ]
+    }
+   ],
    "source": [
     "# Get detailed pairwise scores\n",
     "pairs, scores = train_embeddings.scores\n",
@@ -264,97 +1398,6 @@
     "print(f\"Std pairwise score: {np.std(scores):.4f}\")"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 7. Grid Search with Consistency\n",
-    "\n",
-    "We can use sklearn's `GridSearchCV` with iTuna to find hyperparameters that yield consistent representations."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from sklearn.model_selection import GridSearchCV\n",
-    "\n",
-    "# Define parameter grid\n",
-    "param_grid = {\n",
-    "    \"estimator__temperature\": [0.5, 1.0, 1.5],\n",
-    "    \"estimator__output_dimension\": [3, 8],\n",
-    "}\n",
-    "\n",
-    "# Create base ensemble\n",
-    "base_ensemble = ConsistencyEnsemble(\n",
-    "    estimator=CEBRA(\n",
-    "        model_architecture=\"offset10-model\",\n",
-    "        batch_size=512,\n",
-    "        learning_rate=3e-4,\n",
-    "        max_iterations=200,  # Fewer iterations for grid search\n",
-    "        conditional=\"time\",\n",
-    "        distance=\"cosine\",\n",
-    "        device=\"cuda_if_available\",\n",
-    "        verbose=False,\n",
-    "        time_offsets=10,\n",
-    "    ),\n",
-    "    consistency_transform=metrics.PairwiseConsistency(\n",
-    "        indeterminacy=metrics.Linear(),\n",
-    "        symmetric=False,\n",
-    "    ),\n",
-    "    random_states=3,\n",
-    ")\n",
-    "\n",
-    "# Run grid search\n",
-    "# Note: This uses consistency score as the optimization target\n",
-    "grid_search = GridSearchCV(\n",
-    "    base_ensemble,\n",
-    "    param_grid,\n",
-    "    cv=2,\n",
-    "    scoring=\"r2\",  # ConsistencyEnsemble.score() returns R2\n",
-    "    verbose=1,\n",
-    "    n_jobs=1,\n",
-    ")\n",
-    "\n",
-    "# Fit (this will take a while)\n",
-    "# grid_search.fit(train_data)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Uncomment after running grid search:\n",
-    "# print(f\"Best parameters: {grid_search.best_params_}\")\n",
-    "# print(f\"Best consistency score: {grid_search.best_score_:.4f}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Using Backends for Large Experiments\n",
-    "\n",
-    "For large-scale experiments with many hyperparameters, use iTuna's caching backends to avoid re-training."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Enable disk caching for grid search\n",
-    "with ituna.config.config_context(DEFAULT_BACKEND=\"disk_cache\"):\n",
-    "    # Models will be cached, so re-running is fast\n",
-    "    ensemble.fit(train_data)\n",
-    "    print(f\"Consistency: {ensemble.score(train_data):.4f}\")"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -376,14 +1419,13 @@
   }
  ],
  "metadata": {
+  "jupytext": {
+   "formats": "ipynb,py:percent"
+  },
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
-  },
-  "language_info": {
-   "name": "python",
-   "version": "3.10.0"
   }
  },
  "nbformat": 4,
diff --git a/docs/demos/cebra_best_practices.py b/docs/demos/cebra_best_practices.py
new file mode 100644
index 0000000..83f009e
--- /dev/null
+++ b/docs/demos/cebra_best_practices.py
@@ -0,0 +1,230 @@
+# ---
+# jupyter:
+#   jupytext:
+#     cell_metadata_filter: tags
+#     formats: ipynb,py:percent
+#     notebook_metadata_filter: kernelspec,language_info,jupytext
+#     text_representation:
+#       extension: .py
+#       format_name: percent
+#       format_version: '1.3'
+#       jupytext_version: 1.19.1
+#   kernelspec:
+#     display_name: Python 3 (ipykernel)
+#     language: python
+#     name: python3
+# ---
+
+# %% [markdown]
+# # CEBRA Best Practices with 🐟<b>i</b><span style="color: #3C92ED;">Tuna</span>
+#
+# *This notebook is based on the ["Best Practices for Training CEBRA models" notebook](https://cebra.ai/docs/demo_notebooks/CEBRA_best_practices.html)*
+#
+# This demo shows a complete workflow for training CEBRA models with consistency evaluation using iTuna. We cover:
+#
+# 1. Setting up a CEBRA model
+# 2. Loading neural data
+# 3. Train/validation splits
+# 4. Consistency evaluation with `ConsistencyEnsemble`
+# 5. Visualizing and interpreting results
+# 6. Grid search for hyperparameters
+#
+# ## Prerequisites
+#
+# ```bash
+# pip install ituna cebra[datasets,integrations]
+# ```
+
+# %%
+import numpy as np
+import matplotlib.pyplot as plt
+from cebra import CEBRA
+import cebra.datasets
+
+import ituna
+from ituna import ConsistencyEnsemble, metrics
+
+# %% [markdown]
+# ## 🐟<b>i</b><span style="color: #3C92ED;">Tuna</span> Caching Magic
+#
+# Re-training models every time we re-run the notebook is annoying, especially if we train lots of models for consitency analysis. 
+#
+# Therefore with 🐟<b>i</b><span style="color: #3C92ED;">Tuna</span> we make it as easy as possible to automatically cache every model training. 
+#
+# - For a full walkthrough of caching, distributed execution, and backend routing, see: `docs/tutorials/backends.ipynb`
+# - If you want to cache *standalone* sklearn estimators (outside `ConsistencyEnsemble`), see: `docs/guides/sklearn_caching.ipynb`
+#
+
+# %%
+ituna.config.set(
+    DEFAULT_BACKEND="disk_cache",
+)
+print(ituna.config.get_config())
+
+# %% [markdown]
+# ## 1. Set up a CEBRA Model
+#
+# CEBRA is a self-supervised representation learning method for neural data. It learns embeddings that capture the temporal structure of neural activity.
+#
+# CEBRA models are identifiable up to an **affine transformation**, so we use `metrics.Linear()` (which includes the intercept) as our indeterminacy class.
+
+# %%
+# Define a CEBRA-Time model
+cebra_model = CEBRA(
+    model_architecture="offset10-model",
+    batch_size=512,
+    learning_rate=3e-4,
+    temperature=1.12,
+    max_iterations=500,
+    conditional="time",
+    output_dimension=3,
+    distance="cosine",
+    device="cuda_if_available",
+    verbose=True,
+    time_offsets=10,
+)
+
+# %% [markdown]
+# ## 2. Load the Data
+#
+# We'll use the rat hippocampus dataset from CEBRA's built-in datasets. This contains neural recordings from hippocampus during spatial navigation.
+
+# %%
+# Load hippocampus dataset
+hippocampus = cebra.datasets.init("rat-hippocampus-single-achilles")
+
+neural_data = hippocampus.neural.numpy()
+position_labels = hippocampus.continuous_index.numpy()
+
+print(f"Neural data shape: {neural_data.shape}")
+print(f"Position labels shape: {position_labels.shape}")
+
+# %% [markdown]
+# ## 3. Create Train/Validation Split
+#
+# For proper evaluation, we split the data temporally into training and validation sets.
+
+# %%
+# Time-based split (80% train, 20% validation)
+split_idx = int(len(neural_data) * 0.8)
+
+train_data = neural_data[:split_idx]
+val_data = neural_data[split_idx:]
+
+train_labels = position_labels[:split_idx]
+val_labels = position_labels[split_idx:]
+
+print(f"Train data: {train_data.shape}")
+print(f"Validation data: {val_data.shape}")
+
+# %% [markdown]
+# ## 4. Fit with ConsistencyEnsemble
+#
+# Now we wrap the CEBRA model in a `ConsistencyEnsemble` to train multiple instances and evaluate consistency.
+
+# %%
+# Create ConsistencyEnsemble with Linear indeterminacy (for CEBRA)
+ensemble = ConsistencyEnsemble(
+    estimator=cebra_model,
+    consistency_transform=metrics.PairwiseConsistency(
+        indeterminacy=metrics.Linear(),  # CEBRA is identifiable up to linear transform
+        symmetric=False,
+        include_diagonal=True,
+    ),
+    random_states=5,  # Train 5 models
+)
+
+# Fit on training data
+ensemble.fit(train_data)
+
+# %%
+# Evaluate consistency
+train_score = ensemble.score(train_data)
+print(f"Train consistency score: {train_score:.4f}")
+
+# Also check on validation data
+val_score = ensemble.score(val_data)
+print(f"Validation consistency score: {val_score:.4f}")
+
+# %% [markdown]
+# ## 5. Visualize Embeddings
+#
+# Let's visualize the learned embeddings colored by position.
+
+# %%
+# Get aligned embeddings
+train_embeddings = ensemble.transform(train_data)
+val_embeddings = ensemble.transform(val_data)
+
+print(f"Train embedding shape: {train_embeddings.shape}")
+print(f"Validation embedding shape: {val_embeddings.shape}")
+
+# %%
+# Plot 3D embeddings
+fig = plt.figure(figsize=(12, 5))
+
+# Train embeddings
+ax1 = fig.add_subplot(121, projection="3d")
+scatter1 = ax1.scatter(
+    train_embeddings[:, 0],
+    train_embeddings[:, 1],
+    train_embeddings[:, 2],
+    c=train_labels[:, 0],
+    cmap="rainbow",
+    s=1,
+    alpha=0.5,
+)
+ax1.set_title(f"Train (consistency: {train_score:.3f})")
+ax1.set_xlabel("Dim 1")
+ax1.set_ylabel("Dim 2")
+ax1.set_zlabel("Dim 3")
+
+# Validation embeddings
+ax2 = fig.add_subplot(122, projection="3d")
+scatter2 = ax2.scatter(
+    val_embeddings[:, 0],
+    val_embeddings[:, 1],
+    val_embeddings[:, 2],
+    c=val_labels[:, 0],
+    cmap="rainbow",
+    s=1,
+    alpha=0.5,
+)
+ax2.set_title(f"Validation (consistency: {val_score:.3f})")
+ax2.set_xlabel("Dim 1")
+ax2.set_ylabel("Dim 2")
+ax2.set_zlabel("Dim 3")
+
+plt.tight_layout()
+plt.show()
+
+# %% [markdown]
+# ## 6. Analyze Pairwise Consistency
+#
+# We can examine the consistency between individual model pairs.
+
+# %%
+# Get detailed pairwise scores
+pairs, scores = train_embeddings.scores
+
+print("Pairwise consistency scores:")
+for (i, j), score in zip(pairs, scores):
+    print(f"  Model {i} -> Model {j}: {score:.4f}")
+
+print(f"\nMean pairwise score: {np.mean(scores):.4f}")
+print(f"Std pairwise score: {np.std(scores):.4f}")
+
+# %% [markdown]
+# ## Summary
+#
+# Key takeaways for CEBRA with iTuna:
+#
+# 1. **Use `metrics.Linear()` for CEBRA** - CEBRA embeddings are identifiable up to linear transformations
+# 2. **Train multiple seeds** - Use `random_states=5` or more for robust consistency estimates
+# 3. **Check both train and validation** - High consistency on both suggests stable representations
+# 4. **Use caching for grid search** - Enable `disk_cache` backend to avoid re-training
+# 5. **Consistency score > 0.9** - Generally indicates reliable, reproducible embeddings
+#
+# For more examples, see:
+# - `ituna-experiments/cebra/` - Extended CEBRA experiments
+# - `iTune Reference.ipynb` - Comprehensive reference notebook
diff --git a/docs/guides/sklearn_caching.ipynb b/docs/guides/sklearn_caching.ipynb
new file mode 100644
index 0000000..34a934e
--- /dev/null
+++ b/docs/guides/sklearn_caching.ipynb
@@ -0,0 +1,367 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "ac500a68",
+   "metadata": {},
+   "source": [
+    "# Caching Standalone sklearn Estimators\n",
+    "\n",
+    "iTuna's caching backends are most commonly used through `ConsistencyEnsemble`, but you can also cache\n",
+    "regular sklearn estimators directly.\n",
+    "\n",
+    "This is useful when:\n",
+    "\n",
+    "- You call `.fit()` repeatedly during exploratory analysis\n",
+    "- You run hyperparameter searches where the same configuration may be revisited\n",
+    "- You want to cache **predict/score/transform** results for expensive models\n",
+    "\n",
+    "Under the hood, iTuna routes calls through the configured backend (usually `disk_cache`).\n",
+    "\n",
+    "The main reason *not* to use disk caching is if your estimator cannot be serialized\n",
+    "(via pickle/joblib or a custom `.save()`/`.load()` mechanism)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "a6c93807",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tsbau/simonsworkspace/ituna-dev/ituna/_backends/utils.py:22: UserWarning: config_dataclass is not available, saving/loading Configurable objects will not be available\n",
+      "  warnings.warn(\"config_dataclass is not available, saving/loading Configurable objects will not be available\")\n"
+     ]
+    }
+   ],
+   "source": [
+    "from sklearn.datasets import make_regression\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.neural_network import MLPRegressor\n",
+    "\n",
+    "import ituna\n",
+    "\n",
+    "import time"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c7eb79b0",
+   "metadata": {},
+   "source": [
+    "## 1) Configure a persistent backend\n",
+    "\n",
+    "For caching across runs, use `disk_cache` (or `disk_cache_distributed`)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "a13644a5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'DEFAULT_BACKEND': 'disk_cache', 'BACKEND_KWARGS': {}, 'BACKEND_ROUTES': {}, 'CACHE_DIR': './sklearn_cache', 'FILE_LOCK_TIMEOUT': 30}\n"
+     ]
+    }
+   ],
+   "source": [
+    "ituna.config.set(\n",
+    "    DEFAULT_BACKEND=\"disk_cache\",\n",
+    "    CACHE_DIR=\"./sklearn_cache\",\n",
+    ")\n",
+    "print(ituna.config.get_config())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e80f3913",
+   "metadata": {},
+   "source": [
+    "## 2) Instance-level caching (`ituna.sklearn.cached`)\n",
+    "\n",
+    "`ituna.sklearn.cached(estimator, methods=...)` patches the estimator **instance in-place**\n",
+    "(type-preserving) so that selected methods route through iTuna's backends.\n",
+    "\n",
+    "Supported methods: `fit`, `transform`, `predict`, `score`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "375ce95e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Fit time: 26.65767s\n",
+      "Pred shape: (500,)\n",
+      "Score time: 0.00174s\n",
+      "R2: 0.9896977865833773\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tsbau/mambaforge/envs/ituna-dev/lib/python3.12/site-packages/sklearn/neural_network/_multilayer_perceptron.py:785: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (20000) reached and the optimization hasn't converged yet.\n",
+      "  warnings.warn(\n"
+     ]
+    }
+   ],
+   "source": [
+    "X, y = make_regression(n_samples=2000, n_features=100, n_informative=5, tail_strength=0.8, noise=0.0, random_state=1)\n",
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=1)\n",
+    "\n",
+    "model = MLPRegressor(\n",
+    "    hidden_layer_sizes=(32,),\n",
+    "    max_iter=20000,\n",
+    "    random_state=0,\n",
+    "    n_iter_no_change=10000,\n",
+    "    tol=1e-6,\n",
+    ")\n",
+    "\n",
+    "ituna.sklearn.cached(model, methods=[\"fit\", \"predict\", \"score\"])\n",
+    "\n",
+    "start = time.time()\n",
+    "model.fit(X_train, y_train)\n",
+    "print(f\"Fit time: {time.time() - start:.5f}s\")\n",
+    "\n",
+    "pred = model.predict(X_test)\n",
+    "print(\"Pred shape:\", pred.shape)\n",
+    "start = time.time()\n",
+    "score = model.score(X_test, y_test)\n",
+    "print(f\"Score time: {time.time() - start:.5f}s\")\n",
+    "print(\"R2:\", score)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7ef790b1",
+   "metadata": {},
+   "source": [
+    "If you create a **new instance** with the same hyperparameters and data, it will reuse cached artifacts\n",
+    "once you apply `cached(...)` to that instance as well:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "c8f89db9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Fit time: 0.03993s\n",
+      "Pred shape: (500,)\n",
+      "Score time: 0.00060s\n",
+      "R2: 0.9896977865833773\n"
+     ]
+    }
+   ],
+   "source": [
+    "model2 = MLPRegressor(\n",
+    "    hidden_layer_sizes=(32,),\n",
+    "    max_iter=20000,\n",
+    "    random_state=0,\n",
+    "    n_iter_no_change=10000,\n",
+    "    tol=1e-6,\n",
+    ")\n",
+    "# register the model2 to have caching\n",
+    "ituna.sklearn.cached(model2, methods=[\"fit\", \"predict\", \"score\"])\n",
+    "\n",
+    "start = time.time()\n",
+    "model2.fit(X_train, y_train)\n",
+    "print(f\"Fit time: {time.time() - start:.5f}s\")\n",
+    "\n",
+    "pred = model2.predict(X_test)\n",
+    "print(\"Pred shape:\", pred.shape)\n",
+    "start = time.time()\n",
+    "score = model2.score(X_test, y_test)\n",
+    "print(f\"Score time: {time.time() - start:.5f}s\")\n",
+    "print(\"R2:\", score)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4763dd4b",
+   "metadata": {},
+   "source": [
+    "## 3) Global caching (`enable_global_cache`)\n",
+    "\n",
+    "If you want caching to apply automatically to **all future instances** of a class, enable a global patch:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "13943bd2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Fit time: 20.23549s\n",
+      "Global cache status: {'sklearn.neural_network._multilayer_perceptron.MLPRegressor': ['fit']}\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Register the class MLPRegressor to have caching on the .fit() method\n",
+    "ituna.sklearn.enable_global_cache([MLPRegressor], methods=[\"fit\"])\n",
+    "\n",
+    "model3 = MLPRegressor(\n",
+    "    hidden_layer_sizes=(32,),\n",
+    "    max_iter=20000,\n",
+    "    random_state=1,\n",
+    "    n_iter_no_change=10000,\n",
+    "    tol=1e-6,\n",
+    ")\n",
+    "\n",
+    "start = time.time()\n",
+    "model3.fit(X_train, y_train)  # cached automatically\n",
+    "print(f\"Fit time: {time.time() - start:.5f}s\")\n",
+    "\n",
+    "print(\"Global cache status:\", ituna.sklearn.get_global_cache_status())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "ea35f9c2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Fit time: 0.02844s\n"
+     ]
+    }
+   ],
+   "source": [
+    "model4 = MLPRegressor(\n",
+    "    hidden_layer_sizes=(32,),\n",
+    "    max_iter=20000,\n",
+    "    random_state=1,\n",
+    "    n_iter_no_change=10000,\n",
+    "    tol=1e-6,\n",
+    ")\n",
+    "\n",
+    "start = time.time()\n",
+    "model4.fit(X_train, y_train)  # cached automatically\n",
+    "print(f\"Fit time: {time.time() - start:.5f}s\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ddefc64a",
+   "metadata": {},
+   "source": [
+    "Restore original behavior:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "3e00126e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Global cache status: {}\n"
+     ]
+    }
+   ],
+   "source": [
+    "ituna.sklearn.disable_global_cache([MLPRegressor], methods=[\"fit\"])\n",
+    "print(\"Global cache status:\", ituna.sklearn.get_global_cache_status())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "ad5833d3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Fit time: 21.04154s\n"
+     ]
+    }
+   ],
+   "source": [
+    "model5 = MLPRegressor(\n",
+    "    hidden_layer_sizes=(32,),\n",
+    "    max_iter=20000,\n",
+    "    random_state=1,\n",
+    "    n_iter_no_change=10000,\n",
+    "    tol=1e-6,\n",
+    ")\n",
+    "\n",
+    "start = time.time()\n",
+    "model5.fit(X_train, y_train)  # cached automatically\n",
+    "print(f\"Fit time: {time.time() - start:.5f}s\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5a314f70",
+   "metadata": {},
+   "source": [
+    "## Notes / Caveats\n",
+    "\n",
+    "- Caching is most effective when your estimator's outputs are deterministic for a given `(params, data)`.\n",
+    "- For nested iTuna usage (e.g., globally patched sklearn models used inside `ConsistencyEnsemble`),\n",
+    "  iTuna suspends global patches internally to avoid double-caching loops."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ae0e1c6e",
+   "metadata": {},
+   "source": []
+  }
+ ],
+ "metadata": {
+  "jupytext": {
+   "cell_metadata_filter": "tags",
+   "formats": "ipynb,py:percent",
+   "notebook_metadata_filter": "kernelspec,language_info,jupytext"
+  },
+  "kernelspec": {
+   "display_name": "ituna-dev",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/guides/sklearn_caching.py b/docs/guides/sklearn_caching.py
new file mode 100644
index 0000000..9530023
--- /dev/null
+++ b/docs/guides/sklearn_caching.py
@@ -0,0 +1,189 @@
+# ---
+# jupyter:
+#   jupytext:
+#     cell_metadata_filter: tags
+#     formats: ipynb,py:percent
+#     notebook_metadata_filter: kernelspec,language_info,jupytext
+#     text_representation:
+#       extension: .py
+#       format_name: percent
+#       format_version: '1.3'
+#       jupytext_version: 1.19.1
+#   kernelspec:
+#     display_name: ituna-dev
+#     language: python
+#     name: python3
+#   language_info:
+#     codemirror_mode:
+#       name: ipython
+#       version: 3
+#     file_extension: .py
+#     mimetype: text/x-python
+#     name: python
+#     nbconvert_exporter: python
+#     pygments_lexer: ipython3
+#     version: 3.12.12
+# ---
+
+# %% [markdown]
+# # Caching Standalone sklearn Estimators
+#
+# iTuna's caching backends are most commonly used through `ConsistencyEnsemble`, but you can also cache
+# regular sklearn estimators directly.
+#
+# This is useful when:
+#
+# - You call `.fit()` repeatedly during exploratory analysis
+# - You run hyperparameter searches where the same configuration may be revisited
+# - You want to cache **predict/score/transform** results for expensive models
+#
+# Under the hood, iTuna routes calls through the configured backend (usually `disk_cache`).
+#
+# The main reason *not* to use disk caching is if your estimator cannot be serialized
+# (via pickle/joblib or a custom `.save()`/`.load()` mechanism).
+
+# %%
+from sklearn.datasets import make_regression
+from sklearn.model_selection import train_test_split
+from sklearn.neural_network import MLPRegressor
+
+import ituna
+
+import time
+
+# %% [markdown]
+# ## 1) Configure a persistent backend
+#
+# For caching across runs, use `disk_cache` (or `disk_cache_distributed`).
+
+# %%
+ituna.config.set(
+    DEFAULT_BACKEND="disk_cache",
+    CACHE_DIR="./sklearn_cache",
+)
+print(ituna.config.get_config())
+
+# %% [markdown]
+# ## 2) Instance-level caching (`ituna.sklearn.cached`)
+#
+# `ituna.sklearn.cached(estimator, methods=...)` patches the estimator **instance in-place**
+# (type-preserving) so that selected methods route through iTuna's backends.
+#
+# Supported methods: `fit`, `transform`, `predict`, `score`.
+
+# %%
+X, y = make_regression(n_samples=2000, n_features=100, n_informative=5, tail_strength=0.8, noise=0.0, random_state=1)
+X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=1)
+
+model = MLPRegressor(
+    hidden_layer_sizes=(32,),
+    max_iter=20000,
+    random_state=0,
+    n_iter_no_change=10000,
+    tol=1e-6,
+)
+
+ituna.sklearn.cached(model, methods=["fit", "predict", "score"])
+
+start = time.time()
+model.fit(X_train, y_train)
+print(f"Fit time: {time.time() - start:.5f}s")
+
+pred = model.predict(X_test)
+print("Pred shape:", pred.shape)
+start = time.time()
+score = model.score(X_test, y_test)
+print(f"Score time: {time.time() - start:.5f}s")
+print("R2:", score)
+
+# %% [markdown]
+# If you create a **new instance** with the same hyperparameters and data, it will reuse cached artifacts
+# once you apply `cached(...)` to that instance as well:
+
+# %%
+model2 = MLPRegressor(
+    hidden_layer_sizes=(32,),
+    max_iter=20000,
+    random_state=0,
+    n_iter_no_change=10000,
+    tol=1e-6,
+)
+# register the model2 to have caching
+ituna.sklearn.cached(model2, methods=["fit", "predict", "score"])
+
+start = time.time()
+model2.fit(X_train, y_train)
+print(f"Fit time: {time.time() - start:.5f}s")
+
+pred = model2.predict(X_test)
+print("Pred shape:", pred.shape)
+start = time.time()
+score = model2.score(X_test, y_test)
+print(f"Score time: {time.time() - start:.5f}s")
+print("R2:", score)
+
+# %% [markdown]
+# ## 3) Global caching (`enable_global_cache`)
+#
+# If you want caching to apply automatically to **all future instances** of a class, enable a global patch:
+
+# %%
+# Register the class MLPRegressor to have caching on the .fit() method
+ituna.sklearn.enable_global_cache([MLPRegressor], methods=["fit"])
+
+model3 = MLPRegressor(
+    hidden_layer_sizes=(32,),
+    max_iter=20000,
+    random_state=1,
+    n_iter_no_change=10000,
+    tol=1e-6,
+)
+
+start = time.time()
+model3.fit(X_train, y_train)  # cached automatically
+print(f"Fit time: {time.time() - start:.5f}s")
+
+print("Global cache status:", ituna.sklearn.get_global_cache_status())
+
+# %%
+model4 = MLPRegressor(
+    hidden_layer_sizes=(32,),
+    max_iter=20000,
+    random_state=1,
+    n_iter_no_change=10000,
+    tol=1e-6,
+)
+
+start = time.time()
+model4.fit(X_train, y_train)  # cached automatically
+print(f"Fit time: {time.time() - start:.5f}s")
+
+# %% [markdown]
+# Restore original behavior:
+
+# %%
+ituna.sklearn.disable_global_cache([MLPRegressor], methods=["fit"])
+print("Global cache status:", ituna.sklearn.get_global_cache_status())
+
+# %%
+model5 = MLPRegressor(
+    hidden_layer_sizes=(32,),
+    max_iter=20000,
+    random_state=1,
+    n_iter_no_change=10000,
+    tol=1e-6,
+)
+
+start = time.time()
+model5.fit(X_train, y_train)  # cached automatically
+print(f"Fit time: {time.time() - start:.5f}s")
+
+# %% [markdown]
+# ## Notes / Caveats
+#
+# - Caching is most effective when your estimator's outputs are deterministic for a given `(params, data)`.
+# - For nested iTuna usage (e.g., globally patched sklearn models used inside `ConsistencyEnsemble`),
+#   iTuna suspends global patches internally to avoid double-caching loops.
+
+# %% [markdown]
+#
diff --git a/docs/tutorials/backends.ipynb b/docs/tutorials/backends.ipynb
index 4c6c6a8..4219dd4 100644
--- a/docs/tutorials/backends.ipynb
+++ b/docs/tutorials/backends.ipynb
@@ -24,13 +24,15 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/hkfs/home/haicore/hgf_hmgu/hgf_sfs7789/git/itune-ref/ituna/_backends/utils.py:22: UserWarning: config_dataclass is not available, saving/loading Configurable objects will not be available\n",
-      "  warnings.warn(\"config_dataclass is not available, saving/loading Configurable objects will not be available\")\n"
+      "/hkfs/home/haicore/hgf_hmgu/hgf_sfs7789/git/ituna-dev/ituna/_backends/utils.py:22: UserWarning: config_dataclass is not available, saving/loading Configurable objects will not be available\n",
+      "  warnings.warn(\"config_dataclass is not available, saving/loading Configurable objects will not be available\")\n",
+      "/home/hgf_hmgu/hgf_sfs7789/miniconda3/envs/ituna-dev/lib/python3.12/site-packages/datajoint/settings.py:979: UserWarning: No datajoint.json found. Using defaults and environment variables. Run `dj.config.save_template()` to create a template configuration.\n",
+      "  config = _create_config()\n"
      ]
     }
    ],
    "source": [
-    "import numpy as np\n",
+    "from sklearn.datasets import make_blobs\n",
     "from sklearn.decomposition import FastICA\n",
     "\n",
     "import ituna"
@@ -43,8 +45,13 @@
    "outputs": [],
    "source": [
     "# Sample data for all examples\n",
-    "np.random.seed(42)\n",
-    "X = np.random.randn(1000, 20)"
+    "X, _ = make_blobs(\n",
+    "    n_samples=1000,\n",
+    "    n_features=20,\n",
+    "    centers=6,\n",
+    "    cluster_std=2.0,\n",
+    "    random_state=420,\n",
+    ")"
    ]
   },
   {
@@ -65,7 +72,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Current config: {'DEFAULT_BACKEND': 'in_memory', 'BACKEND_KWARGS': {}, 'CACHE_DIR': 'backend_store', 'FILE_LOCK_TIMEOUT': 30}\n"
+      "Current config: {'DEFAULT_BACKEND': 'in_memory', 'BACKEND_KWARGS': {}, 'BACKEND_ROUTES': {}, 'CACHE_DIR': 'backend_store', 'FILE_LOCK_TIMEOUT': 30}\n"
      ]
     }
    ],
@@ -94,7 +101,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Updated config: {'DEFAULT_BACKEND': 'disk_cache', 'BACKEND_KWARGS': {}, 'CACHE_DIR': 'backend_store', 'FILE_LOCK_TIMEOUT': 30}\n"
+      "Updated config: {'DEFAULT_BACKEND': 'disk_cache', 'BACKEND_KWARGS': {}, 'BACKEND_ROUTES': {}, 'CACHE_DIR': 'backend_store', 'FILE_LOCK_TIMEOUT': 30}\n"
      ]
     }
    ],
@@ -115,26 +122,14 @@
      "output_type": "stream",
      "text": [
       "First run (training):\n",
-      "Score: 0.7096\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/hgf_hmgu/hgf_sfs7789/miniconda3/envs/ituna/lib/python3.10/site-packages/sklearn/decomposition/_fastica.py:127: ConvergenceWarning: FastICA did not converge. Consider increasing tolerance or the maximum number of iterations.\n",
-      "  warnings.warn(\n",
-      "/home/hgf_hmgu/hgf_sfs7789/miniconda3/envs/ituna/lib/python3.10/site-packages/sklearn/decomposition/_fastica.py:127: ConvergenceWarning: FastICA did not converge. Consider increasing tolerance or the maximum number of iterations.\n",
-      "  warnings.warn(\n",
-      "/home/hgf_hmgu/hgf_sfs7789/miniconda3/envs/ituna/lib/python3.10/site-packages/sklearn/decomposition/_fastica.py:127: ConvergenceWarning: FastICA did not converge. Consider increasing tolerance or the maximum number of iterations.\n",
-      "  warnings.warn(\n"
+      "Score: -0.1156\n"
      ]
     }
    ],
    "source": [
     "# Create and fit an ensemble - models will be cached\n",
     "ensemble = ituna.ConsistencyEnsemble(\n",
-    "    estimator=FastICA(n_components=5, max_iter=500),\n",
+    "    estimator=FastICA(n_components=5, max_iter=1000),\n",
     "    consistency_transform=ituna.metrics.PairwiseConsistency(\n",
     "        indeterminacy=ituna.metrics.Permutation(),\n",
     "    ),\n",
@@ -158,7 +153,7 @@
      "text": [
       "\n",
       "Second run (loading from cache):\n",
-      "Score: 0.7096\n"
+      "Score: -0.1156\n"
      ]
     }
    ],
@@ -166,7 +161,7 @@
     "# Second run: loads from cache (much faster)\n",
     "print(\"\\nSecond run (loading from cache):\")\n",
     "ensemble2 = ituna.ConsistencyEnsemble(\n",
-    "    estimator=FastICA(n_components=5, max_iter=500),\n",
+    "    estimator=FastICA(n_components=5, max_iter=1000),\n",
     "    consistency_transform=ituna.metrics.PairwiseConsistency(\n",
     "        indeterminacy=ituna.metrics.Permutation(),\n",
     "    ),\n",
@@ -199,27 +194,21 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "New hyperparameter - trains fresh:\n",
-      "Score: 0.6284\n"
+      "New hyperparameter - trains fresh:\n"
      ]
     },
     {
-     "name": "stderr",
+     "name": "stdout",
      "output_type": "stream",
      "text": [
-      "/home/hgf_hmgu/hgf_sfs7789/miniconda3/envs/ituna/lib/python3.10/site-packages/sklearn/decomposition/_fastica.py:127: ConvergenceWarning: FastICA did not converge. Consider increasing tolerance or the maximum number of iterations.\n",
-      "  warnings.warn(\n",
-      "/home/hgf_hmgu/hgf_sfs7789/miniconda3/envs/ituna/lib/python3.10/site-packages/sklearn/decomposition/_fastica.py:127: ConvergenceWarning: FastICA did not converge. Consider increasing tolerance or the maximum number of iterations.\n",
-      "  warnings.warn(\n",
-      "/home/hgf_hmgu/hgf_sfs7789/miniconda3/envs/ituna/lib/python3.10/site-packages/sklearn/decomposition/_fastica.py:127: ConvergenceWarning: FastICA did not converge. Consider increasing tolerance or the maximum number of iterations.\n",
-      "  warnings.warn(\n"
+      "Score: -0.1156\n"
      ]
     }
    ],
    "source": [
     "# Changing max_iter creates a new cache entry\n",
     "ensemble3 = ituna.ConsistencyEnsemble(\n",
-    "    estimator=FastICA(n_components=5, max_iter=501),  # Different max_iter!\n",
+    "    estimator=FastICA(n_components=5, max_iter=1001),  # Different max_iter!\n",
     "    consistency_transform=ituna.metrics.PairwiseConsistency(\n",
     "        indeterminacy=ituna.metrics.Permutation(),\n",
     "    ),\n",
@@ -334,7 +323,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Distributed config: {'DEFAULT_BACKEND': 'disk_cache_distributed', 'BACKEND_KWARGS': {'trigger_type': 'auto', 'num_workers': 4}, 'CACHE_DIR': './my_model_cache', 'FILE_LOCK_TIMEOUT': 30}\n"
+      "Distributed config: {'DEFAULT_BACKEND': 'disk_cache_distributed', 'BACKEND_KWARGS': {'trigger_type': 'auto', 'num_workers': 4}, 'BACKEND_ROUTES': {}, 'CACHE_DIR': './my_model_cache', 'FILE_LOCK_TIMEOUT': 30}\n"
      ]
     }
    ],
@@ -358,27 +347,28 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "Fitting models: 100%|██████████| 10/10 [00:04<00:00,  2.46it/s, trained=10/10, errors=0, reserved=0, sweep_trained=10/10, sweep_errors=0, sweep_reserved=0]\n"
+      "Fitting models: 100%|█| 7/7 [00:09<00:00,  1.30s/it, trained=7/7, errors=0, reserved=0, sweep_trained=7/7, swee\n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Score: 0.6479\n"
+      "Score: 0.1174\n"
      ]
     }
    ],
    "source": [
     "# Train with 10 random states in parallel\n",
     "ensemble_parallel = ituna.ConsistencyEnsemble(\n",
-    "    estimator=FastICA(n_components=5, max_iter=500),\n",
+    "    estimator=FastICA(n_components=5, max_iter=1000),\n",
     "    consistency_transform=ituna.metrics.PairwiseConsistency(\n",
     "        indeterminacy=ituna.metrics.Permutation(),\n",
     "    ),\n",
     "    random_states=10,\n",
     ")\n",
     "\n",
+    "# NOTE: this will only train 7 models because 3 models have already been trained earlier with the same configuration\n",
     "ensemble_parallel.fit(X)\n",
     "print(f\"Score: {ensemble_parallel.score(X):.4f}\")"
    ]
@@ -410,6 +400,56 @@
     "# and wait for external workers to complete the training"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "To start a worker process for the sweep manually, execute the following command:\n",
+      "ituna-fit-distributed --sweep-name my_experiment_sweep --cache-dir /hkfs/home/haicore/hgf_hmgu/hgf_sfs7789/git/ituna-dev/my_model_cache --order-by random\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Fitting models: 100%|█| 10/10 [03:56<00:00, 23.60s/it, trained=10/10, errors=0, reserved=0, sweep_trained=20/20"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Score: 0.1174\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Train with 10 random states in parallel\n",
+    "ensemble_parallel = ituna.ConsistencyEnsemble(\n",
+    "    estimator=FastICA(n_components=5, max_iter=1001), # Different max_iter!\n",
+    "    consistency_transform=ituna.metrics.PairwiseConsistency(\n",
+    "        indeterminacy=ituna.metrics.Permutation(),\n",
+    "    ),\n",
+    "    random_states=10,\n",
+    ")\n",
+    "\n",
+    "ensemble_parallel.fit(X)\n",
+    "print(f\"Score: {ensemble_parallel.score(X):.4f}\")"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -456,7 +496,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -469,6 +509,199 @@
     "# }"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Advanced: Route Different Operations to Different Backends\n",
+    "\n",
+    "Routing becomes valuable when you want to squeeze out *all* avoidable recomputation. Common reasons:\n",
+    "\n",
+    "- **Expensive estimator `transform`**: your model is huge, and producing embeddings is a real compute step.\n",
+    "- **Expensive consistency transforms / indeterminacies**: alignment and scoring is non-trivial (or uses heavy internal models).\n",
+    "- **Lots of models**: large grid searches where even small overhead per model adds up.\n",
+    "\n",
+    "In those workflows, you often want different backend behavior per operation:\n",
+    "\n",
+    "- Base estimator `fit` runs via `disk_cache_distributed` in manual mode (register on login node, train via workers)\n",
+    "- `ConsistencyTransform.fit` runs locally via `disk_cache` (fast and cached)\n",
+    "- Optional: estimator `transform` calls also use `disk_cache` to avoid recomputing embeddings during collection passes\n",
+    "\n",
+    "You can configure this with `register_backend_route(method=..., model_class=..., backend=...)`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Resolved config: {'DEFAULT_BACKEND': 'disk_cache_distributed', 'BACKEND_KWARGS': {'trigger_type': 'manual', 'sweep_type': 'constant', 'sweep_name': 'routing_demo_sweep', 'fit_time_out': 1}, 'BACKEND_ROUTES': {('fit', 'ituna.metrics.ConsistencyTransform'): {'backend': 'disk_cache'}}, 'CACHE_DIR': './my_model_cache', 'FILE_LOCK_TIMEOUT': 30}\n",
+      "To start a worker process for the sweep manually, execute the following command:\n",
+      "ituna-fit-distributed --sweep-name routing_demo_sweep --cache-dir /hkfs/home/haicore/hgf_hmgu/hgf_sfs7789/git/ituna-dev/my_model_cache --order-by random\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Fitting models:   0%| | 0/5 [00:01<?, ?it/s, trained=0/5, errors=0, reserved=0, sweep_trained=0/5, sweep_errors"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Expected during registration phase when workers are not running.\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Route estimator fit -> distributed/manual, transform fit -> disk_cache\n",
+    "ituna.config.set(\n",
+    "    DEFAULT_BACKEND=\"disk_cache_distributed\",\n",
+    "    CACHE_DIR=\"./my_model_cache\",\n",
+    "    BACKEND_KWARGS={\n",
+    "        \"trigger_type\": \"manual\",\n",
+    "        \"sweep_type\": \"constant\",\n",
+    "        \"sweep_name\": \"routing_demo_sweep\",\n",
+    "        \"fit_time_out\": 1,\n",
+    "    },\n",
+    "    BACKEND_ROUTES={},\n",
+    ")\n",
+    "\n",
+    "# Route all ConsistencyTransform fit calls to local disk cache\n",
+    "ituna.config.register_backend_route(\n",
+    "    method=\"fit\",\n",
+    "    model_class=ituna.metrics.ConsistencyTransform,\n",
+    "    backend=\"disk_cache\",\n",
+    ")\n",
+    "\n",
+    "print(\"Resolved config:\", ituna.config.get_config())\n",
+    "\n",
+    "ensemble_routed = ituna.ConsistencyEnsemble(\n",
+    "    estimator=FastICA(n_components=5, max_iter=500),\n",
+    "    consistency_transform=ituna.metrics.PairwiseConsistency(\n",
+    "        indeterminacy=ituna.metrics.Permutation(),\n",
+    "    ),\n",
+    "    random_states=5,\n",
+    ")\n",
+    "\n",
+    "# In manual mode this prints the worker command and waits up to fit_time_out\n",
+    "# Base estimator fits are distributed; consistency transform fit is cached locally via disk_cache.\n",
+    "try:\n",
+    "    ensemble_routed.fit(X)\n",
+    "except TimeoutError:\n",
+    "    print(\"Expected during registration phase when workers are not running.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Optional: Cache Estimator `transform` Calls\n",
+    "\n",
+    "For large sweeps, collection passes may spend significant time recomputing embeddings (`model.transform(X)`) across many cached estimators.\n",
+    "\n",
+    "You can route `transform` to `disk_cache` so repeated transform calls on the same model+data are loaded from cache.\n",
+    "\n",
+    "Use this only when transform outputs are deterministic for your estimator and input data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Transform cache directory: my_model_cache/transforms\n",
+      "Exists now: True\n"
+     ]
+    }
+   ],
+   "source": [
+    "from pathlib import Path\n",
+    "\n",
+    "# Route FastICA transform calls to disk cache (optional)\n",
+    "ituna.config.register_backend_route(\n",
+    "    method=\"transform\",\n",
+    "    model_class=FastICA,\n",
+    "    backend=\"disk_cache\",\n",
+    ")\n",
+    "\n",
+    "# Example flow:\n",
+    "# 1) Fit once with workers running\n",
+    "# 2) Run transform/score repeatedly in analysis notebooks\n",
+    "# 3) Repeated transform calls can load from ./my_model_cache/transforms\n",
+    "\n",
+    "transform_cache_dir = Path(ituna.config.CACHE_DIR) / \"transforms\"\n",
+    "print(\"Transform cache directory:\", transform_cache_dir)\n",
+    "print(\"Exists now:\", transform_cache_dir.exists())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7a332ffa",
+   "metadata": {},
+   "source": [
+    "## Performance Tips (Fast Reruns)\n",
+    "\n",
+    "iTuna's caching backends help you avoid re-training and (optionally) avoid recomputing embeddings.\n",
+    "For full hyperparameter searches, you can go one step further: **persist the search itself**.\n",
+    "\n",
+    "### Hyperparameter Search: Use Optuna Storage as a \\\"trial cache\\\"\n",
+    "\n",
+    "If you use [Optuna](https://optuna.org/), configure a persistent storage backend (e.g. SQLite).\n",
+    "Then, rerunning your script/notebook can **resume** a study and skip already-completed trials entirely.\n",
+    "\n",
+    "Minimal pattern:\n",
+    "\n",
+    "```python\n",
+    "import optuna\n",
+    "from optuna.trial import TrialState\n",
+    "\n",
+    "STORAGE = \"sqlite:///ituna_optuna.db\"\n",
+    "STUDY_NAME = \"my_sweep\"\n",
+    "N_TRIALS = 50\n",
+    "\n",
+    "def objective(trial):\n",
+    "    # Suggest hyperparameters...\n",
+    "    # Build + score an iTuna ConsistencyEnsemble...\n",
+    "    return score\n",
+    "\n",
+    "study = optuna.create_study(\n",
+    "    direction=\"maximize\",\n",
+    "    study_name=STUDY_NAME,\n",
+    "    storage=STORAGE,\n",
+    "    load_if_exists=True,\n",
+    ")\n",
+    "\n",
+    "n_complete = sum(t.state == TrialState.COMPLETE for t in study.trials)\n",
+    "if n_complete < N_TRIALS:\n",
+    "    study.optimize(objective, n_trials=N_TRIALS - n_complete, n_jobs=1)\n",
+    "else:\n",
+    "    print(f\"Study already complete ({n_complete}/{N_TRIALS}). Skipping optimize().\")\n",
+    "```\n",
+    "\n",
+    "Combine this with iTuna's caching backends and routing to make reruns close to instantaneous:\n",
+    "- Optuna storage avoids recomputing completed trials.\n",
+    "- iTuna caching avoids recomputing model fits / transforms inside a trial."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -479,40 +712,48 @@
     "|---------|----------|\n",
     "| `in_memory` | Quick experiments, no caching needed |\n",
     "| `disk_cache` | Iterative analysis, avoid re-training |\n",
-    "| `disk_cache_distributed` | Large sweeps, multi-core machines |\n",
+    "| `disk_cache_distributed` | Large sweeps, multi-core/HPC workflows |\n",
     "| `datajoint` | Team collaboration, shared database |\n",
     "\n",
-    "Key configuration options:\n",
+    "You can combine these with backend routes:\n",
     "\n",
     "```python\n",
     "import ituna\n",
+    "from sklearn.decomposition import FastICA\n",
     "\n",
-    "# Set backend globally\n",
-    "ituna.config.DEFAULT_BACKEND = \"disk_cache\"\n",
-    "ituna.config.CACHE_DIR = \"./my_cache\"\n",
+    "ituna.config.set(\n",
+    "    DEFAULT_BACKEND=\"disk_cache_distributed\",\n",
+    "    CACHE_DIR=\"./my_cache\",\n",
+    "    BACKEND_KWARGS={\"trigger_type\": \"manual\", \"sweep_type\": \"constant\", \"sweep_name\": \"my_sweep\"},\n",
+    ")\n",
     "\n",
-    "# Or use context manager\n",
-    "with ituna.config.config_context(DEFAULT_BACKEND=\"disk_cache\"):\n",
-    "    ensemble.fit(X)\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Reset to defaults for clean state\n",
-    "ituna.config.DEFAULT_BACKEND = \"in_memory\"\n",
-    "ituna.config.BACKEND_KWARGS = {}\n",
-    "ituna.config.CACHE_DIR = \"backend_store\""
+    "# Route consistency transform fits to local disk cache\n",
+    "ituna.config.register_backend_route(\n",
+    "    method=\"fit\",\n",
+    "    model_class=ituna.metrics.ConsistencyTransform,\n",
+    "    backend=\"disk_cache\",\n",
+    ")\n",
+    "\n",
+    "# Optional: route transform calls to disk cache for repeated collection passes\n",
+    "ituna.config.register_backend_route(\n",
+    "    method=\"transform\",\n",
+    "    model_class=FastICA,\n",
+    "    backend=\"disk_cache\",\n",
+    ")\n",
+    "```\n",
+    "\n",
+    "This pattern gives distributed/manual estimator training while keeping consistency + transform workloads cache-friendly during collection."
    ]
   }
  ],
  "metadata": {
+  "jupytext": {
+   "cell_metadata_filter": "tags",
+   "formats": "ipynb,py:percent",
+   "notebook_metadata_filter": "kernelspec,language_info,jupytext"
+  },
   "kernelspec": {
-   "display_name": "ituna",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -526,7 +767,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.19"
+   "version": "3.12.12"
   }
  },
  "nbformat": 4,
diff --git a/docs/tutorials/backends.py b/docs/tutorials/backends.py
new file mode 100644
index 0000000..4b9168b
--- /dev/null
+++ b/docs/tutorials/backends.py
@@ -0,0 +1,434 @@
+# ---
+# jupyter:
+#   jupytext:
+#     cell_metadata_filter: tags
+#     formats: ipynb,py:percent
+#     notebook_metadata_filter: kernelspec,language_info,jupytext
+#     text_representation:
+#       extension: .py
+#       format_name: percent
+#       format_version: '1.3'
+#       jupytext_version: 1.19.1
+#   kernelspec:
+#     display_name: ituna
+#     language: python
+#     name: python3
+#   language_info:
+#     codemirror_mode:
+#       name: ipython
+#       version: 3
+#     file_extension: .py
+#     mimetype: text/x-python
+#     name: python
+#     nbconvert_exporter: python
+#     pygments_lexer: ipython3
+#     version: 3.10.19
+# ---
+
+# %% [markdown]
+# # Backends: Caching and Distributed Computing
+#
+# Training multiple model instances for consistency evaluation can be computationally expensive. iTuna provides several backends to help:
+#
+# 1. **Disk caching** - Avoid re-training identical models
+# 2. **Distributed execution** - Train models in parallel across multiple processes
+# 3. **DataJoint integration** - Database-backed caching for team collaboration
+#
+# This tutorial covers how to configure and use these backends.
+
+# %%
+from sklearn.datasets import make_blobs
+from sklearn.decomposition import FastICA
+
+import ituna
+
+# %%
+# Sample data for all examples
+X, _ = make_blobs(
+    n_samples=1000,
+    n_features=20,
+    centers=6,
+    cluster_std=2.0,
+    random_state=42,
+)
+
+# %% [markdown]
+# ## Default Backend: In-Memory
+#
+# By default, iTuna uses the `in_memory` backend, which trains all models fresh each time without caching.
+
+# %%
+# Check current configuration
+print("Current config:", ituna.config.get_config())
+
+# %% [markdown]
+# ## Disk Cache Backend
+#
+# The `disk_cache` backend saves trained models to disk. If you run the same model on the same data again, it loads from cache instead of re-training.
+#
+# This is extremely useful during exploratory analysis when you're iterating on visualization or downstream analysis without changing the model.
+
+# %%
+# Enable disk caching globally
+ituna.config.DEFAULT_BACKEND = "disk_cache"
+
+print("Updated config:", ituna.config.get_config())
+
+# %%
+# Create and fit an ensemble - models will be cached
+ensemble = ituna.ConsistencyEnsemble(
+    estimator=FastICA(n_components=5, max_iter=500),
+    consistency_transform=ituna.metrics.PairwiseConsistency(
+        indeterminacy=ituna.metrics.Permutation(),
+    ),
+    random_states=3,
+)
+
+# First run: trains and caches models
+print("First run (training):")
+ensemble.fit(X)
+print(f"Score: {ensemble.score(X):.4f}")
+
+# %%
+# Second run: loads from cache (much faster)
+print("\nSecond run (loading from cache):")
+ensemble2 = ituna.ConsistencyEnsemble(
+    estimator=FastICA(n_components=5, max_iter=500),
+    consistency_transform=ituna.metrics.PairwiseConsistency(
+        indeterminacy=ituna.metrics.Permutation(),
+    ),
+    random_states=3,
+)
+ensemble2.fit(X)
+print(f"Score: {ensemble2.score(X):.4f}")
+
+# %% [markdown]
+# ### Cache Invalidation
+#
+# The cache key is computed from:
+# - Model class and all hyperparameters
+# - Data hash
+# - Random state
+#
+# If you change **any** hyperparameter, it's treated as a new model and will be trained fresh.
+
+# %%
+# Changing max_iter creates a new cache entry
+ensemble3 = ituna.ConsistencyEnsemble(
+    estimator=FastICA(n_components=5, max_iter=501),  # Different max_iter!
+    consistency_transform=ituna.metrics.PairwiseConsistency(
+        indeterminacy=ituna.metrics.Permutation(),
+    ),
+    random_states=3,
+)
+
+print("New hyperparameter - trains fresh:")
+ensemble3.fit(X)
+print(f"Score: {ensemble3.score(X):.4f}")
+
+# %% [markdown]
+# ### Custom Cache Directory
+#
+# By default, models are cached in `./backend_store`. You can customize this:
+
+# %%
+# Set custom cache directory
+ituna.config.CACHE_DIR = "./my_model_cache"
+
+print(f"Cache directory: {ituna.config.CACHE_DIR}")
+
+# %% [markdown]
+# ### Shared Caching
+#
+# The disk cache is robust to concurrent access, so you can:
+#
+# - Share a cache directory across multiple notebooks
+# - Share a cache with collaborators (e.g., on a network drive)
+#
+# If someone has already trained a model with the same configuration on the same data, you'll load their cached model instead of re-training.
+
+# %% [markdown]
+# ## Using Context Managers
+#
+# Instead of changing global config, you can use context managers for temporary settings:
+
+# %%
+# Reset to default
+ituna.config.DEFAULT_BACKEND = "in_memory"
+
+# Use disk cache only within this block
+with ituna.config.config_context(DEFAULT_BACKEND="disk_cache"):
+    print("Inside context:", ituna.config.get_config()["DEFAULT_BACKEND"])
+    ensemble.fit(X)
+
+print("Outside context:", ituna.config.get_config()["DEFAULT_BACKEND"])
+
+# %% [markdown]
+# ## Distributed Backend
+#
+# The `disk_cache_distributed` backend trains models in parallel across multiple processes. This is useful when:
+#
+# - You have a multi-core machine and want to utilize all cores
+# - Training many models (large `random_states` value)
+#
+# ### Auto Mode
+#
+# In `auto` mode, iTuna automatically spawns worker processes:
+
+# %%
+# Configure distributed backend with auto workers
+ituna.config.DEFAULT_BACKEND = "disk_cache_distributed"
+ituna.config.BACKEND_KWARGS = {
+    "trigger_type": "auto",
+    "num_workers": 4,  # Number of parallel processes
+}
+
+print("Distributed config:", ituna.config.get_config())
+
+# %%
+# Train with 10 random states in parallel
+ensemble_parallel = ituna.ConsistencyEnsemble(
+    estimator=FastICA(n_components=5, max_iter=500),
+    consistency_transform=ituna.metrics.PairwiseConsistency(
+        indeterminacy=ituna.metrics.Permutation(),
+    ),
+    random_states=10,
+)
+
+ensemble_parallel.fit(X)
+print(f"Score: {ensemble_parallel.score(X):.4f}")
+
+# %% [markdown]
+# ### Manual Mode (for HPC clusters)
+#
+# In `manual` mode, iTuna prints a command that you can run on external compute nodes (e.g., SLURM jobs). This is ideal for HPC environments.
+
+# %%
+# Configure manual distributed backend
+ituna.config.DEFAULT_BACKEND = "disk_cache_distributed"
+ituna.config.BACKEND_KWARGS = {
+    "trigger_type": "manual",
+    "sweep_type": "constant",
+    "sweep_name": "my_experiment_sweep",
+}
+
+# When you call fit(), it will print the worker command
+# and wait for external workers to complete the training
+
+# %% [markdown]
+# ### CLI Worker Commands
+#
+# iTuna provides command-line tools for running workers:
+#
+# ```bash
+# # Local distributed backend
+# ituna-fit-distributed --sweep-name <uuid> --cache-dir ./backend_store
+#
+# # With DataJoint backend
+# ituna-fit-distributed-datajoint --sweep-name <uuid> --schema-name myschema
+# ```
+#
+# These can be submitted as SLURM jobs or run on any machine with access to the cache.
+
+# %% [markdown]
+# ## DataJoint Backend
+#
+# For team collaboration with database-backed caching, use the DataJoint backend.
+#
+# ### Setup
+#
+# 1. Install DataJoint support:
+#    ```bash
+#    pip install ituna[datajoint]
+#    ```
+#
+# 2. Configure database credentials in `.env` (see `.env.template`):
+#    ```
+#    DJ_HOST=your-database-host
+#    DJ_USER=your-username
+#    DJ_PASS=your-password
+#    ```
+#
+# 3. Use the backend:
+
+# %%
+# DataJoint backend configuration (requires setup)
+# config.DEFAULT_BACKEND = "datajoint"
+# config.BACKEND_KWARGS = {
+#     "trigger_type": "auto",
+#     "num_workers": 4,
+#     "schema_name": "my_ituna_schema",
+# }
+
+# %% [markdown]
+# ## Advanced: Route Different Operations to Different Backends
+#
+# Routing becomes valuable when you want to squeeze out *all* avoidable recomputation. Common reasons:
+#
+# - **Expensive estimator `transform`**: your model is huge, and producing embeddings is a real compute step.
+# - **Expensive consistency transforms / indeterminacies**: alignment and scoring is non-trivial (or uses heavy internal models).
+# - **Lots of models**: large grid searches where even small overhead per model adds up.
+#
+# In those workflows, you often want different backend behavior per operation:
+#
+# - Base estimator `fit` runs via `disk_cache_distributed` in manual mode (register on login node, train via workers)
+# - `ConsistencyTransform.fit` runs locally via `disk_cache` (fast and cached)
+# - Optional: estimator `transform` calls also use `disk_cache` to avoid recomputing embeddings during collection passes
+#
+# You can configure this with `register_backend_route(method=..., model_class=..., backend=...)`.
+
+# %%
+# Route estimator fit -> distributed/manual, transform fit -> disk_cache
+ituna.config.set(
+    DEFAULT_BACKEND="disk_cache_distributed",
+    CACHE_DIR="./my_model_cache",
+    BACKEND_KWARGS={
+        "trigger_type": "manual",
+        "sweep_type": "constant",
+        "sweep_name": "routing_demo_sweep",
+        "fit_time_out": 1,
+    },
+    BACKEND_ROUTES={},
+)
+
+# Route all ConsistencyTransform fit calls to local disk cache
+ituna.config.register_backend_route(
+    method="fit",
+    model_class=ituna.metrics.ConsistencyTransform,
+    backend="disk_cache",
+)
+
+print("Resolved config:", ituna.config.get_config())
+
+ensemble_routed = ituna.ConsistencyEnsemble(
+    estimator=FastICA(n_components=5, max_iter=500),
+    consistency_transform=ituna.metrics.PairwiseConsistency(
+        indeterminacy=ituna.metrics.Permutation(),
+    ),
+    random_states=5,
+)
+
+# In manual mode this prints the worker command and waits up to fit_time_out
+# Base estimator fits are distributed; consistency transform fit is cached locally via disk_cache.
+try:
+    ensemble_routed.fit(X)
+except TimeoutError:
+    print("Expected during registration phase when workers are not running.")
+
+# %% [markdown]
+# ### Optional: Cache Estimator `transform` Calls
+#
+# For large sweeps, collection passes may spend significant time recomputing embeddings (`model.transform(X)`) across many cached estimators.
+#
+# You can route `transform` to `disk_cache` so repeated transform calls on the same model+data are loaded from cache.
+#
+# Use this only when transform outputs are deterministic for your estimator and input data.
+
+# %%
+from pathlib import Path
+
+# Route FastICA transform calls to disk cache (optional)
+ituna.config.register_backend_route(
+    method="transform",
+    model_class=FastICA,
+    backend="disk_cache",
+)
+
+# Example flow:
+# 1) Fit once with workers running
+# 2) Run transform/score repeatedly in analysis notebooks
+# 3) Repeated transform calls can load from ./my_model_cache/transforms
+
+transform_cache_dir = Path(ituna.config.CACHE_DIR) / "transforms"
+print("Transform cache directory:", transform_cache_dir)
+print("Exists now:", transform_cache_dir.exists())
+
+# %% [markdown]
+# ## Performance Tips (Fast Reruns)
+#
+# iTuna's caching backends help you avoid re-training and (optionally) avoid recomputing embeddings.
+# For full hyperparameter searches, you can go one step further: **persist the search itself**.
+#
+# ### Hyperparameter Search: Use Optuna Storage as a \"trial cache\"
+#
+# If you use [Optuna](https://optuna.org/), configure a persistent storage backend (e.g. SQLite).
+# Then, rerunning your script/notebook can **resume** a study and skip already-completed trials entirely.
+#
+# Minimal pattern:
+#
+# ```python
+# import optuna
+# from optuna.trial import TrialState
+#
+# STORAGE = "sqlite:///ituna_optuna.db"
+# STUDY_NAME = "my_sweep"
+# N_TRIALS = 50
+#
+# def objective(trial):
+#     # Suggest hyperparameters...
+#     # Build + score an iTuna ConsistencyEnsemble...
+#     return score
+#
+# study = optuna.create_study(
+#     direction="maximize",
+#     study_name=STUDY_NAME,
+#     storage=STORAGE,
+#     load_if_exists=True,
+# )
+#
+# n_complete = sum(t.state == TrialState.COMPLETE for t in study.trials)
+# if n_complete < N_TRIALS:
+#     study.optimize(objective, n_trials=N_TRIALS - n_complete, n_jobs=1)
+# else:
+#     print(f"Study already complete ({n_complete}/{N_TRIALS}). Skipping optimize().")
+# ```
+#
+# Combine this with iTuna's caching backends and routing to make reruns close to instantaneous:
+# - Optuna storage avoids recomputing completed trials.
+# - iTuna caching avoids recomputing model fits / transforms inside a trial.
+
+# %% [markdown]
+# ## Summary
+#
+# | Backend | Use Case |
+# |---------|----------|
+# | `in_memory` | Quick experiments, no caching needed |
+# | `disk_cache` | Iterative analysis, avoid re-training |
+# | `disk_cache_distributed` | Large sweeps, multi-core/HPC workflows |
+# | `datajoint` | Team collaboration, shared database |
+#
+# You can combine these with backend routes:
+#
+# ```python
+# import ituna
+# from sklearn.decomposition import FastICA
+#
+# ituna.config.set(
+#     DEFAULT_BACKEND="disk_cache_distributed",
+#     CACHE_DIR="./my_cache",
+#     BACKEND_KWARGS={"trigger_type": "manual", "sweep_type": "constant", "sweep_name": "my_sweep"},
+# )
+#
+# # Route consistency transform fits to local disk cache
+# ituna.config.register_backend_route(
+#     method="fit",
+#     model_class=ituna.metrics.ConsistencyTransform,
+#     backend="disk_cache",
+# )
+#
+# # Optional: route transform calls to disk cache for repeated collection passes
+# ituna.config.register_backend_route(
+#     method="transform",
+#     model_class=FastICA,
+#     backend="disk_cache",
+# )
+# ```
+#
+# This pattern gives distributed/manual estimator training while keeping consistency + transform workloads cache-friendly during collection.
+
+# %%
+# Reset to defaults for clean state
+ituna.config.DEFAULT_BACKEND = "in_memory"
+ituna.config.BACKEND_KWARGS = {}
+ituna.config.BACKEND_ROUTES = {}
+ituna.config.CACHE_DIR = "backend_store"
diff --git a/docs/tutorials/core.ipynb b/docs/tutorials/core.ipynb
index 0dd48f4..9847c28 100644
--- a/docs/tutorials/core.ipynb
+++ b/docs/tutorials/core.ipynb
@@ -446,6 +446,9 @@
   }
  ],
  "metadata": {
+  "jupytext": {
+   "formats": "ipynb,py:percent"
+  },
   "kernelspec": {
    "display_name": "ituna",
    "language": "python",
diff --git a/docs/tutorials/core.py b/docs/tutorials/core.py
new file mode 100644
index 0000000..2f44dce
--- /dev/null
+++ b/docs/tutorials/core.py
@@ -0,0 +1,240 @@
+# %% [markdown]
+# # Core Concepts
+#
+# This tutorial covers the fundamental building blocks of iTuna:
+#
+# 1. **ConsistencyEnsemble** - The main class for evaluating model consistency
+# 2. **Indeterminacy classes** - How to handle different types of model ambiguity
+# 3. **Consistency scoring** - Measuring and interpreting consistency
+# 4. **Working with embeddings** - Accessing aligned representations
+
+# %%
+import numpy as np
+from sklearn.decomposition import FastICA
+from sklearn.decomposition import PCA
+
+import ituna
+
+# %% [markdown]
+# ## ConsistencyEnsemble
+#
+# `ConsistencyEnsemble` is iTuna's main class. It wraps any sklearn-compatible transformer and:
+#
+# 1. Creates multiple clones of the base estimator
+# 2. Fits each clone with a different random seed
+# 3. Aligns the resulting embeddings under the specified indeterminacy
+# 4. Computes consistency scores across all model pairs
+#
+# ### Requirements for the base estimator
+#
+# Your model must follow the sklearn API:
+# - Implement `fit(X)` and `transform(X)` methods
+# - Be clonable via `sklearn.base.clone()`
+# - Accept a `random_state` parameter (for reproducibility)
+#
+# Most sklearn transformers work out of the box. For custom models, inherit from `sklearn.base.TransformerMixin` and `sklearn.base.BaseEstimator`.
+
+# %% [markdown]
+# ## Indeterminacy Classes
+#
+# Different representation learning algorithms are identifiable up to different classes of transformations. iTuna provides four built-in indeterminacy classes:
+#
+# | Class | Transformation | Example Models |
+# |-------|---------------|----------------|
+# | `Identity` | None (exact match) | Fully identifiable models |
+# | `Permutation` | Sign flips + reordering | FastICA, sparse coding |
+# | `Linear` | Linear transformation | PCA, factor analysis |
+# | `Affine` | Linear + intercept | CEBRA, autoencoders |
+#
+# Choosing the correct indeterminacy class is crucial: if you pick one that's too restrictive, consistent models will appear inconsistent. If you pick one that's too permissive, you may miss genuine inconsistencies.
+
+# %% [markdown]
+# ### Example: FastICA with Permutation indeterminacy
+#
+# Independent Component Analysis (ICA) recovers independent sources from mixed signals. The recovered components are identifiable up to **permutation and sign flips** - we don't know which component is which, or whether it's flipped.
+
+# %%
+# Generate synthetic ICA data
+np.random.seed(42)
+n_samples = 2000
+n_sources = 5
+
+# Create independent sources
+t = np.linspace(0, 10, n_samples)
+sources = np.column_stack(
+    [
+        np.sin(2 * t),  # Sinusoid
+        np.sign(np.sin(3 * t)),  # Square wave
+        np.random.laplace(size=n_samples),  # Super-Gaussian
+        np.random.uniform(-1, 1, n_samples),  # Uniform
+        (t % 1) - 0.5,  # Sawtooth
+    ]
+)
+
+# Mix the sources
+mixing_matrix = np.random.randn(n_sources, n_sources)
+X_ica = sources @ mixing_matrix.T
+X_ica += 0.1 * np.random.randn(*X_ica.shape)  # Add noise
+
+print(f"Data shape: {X_ica.shape}")
+
+# %%
+# Create a FastICA model
+ica_model = FastICA(n_components=5, max_iter=1000)
+
+# Wrap in ConsistencyEnsemble with Permutation indeterminacy
+ica_ensemble = ituna.ConsistencyEnsemble(
+    estimator=ica_model,
+    consistency_transform=ituna.metrics.PairwiseConsistency(
+        indeterminacy=ituna.metrics.Permutation(),
+        symmetric=False,
+        include_diagonal=True,
+    ),
+    random_states=5,  # Train 5 models with different seeds
+)
+
+# Fit the ensemble
+ica_ensemble.fit(X_ica)
+
+# Get consistency score
+score = ica_ensemble.score(X_ica)
+print(f"ICA Consistency score: {score:.4f}")
+
+# %% [markdown]
+# ### Example: PCA with Linear indeterminacy
+#
+# PCA finds orthogonal directions of maximum variance. The principal components are identifiable up to **linear transformations** (rotations and reflections within eigenspaces of equal variance).
+
+# %%
+# Generate data for PCA
+np.random.seed(42)
+X_pca = np.random.randn(1000, 20)
+
+# Create PCA model
+pca_model = PCA(n_components=5)
+
+# Wrap in ConsistencyEnsemble with Linear indeterminacy
+pca_ensemble = ituna.ConsistencyEnsemble(
+    estimator=pca_model,
+    consistency_transform=ituna.metrics.PairwiseConsistency(
+        indeterminacy=ituna.metrics.Linear(),
+        symmetric=False,
+        include_diagonal=True,
+    ),
+    random_states=5,
+)
+
+pca_ensemble.fit(X_pca)
+score = pca_ensemble.score(X_pca)
+print(f"PCA Consistency score: {score:.4f}")
+
+# %% [markdown]
+# ## Understanding Consistency Scores
+#
+# The consistency score measures how well embeddings from different model instances align after accounting for the indeterminacy.
+#
+# - **Score = 1.0**: Perfect consistency - all models produce equivalent embeddings
+# - **Score close to 1.0**: High consistency - models are reliably converging to the same solution
+# - **Low score**: Models are finding different solutions, suggesting the representation may not be reproducible
+#
+# The score is computed as the R² between embeddings after fitting the indeterminacy transformation.
+
+# %% [markdown]
+# ## Working with Embeddings
+#
+# After fitting, you can access the embeddings and alignment information via `transform()`:
+
+# %%
+# Get embeddings with alignment metadata
+embeddings = ica_ensemble.transform(X_ica)
+
+print(f"Mean aligned embedding shape: {embeddings.shape}")
+print(f"Number of individual model embeddings: {len(embeddings.embeddings)}")
+
+# Access individual embeddings
+for i, emb in enumerate(embeddings.embeddings):
+    print(f"  Model {i} embedding shape: {emb.shape}")
+
+# %%
+# Access pairwise consistency scores
+pairs, scores = embeddings.scores
+
+print("\nPairwise consistency scores:")
+for (i, j), s in zip(pairs, scores):
+    print(f"  Model {i} -> Model {j}: {s:.4f}")
+
+
+# %%
+# or use built in utils to convert to dense matrix
+score_matrix = ituna.utils.sparse_to_dense(
+    *embeddings.scores,
+    shape=(len(embeddings.embeddings), len(embeddings.embeddings)),
+)
+print("Scores:\n", score_matrix)
+
+# %% [markdown]
+# ## PairwiseConsistency Options
+#
+# The `PairwiseConsistency` transform has several options:
+#
+# - **`indeterminacy`**: The indeterminacy class to use for alignment
+# - **`symmetric`**: If `True`, also compute j→i alignments (default: `False`)
+# - **`include_diagonal`**: If `True`, include self-alignments i→i (default: `True`)
+
+# %%
+# Example with symmetric=True
+symmetric_ensemble = ituna.ConsistencyEnsemble(
+    estimator=FastICA(n_components=5, max_iter=1000),
+    consistency_transform=ituna.metrics.PairwiseConsistency(
+        indeterminacy=ituna.metrics.Permutation(),
+        symmetric=True,  # Include both i->j and j->i
+        include_diagonal=False,  # Exclude self-alignments
+    ),
+    random_states=3,
+)
+
+symmetric_ensemble.fit(X_ica)
+emb = symmetric_ensemble.transform(X_ica)
+
+pairs, scores = emb.scores
+print(f"Number of pairwise comparisons: {len(pairs)}")
+for (i, j), s in zip(pairs, scores):
+    print(f"  Model {i} <-> Model {j}: {s:.4f}")
+
+# %% [markdown]
+# ## Custom Indeterminacy Classes
+#
+# You can also use any sklearn regressor as a custom indeterminacy class. The regressor is fitted to align embeddings from one model to another.
+#
+# For example, to use Ridge regression:
+
+# %%
+from sklearn.linear_model import Ridge
+
+# Use Ridge regression as indeterminacy
+ridge_ensemble = ituna.ConsistencyEnsemble(
+    estimator=FastICA(n_components=5, max_iter=1000),
+    consistency_transform=ituna.metrics.PairwiseConsistency(
+        indeterminacy=Ridge(alpha=0.1),  # Any sklearn regressor works
+        symmetric=False,
+    ),
+    random_states=3,
+)
+
+ridge_ensemble.fit(X_ica)
+print(f"Consistency score with Ridge: {ridge_ensemble.score(X_ica):.4f}")
+
+# %% [markdown]
+# ## Summary
+#
+# Key takeaways:
+#
+# 1. **`ConsistencyEnsemble`** wraps any sklearn transformer to evaluate consistency
+# 2. Choose the **indeterminacy class** based on your model's theoretical identifiability:
+#    - `Permutation` for ICA-like models
+#    - `Linear` for PCA-like models
+#    - `Affine` for models like CEBRA
+# 3. **Consistency scores** close to 1.0 indicate reproducible representations
+# 4. Use **`transform()`** to access aligned embeddings and detailed pairwise scores
+#
+# Next, check out the [Backends tutorial](backends.ipynb) to learn about caching and distributed computation.
diff --git a/docs/tutorials/quickstart.ipynb b/docs/tutorials/quickstart.ipynb
index deabd3d..d984e0a 100644
--- a/docs/tutorials/quickstart.ipynb
+++ b/docs/tutorials/quickstart.ipynb
@@ -1,105 +1,132 @@
 {
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "id": "81534cbe",
-      "metadata": {},
-      "source": [
-        "# Quickstart\n",
-        "\n",
-        "This notebook shows the smallest end-to-end iTuna workflow."
-      ]
-    },
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "81534cbe",
+   "metadata": {},
+   "source": [
+    "# Quickstart\n",
+    "\n",
+    "This notebook shows the smallest end-to-end iTuna workflow."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f9991586",
+   "metadata": {},
+   "source": [
+    "## Optional: Enable disk caching (recommended)\n",
+    "\n",
+    "By default, iTuna uses the `in_memory` backend (no caching). For most users, enabling the `disk_cache`\n",
+    "backend is a free win: repeated runs with the same model + data will **reuse cached fitted models**.\n",
+    "\n",
+    "The main reason *not* to use disk caching is if your sklearn estimator cannot be serialized\n",
+    "(via pickle/joblib or a custom `.save()`/`.load()` mechanism)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "93a99f18",
+   "metadata": {},
+   "outputs": [
     {
-      "cell_type": "code",
-      "execution_count": 7,
-      "id": "93a99f18",
-      "metadata": {},
-      "outputs": [
-        {
-          "name": "stderr",
-          "output_type": "stream",
-          "text": [
-            "/home/hgf_hmgu/hgf_sfs7789/miniconda3/envs/ituna/lib/python3.10/site-packages/sklearn/decomposition/_fastica.py:127: ConvergenceWarning: FastICA did not converge. Consider increasing tolerance or the maximum number of iterations.\n",
-            "  warnings.warn(\n",
-            "/home/hgf_hmgu/hgf_sfs7789/miniconda3/envs/ituna/lib/python3.10/site-packages/sklearn/decomposition/_fastica.py:127: ConvergenceWarning: FastICA did not converge. Consider increasing tolerance or the maximum number of iterations.\n",
-            "  warnings.warn(\n",
-            "/home/hgf_hmgu/hgf_sfs7789/miniconda3/envs/ituna/lib/python3.10/site-packages/sklearn/decomposition/_fastica.py:127: ConvergenceWarning: FastICA did not converge. Consider increasing tolerance or the maximum number of iterations.\n",
-            "  warnings.warn(\n",
-            "/home/hgf_hmgu/hgf_sfs7789/miniconda3/envs/ituna/lib/python3.10/site-packages/sklearn/decomposition/_fastica.py:127: ConvergenceWarning: FastICA did not converge. Consider increasing tolerance or the maximum number of iterations.\n",
-            "  warnings.warn(\n",
-            "/home/hgf_hmgu/hgf_sfs7789/miniconda3/envs/ituna/lib/python3.10/site-packages/sklearn/decomposition/_fastica.py:127: ConvergenceWarning: FastICA did not converge. Consider increasing tolerance or the maximum number of iterations.\n",
-            "  warnings.warn(\n"
-          ]
-        },
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Consistency score: 0.413662638435334\n",
-            "Embedding shape: (1000, 16)\n",
-            "Scores:\n",
-            " [[1.         0.21720489 0.39027938 0.19145318 0.32692556]\n",
-            " [0.21720489 1.         0.15710815 0.38241257 0.14474775]\n",
-            " [0.39027938 0.15710815 1.         0.25456576 0.32374832]\n",
-            " [0.19145318 0.38241257 0.25456576 1.         0.28233742]\n",
-            " [0.32692556 0.14474775 0.32374832 0.28233742 1.        ]]\n"
-          ]
-        }
-      ],
-      "source": [
-        "import numpy as np\n",
-        "from sklearn.decomposition import FastICA\n",
-        "\n",
-        "import ituna\n",
-        "\n",
-        "X = np.random.randn(1000, 64)\n",
-        "\n",
-        "ensemble = ituna.ConsistencyEnsemble(\n",
-        "    estimator=FastICA(n_components=16, random_state=0, max_iter=2000),\n",
-        "    consistency_transform=ituna.metrics.PairwiseConsistency(\n",
-        "        indeterminacy=ituna.metrics.Permutation(),\n",
-        "        symmetric=False,\n",
-        "        include_diagonal=True,\n",
-        "    ),\n",
-        "    random_states=5,\n",
-        ")\n",
-        "\n",
-        "ensemble.fit(X)\n",
-        "print(\"Consistency score:\", ensemble.score(X))\n",
-        "emb = ensemble.transform(X)\n",
-        "print(\"Embedding shape:\", emb.shape)\n",
-        "print(\"Scores:\\n\", ituna.utils.sparse_to_dense(*emb.scores, shape=(5, 5)))"
-      ]
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/hgf_hmgu/hgf_sfs7789/miniconda3/envs/ituna/lib/python3.10/site-packages/sklearn/decomposition/_fastica.py:127: ConvergenceWarning: FastICA did not converge. Consider increasing tolerance or the maximum number of iterations.\n",
+      "  warnings.warn(\n",
+      "/home/hgf_hmgu/hgf_sfs7789/miniconda3/envs/ituna/lib/python3.10/site-packages/sklearn/decomposition/_fastica.py:127: ConvergenceWarning: FastICA did not converge. Consider increasing tolerance or the maximum number of iterations.\n",
+      "  warnings.warn(\n",
+      "/home/hgf_hmgu/hgf_sfs7789/miniconda3/envs/ituna/lib/python3.10/site-packages/sklearn/decomposition/_fastica.py:127: ConvergenceWarning: FastICA did not converge. Consider increasing tolerance or the maximum number of iterations.\n",
+      "  warnings.warn(\n",
+      "/home/hgf_hmgu/hgf_sfs7789/miniconda3/envs/ituna/lib/python3.10/site-packages/sklearn/decomposition/_fastica.py:127: ConvergenceWarning: FastICA did not converge. Consider increasing tolerance or the maximum number of iterations.\n",
+      "  warnings.warn(\n",
+      "/home/hgf_hmgu/hgf_sfs7789/miniconda3/envs/ituna/lib/python3.10/site-packages/sklearn/decomposition/_fastica.py:127: ConvergenceWarning: FastICA did not converge. Consider increasing tolerance or the maximum number of iterations.\n",
+      "  warnings.warn(\n"
+     ]
     },
     {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "76c422fa",
-      "metadata": {},
-      "outputs": [],
-      "source": []
-    }
-  ],
-  "metadata": {
-    "kernelspec": {
-      "display_name": "ituna",
-      "language": "python",
-      "name": "python3"
-    },
-    "language_info": {
-      "codemirror_mode": {
-        "name": "ipython",
-        "version": 3
-      },
-      "file_extension": ".py",
-      "mimetype": "text/x-python",
-      "name": "python",
-      "nbconvert_exporter": "python",
-      "pygments_lexer": "ipython3",
-      "version": "3.10.19"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Consistency score: 0.413662638435334\n",
+      "Embedding shape: (1000, 16)\n",
+      "Scores:\n",
+      " [[1.         0.21720489 0.39027938 0.19145318 0.32692556]\n",
+      " [0.21720489 1.         0.15710815 0.38241257 0.14474775]\n",
+      " [0.39027938 0.15710815 1.         0.25456576 0.32374832]\n",
+      " [0.19145318 0.38241257 0.25456576 1.         0.28233742]\n",
+      " [0.32692556 0.14474775 0.32374832 0.28233742 1.        ]]\n"
+     ]
     }
+   ],
+   "source": [
+    "from sklearn.datasets import make_blobs\n",
+    "from sklearn.decomposition import FastICA\n",
+    "\n",
+    "import ituna\n",
+    "\n",
+    "# Structured synthetic data from sklearn's dataset generators\n",
+    "X, _ = make_blobs(\n",
+    "    n_samples=1000,\n",
+    "    n_features=64,\n",
+    "    centers=8,\n",
+    "    cluster_std=3.0,\n",
+    "    random_state=0,\n",
+    ")\n",
+    "\n",
+    "# Optional: persist fitted models across reruns.\n",
+    "ituna.config.set(DEFAULT_BACKEND=\"disk_cache\", CACHE_DIR=\"./ituna_cache\")\n",
+    "\n",
+    "ensemble = ituna.ConsistencyEnsemble(\n",
+    "    estimator=FastICA(n_components=16, random_state=0, max_iter=2000),\n",
+    "    consistency_transform=ituna.metrics.PairwiseConsistency(\n",
+    "        indeterminacy=ituna.metrics.Permutation(),\n",
+    "        symmetric=False,\n",
+    "        include_diagonal=True,\n",
+    "    ),\n",
+    "    random_states=5,\n",
+    ")\n",
+    "\n",
+    "ensemble.fit(X)\n",
+    "print(\"Consistency score:\", ensemble.score(X))\n",
+    "emb = ensemble.transform(X)\n",
+    "print(\"Embedding shape:\", emb.shape)\n",
+    "print(\"Scores:\\n\", ituna.utils.sparse_to_dense(*emb.scores, shape=(5, 5)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "76c422fa",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "jupytext": {
+   "formats": "ipynb,py:percent"
+  },
+  "kernelspec": {
+   "display_name": "ituna",
+   "language": "python",
+   "name": "python3"
   },
-  "nbformat": 4,
-  "nbformat_minor": 5
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.19"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
 }
diff --git a/docs/tutorials/quickstart.py b/docs/tutorials/quickstart.py
new file mode 100644
index 0000000..07438e2
--- /dev/null
+++ b/docs/tutorials/quickstart.py
@@ -0,0 +1,76 @@
+# ---
+# jupyter:
+#   jupytext:
+#     cell_metadata_filter: tags
+#     formats: ipynb,py:percent
+#     notebook_metadata_filter: kernelspec,language_info,jupytext
+#     text_representation:
+#       extension: .py
+#       format_name: percent
+#       format_version: '1.3'
+#       jupytext_version: 1.19.1
+#   kernelspec:
+#     display_name: ituna
+#     language: python
+#     name: python3
+#   language_info:
+#     codemirror_mode:
+#       name: ipython
+#       version: 3
+#     file_extension: .py
+#     mimetype: text/x-python
+#     name: python
+#     nbconvert_exporter: python
+#     pygments_lexer: ipython3
+#     version: 3.10.19
+# ---
+
+# %% [markdown]
+# # Quickstart
+#
+# This notebook shows the smallest end-to-end iTuna workflow.
+
+# %% [markdown]
+# ## Optional: Enable disk caching (recommended)
+#
+# By default, iTuna uses the `in_memory` backend (no caching). For most users, enabling the `disk_cache`
+# backend is a free win: repeated runs with the same model + data will **reuse cached fitted models**.
+#
+# The main reason *not* to use disk caching is if your sklearn estimator cannot be serialized
+# (via pickle/joblib or a custom `.save()`/`.load()` mechanism).
+
+# %%
+from sklearn.datasets import make_blobs
+from sklearn.decomposition import FastICA
+
+import ituna
+
+# Structured synthetic data from sklearn's dataset generators
+X, _ = make_blobs(
+    n_samples=1000,
+    n_features=64,
+    centers=8,
+    cluster_std=3.0,
+    random_state=0,
+)
+
+# Optional: persist fitted models across reruns.
+ituna.config.set(DEFAULT_BACKEND="disk_cache", CACHE_DIR="./ituna_cache")
+
+ensemble = ituna.ConsistencyEnsemble(
+    estimator=FastICA(n_components=16, random_state=0, max_iter=2000),
+    consistency_transform=ituna.metrics.PairwiseConsistency(
+        indeterminacy=ituna.metrics.Permutation(),
+        symmetric=False,
+        include_diagonal=True,
+    ),
+    random_states=5,
+)
+
+ensemble.fit(X)
+print("Consistency score:", ensemble.score(X))
+emb = ensemble.transform(X)
+print("Embedding shape:", emb.shape)
+print("Scores:\n", ituna.utils.sparse_to_dense(*emb.scores, shape=(5, 5)))
+
+# %%
diff --git a/ituna/__init__.py b/ituna/__init__.py
index f2cb7d8..d2b6b78 100644
--- a/ituna/__init__.py
+++ b/ituna/__init__.py
@@ -6,6 +6,7 @@
 from ituna import config
 from ituna import estimator
 from ituna import metrics
+from ituna import sklearn
 from ituna import utils
 from ituna.estimator import ConsistencyEnsemble
 
@@ -14,6 +15,7 @@
     "config",
     "estimator",
     "metrics",
+    "sklearn",
     "utils",
     "_backends",
 ]
diff --git a/ituna/_backends/__init__.py b/ituna/_backends/__init__.py
index 69fe6e0..995a75a 100644
--- a/ituna/_backends/__init__.py
+++ b/ituna/_backends/__init__.py
@@ -1,3 +1,6 @@
+import copy
+from typing import Optional
+
 from ituna._backends import utils
 from ituna._backends.base import Backend
 from ituna._backends.datajoint import DatajointBackend
@@ -14,18 +17,12 @@
 }
 
 
-# backend factory
-def get_backend(backend_name: str = None):
-    """
-    Factory function to get a backend instance.
-
-    If backend_name is None, it uses the default from the global config.
-    """
+def _build_backend(backend_name: str, backend_kwargs: Optional[dict] = None):
     # delayed import so it uses the updated config
     from ituna import config
 
-    if backend_name is None:
-        backend_name = config.DEFAULT_BACKEND
+    if backend_kwargs is None:
+        backend_kwargs = {}
 
     if backend_name not in _BACKENDS:
         raise ValueError(f"Unknown backend: '{backend_name}'. Available backends are: {list(_BACKENDS.keys())}")
@@ -33,19 +30,40 @@ def get_backend(backend_name: str = None):
     backend_factory = _BACKENDS[backend_name]
 
     kwargs = {}
-    if backend_name == "disk_cache" and config.CACHE_DIR:
-        kwargs["cache_dir"] = config.CACHE_DIR
-    elif backend_name == "disk_cache_distributed" and config.CACHE_DIR:
-        kwargs["cache_dir"] = config.CACHE_DIR
-        if config.BACKEND_KWARGS:
-            kwargs.update(config.BACKEND_KWARGS)
-    elif backend_name == "datajoint" and config.BACKEND_KWARGS:
-        kwargs["cache_dir"] = config.CACHE_DIR
-        if config.BACKEND_KWARGS:
-            kwargs.update(config.BACKEND_KWARGS)
+    if backend_name == "disk_cache":
+        if config.CACHE_DIR:
+            kwargs["cache_dir"] = config.CACHE_DIR
+    elif backend_name == "disk_cache_distributed":
+        if config.CACHE_DIR:
+            kwargs["cache_dir"] = config.CACHE_DIR
+        kwargs.update(backend_kwargs)
+    elif backend_name == "datajoint":
+        if config.CACHE_DIR:
+            kwargs["cache_dir"] = config.CACHE_DIR
+        kwargs.update(backend_kwargs)
     return backend_factory(**kwargs)
 
 
+# backend factory
+def get_backend(backend_name: str = None, method: str = None, model_class=None):
+    """
+    Factory function to get a backend instance.
+
+    If backend_name is None, it uses the default from the global config.
+    """
+    from ituna import config
+
+    if backend_name is None:
+        backend_name, backend_kwargs = config.resolve_backend_route(
+            method=method,
+            model_class=model_class,
+        )
+    else:
+        backend_kwargs = copy.deepcopy(config.BACKEND_KWARGS)
+
+    return _build_backend(backend_name=backend_name, backend_kwargs=backend_kwargs)
+
+
 __all__ = [
     "get_backend",
     "Backend",
diff --git a/ituna/_backends/base.py b/ituna/_backends/base.py
index 109dbab..49f1aa7 100644
--- a/ituna/_backends/base.py
+++ b/ituna/_backends/base.py
@@ -46,6 +46,20 @@ def fit_models(
         """
         pass
 
+    def call_models(
+        self,
+        models: List[sklearn.base.BaseEstimator],
+        method_name: str,
+        *args,
+        **kwargs,
+    ) -> List:
+        """Call a method on each model and return outputs."""
+        outputs = []
+        for model in models:
+            method = getattr(model, method_name)
+            outputs.append(method(*args, **kwargs))
+        return outputs
+
 
 @typeguard.typechecked
 class DistributedComputationMixin(ABC):
diff --git a/ituna/_backends/datajoint.py b/ituna/_backends/datajoint.py
index a3377af..0ad7f9e 100644
--- a/ituna/_backends/datajoint.py
+++ b/ituna/_backends/datajoint.py
@@ -10,6 +10,7 @@
 from ituna import estimator
 from ituna._backends import base
 from ituna._backends import utils
+from ituna._cache_guard import suspend_global_cache_patch
 
 _DATAJOINT_IMPORTS_MISSING = []
 try:
@@ -644,7 +645,8 @@ def make(self, key, **kwargs):
                     # get model training entry
                     model, data_args, _ = ModelTrainingTable().get_model_training(key)
 
-                    trained_model = model.fit(*data_args.args, **data_args.kwargs)
+                    with suspend_global_cache_patch():
+                        trained_model = model.fit(*data_args.args, **data_args.kwargs)
 
                     trained_model_logs_abs = backend_self._trained_models_dir / f"{key['arg_hash']}"
                     print(
@@ -745,7 +747,8 @@ class EncoderTransformsResultsTable(dj.Computed):
                 def make(self, key, **kwargs):
                     """Compute the encoder transform results."""
                     trained_model, data = EncoderTransformsTable().get_encoder_transform(key)
-                    result = trained_model.transform(data)
+                    with suspend_global_cache_patch():
+                        result = trained_model.transform(data)
                     result_data_hash = DatasetTable().insert_data(result, skip_duplicates=True)
                     self.insert1(
                         dict(
diff --git a/ituna/_backends/disk_cache.py b/ituna/_backends/disk_cache.py
index 0cced43..71d6d25 100644
--- a/ituna/_backends/disk_cache.py
+++ b/ituna/_backends/disk_cache.py
@@ -3,6 +3,7 @@
 import traceback
 from typing import Any, List, Literal, Optional, Tuple, Union
 
+import numpy as np
 import pandas as pd
 import sklearn
 import sklearn.base
@@ -11,8 +12,8 @@
 from ituna import estimator
 from ituna import metrics
 from ituna._backends import base
-from ituna._backends import in_memory
 from ituna._backends import utils
+from ituna._cache_guard import suspend_global_cache_patch
 
 
 @typeguard.typechecked
@@ -25,6 +26,9 @@ def __init__(self, cache_dir: Union[str, pathlib.Path], **kwargs):
         self.trained_models_cache = self.cache_dir / "trained_models"
         self.trained_models_cache.mkdir(parents=True, exist_ok=True)
 
+        self.transform_cache = self.cache_dir / "transforms"
+        self.transform_cache.mkdir(parents=True, exist_ok=True)
+
     def _hash_model(self, model, model_id: Optional[int] = None):
         # Only pass model_id if model is non-deterministic
         kwargs = {}
@@ -52,6 +56,9 @@ def _retrieve_trained_model(self, model_data_hash: str) -> Optional[sklearn.base
             model = utils.load_model(model_path)
         except FileNotFoundError:
             model = None
+        if model is not None:
+            # store stable training identity for downstream cached transform calls
+            model._ituna_model_data_hash = model_data_hash
 
         return model
 
@@ -88,10 +95,6 @@ def fit_models(
         """
         Fit models in the queue.
         """
-        if any(isinstance(model, metrics.ConsistencyTransform) for model in models):
-            # fall back to in memory backend for anything that is not a ConsistencyEnsemble
-            return in_memory.InMemoryBackend().fit_models(models, *args, **kwargs)
-
         data = utils.DataArguments(*args, **kwargs)
         trained_models = []
         for i, model in enumerate(models):
@@ -100,13 +103,82 @@ def fit_models(
             # try retrieving model from cache
             trained_model = self._retrieve_trained_model(model_data_hash)
             if trained_model is None:
-                trained_model = model.fit(*data.args, **data.kwargs)
+                with suspend_global_cache_patch():
+                    trained_model = model.fit(*data.args, **data.kwargs)
                 self._store_trained_model(trained_model, data, model_data_hash=model_data_hash)
+            trained_model._ituna_model_data_hash = model_data_hash
 
             trained_models.append(trained_model)
 
         return trained_models
 
+    def _hash_method_call(
+        self,
+        model: sklearn.base.BaseEstimator,
+        method_name: str,
+        data: utils.DataArguments,
+        model_id: Optional[int] = None,
+    ) -> str:
+        model_data_hash = getattr(model, "_ituna_model_data_hash", None)
+        if model_data_hash is None:
+            model_data_hash = self._hash_model_data(model=model, data=data, model_id=model_id)
+        return utils.hash_str(f"{method_name}:{model_data_hash}:{data.hash}")
+
+    def _to_cache_payload(self, output: Any) -> Any:
+        if isinstance(output, np.ndarray) and output.__class__ is not np.ndarray:
+            # Preserve semantics for ndarray subclasses (e.g., PairwiseConsistencyArray)
+            # by falling back to uncached execution until dedicated serialization is added.
+            raise TypeError("Caching ndarray subclasses is not supported")
+        if np.isscalar(output):
+            return {"__ituna_scalar__": True, "value": output.item() if hasattr(output, "item") else output}
+        return output
+
+    def _from_cache_payload(self, payload: Any) -> Any:
+        if isinstance(payload, dict) and payload.get("__ituna_scalar__") is True:
+            return payload["value"]
+        return payload
+
+    def call_models(
+        self,
+        models: List[sklearn.base.BaseEstimator],
+        method_name: str,
+        *args,
+        **kwargs,
+    ) -> List[Any]:
+        data = utils.DataArguments(*args, **kwargs)
+        outputs = []
+        for i, model in enumerate(models):
+            method_hash = self._hash_method_call(
+                model=model,
+                method_name=method_name,
+                data=data,
+                model_id=i,
+            )
+            method_path = self.transform_cache / method_hash
+            try:
+                payload = utils.load_data(method_path)
+                output = self._from_cache_payload(payload)
+            except FileNotFoundError:
+                with suspend_global_cache_patch():
+                    output = getattr(model, method_name)(*data.args, **data.kwargs)
+                try:
+                    payload = self._to_cache_payload(output)
+                    utils.store_data(method_path, payload)
+                except TypeError:
+                    # Unsupported output type: execute without persisting.
+                    pass
+            outputs.append(output)
+        return outputs
+
+    def transform_models(
+        self,
+        models: List[sklearn.base.BaseEstimator],
+        *args,
+        **kwargs,
+    ) -> List[Any]:
+        """Transform data with per-model disk cache for transform outputs."""
+        return self.call_models(models, "transform", *args, **kwargs)
+
 
 @typeguard.typechecked
 class DiskCacheDistributedBackend(DiskCacheBackend, base.DistributedComputationMixin):
@@ -307,19 +379,35 @@ def fit_models(
         """
 
         if any(isinstance(model, metrics.ConsistencyTransform) for model in models):
-            # fall back to in memory backend for anything that is not a ConsistencyEnsemble
-            return in_memory.InMemoryBackend().fit_models(models, *args, **kwargs)
+            # Keep consistency transform fitting local while still using disk cache.
+            local_cache_backend = DiskCacheBackend(cache_dir=self.cache_dir)
+            return local_cache_backend.fit_models(models, *args, **kwargs)
 
         data = utils.DataArguments(*args, **kwargs)
+        model_data_hashes = [self._hash_model_data(model, data, model_id=i) for i, model in enumerate(models)]
+
+        # Fast path: every requested model is already trained.
+        # This avoids unnecessary sweep registration and model/data re-storage
+        # during cache-only collection reruns.
+        cached_only = all((self.trained_models_cache / model_data_hash).with_suffix(".pkl").exists() for model_data_hash in model_data_hashes)
+        if cached_only:
+            return [self._retrieve_trained_model(model_data_hash) for model_data_hash in model_data_hashes]
 
         # add data to cache
         data_hash, _ = self._store_data(data)
 
-        training_queue = {self._hash_model_data(model, data, model_id=i): model for i, model in enumerate(models)}
+        training_queue = [(i, model_data_hash, model) for i, (model_data_hash, model) in enumerate(zip(model_data_hashes, models))]
+        missing_queue = [
+            (i, model_data_hash, model)
+            for i, model_data_hash, model in training_queue
+            if not (self.trained_models_cache / model_data_hash).with_suffix(".pkl").exists()
+        ]
+        if not missing_queue:
+            return [self._retrieve_trained_model(model_data_hash) for model_data_hash in model_data_hashes]
 
         sweep_name = self._get_sweep_name()
 
-        for i, (model_data_hash, model) in enumerate(training_queue.items()):
+        for i, model_data_hash, model in missing_queue:
             model_hash, _ = self._store_model(model, model_id=i)
             self._add_to_sweep(
                 model_hash=model_hash,
@@ -331,9 +419,9 @@ def fit_models(
         self._trigger_sweep(sweep_name)
 
         # wait for sweep to finish
-        trained_models = self._collect_trained_models(sweep_name, list(training_queue.keys()))
+        self._collect_trained_models(sweep_name, [model_data_hash for _, model_data_hash, _ in missing_queue])
 
-        return trained_models
+        return [self._retrieve_trained_model(model_data_hash) for model_data_hash in model_data_hashes]
 
     def _get_sweep_status(
         self,
@@ -482,7 +570,8 @@ def fit_sweep_models(
                     raise ValueError(f"Data with hash {data_hash} not found in cache")
 
                 # Fit the model
-                trained_model = model.fit(*fit_data.args, **fit_data.kwargs)
+                with suspend_global_cache_patch():
+                    trained_model = model.fit(*fit_data.args, **fit_data.kwargs)
 
                 # Store trained model
                 self._store_trained_model(trained_model, fit_data, model_data_hash=model_data_hash)
diff --git a/ituna/_backends/in_memory.py b/ituna/_backends/in_memory.py
index e2105a1..658c925 100644
--- a/ituna/_backends/in_memory.py
+++ b/ituna/_backends/in_memory.py
@@ -3,6 +3,7 @@
 import sklearn.base
 
 from ituna._backends import base
+from ituna._cache_guard import suspend_global_cache_patch
 
 
 class InMemoryBackend(base.Backend):
@@ -17,11 +18,12 @@ def fit_models(
         """
         trained_models = []
         for model in models:
-            trained_models.append(
-                model.fit(
-                    *data_args,
-                    **fit_params,
+            with suspend_global_cache_patch():
+                trained_models.append(
+                    model.fit(
+                        *data_args,
+                        **fit_params,
+                    )
                 )
-            )
 
         return trained_models
diff --git a/ituna/_backends/utils.py b/ituna/_backends/utils.py
index 57b2432..e20787f 100644
--- a/ituna/_backends/utils.py
+++ b/ituna/_backends/utils.py
@@ -415,11 +415,16 @@ def load_model_pickle(
 
 
 @typeguard.typechecked
-def store_model(model_path: Union[str, Path], model: sklearn.base.BaseEstimator):
+def store_model(model_path: Union[str, Path], model: sklearn.base.BaseEstimator, overwrite: bool = False):
+    model_path = Path(model_path)
+    pkl_path = model_path.with_suffix(".pkl")
+    if pkl_path.exists() and not overwrite:
+        return
+
     if hasattr(model, "_estimator_factory"):
         model._estimator_factory.save(model_path, model)
         # store factory
-        store_model_pickle(model_path, model._estimator_factory)
+        store_model_pickle(model_path, model._estimator_factory, overwrite=overwrite)
         return
 
     # try default estimator factory
@@ -427,28 +432,31 @@ def store_model(model_path: Union[str, Path], model: sklearn.base.BaseEstimator)
         try:
             model_factory.save(model_path, model)
             # store factory
-            store_model_pickle(model_path, model_factory)
+            store_model_pickle(model_path, model_factory, overwrite=overwrite)
             return
         except UnsupportedEstimator:
             continue
         except Exception as factory_exception:
             # Try default pickle before re-raising the error
             try:
-                store_model_pickle(model_path, model)
+                store_model_pickle(model_path, model, overwrite=overwrite)
                 return
             except Exception as pickle_exception:
                 # Re-raise the original exception from the factory
                 raise pickle_exception from factory_exception
     # finally default to pickle
-    store_model_pickle(model_path, model)
+    store_model_pickle(model_path, model, overwrite=overwrite)
 
 
 @typeguard.typechecked
 def store_model_pickle(
     model_path: Union[str, Path],
     model: Union[sklearn.base.BaseEstimator, EstimatorFactory],
+    overwrite: bool = False,
 ):
     model_path = model_path.with_suffix(".pkl")
+    if model_path.exists() and not overwrite:
+        return
 
     with file_lock_context(model_path):
         joblib.dump(model, model_path)
diff --git a/ituna/_cache_guard.py b/ituna/_cache_guard.py
new file mode 100644
index 0000000..8b88867
--- /dev/null
+++ b/ituna/_cache_guard.py
@@ -0,0 +1,18 @@
+import contextlib
+import contextvars
+
+_PATCH_SUSPENDED = contextvars.ContextVar("ituna_patch_suspended", default=False)
+
+
+@contextlib.contextmanager
+def suspend_global_cache_patch():
+    """Temporarily suspend sklearn cache patch interception."""
+    token = _PATCH_SUSPENDED.set(True)
+    try:
+        yield
+    finally:
+        _PATCH_SUSPENDED.reset(token)
+
+
+def is_global_cache_patch_suspended() -> bool:
+    return _PATCH_SUSPENDED.get()
diff --git a/ituna/config.py b/ituna/config.py
index ee55131..3d2d226 100644
--- a/ituna/config.py
+++ b/ituna/config.py
@@ -7,10 +7,85 @@
 # The default backend to use. Can be 'in_memory', 'disk_cache', 'disk_cache_distributed', 'datajoint'.
 DEFAULT_BACKEND = "in_memory"
 BACKEND_KWARGS = dict()
+BACKEND_ROUTES = dict()
 CACHE_DIR = "backend_store"
 FILE_LOCK_TIMEOUT = 30  # in seconds
 
 
+def _class_to_path(model_class):
+    if model_class is None:
+        return None
+    if isinstance(model_class, str):
+        return model_class
+    return f"{model_class.__module__}.{model_class.__qualname__}"
+
+
+def _route_key(method=None, model_class=None):
+    return (method, _class_to_path(model_class))
+
+
+def _class_path_candidates(model_class):
+    """Return class path candidates from most specific to least specific."""
+    class_path = _class_to_path(model_class)
+    if class_path is None:
+        return [None]
+    if isinstance(model_class, str):
+        return [class_path]
+    candidates = []
+    for cls in model_class.__mro__:
+        if cls is object:
+            continue
+        candidates.append(_class_to_path(cls))
+    return candidates
+
+
+def register_backend_route(method=None, model_class=None, backend=None, backend_kwargs=None):
+    """Register a backend route override.
+
+    Routes are resolved by specificity in this order:
+    1. (method, model_class)
+    2. (method, None)
+    3. (None, model_class)
+    4. DEFAULT_BACKEND + BACKEND_KWARGS
+    """
+    key = _route_key(method=method, model_class=model_class)
+    route = {"backend": backend or DEFAULT_BACKEND}
+    if backend_kwargs is not None:
+        route["backend_kwargs"] = copy.deepcopy(backend_kwargs)
+    BACKEND_ROUTES[key] = route
+
+
+def remove_backend_route(method=None, model_class=None):
+    """Remove a backend route override if it exists."""
+    key = _route_key(method=method, model_class=model_class)
+    BACKEND_ROUTES.pop(key, None)
+
+
+def clear_backend_routes():
+    """Remove all backend route overrides."""
+    BACKEND_ROUTES.clear()
+
+
+def resolve_backend_route(method=None, model_class=None):
+    """Resolve backend name and kwargs for a method/class operation."""
+    class_candidates = _class_path_candidates(model_class)
+    route_candidates = []
+    for class_path in class_candidates:
+        route_candidates.append((method, class_path))
+    route_candidates.append((method, None))
+    for class_path in class_candidates:
+        route_candidates.append((None, class_path))
+    for key in route_candidates:
+        if key in BACKEND_ROUTES:
+            route = BACKEND_ROUTES[key]
+            backend_name = route.get("backend", DEFAULT_BACKEND)
+            route_kwargs = route.get("backend_kwargs", {})
+            resolved_kwargs = copy.deepcopy(BACKEND_KWARGS)
+            _deep_update(resolved_kwargs, route_kwargs)
+            return backend_name, resolved_kwargs
+    return DEFAULT_BACKEND, copy.deepcopy(BACKEND_KWARGS)
+
+
 def _deep_update(target_dict, update_dict):
     """Recursively update nested dictionaries.
 
diff --git a/ituna/estimator.py b/ituna/estimator.py
index 48efff0..6e5d9a4 100644
--- a/ituna/estimator.py
+++ b/ituna/estimator.py
@@ -111,8 +111,6 @@ def __init__(
         self.consistency_transform: metrics.ConsistencyTransform = consistency_transform
         self.random_states = random_states
 
-        self._backend: backends.Backend = backends.get_backend()
-
         base_params = estimator.get_params()
         non_deterministic = check_non_deterministic(estimator)
 
@@ -140,6 +138,14 @@ def _init_estimators(self) -> List[sklearn.base.BaseEstimator]:
             estimators.append(clone_with_seed(self.estimator, random_state))
         return estimators
 
+    @property
+    def _backend(self):
+        """Backward-compatible backend accessor.
+
+        Kept for private/test compatibility while backend selection is now resolved lazily.
+        """
+        return backends.get_backend()
+
     def __sklearn_tags__(self):
         # NOTE(ppommer): new way to specify tags (sklearn >= 1.6.dev)
         # Explicitly build the complete tag structure
@@ -193,14 +199,22 @@ def fit(self, *args, **kwargs):
             Returns the instance itself.
         """
 
-        self.estimators_: sklearn.base.TransformerMixin = self._backend.fit_models(
+        estimator_backend = backends.get_backend(
+            method="fit",
+            model_class=self.estimator.__class__,
+        )
+        self.estimators_: sklearn.base.TransformerMixin = estimator_backend.fit_models(
             self._init_estimators(),
             *args,
             **kwargs,
         )
 
         embeddings = self._transforms(*args[:1])
-        self.consistency_transform_ = self._backend.fit_models(
+        consistency_transform_backend = backends.get_backend(
+            method="fit",
+            model_class=self.consistency_transform.__class__,
+        )
+        self.consistency_transform_ = consistency_transform_backend.fit_models(
             [sklearn.base.clone(self.consistency_transform)],
             embeddings,
         )[0]
@@ -220,10 +234,11 @@ def _transforms(self, X) -> List[np.ndarray]:
         X_transformed : List[np.ndarray]
              List of n_estimators transformed data shaped (n_samples, n_features_out)
         """
-        results = []
-        for model in self.estimators_:
-            results.append(model.transform(X))
-        return results
+        transform_backend = backends.get_backend(
+            method="transform",
+            model_class=self.estimator.__class__,
+        )
+        return transform_backend.call_models(self.estimators_, "transform", X)
 
     def transform(self, X):
         """
diff --git a/ituna/sklearn.py b/ituna/sklearn.py
new file mode 100644
index 0000000..252529c
--- /dev/null
+++ b/ituna/sklearn.py
@@ -0,0 +1,171 @@
+import functools
+from types import MethodType
+from typing import Any, Dict, Iterable, Optional, Set, Tuple
+import warnings
+
+import sklearn.base
+
+from ituna import _backends as backends
+from ituna._cache_guard import is_global_cache_patch_suspended
+from ituna._cache_guard import suspend_global_cache_patch
+
+_PATCHED_METHODS: Dict[Tuple[type, str], Any] = {}
+_PATCHED_INSTANCE_METHODS: Dict[Tuple[int, str], Any] = {}
+
+
+def _resolve_methods(methods: Optional[Iterable[str]]) -> Set[str]:
+    resolved = set(methods or ["fit", "transform"])
+    unsupported = resolved.difference({"fit", "transform", "predict", "score"})
+    if unsupported:
+        raise ValueError(f"Unsupported patch methods: {sorted(unsupported)}. Supported methods are: ['fit', 'transform', 'predict', 'score']")
+    return resolved
+
+
+def _make_fit_instance_method(original_bound):
+    @functools.wraps(original_bound)
+    def patched(self, *args, **kwargs):
+        if is_global_cache_patch_suspended():
+            return original_bound(*args, **kwargs)
+        backend = backends.get_backend(method="fit", model_class=self.__class__)
+        with suspend_global_cache_patch():
+            fitted_model = backend.fit_models([self], *args, **kwargs)[0]
+        if fitted_model is not self:
+            self.__dict__.update(getattr(fitted_model, "__dict__", {}))
+        return self
+
+    return patched
+
+
+def _make_call_instance_method(method_name: str, original_bound):
+    @functools.wraps(original_bound)
+    def patched(self, *args, **kwargs):
+        if is_global_cache_patch_suspended():
+            return original_bound(*args, **kwargs)
+        backend = backends.get_backend(method=method_name, model_class=self.__class__)
+        with suspend_global_cache_patch():
+            return backend.call_models([self], method_name, *args, **kwargs)[0]
+
+    return patched
+
+
+def _patch_estimator_instance(estimator: sklearn.base.BaseEstimator, methods: Set[str]):
+    for method_name in methods:
+        if not hasattr(estimator, method_name):
+            raise ValueError(f"{estimator.__class__.__module__}.{estimator.__class__.__qualname__} does not implement {method_name}()")
+        key = (id(estimator), method_name)
+        if key in _PATCHED_INSTANCE_METHODS:
+            continue
+        original_bound = getattr(estimator, method_name)
+        _PATCHED_INSTANCE_METHODS[key] = original_bound
+        if method_name == "fit":
+            patched = _make_fit_instance_method(original_bound)
+        else:
+            patched = _make_call_instance_method(method_name, original_bound)
+        setattr(estimator, method_name, MethodType(patched, estimator))
+
+
+def cached(
+    estimator: sklearn.base.BaseEstimator,
+    methods: Optional[Iterable[str]] = None,
+):
+    """Patch an estimator instance in place to use iTuna caching routes."""
+    from ituna.estimator import check_non_deterministic
+
+    if check_non_deterministic(estimator):
+        warnings.warn(
+            "ituna.sklearn.cached() was called for an estimator marked as non-deterministic by sklearn tags. "
+            "Caching non-deterministic estimators may produce unintended side effects. Use with caution. "
+            "Use the ConsistencyEnsemble wrapper to safely train multiple non-deterministic estimators with caching.",
+            UserWarning,
+            stacklevel=2,
+        )
+    resolved_methods = _resolve_methods(methods)
+    _patch_estimator_instance(estimator, resolved_methods)
+    return estimator
+
+
+def _patch_fit_method(cls: type):
+    key = (cls, "fit")
+    if key in _PATCHED_METHODS:
+        return
+    if not hasattr(cls, "fit"):
+        raise ValueError(f"{cls.__module__}.{cls.__qualname__} does not implement fit()")
+
+    original = getattr(cls, "fit")
+    _PATCHED_METHODS[key] = original
+
+    @functools.wraps(original)
+    def patched_fit(self, *args, **kwargs):
+        if is_global_cache_patch_suspended():
+            return original(self, *args, **kwargs)
+
+        backend = backends.get_backend(method="fit", model_class=self.__class__)
+        with suspend_global_cache_patch():
+            fitted_model = backend.fit_models([self], *args, **kwargs)[0]
+        if fitted_model is not self:
+            self.__dict__.update(getattr(fitted_model, "__dict__", {}))
+        return self
+
+    setattr(cls, "fit", patched_fit)
+
+
+def _patch_call_method(cls: type, method_name: str):
+    key = (cls, method_name)
+    if key in _PATCHED_METHODS:
+        return
+    if not hasattr(cls, method_name):
+        raise ValueError(f"{cls.__module__}.{cls.__qualname__} does not implement {method_name}()")
+
+    original = getattr(cls, method_name)
+    _PATCHED_METHODS[key] = original
+
+    @functools.wraps(original)
+    def patched_call(self, *args, **kwargs):
+        if is_global_cache_patch_suspended():
+            return original(self, *args, **kwargs)
+
+        backend = backends.get_backend(method=method_name, model_class=self.__class__)
+        with suspend_global_cache_patch():
+            return backend.call_models([self], method_name, *args, **kwargs)[0]
+
+    setattr(cls, method_name, patched_call)
+
+
+def enable_global_cache(
+    model_classes: Iterable[type],
+    methods: Optional[Iterable[str]] = None,
+):
+    """Globally patch selected methods for selected sklearn classes."""
+    resolved_methods = _resolve_methods(methods)
+    for cls in model_classes:
+        for method_name in resolved_methods:
+            if method_name == "fit":
+                _patch_fit_method(cls)
+            else:
+                _patch_call_method(cls, method_name)
+
+
+def disable_global_cache(
+    model_classes: Optional[Iterable[type]] = None,
+    methods: Optional[Iterable[str]] = None,
+):
+    """Restore original sklearn methods for previously patched classes."""
+    resolved_methods = _resolve_methods(methods)
+    requested_classes = set(model_classes) if model_classes is not None else None
+
+    for (cls, method), original in list(_PATCHED_METHODS.items()):
+        if requested_classes is not None and cls not in requested_classes:
+            continue
+        if method not in resolved_methods:
+            continue
+        setattr(cls, method, original)
+        _PATCHED_METHODS.pop((cls, method), None)
+
+
+def get_global_cache_status() -> Dict[str, list]:
+    """Return current global patch state for debugging and UX introspection."""
+    status = {}
+    for cls, method in sorted(_PATCHED_METHODS.keys(), key=lambda x: (x[0].__module__, x[0].__qualname__, x[1])):
+        class_path = f"{cls.__module__}.{cls.__qualname__}"
+        status.setdefault(class_path, []).append(method)
+    return status
diff --git a/jupytext.toml b/jupytext.toml
new file mode 100644
index 0000000..27aee39
--- /dev/null
+++ b/jupytext.toml
@@ -0,0 +1,5 @@
+formats = "ipynb,py:percent"
+
+# Keep notebooks stable across environments, but preserve useful metadata.
+notebook_metadata_filter = "kernelspec,language_info,jupytext"
+cell_metadata_filter = "tags"
diff --git a/pyproject.toml b/pyproject.toml
index f8063f9..3d0d2f8 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -47,7 +47,7 @@ dev = [
     "pre-commit>=3.0",
     "cebra>=0.4.0",
     "ruff",
-     # Cebra requires pkg_resources, which is part of setuptools. 
+     # Cebra requires pkg_resources, which is part of setuptools.
      # However, setuptools is not always installed by default anymore, so we need it here
     "setuptools",
 ]
@@ -55,6 +55,7 @@ docs = [
     "matplotlib",
     "cebra[datasets,demos]>=0.4.0",
     "jupyter-book<2",
+    "jupytext",
     "ghp-import",
 ]
 dashboard = [
diff --git a/requirements-docs.txt b/requirements-docs.txt
index 417bc5a..a6a86e4 100644
--- a/requirements-docs.txt
+++ b/requirements-docs.txt
@@ -2,5 +2,6 @@ numpy
 matplotlib
 umap-learn
 cebra[datasets,demos]
+jupytext
 ituna[datajoint]
 third_party/dj_ml_core-0.2.4-py3-none-any.whl
diff --git a/ruff.toml b/ruff.toml
index 9dcdd40..caf55af 100644
--- a/ruff.toml
+++ b/ruff.toml
@@ -7,6 +7,7 @@ line-length = 160
 # Exclude a variety of commonly ignored directories.
 exclude = [
     "**/*.ipynb",
+    "docs/**",
     ".bzr",
     ".direnv",
     ".eggs",
diff --git a/tests/test_backend_routing.py b/tests/test_backend_routing.py
new file mode 100644
index 0000000..77f7d1f
--- /dev/null
+++ b/tests/test_backend_routing.py
@@ -0,0 +1,210 @@
+from pathlib import Path
+import subprocess
+import tempfile
+import threading
+import time
+import warnings
+
+import numpy as np
+import pytest
+from sklearn.decomposition import FastICA
+from sklearn.decomposition import PCA
+
+import ituna
+from ituna import config
+from ituna import metrics
+
+
+def test_backend_route_specificity_resolution():
+    with tempfile.TemporaryDirectory() as tmpdir:
+        cache_dir = Path(tmpdir)
+        with config.config_context(
+            DEFAULT_BACKEND="in_memory",
+            CACHE_DIR=cache_dir,
+            BACKEND_KWARGS={},
+            BACKEND_ROUTES={},
+        ):
+            config.register_backend_route(method="fit", backend="disk_cache")
+            config.register_backend_route(model_class=metrics.ConsistencyTransform, backend="disk_cache_distributed", backend_kwargs={"trigger_type": "manual"})
+            config.register_backend_route(method="fit", model_class=metrics.ConsistencyTransform, backend="datajoint", backend_kwargs={"schema_name": "x"})
+
+            backend_name, kwargs = config.resolve_backend_route(method="fit", model_class=metrics.PairwiseConsistency)
+            assert backend_name == "datajoint"
+            assert kwargs["schema_name"] == "x"
+
+            backend_name, kwargs = config.resolve_backend_route(method="fit", model_class=PCA)
+            assert backend_name == "disk_cache"
+            assert kwargs == {}
+
+            backend_name, kwargs = config.resolve_backend_route(method="score", model_class=metrics.PairwiseConsistency)
+            assert backend_name == "disk_cache_distributed"
+            assert kwargs["trigger_type"] == "manual"
+
+
+def test_consistency_transform_fit_route_is_cached_with_disk_cache(ica_data):
+    with tempfile.TemporaryDirectory() as tmpdir:
+        cache_dir = Path(tmpdir)
+        with config.config_context(
+            DEFAULT_BACKEND="in_memory",
+            CACHE_DIR=cache_dir,
+            BACKEND_KWARGS={},
+            BACKEND_ROUTES={},
+        ):
+            config.register_backend_route(
+                method="fit",
+                model_class=metrics.ConsistencyTransform,
+                backend="disk_cache",
+            )
+
+            ensemble = ituna.ConsistencyEnsemble(
+                estimator=PCA(n_components=3, random_state=42),
+                consistency_transform=metrics.PairwiseConsistency(
+                    indeterminacy=metrics.Linear(),
+                    symmetric=False,
+                    include_diagonal=True,
+                ),
+                random_states=[0, 1],
+            )
+            ensemble.fit(ica_data)
+
+            cached_files = list((cache_dir / "trained_models").glob("*.pkl"))
+            # Base estimators were in-memory, but consistency transform should be cached.
+            assert len(cached_files) == 1
+
+
+def test_transform_calls_are_cached_in_disk_cache_backend(ica_data):
+    with tempfile.TemporaryDirectory() as tmpdir:
+        cache_dir = Path(tmpdir)
+        with config.config_context(
+            DEFAULT_BACKEND="disk_cache",
+            CACHE_DIR=cache_dir,
+            BACKEND_KWARGS={},
+            BACKEND_ROUTES={},
+        ):
+            ensemble = ituna.ConsistencyEnsemble(
+                estimator=PCA(n_components=3, random_state=42),
+                consistency_transform=metrics.PairwiseConsistency(
+                    indeterminacy=metrics.Linear(),
+                    symmetric=False,
+                    include_diagonal=True,
+                ),
+                random_states=[0, 1, 2],
+            )
+            ensemble.fit(ica_data)
+
+            transform_cache_files_before = list((cache_dir / "transforms").glob("*"))
+            assert len(transform_cache_files_before) >= len(ensemble.estimators_)
+
+            # If transforms are recomputed instead of loaded from cache, this will crash.
+            for estimator_model in ensemble.estimators_:
+                estimator_model.transform = lambda X: (_ for _ in ()).throw(RuntimeError("transform recomputed"))
+
+            cached_results = ensemble._transforms(ica_data)
+            assert len(cached_results) == len(ensemble.estimators_)
+            assert all(isinstance(result, np.ndarray) for result in cached_results)
+
+
+def _run_manual_worker(cache_dir: Path, sweep_name: str, poll_interval: float = 0.1, timeout: float = 10.0):
+    """Poll for the sweep file and run the distributed worker command."""
+    sweep_file = cache_dir / "sweep_data" / f"{sweep_name}.csv"
+    start_time = time.time()
+
+    while not sweep_file.exists():
+        if time.time() - start_time > timeout:
+            raise TimeoutError(f"Sweep file {sweep_file} did not appear within {timeout} seconds.")
+        time.sleep(poll_interval)
+
+    cmd = [
+        "ituna-fit-distributed",
+        "--sweep-name",
+        sweep_name,
+        "--cache-dir",
+        str(cache_dir.resolve()),
+        "--order-by",
+        "random",
+    ]
+    result = subprocess.run(cmd, capture_output=True, text=True, check=False)
+    if result.returncode != 0:
+        print("Manual worker command failed.")
+        print("stdout:", result.stdout)
+        print("stderr:", result.stderr)
+        result.check_returncode()
+
+
+@pytest.mark.parametrize("estimator_cls", [FastICA, PCA])
+def test_tutorial_route_pattern_distributed_fit_disk_cache_transforms(ica_data, estimator_cls):
+    """Integration test mirroring tutorial route-registration workflow."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        cache_dir = Path(tmpdir)
+        sweep_name = "tutorial_route_pattern"
+        with config.config_context(
+            DEFAULT_BACKEND="disk_cache_distributed",
+            CACHE_DIR=cache_dir,
+            BACKEND_KWARGS={
+                "trigger_type": "manual",
+                "sweep_type": "constant",
+                "sweep_name": sweep_name,
+                "fit_time_out": 60,
+            },
+            BACKEND_ROUTES={},
+        ):
+            config.register_backend_route(
+                method="fit",
+                model_class=metrics.ConsistencyTransform,
+                backend="disk_cache",
+            )
+            config.register_backend_route(
+                method="transform",
+                model_class=estimator_cls,
+                backend="disk_cache",
+            )
+
+            if estimator_cls == FastICA:
+                estimator = FastICA(n_components=3, random_state=42, max_iter=200)
+            else:
+                estimator = PCA(n_components=3, random_state=42)
+
+            ensemble = ituna.ConsistencyEnsemble(
+                estimator=estimator,
+                consistency_transform=metrics.PairwiseConsistency(
+                    indeterminacy=metrics.Permutation(),
+                    symmetric=False,
+                    include_diagonal=True,
+                ),
+                random_states=2,
+            )
+
+            worker_thread = threading.Thread(
+                target=_run_manual_worker,
+                args=(cache_dir, sweep_name),
+            )
+            worker_thread.start()
+
+            with warnings.catch_warnings():
+                if estimator_cls == FastICA:
+                    warnings.filterwarnings(
+                        "ignore",
+                        category=UserWarning,
+                        module="sklearn.decomposition._fastica",
+                    )
+                ensemble.fit(ica_data)
+                _ = ensemble.score(ica_data)
+                _ = ensemble.transform(ica_data)
+
+            worker_thread.join()
+
+            # Estimator fits (2) + consistency transform fit (1) should be cached.
+            trained_model_files = list((cache_dir / "trained_models").glob("*.pkl"))
+            assert len(trained_model_files) == 3
+
+            # ConsistencyTransform fit should not be part of the distributed sweep.
+            sweep_csv = cache_dir / "sweep_data" / f"{sweep_name}.csv"
+            assert sweep_csv.exists()
+            with open(sweep_csv, "r", encoding="utf-8") as f:
+                line_count = len([line for line in f if line.strip()])
+            # header + two estimator entries
+            assert line_count == 3
+
+            # Transform caching route should create transform cache files.
+            transform_cache_files = list((cache_dir / "transforms").glob("*"))
+            assert len(transform_cache_files) >= len(ensemble.estimators_)
diff --git a/tests/test_diskcache.py b/tests/test_diskcache.py
index 4c27096..cf94261 100644
--- a/tests/test_diskcache.py
+++ b/tests/test_diskcache.py
@@ -56,7 +56,8 @@ def test_disk_cache_backend(ica_data, estimator_cls):
             model_cache_dir = cache_dir / "trained_models"
             assert model_cache_dir.exists()
             cached_files = list(model_cache_dir.glob("*.pkl"))
-            assert len(cached_files) == len(ensemble.random_states)
+            # +1 for cached consistency transform
+            assert len(cached_files) == len(ensemble.random_states) + 1
 
             # Second fit, should load from cache
             if estimator_cls == FastICA:
diff --git a/tests/test_diskcache_distributed.py b/tests/test_diskcache_distributed.py
index 87e81f9..1561399 100644
--- a/tests/test_diskcache_distributed.py
+++ b/tests/test_diskcache_distributed.py
@@ -14,6 +14,8 @@
 import ituna
 from ituna import config
 from ituna import metrics
+from ituna._backends.disk_cache import DiskCacheBackend
+from ituna._backends.disk_cache import DiskCacheDistributedBackend
 
 
 def get_estimator(estimator_cls):
@@ -95,7 +97,8 @@ def test_multi_process(ica_data, estimator_cls):
             model_cache_dir = cache_dir / "trained_models"
             assert model_cache_dir.exists()
             cached_files = list(model_cache_dir.glob("*.pkl"))
-            assert len(cached_files) == ensemble.random_states
+            # +1 for cached consistency transform
+            assert len(cached_files) == ensemble.random_states + 1
 
             estimator2 = get_estimator(estimator_cls)
 
@@ -223,7 +226,8 @@ def test_manual_trigger(ica_data, estimator_cls):
             model_cache_dir = cache_dir / "trained_models"
             assert model_cache_dir.exists()
             cached_files = list(model_cache_dir.glob("*.pkl"))
-            assert len(cached_files) == ensemble.random_states
+            # +1 for cached consistency transform
+            assert len(cached_files) == ensemble.random_states + 1
 
             estimator2 = get_estimator(estimator_cls)
 
@@ -251,3 +255,37 @@ def test_manual_trigger(ica_data, estimator_cls):
             np.testing.assert_allclose(score1, score2)
             np.testing.assert_allclose(transform1, transform2)
             assert isinstance(score1, (int, float, np.number))
+
+
+def test_distributed_fast_path_skips_sweep_when_all_models_already_cached(ica_data, monkeypatch):
+    with tempfile.TemporaryDirectory() as tmpdir:
+        cache_dir = Path(tmpdir)
+
+        def make_models():
+            return [
+                PCA(n_components=3, random_state=0),
+                PCA(n_components=3, random_state=1),
+            ]
+
+        local_backend = DiskCacheBackend(cache_dir=cache_dir)
+        local_backend.fit_models(make_models(), ica_data)
+
+        distributed_backend = DiskCacheDistributedBackend(
+            cache_dir=cache_dir,
+            trigger_type="manual",
+            sweep_type="constant",
+            sweep_name="fast_path_test",
+            fit_time_out=1,
+        )
+
+        def should_not_run(*args, **kwargs):
+            raise AssertionError("distributed sweep registration should be skipped on full cache hit")
+
+        monkeypatch.setattr(distributed_backend, "_store_model", should_not_run)
+        monkeypatch.setattr(distributed_backend, "_add_to_sweep", should_not_run)
+        monkeypatch.setattr(distributed_backend, "_trigger_sweep", should_not_run)
+
+        trained_models = distributed_backend.fit_models(make_models(), ica_data)
+        assert len(trained_models) == 2
+        assert all(model is not None for model in trained_models)
+        assert not (cache_dir / "sweep_data" / "fast_path_test.csv").exists()
diff --git a/tests/test_sklearn_cache_wrapper.py b/tests/test_sklearn_cache_wrapper.py
new file mode 100644
index 0000000..727f4c8
--- /dev/null
+++ b/tests/test_sklearn_cache_wrapper.py
@@ -0,0 +1,246 @@
+from pathlib import Path
+import tempfile
+import warnings
+
+import numpy as np
+import pytest
+from sklearn.decomposition import PCA
+from sklearn.linear_model import LinearRegression
+from sklearn.utils.estimator_checks import check_estimator
+
+import ituna
+from ituna import metrics
+import ituna.estimator
+
+
+def test_cached_local_patch_preserves_estimator_type(ica_data):
+    estimator = PCA(n_components=3, random_state=42)
+    patched = ituna.sklearn.cached(estimator)
+    assert patched is estimator
+    assert isinstance(patched, PCA)
+    patched.fit(ica_data)
+
+
+def test_cached_local_patch_fit_uses_route_outside_ensemble(ica_data, monkeypatch):
+    with tempfile.TemporaryDirectory() as tmpdir:
+        cache_dir = Path(tmpdir)
+        with ituna.config.config_context(
+            DEFAULT_BACKEND="in_memory",
+            CACHE_DIR=cache_dir,
+            BACKEND_KWARGS={},
+            BACKEND_ROUTES={},
+        ):
+            ituna.config.register_backend_route(
+                method="fit",
+                model_class=PCA,
+                backend="disk_cache",
+            )
+
+            patched = ituna.sklearn.cached(PCA(n_components=3, random_state=42), methods=["fit"])
+            patched.fit(ica_data)
+            assert len(list((cache_dir / "trained_models").glob("*.pkl"))) == 1
+
+            # If cache misses on second local fit, this patched method would crash.
+            monkeypatch.setattr(PCA, "fit", lambda *a, **k: (_ for _ in ()).throw(RuntimeError("fit recomputed")))
+            patched_again = ituna.sklearn.cached(PCA(n_components=3, random_state=42), methods=["fit"])
+            patched_again.fit(ica_data)
+
+
+def test_cached_local_patch_transform_uses_disk_cache(ica_data):
+    with tempfile.TemporaryDirectory() as tmpdir:
+        cache_dir = Path(tmpdir)
+        with ituna.config.config_context(
+            DEFAULT_BACKEND="disk_cache",
+            CACHE_DIR=cache_dir,
+            BACKEND_KWARGS={},
+            BACKEND_ROUTES={},
+        ):
+            patched = ituna.sklearn.cached(PCA(n_components=3, random_state=42), methods=["fit", "transform"])
+            patched.fit(ica_data)
+            first = patched.transform(ica_data)
+            assert len(list((cache_dir / "transforms").glob("*"))) >= 1
+
+            second = ituna.sklearn.cached(PCA(n_components=3, random_state=42), methods=["fit", "transform"]).fit(ica_data).transform(ica_data)
+            np.testing.assert_allclose(first, second)
+
+
+def test_enable_global_cache_for_regular_sklearn_usage(ica_data):
+    with tempfile.TemporaryDirectory() as tmpdir:
+        cache_dir = Path(tmpdir)
+        with ituna.config.config_context(
+            DEFAULT_BACKEND="disk_cache",
+            CACHE_DIR=cache_dir,
+            BACKEND_KWARGS={},
+            BACKEND_ROUTES={},
+        ):
+            ituna.config.register_backend_route(method="fit", model_class=PCA, backend="disk_cache")
+            ituna.config.register_backend_route(method="transform", model_class=PCA, backend="disk_cache")
+
+            ituna.sklearn.enable_global_cache([PCA], methods=["fit", "transform"])
+            try:
+                status = ituna.sklearn.get_global_cache_status()
+                pca_key = f"{PCA.__module__}.{PCA.__qualname__}"
+                assert sorted(status[pca_key]) == ["fit", "transform"]
+
+                pca = PCA(n_components=3, random_state=42)
+                pca.fit(ica_data)
+                transformed = pca.transform(ica_data)
+                assert transformed.shape[0] == ica_data.shape[0]
+                assert len(list((cache_dir / "trained_models").glob("*.pkl"))) == 1
+                assert len(list((cache_dir / "transforms").glob("*"))) >= 1
+            finally:
+                ituna.sklearn.disable_global_cache([PCA], methods=["fit", "transform"])
+
+            assert ituna.sklearn.get_global_cache_status() == {}
+
+
+def test_global_patch_predict_and_score_cache():
+    rng = np.random.RandomState(0)
+    X = rng.randn(120, 4)
+    y = X @ np.array([0.5, -1.2, 2.0, 0.3]) + 0.1 * rng.randn(120)
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        cache_dir = Path(tmpdir)
+        with ituna.config.config_context(
+            DEFAULT_BACKEND="disk_cache",
+            CACHE_DIR=cache_dir,
+            BACKEND_KWARGS={},
+            BACKEND_ROUTES={},
+        ):
+            ituna.config.register_backend_route(method="fit", model_class=LinearRegression, backend="disk_cache")
+            ituna.config.register_backend_route(method="predict", model_class=LinearRegression, backend="disk_cache")
+            ituna.config.register_backend_route(method="score", model_class=LinearRegression, backend="disk_cache")
+
+            ituna.sklearn.enable_global_cache([LinearRegression], methods=["fit", "predict", "score"])
+            try:
+                model = LinearRegression()
+                model.fit(X, y)
+                preds = model.predict(X)
+                score_val = model.score(X, y)
+                assert preds.shape[0] == X.shape[0]
+                assert isinstance(score_val, float)
+                assert len(list((cache_dir / "transforms").glob("*"))) >= 2
+            finally:
+                ituna.sklearn.disable_global_cache([LinearRegression], methods=["fit", "predict", "score"])
+
+
+def test_global_patch_does_not_recache_internal_indeterminacy_models(ica_data):
+    with tempfile.TemporaryDirectory() as tmpdir:
+        cache_dir = Path(tmpdir)
+        with ituna.config.config_context(
+            DEFAULT_BACKEND="disk_cache",
+            CACHE_DIR=cache_dir,
+            BACKEND_KWARGS={},
+            BACKEND_ROUTES={},
+        ):
+            ituna.config.register_backend_route(method="fit", model_class=LinearRegression, backend="disk_cache")
+            ituna.sklearn.enable_global_cache([LinearRegression], methods=["fit"])
+            try:
+                ensemble = ituna.ConsistencyEnsemble(
+                    estimator=PCA(n_components=3, random_state=42),
+                    consistency_transform=metrics.PairwiseConsistency(
+                        indeterminacy=metrics.Linear(),
+                        symmetric=False,
+                        include_diagonal=True,
+                    ),
+                    random_states=2,
+                )
+                ensemble.fit(ica_data)
+                cached_files = list((cache_dir / "trained_models").glob("*.pkl"))
+                # 2 estimator fits + 1 consistency transform fit; internal indeterminacy fits should not be globally recached.
+                assert len(cached_files) == 3
+            finally:
+                ituna.sklearn.disable_global_cache([LinearRegression], methods=["fit"])
+
+
+def test_sklearn_check_estimator_with_local_cached_patch():
+    estimator = ituna.sklearn.cached(PCA(n_components=2, random_state=0), methods=["fit", "transform"])
+    check_estimator(estimator)
+
+
+def test_cached_warns_for_non_deterministic_estimators(monkeypatch):
+    monkeypatch.setattr(ituna.estimator, "check_non_deterministic", lambda _estimator: True)
+    with pytest.warns(UserWarning, match="non-deterministic"):
+        ituna.sklearn.cached(PCA(n_components=2, random_state=0), methods=["fit"])
+
+
+def test_cached_does_not_warn_for_deterministic_estimators(monkeypatch):
+    monkeypatch.setattr(ituna.estimator, "check_non_deterministic", lambda _estimator: False)
+    with warnings.catch_warnings(record=True) as record:
+        warnings.simplefilter("always")
+        ituna.sklearn.cached(PCA(n_components=2, random_state=0), methods=["fit"])
+    assert len(record) == 0
+
+
+def test_cached_consistency_ensemble_mixed_backend_route_fit_cache(ica_data, monkeypatch):
+    with tempfile.TemporaryDirectory() as tmpdir:
+        cache_dir = Path(tmpdir)
+        with ituna.config.config_context(
+            DEFAULT_BACKEND="in_memory",
+            CACHE_DIR=cache_dir,
+            BACKEND_KWARGS={},
+            BACKEND_ROUTES={},
+        ):
+            ituna.config.register_backend_route(
+                method="fit",
+                model_class=ituna.ConsistencyEnsemble,
+                backend="disk_cache",
+            )
+
+            ensemble = ituna.ConsistencyEnsemble(
+                estimator=PCA(n_components=3, random_state=42),
+                consistency_transform=metrics.PairwiseConsistency(
+                    indeterminacy=metrics.Linear(),
+                    symmetric=False,
+                    include_diagonal=True,
+                ),
+                random_states=2,
+            )
+            cached_ensemble = ituna.sklearn.cached(ensemble, methods=["fit"])
+            cached_ensemble.fit(ica_data)
+            assert len(list((cache_dir / "trained_models").glob("*.pkl"))) == 1
+
+            monkeypatch.setattr(
+                ituna.ConsistencyEnsemble,
+                "fit",
+                lambda *a, **k: (_ for _ in ()).throw(RuntimeError("ensemble fit recomputed")),
+            )
+            second = ituna.sklearn.cached(
+                ituna.ConsistencyEnsemble(
+                    estimator=PCA(n_components=3, random_state=42),
+                    consistency_transform=metrics.PairwiseConsistency(
+                        indeterminacy=metrics.Linear(),
+                        symmetric=False,
+                        include_diagonal=True,
+                    ),
+                    random_states=2,
+                ),
+                methods=["fit"],
+            )
+            second.fit(ica_data)
+
+
+def test_cached_consistency_ensemble_disk_cache_for_outer_and_inner_fit(ica_data):
+    with tempfile.TemporaryDirectory() as tmpdir:
+        cache_dir = Path(tmpdir)
+        with ituna.config.config_context(
+            DEFAULT_BACKEND="disk_cache",
+            CACHE_DIR=cache_dir,
+            BACKEND_KWARGS={},
+            BACKEND_ROUTES={},
+        ):
+            ensemble = ituna.ConsistencyEnsemble(
+                estimator=PCA(n_components=3, random_state=42),
+                consistency_transform=metrics.PairwiseConsistency(
+                    indeterminacy=metrics.Linear(),
+                    symmetric=False,
+                    include_diagonal=True,
+                ),
+                random_states=2,
+            )
+            cached_ensemble = ituna.sklearn.cached(ensemble, methods=["fit"])
+            cached_ensemble.fit(ica_data)
+            assert len(list((cache_dir / "trained_models").glob("*.pkl"))) >= 1
+
+            transformed = cached_ensemble.transform(ica_data)
+            assert isinstance(transformed, metrics.PairwiseConsistencyArray)