| --- |
| title: The Clutch |
| emoji: 🔌 |
| colorFrom: green |
| colorTo: gray |
| sdk: gradio |
| sdk_version: 6.19.0 |
| app_file: app.py |
| pinned: false |
| license: mit |
| short_description: Spend expensive compute only when reality drifts. |
| --- |
| |
| # 🔌 The Clutch — *spend expensive compute only when reality drifts* |
|
|
| A **substrate-agnostic dual-process controller**, distilled from Antti Luode's Loom |
| Navigator to its one reusable idea, then given a live demo you can *watch*. |
|
|
| > Run a **cheap cached policy** by default. Only pay for an **expensive planner** when a |
| > *surprise* signal trips a **gate**. When things go calm, **latch** the fresh plan back |
| > into the cache. |
|
|
| `clutch.py` is ~120 lines, has **no dependencies**, and makes **no assumption about what |
| the substrates are**. You hand it three callbacks — a cheap cached step, an expensive |
| planner, and a scalar error signal — and pick a gate. That is the whole interface. |
|
|
| ## What the Space shows |
|
|
| 0. **Tune it on YOUR data** — the tool, not the demo. Paste or upload any 1-D time |
| series (latency metric, sensor stream, price feed). The Space runs the real |
| closed-loop clutch on it, sweeps ~80 gate configs, plots the accuracy-vs-compute |
| Pareto frontier, and returns a **copy-paste `Clutch(...)` config tuned to your data** |
| plus a dollar-savings estimate. If gating doesn't pay on your series, it says so. |
| 1. **Watch it navigate** — an agent patrols A↔B on a 60×60 grid while walls with a gap |
| drop at scripted times, breaking its cached route. Every maze is *guaranteed solvable* |
| (schedules that would disconnect A–B are rejected), so the outcome reflects the gate, |
| not luck. You see, frame by frame, when the gate keeps the cheap habit (green) and when |
| it trips and pays for a fresh plan (red), with the compute counter running against |
| replan-every-step. |
| 2. **Same clutch, different world** — the *identical* `Clutch` class forecasts a streaming |
| signal with abrupt regime changes, refitting a model **only when prediction error trips |
| the gate**. This is concept-drift-gated retraining; only the three callbacks changed. |
| 3. **The honest benchmark** — reproduce the multi-seed measurement in-browser. Compute is |
| counted honestly (BFS cells expanded / training samples fit). |
| 4. **What this is / where it's valuable** — the LLM-agent-loop framing (the expensive call |
| is a token-billed re-plan) with drop-in code, plus the honest negative result. |
|
|
| ## Headline numbers (reproducible in tab 3) |
|
|
| Grid navigation, 16 seeds, patrol ×3, no sensor noise: |
|
|
| | strategy | success | BFS expanded | plan calls | vs replan-all | |
| |---|---:|---:|---:|---:| |
| | ALWAYS_COGNITIVE | 94% | 227,309 | 250.8 | 100.0% | |
| | ALWAYS_HABITUAL | 0% | 2,221 | 1.0 | brittle | |
| | **CLUTCH (leaky integrator)** | **100%** | **8,100** | **3.4** | **3.6%** | |
|
|
| The clutch hits the goal *more reliably than replanning every step* (100% vs 94% — |
| constant replanning occasionally lets a wall seal the agent mid-corridor) while spending |
| **~1/28th the compute**. |
|
|
| ## The honest negative result |
|
|
| The **accelerometer / jerk gate** (2nd-derivative of error, the Park–Cohen framing) is |
| *not* a free lunch. Under sensor noise it fires ~1.7× more than the leaky integrator and |
| burns ~50% more compute for the same success; on the drift task it *under*-fires and |
| fails. Across both substrates the plain **leaky integrator is the better engine here.** |
| The derivative gate's edge would show on tasks needing *fast* reaction to abrupt change — |
| which neither of these stresses. Stated, not hidden. |
|
|
| ## Files |
|
|
| - `clutch.py` — the controller + gates. Drop-in, zero deps. |
| - `nav.py` — grid-navigation substrate (frame capture + benchmark). |
| - `drift.py` — concept-drift substrate driving the *same* `Clutch`. |
| - `viz.py` — matplotlib rendering (animation + plots). |
| - `tuner.py` — the bring-your-own-data gate tuner (parse → sweep → Pareto → config). |
| - `app.py` — the Gradio Space. |
| - `benchmark_orig.py` — the original headless benchmark. Run: `python3 benchmark_orig.py`. |
|
|
| Built on `clutch.py` / `benchmark.py` by Antti Luode (PerceptionLab). *Do not hype. Do |
| not lie. Just show.* |
|
|
