NEURON-LOOPS · ENGINEERING ARCHIVE · DO NOT DEPLOY WITHOUT READING THE FILE

FILE NL-VEIL In the matter of the local‑first swarm engine
NL‑VEIL

One binary, many minds, one shared memory  ·  written in Zig
Maintainer of record: gary23w  ·  case opened 2026, still open

At 9:12 on an ordinary evening, somebody sat down at the desk and typed one line: cast a swarm to build it. By 9:40 the gateway had checked the key at the door, the supervisor had detached a worker, and eleven minds were reading one shared memory. Every tool call, every failure, every lesson the hive kept — it all went in the file.

The board below is exactly as the engine left it after the last cast. Drag anything. Pull the string. Read everything twice.

SOURCE OF RECORD: github.com/gary23w/nl-veil

THE BOARD

Thirteen items, twelve lengths of red string. The string is the architecture; every item opens a source document.

DRAG ITEMS · PULL THE STRING · CLICK TO READ THE DOC  (keyboard: tab to an item, arrows move it, enter examines)

DOCUMENT INVENTORY

Contents sheet: every source file across the modules — the server (its CLI and the server-side chat brain) and the native desktop, veil-desk. Generated from source; amended as the source moves.

NEURON‑LOOPS ENGINEERING — FILE NL‑VEIL — CONTENTS OF FILE

    photographs and tag examinations are pinned to the board. where else would they be. —g.

    A CAST, RECONSTRUCTED

    Round by round, from the one‑line goal to the collected deliverables. Sources in brackets open the file. Three entries circled in grease pencil.

    1. 21:12

      The goal arrives: one line, typed at the desk. The gateway checks the key at the door. The audit log writes down the knock before anything answers it.

      [, ]
    2. 21:13

      The supervisor detaches a worker. Casts run as separate processes; a cast survives the server that started it, the way a boat survives the dock.

      []
    3. 21:14

      The blueprint is drawn. The goal declares its file tree and every file gets an owner; no mind writes a teammate’s slice. Eleven minds open one shared memory and begin.

      [, ]
    4. 21:20

      A write misses. The failure is recorded with its exact path before anything else happens. The fix comes later; the record comes first.

      []the miss is written down before the fix. that order is the whole method. —g.
    5. 21:26

      Edits from eleven minds meet in one file. Disjoint regions merge on their own. The same region is a conflict, and conflicts are said out loud, never papered over.

      [, ]
    6. 21:31

      The checkpoint is rebuilt from the record: what completed, what’s blocked, what’s pending. No model is asked for its opinion — the ledger already knows.

      []
    7. 21:33

      Out of band, a reviewer reads the round’s real tool trace and mints a lesson into the live hive — only what the trace can ground, nothing a mind merely claimed.

      []a lesson nobody typed. it came off the trace. —g.
    8. 21:38

      The crawler brings back the outside. A fetched fact enters the hive only with a verbatim quote from the page that said it; the rest stays outside where it belongs.

      [, ]
    9. 21:40

      Smoke test. The deliverable is booted and probed, not admired. Passing tests are not a working app; a working app is a working app.

      []
    10. 21:55

      The judge scores the cast. The governor reads the fitness curve, trims what idles, keeps what moves. A plateau is information, not failure.

      []the score is not the goal. read the curve. —g.
    11. 22:05

      Collection. Files, the event stream, the metered spend, and the record of what was actually verified against what was merely assumed. All of it goes in the file.

      [, ]
    12. No cast is closed until somebody reads the file.

    WHAT THE ENGINEER KEPT

    Four memos from the maintainer’s personal jacket. Not part of the generated record. Filed anyway.

    MEMO TO FILE — ON THE ENGINE — NEURON‑LOOPS

    The engine is a floor, not a script. It never learns what a goal means; it learns how goals move. The day a use case gets hardcoded into the loop is the day the loop stops deserving the name. Strategy has to emerge from live signals, or it isn’t strategy — it’s superstition with an if‑statement.

    Every mechanism in this file is general. If you find a branch in the engine that knows what it’s building, tear it out and file the report.

    MEMO TO FILE — ON THE HIVE — NEURON‑LOOPS

    Separate memories made polite strangers. One shared memory made a swarm. Every observation any mind makes lands where every other mind can reach it; the crawler’s facts, the builder’s failures, the judge’s scores — one hive, no private notebooks.

    A mind that shares what it sees is worth six that don’t. We counted.

    MEMO TO FILE — ON FEEDBACK — NEURON‑LOOPS

    Outcome feedback strengthens what exists. It never creates what doesn’t. A win saturates a memory; it does not invent one. We learned this the way you learn everything worth knowing: by watching a thing that should have stayed finished get resurrected by its own reward signal, and then never letting it happen again.

    Plasticity is a privilege of evidence. Nothing mints but the trace.

    MEMO TO FILE — ON PROOF — NEURON‑LOOPS (FINAL)

    Whoever reads after me: the case is one blueprint, one shared memory, one honest record of failure, and a ledger of what was verified against what was merely assumed. Put them in that order and there is only one way to build.

    A benchmark says the score is high. The smoke test says the app boots. Those are different sentences. Knowing isn’t proof — that is the whole difference between a score and the truth, and the engine pays that difference on every cast.

    If you’re reading this, the swarm is yours now.
    Look at the events log again. —g.

    Source document