CoAgnes Labthe study spaceresearch preview · build 1ececa2

a wave is settlingengine working on #0membrane waiting at #0

Wave 1 · record #0sys.knot.defined

#0 · a listener is described

When the engine takes it, the machine stores the listener under its name and gives it a trial lane. The membrane passes it: nothing for the outside world.

Came froma personThe fragment's author added it at the door: the first half of the template. step 2

Read as

when it came in at the door

  1. 2Record #0 enters the logLOG · append

    a wave is settlingengine: next: #0membrane: waiting at #0

    The log
    1. #0a listenernewenginemembrane
    2. end of the log
    The log
    beforeafter
    records in the log01
    #0—a listener · sys.knot.defined

    The door adds the first record to the log: a description of a listener. It gets number #0 — the next free place, at the end.

    Where it happens appendEmissions()Vol. 02 §4.1 · Vol. 03 §1

    The only function that adds records to the log. Each new record gets the next free number, at the end.

    Specification
    Vol. 02 §4.1 · Vol. 03 §1
    Code
    appendEmissions() in core/registers/append-emissions.ts, line 14: the new record gets the next free number
    Journal
    LOG · append · offset: 0, kind: sys.knot.defined · by engine
    Picture
    records in the log: 0 → 1
    core/registers/append-emissions.ts · build 043cc8b
    1. // The one LOG writer (Vol. 02 §4.1, Vol. 03 §1): emissions become tuples by
    2. // receiving the next dense absolute offset — `base + window.length` — and
    3. // nothing else ever grows the log. Each append is journalled under the
    4. // ambient context, so a batch born of a propagated tuple carries that
    5. // tuple's offset as its cause — the cube's provenance line (ADR-002).
    7. import type { WaveEmission, WaveTuple } from "../wave/gate";
    8. import type { RegisterFile } from "./register-file";
    9. import { recordTransition } from "./record-transition";
    11. export function appendEmissions(file: RegisterFile, emissions: readonly WaveEmission[]): void {
    12. const engine = file.registers.engine;
    13. for (const emission of emissions) {
    14. const tuple: WaveTuple = { ...emission, offset: engine.base + engine.window.length };↑ the new record gets the next free number
    15. engine.window.push(tuple);↑ it is added at the end of the log
    16. recordTransition(file, "engine", "LOG", "append", {↑ the change is written into the journal
    17. offset: tuple.offset,
    18. kind: tuple.kind
    19. });
    20. }
    21. }

    AGPL-3.0-onlyThe Lab's demonstration environment, as this fragment ran it (build 043cc8b). The code may change, and may differ from the code of a working machine.

    Nest VM core, incubated in the CoAgnes garden · build 043cc8b (2026-09-21) · this file last changed in f36e70d (2026-08-18)

when the engine took #0

  1. 4The engine takes #0ENGINE.CURSOR · propagate

    a wave is settlingengine: working on #0membrane: waiting at #0

    The log
    1. #0a listenerengine · workingmembrane
    2. #1a doer
    3. end of the log
    The engine
    beforeafter
    pointer — the next record to take#0#1

    The engine's pointer moves past #0, and the machine reacts to it.

    Where it happens takeNextTuple()Vol. 02 §4.1

    The engine's step: take the record under its pointer and move the pointer on — or stop, if the pointer has reached the end.

    Specification
    Vol. 02 §4.1
    Code
    takeNextTuple() in core/registers/take-next-tuple.ts, line 15: at the end of the log, the engine stops
    Journal
    #0 · ENGINE.CURSOR · propagate · offset: 0 · by engine
    Picture
    pointer — the next record to take: #0 → #1
    core/registers/take-next-tuple.ts · build 043cc8b
    1. // ENGINE.CURSOR advance (Vol. 02 §4.1) — the machine's instruction pointer:
    2. // returns the tuple at the cursor and moves it forward exactly once, or null
    3. // at quiescence. Advancing IS the context switch: the ambient wave context
    4. // moves to the propagated tuple in the same movement, so every transition
    5. // journalled during its propagation is attributed to it — the cube's spine.
    6. // The cursor never rewinds.
    8. import type { WaveTuple } from "../wave/gate";
    9. import type { RegisterFile } from "./register-file";
    10. import { recordTransition } from "./record-transition";
    11. import { setDriver, setWaveContext } from "./set-wave-context";
    13. export function takeNextTuple(file: RegisterFile): WaveTuple | null {
    14. const engine = file.registers.engine;
    15. if (engine.cursor >= engine.base + engine.window.length) return null;↑ at the end of the log, the engine stops
    16. const tuple = engine.window[engine.cursor - engine.base];
    17. engine.cursor += 1;↑ the engine's pointer moves on by one
    18. setWaveContext(file, { offset: tuple.offset, phase: "propagate" });
    19. setDriver(file, "engine");
    20. recordTransition(file, "engine", "ENGINE.CURSOR", "propagate", { offset: tuple.offset });↑ the change is written into the journal
    21. return tuple;
    22. }

    AGPL-3.0-onlyThe Lab's demonstration environment, as this fragment ran it (build 043cc8b). The code may change, and may differ from the code of a working machine.

    Nest VM core, incubated in the CoAgnes garden · build 043cc8b (2026-09-21) · this file last changed in 6730f58 (2026-09-13)

  2. 5The listener is added to the figureKNOT.DEFS · register-knot

    a wave is settlingengine: working on #0membrane: waiting at #0

    The log
    1. #0a listenerengine · workingmembrane
    2. #1a doer
    3. end of the log
    The figure
    beforeafter
    listener note.gate—hears note.given → slot note; ready when note != null

    The machine writes the listener's description into its list of listeners, under the name note.gate. Nothing was there before under that name.

    Where it happens registerKnotDefinition()Vol. 02 §4.2 · Vol. 04 §2.1

    Stores a listener's description under its name and gives it a bank of lanes with one trial lane.

    Specification
    Vol. 02 §4.2 · Vol. 04 §2.1
    Code
    registerKnotDefinition() in core/registers/register-knot-definition.ts, line 21: the description is stored under its name
    Journal
    #0 · KNOT.DEFS · register-knot · id: note.gate, strategy: deterministic, replaced: false · by region:root
    Picture
    listener note.gate: — → hears note.given → slot note; ready when note != null
    core/registers/register-knot-definition.ts · build 043cc8b
    1. // KNOT.DEFS write (Vol. 02 §4.2): the definition payload lands as data, and
    2. // re-registration of an id replaces the definition AND resets its clew bank
    3. // to a fresh null-key probe — accumulated clews of the old definition are
    4. // discarded (the machine's only 'edit'). The probe clew is supplied by the
    5. // resolved executor so invalid configuration has already failed at the
    6. // factory (Vol. 04 §2.1); the stale executor cache entry is dropped here so
    7. // the replacement takes effect for the next tuple.
    9. import type { KnotDefinedPayload } from "../topology/gate";
    10. import type { ClewRegisters, TopologyRegisters } from "./topology-registers";
    11. import type { RegisterFile } from "./register-file";
    12. import { recordTransition } from "./record-transition";
    14. export function registerKnotDefinition(
    15. file: RegisterFile,
    16. region: TopologyRegisters,
    17. payload: KnotDefinedPayload,
    18. probeClew: ClewRegisters
    19. ): void {
    20. const replaced = region.knotDefs.has(payload.id);
    21. region.knotDefs.set(payload.id, payload);↑ the description is stored under its name
    22. region.clews.set(payload.id, new Map([[null, probeClew]]));↑ its bank of lanes, with a trial lane
    23. file.ephemeral.knotExecutors.delete(`${region.regionId}/${payload.id}`);
    24. recordTransition(file, `topology:${region.regionId}`, "KNOT.DEFS", "register-knot", {↑ the change is written into the journal
    25. id: payload.id,
    26. strategy: payload.strategy,
    27. replaced
    28. });
    29. // The clew station is born here, with its null-key probe lane — journaled
    30. // on the station itself so fold(journal) holds it before any lane opens
    31. // (the document model's oracle, ADR-004 d10; Vol. 02 §4.5).
    32. recordTransition(file, `topology:${region.regionId}/clew:${payload.id}`, "CLEWS", "open-clew", { key: null, probe: true, replaced }, "registerKnotDefinition");↑ the change is written into the journal
    33. }

    AGPL-3.0-onlyThe Lab's demonstration environment, as this fragment ran it (build 043cc8b). The code may change, and may differ from the code of a working machine.

    Nest VM core, incubated in the CoAgnes garden · build 043cc8b (2026-09-21) · this file last changed in 6730f58 (2026-09-13)

    A finding for the machine's authors, recorded and left as it is: the journal stamps CLEWS·open-clew → core/registers/ensure-clew.ts for registerKnotDefinition(), which lives in core/registers/register-knot-definition.ts (the op map's file for that register · action).

  3. 6The listener gets a trial laneCLEWS · open-clew

    a wave is settlingengine: working on #0membrane: waiting at #0

    The log
    1. #0a listenerengine · workingmembrane
    2. #1a doer
    3. end of the log
    The listener note.gate · appears
    beforeafter
    lane · trial lane (no key)—open

    A listener keeps a lane for each conversation. Before any note arrives it gets one trial lane with no key — proof that its description works.

    Where it happens registerKnotDefinition()Vol. 02 §4.2 · Vol. 04 §2.1

    Stores a listener's description under its name and gives it a bank of lanes with one trial lane.

    Specification
    Vol. 02 §4.2 · Vol. 04 §2.1
    Code
    registerKnotDefinition() in core/registers/register-knot-definition.ts, line 21: the description is stored under its name
    Journal
    #0 · CLEWS · open-clew · key: null, probe: true, replaced: false · by region:root
    Picture
    lane · trial lane (no key): — → open
    core/registers/register-knot-definition.ts · build 043cc8b
    1. // KNOT.DEFS write (Vol. 02 §4.2): the definition payload lands as data, and
    2. // re-registration of an id replaces the definition AND resets its clew bank
    3. // to a fresh null-key probe — accumulated clews of the old definition are
    4. // discarded (the machine's only 'edit'). The probe clew is supplied by the
    5. // resolved executor so invalid configuration has already failed at the
    6. // factory (Vol. 04 §2.1); the stale executor cache entry is dropped here so
    7. // the replacement takes effect for the next tuple.
    9. import type { KnotDefinedPayload } from "../topology/gate";
    10. import type { ClewRegisters, TopologyRegisters } from "./topology-registers";
    11. import type { RegisterFile } from "./register-file";
    12. import { recordTransition } from "./record-transition";
    14. export function registerKnotDefinition(
    15. file: RegisterFile,
    16. region: TopologyRegisters,
    17. payload: KnotDefinedPayload,
    18. probeClew: ClewRegisters
    19. ): void {
    20. const replaced = region.knotDefs.has(payload.id);
    21. region.knotDefs.set(payload.id, payload);↑ the description is stored under its name
    22. region.clews.set(payload.id, new Map([[null, probeClew]]));↑ its bank of lanes, with a trial lane
    23. file.ephemeral.knotExecutors.delete(`${region.regionId}/${payload.id}`);
    24. recordTransition(file, `topology:${region.regionId}`, "KNOT.DEFS", "register-knot", {↑ the change is written into the journal
    25. id: payload.id,
    26. strategy: payload.strategy,
    27. replaced
    28. });
    29. // The clew station is born here, with its null-key probe lane — journaled
    30. // on the station itself so fold(journal) holds it before any lane opens
    31. // (the document model's oracle, ADR-004 d10; Vol. 02 §4.5).
    32. recordTransition(file, `topology:${region.regionId}/clew:${payload.id}`, "CLEWS", "open-clew", { key: null, probe: true, replaced }, "registerKnotDefinition");↑ the change is written into the journal
    33. }

    AGPL-3.0-onlyThe Lab's demonstration environment, as this fragment ran it (build 043cc8b). The code may change, and may differ from the code of a working machine.

    Nest VM core, incubated in the CoAgnes garden · build 043cc8b (2026-09-21) · this file last changed in 6730f58 (2026-09-13)

    A finding for the machine's authors, recorded and left as it is: the journal stamps CLEWS·open-clew → core/registers/ensure-clew.ts for registerKnotDefinition(), which lives in core/registers/register-knot-definition.ts (the op map's file for that register · action).

when the membrane passed #0

  1. 9The membrane passes #0MEMBRANE.CURSOR · sweep

    a wave is settlingengine: at the endmembrane: passing #0

    The log
    1. #0a listenermembrane · passing
    2. #1a doer
    3. end of the logengine
    The membrane
    beforeafter
    pointer — the next record to pass#0#1

    With nothing left for the engine to take, the membrane passes over the new records. #0 asks nothing of the outside world, so its pointer simply moves on.

    Where it happens sweepNextTuple()Vol. 02 §4.6 · Vol. 07 §3

    The membrane's step: pass over the record under its pointer and move the pointer on — exactly once per record.

    Specification
    Vol. 02 §4.6 · Vol. 07 §3
    Code
    sweepNextTuple() in core/registers/sweep-next-tuple.ts, line 16: the membrane's pointer moves on by one
    Journal
    #0 · MEMBRANE.CURSOR · sweep · offset: 0 · by membrane
    Picture
    pointer — the next record to pass: #0 → #1
    core/registers/sweep-next-tuple.ts · build 043cc8b
    1. // MEMBRANE.CURSOR advance (Vol. 02 §4.6, Vol. 07 §3): the membrane's own
    2. // reading of the one log — the second reception of one publication, never a
    3. // second truth. The cursor advances exactly once per offset per machine:
    4. // the exactly-once discharge guarantee lives in this movement.
    6. import type { WaveTuple } from "../wave/gate";
    7. import type { RegisterFile } from "./register-file";
    8. import { recordTransition } from "./record-transition";
    9. import { setDriver, setWaveContext } from "./set-wave-context";
    11. export function sweepNextTuple(file: RegisterFile): WaveTuple | null {
    12. const engine = file.registers.engine;
    13. const membrane = file.registers.membrane;
    14. if (membrane.cursor >= engine.base + engine.window.length) return null;
    15. const tuple = engine.window[membrane.cursor - engine.base];
    16. membrane.cursor += 1;↑ the membrane's pointer moves on by one
    17. setWaveContext(file, { offset: tuple.offset, phase: "sweep" });
    18. setDriver(file, "membrane");
    19. recordTransition(file, "membrane", "MEMBRANE.CURSOR", "sweep", { offset: tuple.offset });↑ the change is written into the journal
    20. return tuple;
    21. }

    AGPL-3.0-onlyThe Lab's demonstration environment, as this fragment ran it (build 043cc8b). The code may change, and may differ from the code of a working machine.

    Nest VM core, incubated in the CoAgnes garden · build 043cc8b (2026-09-21) · this file last changed in 6730f58 (2026-09-13)

Choose a step in the stack — or press →.

A listener's definition

Brings a listener into the machine: its name, how it decides it is ready, what it collects into which slot, and the condition that makes it ready. The machine reads it once and sets the listener up; from then on the listener hears every matching fact. In a finished figure a loader writes it; here the fragment's author wrote it straight into the log — a liberty of this laboratory machine.

#0sys.knot.defined a person

envelope
offset0Its place in the log — the only address a record has. The engine gives it when the record is added, the next free number, and it never changes.
kindsys.knot.definedWhich of the four kinds of record the machine knows. The kind decides what the payload holds.
key∅No lane (∅): a definition belongs to the whole machine, not to one lane.
payload
idnote.gateThe listener's name, unique in this machine.
strategydeterministicHow it decides it is ready. Deterministic: by a plain condition over its slots — nothing is asked of the world.
payload.config
condition«note != null»When it is ready: as soon as the slot note holds something.
metatitle · gloss · fields ×1Words for people — a title, a gloss, the field a person fills. The machine's own parts never read them; only the screens do.
payload.config.wind.collect[0]
asnoteThe name of the slot the heard value goes into.
match_typenote.givenThe type of fact it hears.
reducelatestWhich value the slot keeps. Latest: the newest replaces the one before.
fieldtextWhich field of the heard fact goes into the slot.

end · #0

In the specificationVol. 03 §1Vol. 03 §2Vol. 03 §5Vol. 04 §2.1Vol. 05 §3Vol. 05 §4

Names it shares with other records

The record as the machine keeps it
{
 "offset": 0,
 "kind": "sys.knot.defined",
 "key": null,
 "payload": {
  "id": "note.gate",
  "strategy": "deterministic",
  "config": {
   "meta": {
    "title": "A note",
    "gloss": "One knot: it hears a note and is ready as soon as it has one.",
    "fields": [
     {
      "name": "text",
      "label": "A note, in your words",
      "kind": "text",
      "for": "note"
     }
    ]
   },
   "wind": {
    "collect": [
     {
      "as": "note",
      "match_type": "note.given",
      "reduce": "latest",
      "field": "text"
     }
    ]
   },
   "condition": "note != null"
  }
 }
}