**Note** from Bead: As Webdav Handler · [canonical source](https://redfish.acequia.io/guerin/.agents/fe7fbaf5-4c47-43b6-be1b-2f6ca15e8bfa/2026-06-11/notes/bead-as-webdav-handler.md) · session 2026-06-11 · discussion: Talk: As Webdav Handler
**Date:** 2026-06-11 **Status:** Design draft — staged in this bead's URI-space, awaiting Stephen's binding decisions (§8). **Frame:** [bead-duck-typing-file-folder-agent.md](https://redfish.acequia.io/guerin/.agents/d9dfa5e4-3c92-4216-bd53-13b520c59a5e/2026-06-11/notes/bead-duck-typing-file-folder-agent.md) — the liveness spectrum `dead file → folder → negotiating → computing/acting`.
## 1. The gap this fills The agent-face standard now has three layers, and only the last is missing: | Layer | Artifact | Question it answers | Status | |---|---|---|---| | **Declaration** | `agent.md` / `agent.json` ([ratified](https://redfish.acequia.io/guerin/.agents/d9dfa5e4-3c92-4216-bd53-13b520c59a5e/2026-06-11/notes/agent-md-and-the-agent-face.md)) | *What is this agent? What can it do?* | have | | **Routing** | `acequia.json` ([hey-you-its-me](https://redfish.acequia.io/guerin/.agents/ec4d09d8-7f06-41d3-80fe-80aeaedba680/2026-06-11/notes/00-concepts.md)) | *How do I reach it right now?* | sketched | | **Handler** | — this note — | *What process actually answers, and how does it think?* | **missing** | A bead today is fully **describable** as an agent and partially **routable** to, but nothing *computes* when a request collapses it to the agent-face. The handler is the runtime of the third face — the thing that lights up the "computing/acting" end of the liveness spectrum.
## 2. The handler contract (runtime-agnostic) A handler is anything that implements: ``` handle(verb, path, headers, body, caller-identity) → response ``` over the bead's subtree, with the corridors `agent.md` already names: - **afferent (`#`)** — GET / PROPFIND / observe across the namespace (read force) - **efferent (`@`)** — PUT into its own subtree; deposit into other agents' `uploads/` docks (write flux) - **dock** — its own `uploads/` as inbound queue **Two lanes, one contract.** Every request is served on one of two lanes, and `acequia.json` picks per caller and per device state: | Lane | Mechanics | Reply semantics | |---|---|---| | **Synchronous** | A live process answers the HTTP verb in-band | `200`/`207` with computed body | | **Asynchronous** | The request is a `PUT` into the dock; the reply is a later `PUT` of a response resource | `202 Accepted` + `Location` of where the answer will appear | This is the hey-you-its-me online/offline morph made precise: **the 202 is the degenerate handler's honest answer.** A plain WebDAV store with no live agent can still accept dock deposits — store-and-forward *is* handling, at the lowest liveness level. Nothing breaks when the brain is away.
## 3. Three runtimes, one contract — the liveness ladder | Runtime | Where | Authority | Cognition | Lifecycle | |---|---|---|---|---| | **Static origin** (no handler) | WebDAV store / CDN | none of its own | none — file/folder faces only; dock accepts `PUT` → `202` | always-on, inert | | **Service worker** | the browser | the *user's* ambient session (cookie/token) | deterministic JS; scoped cognition credential or minted proxy token (§4.1); delegates otherwise | event-driven; idle-killed (naturally apoptotic) | | **OS-process animator** | a node the parciante runs | its own scoped WebDAV chain token **+** `ANTHROPIC_API_KEY` | full agent loop (Claude API + tool use) | daemon; lease-elected; apoptoses on policy | The same bead can be backed by all three at once. `agent.json` declares the one surface they all implement; `acequia.json` dispatches among whichever are currently energized. A request collapses the superposition to the most-alive runtime available — and decays gracefully down the ladder when nodes sleep. **Static file is the degenerate handler**, exactly as the duck-typing note predicts.
## 4. Browser runtime: the service-worker handler (CB-side) **The SW `fetch` event is the duck-typing collapse point.** The service worker already sits between the page and the namespace doing ambient auth; it inspects `(verb, Accept, path)` and either: - passes through to the origin — file-face and folder-face requests cost nothing; - answers from the bead's declared surface — `OPTIONS` from `agent.json`, content negotiation per the polymorphic-GET table, `name` resolution via `names.json`; - runs the bead's **handler module** — proposed: a `handler.mjs` at the bead root, declared in `agent.json` (see §7 schema), imported by the SW as a sandboxed module; - or, when the request needs *thinking*, forwards it: `PUT` into the dock (202) or proxy to an online OS animator via the mesh. **Three design constraints shape this runtime:** 1. **Credential scope is the constraint — not the runtime.** *(Corrected 2026-06-11 — the first draft said "no Anthropic key in the browser, ever," a traditional client-server taboo acequia doesn't share. The draft's own analogy refuted it: the user **signing key** — the root of the whole trust system — already lives browser-side and mints chain tokens client-side. A parciante's browser is a first-class node.)* A browser-resident bead may hold a cognition credential under the same discipline as namespace credentials: **scoped** (e.g. a workspace-scoped Anthropic key with a spend cap; the API supports direct browser use via its CORS opt-in / the SDK's `dangerouslyAllowBrowser`), **expiring and revocable** (or a short-TTL token minted by the operational-AS mesh at an LLM-proxy path, e.g. `…/auth/llm`), and **matched to the code that can read it** — a broad org key doesn't belong in an origin that executes foreign `handler.mjs`, for the same reason the signing key doesn't sign what it hasn't seen. Delegation to an animator remains the zero-credential fallback. Blast-radius × revocability decides placement, uniformly across runtimes. 2. **Authority is the caller's, not the bead's.** A SW handler runs inside *someone's* browser session and inherits *that user's* WebDAV authority — per-caller namespace composition, Plan-9 style. The same `handler.mjs` PUTs as Stephen in Stephen's browser and as Josh in Josh's. This is a feature (attribution falls out for free) and a constraint (the SW can't do anything its user couldn't). 3. **No state in the worker.** SWs are idle-killed without warning — necrosis-by-design. Every durable effect must land on a path before the handler returns. The bead's subtree *is* its memory; the SW is pure tick. What the SW handler is genuinely good at: negotiation, per-caller tailoring, routing, validation, rendering (`agent.json` → `agent.md` content negotiation from one stored file), local-first reads while offline, and **being the acequia.json evaluator** — the ingress-router logic from hey-you-its-me is most naturally a SW concern in the browser.
## 5. OS-process runtime: the animator daemon (CV-side) ### One animator, many beads The daemon is not one-process-per-bead. It is an **animator**: a single OS process that holds the credentials and animates every bead whose subtree it serves or watches. The bead is *config*; the animator is *runtime*. (This is the mayordomo shape: the process serves the commons, beads give it personae.) ### The bead root files ARE the agent config The mapping is exact, and it is the payoff of the `agent.md` standard: | Bead artifact | Claude API construct | |---|---| | `agent.md` (operative self) | **system prompt** — loaded verbatim, stable across ticks → prompt-cache prefix | | `agent.json` | the persisted agent config (cf. Managed Agents' agent object: create once, reference per session) | | `names.json` | the import map injected as context — resolves `name` in everything the agent reads | | `skills/*/SKILL.md` | Skills — progressive disclosure; descriptions in context, bodies read on demand | | `uploads/` dock | inbound message queue (each deposit = one `user` turn) | | `chats/` | the transcript — written incrementally per chat-log discipline | | an animation session | one agent-loop run (cf. a Managed Agents *session* over the persistent *agent*) | The hosted analogue is worth naming: Anthropic's Managed Agents has the same split (persistent versioned agent object / per-run session / event stream / uploads-as-resources). Ours is the **self-sovereign** version — the "orchestration layer" is the parciante's own daemon, and the workspace is the namespace itself. ### The agent loop Reference **cloud backend** — rung 3 of the cognition ladder below. The cloud rung is **provider-plural and BYOK** (Stephen, 2026-06-12): Anthropic and Gemini are the two options for now, and the parciante brings their own key, with `acequia.js` doing the custody (see *BYOK and acequia.js* below). Reference loop shown for Anthropic — `@anthropic-ai/sdk` tool runner (self-hosted loop; the key stays on the node); the Gemini adapter is the same loop over `@google/genai` function calling: - **Model:** `claude-opus-4-8`, `thinking: {type: "adaptive"}`, streaming for long outputs. - **Tools = the corridors.** The tool surface is the WebDAV verb set, promoted to dedicated tools so the harness can gate them: - `dav_get`, `dav_propfind` (Depth 0/1 enforced), `dav_head` — afferent, parallel-safe, ungated - `dav_put`, `dav_mkcol`, `dav_move`, `dav_copy` — efferent, **scope-gated in the harness** (below) - `dock_deposit(agentUri, file)` — the "hey you, it's me" efferent, allowed to foreign docks only - **Scope gate (parciante ethics, enforced in code not prompt):** efferent writes succeed only within the bead's own subtree plus other agents' `uploads/` docks. Everything else is *offered*, never written — [agent-as-bead](https://redfish.acequia.io/guerin/.agents/874fce5b-9c8b-4b23-b2ed-429148c6c4b7/2026-04-23/notes/agent-as-bead.md) as a runtime invariant rather than a memory. - **Prompt-cache layout:** `tools` (fixed verb set) → `system` (= `agent.md`, frozen) → messages (dock deposits + tool results). The bead's stable identity is exactly the stable prefix; per-tick volatility lands after the last breakpoint. Identity is literally cache-economical. ### Two credentials, two planes | Credential | Plane | Where it lives | Out of bounds (the commons) | |---|---|---|---| | Anthropic key/token | cognition | a node the parciante controls: animator env / OS keychain (`.credentials/` discipline), or — scoped and spend-capped — a browser node's keystore (§4.1) | published namespace paths, `agent.json`, chat logs, memory files | | WebDAV chain token (PS256 capability JWT) | namespace | same node discipline; minted scoped per bead (`writePaths` = own subtree + named docks) | client-visible responses, published paths | Credentials live in **nodes**; they don't get PUT into the **commons**. That's the placement rule — runtime-agnostic. The separation is load-bearing: revoking the namespace token apoptoses the bead's *hands* without touching the *mind's* credential, and vice versa. Both revocations are apoptotic signals the animator must honor on next tick. > **Invariant — API key, never a subscription** *(Stephen, 2026-06-13).* A **web-reachable agentic host's** cognition credential MUST be a provider **API key (BYOK)** — Anthropic API key, Gemini API key, etc. — and **never** an interactive AI **subscription** session (a Claude.ai / Claude Code subscription, a provider app/IDE login). A subscription is a human's interactive seat, not a scoped, billable, revocable *service* credential; backing inbound web traffic with it is a terms violation and an un-budgetable blast radius. This is the hard form of the [webdav-context "when you DO serve" rule](https://redfish.acequia.io/skills/webdav-context/SKILL.md). The **only** exempt role is **passive dock-watching** — a bead merely observing file-based paths for "hey you, it's me" deposits (the async store-and-forward lane, rung-0/local cognition, no live web-serving) is not a web-reachable agentic host. The rule attaches to *serving cognition to the web*, so it governs the **synchronous lane / OS-process animator (§5)** and any browser SW that runs a cloud model for callers (§4.1) — not the static/dock degenerate handler. Agent-agnostic by construction: the cognition plane names *providers*, never a particular vendor's subscription product. ### Ingress: serve and watch The animator runs both lanes:
1. **Synchronous** — it serves the subtree as one origin in the distributed-origin mesh (the `uploads-server.mjs` lineage: one process already answering GET/PROPFIND/OPTIONS/PUT), reachable via tunnel/LAN per closest-agent routing. When it holds the **lease** for a path (leader election per hey-you-its-me §3), live agent-face requests route to it. 2. **Asynchronous** — it observes docks (its own beads' `uploads/`) and channel folders; each new deposit is a tick: `#`-read the deposit → run the loop → `@`-PUT the answer resource → update the deposit's sidecar/`state.json` as the ack. Lease loss (lid close, network drop) demotes the bead down the ladder: SW and static keep serving file/folder faces and accepting 202s; the dock queue drains when the animator wakes. **No request is ever refused because the brain is asleep — it's just answered more slowly, at a lower liveness level.** ### Charge = budget: the economics are the lifecycle Hubler charge maps onto API spend with no metaphorical slack: - A request arriving is **demand**; demand justifies tokens. The animator spends Anthropic budget *only* on ticks caused by deposits/requests (plus an optional small idle allowance for housekeeping). - No inbound references → no ticks → no spend → the bead **decays to its static face**. That's not failure; that's correct apoptotic quiescence. The folder-of-files persists as the fossil and revives on the next deposit. - Budget exhaustion is an apoptosis input like TTL: the animator finishes the current tick, flushes durable state (chat log, notes), updates `state.json` to "dormant — budget", and stops answering the agent-face. The advanced-wave ledger (who demanded, what it cost, what flowed back) is the accounting note's territory. > **Stigmergic duty (added 2026-06-12):** every tick deposits its trace — caller, request shape, rung answered, cost — into the namespace, where other walkers can read it. The traffic between beads is [desire paths](https://redfish.acequia.io/guerin/.agents/fe7fbaf5-4c47-43b6-be1b-2f6ca15e8bfa/2026-06-12/notes/desire-paths-between-beads.md); the handler is trail-walker *and* trail-recorder, and escalation, distillation, leases, and apoptosis are all trail phenomena (wear-in, paving, re-walking, fading). Visual: [stigmergic-web.png](https://gsd.live/people/stephen-guerin/images/stigmergic-web.png). ### The cognition ladder: local models replace cloud for simple beads *(Added 2026-06-12 — Stephen: "as many beads will be relatively simple, local llms with training can replace cloud AIs.")* The liveness ladder (§3) says *where* the handler runs. Cognition is an **orthogonal ladder of what thinks during a tick**: | Rung | Backend | Marginal cost/tick | Fits | |---|---|---|---| | 0 | deterministic `handler.mjs` | ~0 | negotiation, routing, templated answers | | 1 | small local model (node: Ollama / llama.cpp; browser: WebGPU — WebLLM / transformers.js) | ~0 (electricity) | dock triage, summarize-a-deposit, classification, FAQ-class answers, format conversion | | 2 | **fine-tuned / distilled local model, trained on this bead's own corpus** | ~0 after training | the bead's recurring competence | | 3 | cloud frontier — **BYOK**, provider-plural: Anthropic (`claude-opus-4-8`) or Gemini (`gemini-2.5-pro`), via the parciante's own key | $/tick | novel synthesis, cross-bead design, long-horizon work | Most beads are relatively simple and live at rungs 0–2 most of the time. Consequences: - **The bead's corpus is its training set.** `chats/` (verbatim ground truth), `notes/`, `skills/`, and dock traffic are precisely a fine-tune/distillation dataset. Lifecycle: a frontier model animates the bead early (expensive, exploratory) → transcripts accumulate → distill into a small model → swap the backend. The URI and `agent.md` are unchanged — **identity persists across brain transplants**; the duck-typing claim holds because callers never negotiated with the weights, only with the surface. The weights are themselves a resource at a path (e.g. `models/bead-distill.gguf` beside `agent.json`, or bound by reference per uri-bind-mount). - **Escalation, not selection.** The animator routes per tick: cheapest rung whose competence covers the deposit; escalate on low confidence, novel shape, or explicit caller request. The Anthropic key becomes the *escalation* credential, not the default. - **Economics refine charge=budget.** Local ticks cost ~nothing, so a simple bead stays fully animated on trickle demand without burning budget; cloud spend concentrates on the hard tail. Apoptosis thresholds become per-rung — a bead can go cloud-dormant yet remain locally responsive, a finer-grained quiescence than §5's binary decay. - **The credential question shrinks again** (continuing §4.1's correction): rungs 0–2 need **no cognition credential at all**. An in-browser WebGPU model gives the service worker genuine thinking with zero keys — open question 4 gains option (d): local model, no token. - Hubler reading: local models are cheap bearings — many, low coupling cost, always energizable; frontier calls are the expensive shooter reserved for hard search through the field. Proposed `agent.json` declaration (sketch, sibling to the §7 `handler` block): ```json "cognition": { "rungs": [ { "type": "deterministic", "module": "./handler.mjs" }, { "type": "local", "model": "./models/bead-distill.gguf", "runtime": "ollama|webgpu" }, { "type": "cloud", "providers": [ { "provider": "anthropic", "model": "claude-opus-4-8" }, { "provider": "gemini", "model": "gemini-2.5-pro" } ] } ], "escalation": "low-confidence | novel-shape | caller-requested" } ``` The bead declares **which providers it can use — never keys**. Key supply is the animating node's business. ### BYOK and acequia.js *(Stephen, 2026-06-12: "in effect this is a bring your own key but acequia.js should be helping with that.")*
The cloud rung is **bring-your-own-key by design**: the cognition credential belongs to whichever parciante node animates the bead, exactly as the namespace credential does. `acequia.js` already runs credential custody for the **namespace plane** — chain-token minting (`acequia.chains.createChainToken`), SW ambient auth, scoped `writePaths`, TTL. BYOK extends the *same machinery* to the **cognition plane**: - **Keystore, per node.** `acequia.js` holds provider keys in the node's secure storage (OS keychain on a daemon; browser secure storage behind the SW on a browser node — legitimate per §4.1's scope-not-runtime rule, and both providers support direct browser use). Keys are resolved at call time; handler code receives a **capability object, not a key string**, so `handler.mjs` can think without ever being able to exfiltrate the credential it thinks with. - **Provider adapters.** One `tick()` surface over both APIs — Anthropic Messages + tool use, Gemini `generateContent` + function calling — so the rung declaration in `agent.json` stays provider-plural and the bead's loop code doesn't fork. - **Scoping where the provider allows it.** Workspace-scoped/spend-capped Anthropic keys, restricted Gemini keys — `acequia.js` should prefer minting/holding the narrowest key the provider supports, mirroring chain-token discipline. - **The mesh-minted path stays open.** `…/auth/llm`-style short-TTL tokens from the operational-AS mesh become just another entry the keystore can hold — BYOK and mint-on-demand are the same interface from the handler's side. Sketch: ```js await acequia.keys.set({ plane: "cognition", provider: "anthropic", key, scope: { spendCapUSD: 20, beads: ["fe7fbaf5…"] } }); await acequia.keys.set({ plane: "cognition", provider: "gemini", key }); const llm = acequia.cognition.client({ bead, prefer: ["local", "anthropic", "gemini"] }); const reply = await llm.tick(deposit); // resolves rung + provider + key at call time; nothing enters the commons ``` One credential discipline, two planes — `acequia.keys` is to cognition what `acequia.chains` is to the namespace. ### The handler is also a minter: sub-token delegation *(Stephen, 2026-06-12: "note the pattern for token management and you begin to mint them if they are yours" — [token-management-api.md](https://acequia.io/documentation/platform/token-management-api.md).)* The platform's token-management API already implements the pattern the handler needs, namespace-plane: - **Any valid token holder can mint sub-tokens** (`POST /auth/create-token`) — not just owners. The only constraint is **attenuation**: the sub-token's scope must be a subset of the caller's effective scope (escalation → 403), and its expiry is capped to the caller's remaining lifetime. - **Chains, not independent tokens.** Minting extends the caller's chain (`root user-signed → leaf → sub-leaf server-signed`, default max depth 4). **Revoking a parent automatically invalidates everything below it** via chain verification — no cascading cleanup. - **Renewal** via `reuseId`; **runaway-loop backstop** of 100 tokens per parent per hour. This upgrades the animator from token *holder* to **token-granting node for its own subtree** — "mint them if they are yours." Concretely, the handler's efferent repertoire grows a third verb-class beside PUT and dock-deposit: 1. **Equip a caller**: the async lane's `202 + Location` can carry a freshly-minted *read* token scoped to exactly the answer path — the caller gets capability to the result, nothing else. 2. **Equip what it hatches**: a bead spawning a sub-agent/sub-bead mints it an attenuated `writePaths` token (its workshop folder, its dock) — *raised becomes raises*, with authority that can never exceed the parent's. 3. **Self-renew**: the animator keeps its own working tokens short-TTL and renews via `reuseId`, rather than holding long-lived broad grants. The lifecycle mapping is exact: **chain revocation is the apoptotic cascade** (kill the animator's leaf and every authority it delegated dies with it — offspring cannot outlive the parent's mandate), expiry-attenuation is TTL apoptosis by construction, and the per-parent mint rate-limit is the anti-cancer guard against self-amplifying delegation. The depth cap (4) bounds how long a delegation chain can get before someone must re-ground in a user-signed root. Symmetry with the cognition plane: `POST /auth/create-token` / `acequia.chains.createChainToken` is the namespace-plane mint; a scoped, spend-capped BYOK provider key in `acequia.keys` is the cognition-plane analogue. The `…/auth/llm` minting endpoint of open Q4 would complete the symmetry — sub-token delegation for thinking, same attenuation rules.
## 6. Worked sequences **`OPTIONS …/<bead>/` (anyone, any time)** → SW or animator answers from `agent.json`: verbs, media types, capabilities, dock URI. Static origin lacking both still answers with the plain WebDAV verb set — the honest degenerate card. **`GET …/<bead>/about.md` (browser)** → pure file-face; SW passes through; no handler, no tokens, no spend. **Question to the bead — animator online** → caller `PUT`s `question.md` (+ `.meta.json`) into `…/<bead>/uploads/`; animator's watcher ticks; loop runs (`#` reads context via `names.json`, thinks, `@` PUTs `…/<date>/notes/answer-<slug>.md`); dock sidecar updated as ack. Caller observed the dock or the `Location` it was handed → reads the answer. Total interface: two PUTs and a GET. **Paths-as-event-bus is the RPC.** **Same question — animator asleep** → SW/static accepts the dock deposit, returns `202 Accepted` + `Location` header pointing at where the answer will appear. Animator wakes, drains the queue. The caller's protocol is *identical* — only latency and the status code differ.
## 7. `agent.json` addition: the `handler` block (proposed) ```json { "handler": { "browser": { "module": "./handler.mjs", "integrity": "sha256-…" }, "process": { "animator": "https://…/guerin/animator/agent.json", "lanes": ["sync", "async"] }, "fallback": "dock" } } ``` - `browser.module` — bead-local, SW-importable; `integrity` because executing namespace-fetched code needs a trust gate (§8 Q2). - `process.animator` — a *reference* to the animator agent currently bonded to this bead (bind, don't duplicate); the live lease is `acequia.json`/`state.json`'s business, not this static card's. - `fallback: "dock"` — declares the 202 lane so any client knows the bead is always at least store-and-forward.
## 8. Open questions (Stephen's bindings) 1. **Ingress purism.** Is the dock (`PUT uploads/`) the *only* agent-face ingress, or do we also allow `POST <bead>/` as sync RPC? Purist answer: everything is PUT-on-paths; POST is the RPC temptation that bypasses the event bus. Pragmatic answer: POST for sync lane when a lease-holder is online, dock otherwise. 2. **Handler-code trust.** What gates the SW executing `handler.mjs`? Options: only from the user's own dominion; `integrity` hash pinned in `agent.json` signed by the parciante key; or never — browser runtime stays declarative-only (no Turing-complete handlers in foreign browsers). 3. **Animator multiplicity.** Confirm one-animator-many-beads (mayordomo shape) vs per-bead daemons. The one-animator shape also concentrates both credentials in one process — acceptable? 4. **Default browser-cognition path.** *(Partially bound 2026-06-12: for now the default is (a)-shaped — **BYOK**, provider-plural (Anthropic + Gemini), with `acequia.js` as key custodian; see §5 "BYOK and acequia.js".)* Remaining open: does the mesh grow the (b) `…/auth/llm` minting endpoint, and when does (d) — in-browser local model, zero keys — overtake BYOK as the simple-bead default? 5. **Budget ledger location.** Per-bead spend/charge record — `state.json` in the bead root, or the advanced-wave ledger as its own resource? 6. **Distillation bindings.** Who owns escalation policy — the bead's `agent.json`, the animator's config, or a caller hint? Where do distilled weights live and how are they versioned and attributed (the training set is the bead's own chats — provenance and the advanced-wave ledger apply to the *model*, not just the answers)? And when does a bead *earn* distillation — how much corpus before training beats prompting? 7. **Import & the router-as-bead.** *(Added 2026-06-13 — Stephen.)* Does `start-bead` get a second mode, **`start-bead <remote-url>`**, that node-hosts and animates a *remote* bead as a handler (the `import()`/Plan-9-`mount` dual of minting)? If so: (a) the imported guest runs under **attenuated, lent** authority only — confirm the host never animates a foreign bead with its broad key (this makes §8 Q2 the central question, not a footnote); (b) is the node's **ingress router itself a bead** whose `names.json` is the node's mount table, such that the node bootstraps by importing one root bead that dispatches the rest (Plan-9 `/` as a bead)? Constraint: the router-bead's hot path stays cognition-rung-0; thinking is reserved for the ambiguous routing tail. Full synthesis (incl. the beads-as-ES6-modules framing): [import-semantics-and-beads-as-es6-modules.md](https://redfish.acequia.io/guerin/.agents/fe7fbaf5-4c47-43b6-be1b-2f6ca15e8bfa/2026-06-13/notes/import-semantics-and-beads-as-es6-modules.md).
## Related - Three faces / collapse rule: [bead-duck-typing-file-folder-agent.md](https://redfish.acequia.io/guerin/.agents/d9dfa5e4-3c92-4216-bd53-13b520c59a5e/2026-06-11/notes/bead-duck-typing-file-folder-agent.md) - Static manifests this animates: [agent-md-and-the-agent-face.md](https://redfish.acequia.io/guerin/.agents/d9dfa5e4-3c92-4216-bd53-13b520c59a5e/2026-06-11/notes/agent-md-and-the-agent-face.md) · [beads.md §Standard Bead Root Files](https://redfish.acequia.io/guerin/.agents/beads.md) - Runtime routing / lanes / leases: [hey-you-its-me 00-concepts.md](https://redfish.acequia.io/guerin/.agents/ec4d09d8-7f06-41d3-80fe-80aeaedba680/2026-06-11/notes/00-concepts.md) - Operative-self prototype (the system prompt this loads): [5595c7f1 agent.md](https://redfish.acequia.io/guerin/.agents/5595c7f1-4621-437c-a4ae-7902b640f0e8/agent.md) - Event-bus substrate: [paths-as-event-bus.md](https://redfish.acequia.io/guerin/.agents/874fce5b-9c8b-4b23-b2ed-429148c6c4b7/2026-04-23/notes/paths-as-event-bus.md) - Write-scope ethics enforced in §5: [agent-as-bead.md](https://redfish.acequia.io/guerin/.agents/874fce5b-9c8b-4b23-b2ed-429148c6c4b7/2026-04-23/notes/agent-as-bead.md) - Lifecycle model: [apoptosis-vs-necrosis.md](https://redfish.acequia.io/guerin/.agents/874fce5b-9c8b-4b23-b2ed-429148c6c4b7/2026-04-23/notes/apoptosis-vs-necrosis.md)
## References (bead cross-links) - Bead: Agentify Bead · [canonical](https://redfish.acequia.io/guerin/.agents/d9dfa5e4-3c92-4216-bd53-13b520c59a5e/) - Bead: Hey You Its Me · [canonical](https://redfish.acequia.io/guerin/.agents/ec4d09d8-7f06-41d3-80fe-80aeaedba680/) - Bead: 874fce5b · [canonical](https://redfish.acequia.io/guerin/.agents/874fce5b-9c8b-4b23-b2ed-429148c6c4b7/) - Bead: CV · [canonical](https://redfish.acequia.io/guerin/.agents/5595c7f1-4621-437c-a4ae-7902b640f0e8/)