CoAgnes Labthe study spaceresearch preview · build 1ececa2

Orientation · Volume 01

Volume 01 — Overview: the Nest Runtime at a Glance

CURRENTsnapshot of 14 July 20267 min read← Introduction and Reading MapVolume 02 — Machine Model and the Architectural Register File →

Reading aids · CoAgnes LabNot part of the specification; where they differ, the volume governs.

At a glance

  • The machine in one paragraph: one append-only log is its only memory; knots wind facts and test readiness; binds, woken by readiness, gather, judge and publish; the world is reached only through controllers on the membrane. §1
  • Six design commitments — one truth, a narrow core, two receptions, integration by publication, declared form with supplied content, honest incompleteness. §2
  • The machine's conceptual figure: a circle with a triangle inscribed — the topology above, the inner and the outer return below, both closing on the log. §3
  • The three stations and what each is denied — the activation knot, the bind descriptor, the output controller — and the observer beside them. §4
  • The three machine classes, what a programme looks like, the three load-bearing obligations, and what the machine deliberately is not. §5§6§7§8

Questions this volume answers

  1. What does the Nest runtime do, in one paragraph? §1
  2. How does it differ from a conventional processor? §1
  3. Which commitments shape the whole architecture? §2
  4. What does the circle-and-triangle figure show? §3
  5. What may a knot, a bind and a controller each do — and never do? §4
  6. What makes a machine deterministic, semantic or hybrid? §5
  7. What does a programme for the machine look like? §6
  8. What must hold for the machine's decoupled model to stay consistent? §7

§1. The machine in one paragraph

The Nest runtimeNest runtime / Nest virtual machine (Nest VM)The whole machine this set specifies: wave log + processors (topology and observers) + membrane + settle loop. In the reference project the bare word Nest historically named the workbench shell; this set reserves the machine sense and calls the workbench Nest Studio. (Vol. 00 §5)Volume 15 — Terminology is a virtual machine for accumulating and integrating understanding. Its only memory is an ordered, append-only log of immutable tuplesWave tupleAn immutable record in the wave log: offset, kind, key, payload. The unit of fact. aka tuple. (Vol. 03 §1)Volume 15 — Terminology. Its programme is a set of records committed to that same log: activation knotsActivation knotAn accumulating unit that matches wave tuples, winds them, and tests readiness; it accumulates understanding. When ready, it activates bind descriptors. Its minimal form is a single condition matcher — a degenerate configuration of the same accumulator, not a different kind. aka knot, clew (for the per-key instance see clew). (Vol. 05)Volume 15 — Terminology, which match and windWindThe act of integrating a matched tuple into the knot's wound state. Deterministic winding completes locally; semantic winding unfolds through the world — the knot projects a winding intention and later winds the returned integration. (Vol. 05 §1, §5)Volume 15 — Terminology incoming facts into accumulated understanding and test readinessReadinessThe state an activation knot reaches when its accumulated understanding satisfies its test; readiness is what activates bind descriptors. Readiness is reified: the topology commits it as a tuple carrying the understanding snapshot. (Vol. 02 §5, Vol. 04 §2.3)Volume 15 — Terminology; and bind descriptorsBind descriptorA bind. Woken by an activation knot, it gathers named understandings from the space, judges them, runs a service, and publishes an integration. aka descriptor, bind. (Vol. 06)Volume 15 — Terminology, which are woken by readiness, gather named understandings into a bound scopeBound scopeThe record of names — from the activation tuple and the demands — over which gates and the service are evaluated. (Vol. 06 §4)Volume 15 — Terminology, judge the scope with gatesGateA predicate over the bound scope. Gates decide between emit and reject; the current form is min_grade over a named entry. (Vol. 06 §5)Volume 15 — Terminology, run a serviceServiceThe function evaluated over the bound scope to produce the integration. Its kind (model instruction, deterministic function, other) is an assembly property. aka service function. (Vol. 06 §3, Vol. 08 §5)Volume 15 — Terminology over it, and publish the resulting integrationIntegrationThe understanding a bind descriptor forms and publishes as a wave tuple; received by others through binding — as an activation or as a demand — so integrations compose into higher-order understanding. (Vol. 06 §1)Volume 15 — Terminology back to the log. Everything external — a language model, an API, a human interface — is reached only through output controllersOutput controllerA receiver of committed tuples facing outward: it claims tuples by kind/fact type and discharges them to the external world exactly once per runtime. It neither judges nor integrates — a third station beside the activation knot and the bind descriptor, standing outside the propagation cycle on its own cursor. aka effector, egress handler. (Vol. 07 §2–3)Volume 15 — Terminology standing on the membraneMembraneThe boundary where the wave meets the world: output controllers face outward, ingress faces inward. (Vol. 07)Volume 15 — Terminology, and everything the world answers re-enters as committed facts. The machine is settledSettledQuiescent with no discharge in flight. (Vol. 03 §7)Volume 15 — Terminology when the log is quiescentQuiescentThe engine cursor has consumed the whole log and produced nothing further. (Vol. 03 §7)Volume 15 — Terminology and no external dischargeDischargeThe asynchronous execution of an external effect for one claimed tuple, resolving with the world's answers as emissions. (Vol. 07 §2)Volume 15 — Terminology is in flight.

Where a conventional processor executes instructions over mutable registers and memory, the Nest runtime propagates facts over immutable history. The programme does not address memory; it declares what it binds to. Control flow is not a branch instruction; it is readiness.

§2. Design philosophy

Six commitments shape every part of the architecture. They are stated here informally; their normative forms appear in the volumes cited.

  1. One truth, append-only. The wave logWave logThe ordered, append-only history of committed wave tuples. The single source of truth; entries are never rewritten, only appended. aka append-log. (Vol. 03)Volume 15 — Terminology is the single source of truth. Entries are never rewritten, only appended. Every state a shell or user interface shows is a derivation of committed tuplesWave tupleAn immutable record in the wave log: offset, kind, key, payload. The unit of fact. aka tuple. (Vol. 03 §1)Volume 15 — Terminology (Vol. 03, Vol. 08 §8).
  2. A narrow, invariant core. The core is the tuple envelope, the append-run engine, and three small contracts (processor, knotActivation knotAn accumulating unit that matches wave tuples, winds them, and tests readiness; it accumulates understanding. When ready, it activates bind descriptors. Its minimal form is a single condition matcher — a degenerate configuration of the same accumulator, not a different kind. aka knot, clew (for the per-key instance see clew). (Vol. 05)Volume 15 — Terminology executor, descriptor executor). Capability is never welded into it; everything grows around it as pluggable modules behind those contracts (Vol. 02 §2, Vol. 11 §2).
  3. One publication, two receptions. A committed tuple may be received inward — wound by knots into further understanding — and outward — claimed by a controllerOutput controllerA receiver of committed tuples facing outward: it claims tuples by kind/fact type and discharges them to the external world exactly once per runtime. It neither judges nor integrates — a third station beside the activation knot and the bind descriptor, standing outside the propagation cycle on its own cursor. aka effector, egress handler. (Vol. 07 §2–3)Volume 15 — Terminology and discharged to the world. Both are readings of the one log; nothing reaches the world that was not first a committed fact (Vol. 07 §1).
  4. IntegrationIntegrationThe understanding a bind descriptor forms and publishes as a wave tuple; received by others through binding — as an activation or as a demand — so integrations compose into higher-order understanding. (Vol. 06 §1)Volume 15 — Terminology by publication. No unit returns a value privately to another. A bind's integration is a committed tuple; others receive it by binding to it. Composition of understanding is therefore visible on the log, always (Vol. 06 §1).
  5. Declared form, supplied content. Wherever a non-deterministic oracle participates (a model, a human), the form of what it may produce is fixed in advance by a declaration — a schema, an emit declarationEmit declarationThe declared publication form carried in the intention: writes (one fact) or unfold (a sown-topology template); the proposed third member is cell. (Vol. 06 §6–8)Volume 15 — Terminology, a template — and the oracle fills content only. The machine validates before committing (Vol. 06 §6–7, Vol. 07 §4).
  6. Honest incompleteness. A wave that settlesSettleThe runtime algorithm alternating propagation with membrane discharges until the machine settles. (Vol. 08 §3)Volume 15 — Terminology without finishing is reported as such — a stalled knot, an unanswered intention, an open barrierBarrierThe join policy over demands (currently all): the rendezvous at which the bound demands become simultaneously available. The current barrier latches: a later readiness refreshes a demand's entry until projection. (Vol. 06 §4)Volume 15 — Terminology are visible states of the log, never masked as success and never silently retried (Vol. 08 §7).

§3. The figure: circle and triangle

The whole machine moves as a circle with a triangle inscribed — the machine's conceptual figure:

                      topology (directing structures)
                      knots · binds · controller claims
                               ▲
                              / \
              re-authored    /   \    declared
              from below    /     \   outward claims
                           /       \
                          ▼         ▼
        inner return: emissions    outer return: intentions
        committed and wound        discharged through the
        into further               membrane, computed by the
        understanding              world, re-entering as facts
                          \         /
                           \       /
                            \     /
                          the wave log
                        (one append-only truth)
Lab fig. 01·1A circle with a triangle inscribed. The top vertex is the topology — knots, binds and controller claims. From it one edge descends to the inner return at the lower left and one to the outer return at the lower right. A short curve closes the inner return on the wave log at the bottom; a wide curve, passing outside the circle through the world, closes the outer return on the same log.Topologyknots · binds · controller claimsre-authoredfrom belowdeclaredoutward claimsInner returnemissions committedand wound into furtherunderstanding —quiescence scaleThe wave logone append-only truthOuter returnintentions discharged,computed by the world,re-entering as facts —world scaleThe machineThe worldThe membranecontrollerthe world computes
Lab fig. 01·1A circle with a triangle inscribed. The top vertex is the topology — knots, binds and controller claims. From it one edge descends to the inner return at the lower left and one to the outer return at the lower right. A short curve closes the inner return on the wave log at the bottom; a wide curve, passing outside the circle through the world, closes the outer return on the same log.Topologyknots · binds · controller claimsre-authoredfrom belowdeclaredoutwardclaimsinnerouterThe wave logone append-only truthThe machineThe membraneThe worldcontrollerthe world computesInner returnemissions committedand wound into furtherunderstanding —quiescence scaleOuter returnintentions discharged,computed by the world,re-entering as facts —world scale
Lab fig. 01·1 The machine's figure, redrawn: the topology at the top directs both descents and is itself re-authored from below; the inner return closes at quiescence scale, the outer return at world scale — two radii, one kind: both are returns to the log. A reading aid by CoAgnes Lab; §3 governs.
  • The top vertex is the topologyTopologyThe live set of registered activation knots and bind descriptors that the wave flows through. (Vol. 02 §5)Volume 15 — Terminology: registered knotsActivation knotAn accumulating unit that matches wave tuples, winds them, and tests readiness; it accumulates understanding. When ready, it activates bind descriptors. Its minimal form is a single condition matcher — a degenerate configuration of the same accumulator, not a different kind. aka knot, clew (for the per-key instance see clew). (Vol. 05)Volume 15 — Terminology, binds, and outward claims. It directs both descents, yet it is not static — a planner bind may raise fresh records out of settledSettledQuiescent with no discharge in flight. (Vol. 03 §7)Volume 15 — Terminology understanding, so the top is continually re-authored from below (Vol. 06 §7, Vol. 10 §6).
  • The lower-left corner is the inner return: emissionsEmissionA wave tuple without its offset — the form in which content is handed to the engine; the engine assigns the offset at append. (Vol. 03 §1)Volume 15 — Terminology committed back to the log and wound into further understanding, closing at quiescenceQuiescentThe engine cursor has consumed the whole log and produced nothing further. (Vol. 03 §7)Volume 15 — Terminology scale.
  • The lower-right corner is the outer return: intention tuplesIntention tupleA committed tuple claimed by an output controller: the reified intent to interact with the world, carrying a correlation identity so the world's answer can find its cascade. (Vol. 04 §4.1, §5.1)Volume 15 — Terminology discharged through controllersOutput controllerA receiver of committed tuples facing outward: it claims tuples by kind/fact type and discharges them to the external world exactly once per runtime. It neither judges nor integrates — a third station beside the activation knot and the bind descriptor, standing outside the propagation cycle on its own cursor. aka effector, egress handler. (Vol. 07 §2–3)Volume 15 — Terminology, computed by the world, re-entering as facts — not an exit but the longest arc of the circle, closing at world scale.

The two corners differ in radius, not in kind: both are returns to the log.

§4. Stations of execution

Three stations receive committed tuplesWave tupleAn immutable record in the wave log: offset, kind, key, payload. The unit of fact. aka tuple. (Vol. 03 §1)Volume 15 — Terminology; each has one competence and is denied the other two. This separation is load-bearing and appears throughout the set.

Lab fig. 01·2A row of records, the log, across the middle. Above it an activation knot takes a matching fact from the log and writes its readiness back; a bind descriptor takes that readiness and writes an integration back. Below it a controller standing on the membrane takes a tuple it claims, discharges it once to the world, and the world's answer returns to the end of the log as a fact. At the top right an observer reads the log along dotted lines and writes nothing.Activation knotwinds · reports readinessBind descriptorgathers · judges · publishes#0#1#2#3#4#5#6#7#8The logmatching factsreadinessintegrationa tuple it claimsThe machineThe worldOutput controllerdischarged exactly oncethe world computesthe answer,as factsobserverreads everything;emits nothing thatchanges behaviour
Lab fig. 01·2A row of records, the log, across the middle. Above it an activation knot takes a matching fact from the log and writes its readiness back; a bind descriptor takes that readiness and writes an integration back. Below it a controller standing on the membrane takes a tuple it claims, discharges it once to the world, and the world's answer returns to the end of the log as a fact. At the top right an observer reads the log along dotted lines and writes nothing.The log#0#1#2#3#4#5#6#7#8observerreads everything;emits nothing thatchanges behaviourActivation knotwinds · reports readinessBind descriptorgathers · judges · publishesa tuple it claimsOutput controllerThe worlddischarged exactly oncethe world computesthe answer,as facts
Lab fig. 01·2 Three stations receive committed tuples, each with one competence: a knot winds the facts it matches and reports readiness; a bind, woken by that readiness, gathers its scope, judges it and publishes an integration; a controller discharges what it claims to the world exactly once and returns the answer as facts. An observer may read everything and emits nothing that changes behaviour. A reading aid by CoAgnes Lab; §4 governs.
StationReceivesMay doMust never do
Activation knotmatching factswind them; project winding intentions bounded to its own accumulation; report readinesspublish integrations for others; judge; touch the world
Bind descriptorreadiness of its knotsgather the bound scope; judge with gates; run/project a service; publish integrations or rejections; emit topology recordswind ambient facts; touch the world directly
Output controllercommitted tuples it claimsdischarge them to the world exactly once; return the world's answer as fact emissionsjudge; integrate; originate semantic content

A fourth kind of participant, the observerObserverA passive wave processor that mirrors tuples and emits nothing behavioural. (Vol. 02 §3.4)Volume 15 — Terminology (any additional wave processor), may read everything and emit nothing that changes behaviour; the Nest Studio live feed is exactly such a mirror (Vol. 08 §8).

§5. Machine classes: deterministic, semantic, hybrid

The class of a machine is decided by the functions bound at two places — knotActivation knotAn accumulating unit that matches wave tuples, winds them, and tests readiness; it accumulates understanding. When ready, it activates bind descriptors. Its minimal form is a single condition matcher — a degenerate configuration of the same accumulator, not a different kind. aka knot, clew (for the per-key instance see clew). (Vol. 05)Volume 15 — Terminology integrationIntegrationThe understanding a bind descriptor forms and publishes as a wave tuple; received by others through binding — as an activation or as a demand — so integrations compose into higher-order understanding. (Vol. 06 §1)Volume 15 — Terminology and bind servicesServiceThe function evaluated over the bound scope to produce the integration. Its kind (model instruction, deterministic function, other) is an assembly property. aka service function. (Vol. 06 §3, Vol. 08 §5)Volume 15 — Terminology — and both are deliberately left to the implementation and assemblyAssemblyThe construction of one machine instance: engine with processors, membrane with controllers — one assembly shared by every shell of a product. (Vol. 08 §1)Volume 15 — Terminology:

  • A deterministic machine installs deterministic executors everywhere: deterministic knots, local integratorsLocal integratorThe pure function (deltas) → {state, grade} used by locally winding semantic knots. (Vol. 05 §5.1)Volume 15 — Terminology that are pure functions, and controllersOutput controllerA receiver of committed tuples facing outward: it claims tuples by kind/fact type and discharges them to the external world exactly once per runtime. It neither judges nor integrates — a third station beside the activation knot and the bind descriptor, standing outside the propagation cycle on its own cursor. aka effector, egress handler. (Vol. 07 §2–3)Volume 15 — Terminology that compute answers deterministically (or no controllers at all). Such a machine is a classical dataflow/rendezvousRendezvousOne key lane's gathering state of an operator bind: activation flag, scope, one-shot projection latch. (Vol. 02 §4.5, Vol. 06 §4)Volume 15 — Terminology engine: same seeds, same log, byte for byte. Standard business processes run here.
  • A semantic machine installs an inference controller on the membraneMembraneThe boundary where the wave meets the world: output controllers face outward, ingress faces inward. (Vol. 07)Volume 15 — Terminology and authors knots with integrate: through_world and binds whose services are operator instructions. Understanding is then integrated by a model; the log records every intention, answer, reasoning, and failure. Replay of the log is still deterministic reading; re-execution is not.
  • A hybrid machine mixes both in one topologyTopologyThe live set of registered activation knots and bind descriptors that the wave flows through. (Vol. 02 §5)Volume 15 — Terminology: deterministic gatesGateA predicate over the bound scope. Gates decide between emit and reject; the current form is min_grade over a named entry. (Vol. 06 §5)Volume 15 — Terminology and rendezvous around semantic integration cells. The bundled problem.frame pipeline is such a figure (Vol. 10 §8).

The three classes share one log format, one propagation algorithm, one settleSettleThe runtime algorithm alternating propagation with membrane discharges until the machine settles. (Vol. 08 §3)Volume 15 — Terminology algorithm, and one authoring grammar. The kind of a bind's service function — LLM-discharged instruction, deterministic function, rule engine, human task — is a property of the installed controllers and declared strategies, constrained only by the protocol contracts of Vol. 04 and the station rules of §4. This is the primary portability claim of the architecture: runtime general, semantics pluggable.

§6. What programmes look like

A programme is an authoring pipelineAuthoring pipelineThe external, human-authored document describing a whole scenario. It lives outside the machine. (Vol. 09)Volume 15 — Terminology: a YAML document (or package with schemas) declaring inputs, knotsActivation knotAn accumulating unit that matches wave tuples, winds them, and tests readiness; it accumulates understanding. When ready, it activates bind descriptors. Its minimal form is a single condition matcher — a degenerate configuration of the same accumulator, not a different kind. aka knot, clew (for the per-key instance see clew). (Vol. 05)Volume 15 — Terminology, and descriptors. A loaderLoaderThe component that splits an authoring pipeline into individual records and commits them as seeds. aka splitter. (Vol. 09 §6)Volume 15 — Terminology compiles it into individual recordsIndividual recordA single activation-knot or bind-descriptor definition, split out of the authoring pipeline at load and committed to the wave log. (Vol. 04 §2)Volume 15 — Terminology — sys.knot.defined and sys.descriptor.defined emissionsEmissionA wave tuple without its offset — the form in which content is handed to the engine; the engine assigns the offset at append. (Vol. 03 §1)Volume 15 — Terminology — which are committed to the log like any other tupleWave tupleAn immutable record in the wave log: offset, kind, key, payload. The unit of fact. aka tuple. (Vol. 03 §1)Volume 15 — Terminology and materialised by the topologyTopologyThe live set of registered activation knots and bind descriptors that the wave flows through. (Vol. 02 §5)Volume 15 — Terminology as they are read (Vol. 09). At runtime a bind may itself emit topology records under a declared template (unfold), so the machine can sow bounded new topology mid-flight; the sown records carry a provenance stampProvenance stampemittedBy: <service uid> on every emission of a delegated emit template — the explicit sowing thread. (Vol. 06 §7.4)Volume 15 — Terminology (Vol. 06 §7).

yaml
# The bundled demo pipeline, complete (the golden fixture's programme, Vol. 14 §2)
pipeline: demo.intent
inputs:
  - { id: message, writes: chat.message.received, field: message }
knots:
  - id: intent.understanding
    strategy: semantic_evaluator
    wind:
      collect:
        - { as: user_messages, match: chat.message.received, reduce: append, field: message }
    condition:
      questions: ["Is the user's end goal clear?", "Are the required parameters gathered?"]
      threshold_grade: 0.8
descriptors:
  - id: action.notify.business.analyst
    on: intent.understanding
    action: emit
    writes: intent.understanding.ready

Fed two seed messages, this programme produces the golden six-tuple log with readinessReadinessThe state an activation knot reaches when its accumulated understanding satisfies its test; readiness is what activates bind descriptors. Readiness is reified: the topology commits it as a tuple carrying the understanding snapshot. (Vol. 02 §5, Vol. 04 §2.3)Volume 15 — Terminology reified at offset 4 and the final fact at offset 5 — the conformance anchor of Vol. 14 §2.

§7. The three load-bearing obligations

The decoupled model — heads seeding cascadesCascadeThe chain (activation knot → bind descriptor → activation knot → …) seeded by a head, whose integrative end a demand gathers. (Vol. 01 §7)Volume 15 — Terminology, demandsDemandA named binding (as:) to an activation knot whose integrated understanding the bind descriptor gathers back. The gathering face of affinity, and the second method through which understanding enters the bind. aka tendril. (Vol. 06 §3–4)Volume 15 — Terminology gathering their ends — is consistent only while three obligations hold. They recur across this set as gatesGateA predicate over the bound scope. Gates decide between emit and reject; the current form is min_grade over a named entry. (Vol. 06 §5)Volume 15 — Terminology on every extension:

  • AttributionAttribution, reachability, terminationThe three load-bearing obligations of the decoupled model. (Vol. 01 §7)Volume 15 — Terminology — every integrationIntegrationThe understanding a bind descriptor forms and publishes as a wave tuple; received by others through binding — as an activation or as a demand — so integrations compose into higher-order understanding. (Vol. 06 §1)Volume 15 — Terminology is attributable to the head or activation it serves. Carried today by keys and the emittedBy provenance stampProvenance stampemittedBy: <service uid> on every emission of a delegated emit template — the explicit sowing thread. (Vol. 06 §7.4)Volume 15 — Terminology; homed in branches and ledgers as they become enforced; extended by Cell ownership in the proposed extension (Vol. 03 §5, Vol. 11 §4, Vol. 12).
  • Reachability — a cascade seeded by a head must be able to reach the demand that gathers it. An authoring obligation, statically checkable over declared records (Vol. 09 §8, Vol. 12 §6).
  • Termination — a cascade may fail to complete; in an append-only machine this is an unfinished quiescenceQuiescentThe engine cursor has consumed the whole log and produced nothing further. (Vol. 03 §7)Volume 15 — Terminology, not an explosion. Handled by budgets, the quiescence rule, and honest unfinished-state reporting (Vol. 05 §6, Vol. 08 §7).

§8. What the machine deliberately is not

  • It is not a message broker: tuplesWave tupleAn immutable record in the wave log: offset, kind, key, payload. The unit of fact. aka tuple. (Vol. 03 §1)Volume 15 — Terminology are never consumed, routed away, or acknowledged out of the log; reception is reading.
  • It is not a workflow engine with mutable task state: there is no state to mutate, only history to append and derive from.
  • It is not an agent framework with private tool-call returns: every external effect and answer crosses the log.
  • Its isolation constructs (branches, ledgers, Cells) are semantic scoping, not an operating-system sandbox; native generated code is out of scope for the runtime proper (Vol. 12 §1, §10).