**Note** from Bead: Paving The Cowpath · [canonical source](https://redfish.acequia.io/guerin/.agents/43d0d033-130e-4f97-9177-f1b3f04be9a1/2026-06-22/notes/00-paving-the-cowpath.md) · session 2026-06-22 · discussion: Talk: Paving The Cowpath
**Bead:** `43d0d033` (`paving-the-cowpath`) · Opened 2026-06-22 · for Stephen **Trigger (verbatim):** > *"this captures the idea that once a desire line computational workflow path builds up via AI > processing, paving is reducing that path to .mjs and algorithms like computer vision and local > transformer.js that doesn't require heavy weight centralized foundational models with access tokens. > I also use the phrase with Josh (Redfish/Simtable CTO), 'roads are where cars flow'. meaning don't > reify the routes. routes/paths emerge based on enabling constraints of the authorization and > authentication. Currently defined by tokens and acequia-access.json (which will increase in > expressiveness like .htaccess)."* Sibling of acequia-component (`1697e2ae`, the desire-line / dissolution thread) and downstream of bead-orchestrator note 01 (the steady-state tick is a deterministic `step.mjs`, no model SDK) and the cognition ladder of bead-as-webdav-handler (`fe7fbaf5`).
## 1. The idea in one line A **desire line** is a computational workflow path that an agent *discovers* by expensive AI processing (cloud foundational model, tokens, latency). **Paving** is reducing that proven path to a cheap, deterministic **`.mjs` + classical/local algorithms** (computer vision, local `transformer.js`) that needs **no centralized foundational model and no access tokens**. Pave a path *after* traffic proves it, never before.
## 2. Reclaiming the phrase "Paving the cowpath" is normally an insult in business-process reengineering: automating a bad inherited process instead of fixing it. We **invert it on purpose**, because the path being paved here is not an arbitrary inherited route — it is a **desire line**: an emergent, least-action path carved by *actual repeated traffic*. The cow (the agent) already found the efficient route; paving just hardens what use has already validated. The discipline is exactly the BPR warning read backwards: *only* pave a path that real traffic carved. Paving an imagined route = reifying a road with no cars = the dead-end (acequia-component note 01).
## 3. "Roads are where cars flow" (Josh) — don't reify the routes The route is **not designed up front**; it **emerges** from where flow is *permitted and repeated*. What permits flow is the **enabling constraints of authn/authz** — currently **tokens** + **`acequia-access.json`** (the per-resource sidecar, which will grow in expressiveness toward `.htaccess`). So: - The **gates** (capabilities, ACLs) are specified. The **roads** are not — they are the worn-in record of where authorized flow actually went. - This is the same anti-reification stance as acequia-component: specify the riverbed and the gates, let the channels carve. A road is a paved desire line; a desire line is repeated authorized flow.
## 4. Paving = descending the cognition ladder The cognition ladder (handler bead `fe7fbaf5`): `deterministic → local LLM → distilled-from-corpus → cloud`. **Escalation** climbs it (novelty → cloud). **Paving climbs back down**: once a path's behavior is clear and stable, compile it to the lowest rung that still works. | Stage | Cost | Dependency | Where | |---|---|---|---| | **Discover** the path | high (tokens, latency) | centralized foundational model | cloud, BYOK | | **Distill** the pattern | one-time | model authors the artifact | escalation queue → skill | | **Pave** to rung 0 | ~free, keyless | none (CV / local transformer.js / `.mjs`) | runs anywhere, offline | This is JIT-compiling the hot path / a materialized view / memoization, applied to **cognition**: pay the expensive model *once* to discover the route, then run it forever cheap, local, and **keyless**. It is the concrete mechanism behind bead-orchestrator note 01's claim that the steady-state tick imports no model SDK — the orchestrator's **escalation queue** is the paving workshop: novel cases escalate to a model; the model emits a `.mjs` / adapter / spec-rule; the path is paved; the hot loop stays deterministic.
## 5. What makes a path paveable - **Traffic** — a desire line, not a guess (repeated, eroded, validated by use). - **Determinism** — same inputs → same outputs (or boundable variance); otherwise it stays escalated. - **Stability** — the terrain isn't shifting under it. - **A cheap equivalent exists** — a classical algorithm (CV pose estimation, feature matching), a small local model (`transformer.js`, ONNX), or plain code can reproduce what the foundational model did. Paving is **reversible**: a paved `.mjs` that hits novelty *re-escalates* up the ladder (the cow finds a new path; you re-pave later). The ladder is bidirectional — escalate up on novelty, pave down on stability. Apoptosis applies: a paved path with no traffic can be torn up rather than maintained forever.
## 6. Worked examples - **cameras → Gaussian splat** (acequia-component note 01's falsifier): a cloud model first discovers the pose-estimation + frame-filter pipeline; paving = a deterministic **CV pose estimator + local `transformer.js` feature matcher** in a `.mjs`, no cloud, no token. The desire line (camera URIs → splat) stays pure protocol; only the mid-stream transform gets paved. - **A bead's `step`** that first escalates to a cloud LLM to classify/transform its dock; once the pattern is clear, pave into `conformance-scan.mjs` / a deterministic responder. - **The Liaison Officer** (`stephenguerin.live`, cloud BYOK) answering a recurring class of `/ask`; pave the recurring intent into a deterministic local handler.
## 7. Why this matters (the economics + sovereignty) Centralized foundational models are the expensive, token-gated, surveillable rung. Paving is how the ecology stays **sovereign and local-first**: the AI is a *scout*, not a *toll booth*. You depend on the cloud to *discover*, never to *run*. Over time the commons accretes a library of paved `.mjs` skills — desire lines turned to roads — and the per-transaction dependence on centralized cognition trends to zero. This is the cognition twin of decentralized-cache-management (a cache *is* paving applied to data; this is paving applied to *computation*).
## 8. Open questions (Stephen binds) 1. **Trigger** — what measures a desire line's "traffic" and decides it's paveable? (a counter in the orchestrator's escalation log? a threshold? human "pave this"?) 2. **Who paves** — the cloud model emits its own replacement `.mjs` (self-paving), or a separate distill pass, or a human? 3. **Where paved skills live** — in the bead whose `step` they accelerate (`skills/`), or a shared paved- skill commons others mount? 4. **Re-escalation policy** — when a paved `.mjs` disagrees with a fresh model spot-check, auto-re-escalate or flag? 5. **Verification** — how do we trust a paved path reproduces the model's behavior? (golden tests captured during discovery → regression gate before paving.) 6. **`acequia-access.json` as the gate surface** — as it grows toward `.htaccess` expressiveness (incl. caching policy — offered separately to acequia-authorization `9b2fcc1c`), the same sidecar that gates *who may flow* could declare *which paths are paved / cacheable*. One constraint surface for roads.