The whole loop, on one brain

Theory update · 2026-06-28 · the loop closes on one brain · experiment grounded-loop, the talkable assembly

Three threads have been running side by side. A fully-neural reading path that segments raw characters with Hebbian char-transition synapses and binds word to referent. A reverse-Hebbian mouth that names a referent. A held-out comprehension test with correction by consequence. Each was a separate script. This round assembles all of them into one brain on our own runtime (cortexshell, cortexgraph), four organs as connected Areas, and runs the whole loop: it reads raw chars, binds word to referent, comprehends a held-out question, speaks a name, and is corrected when it is wrong. The load-bearing fact is that all four phases run on the same organ instances, and the single Hebbian matrix W inside the binder is written by learning, read forward to comprehend, read backward to speak, and re-written by correction. No backprop, gradient-free, online single exposure, bounded memory. The numbers, all on the one brain. Comprehend: held-out referential pointing, choose the meant referent among four distractors never studied together, 0.910 against a shuffle control at 0.217 and chance 0.250. Speak: content production with a silence self-check 0.917, a real comprehension-over-production gap of +0.333, and the gate stays silent on the one word it cannot isolate rather than misnaming it. Correct: the environment re-utters a misunderstood word with the right referent in focus, a consequence and not a label, and that lifts the mistaken word's comprehension 0.472 to 0.674, where a yoked recast reaches only 0.506 (corrected over yoked +0.169, winning three of four seeds). And it holds a sample conversation: the brain points to and names apple, cup, box, and ball. A grep of the live path confirms no counting and no hand-tokenizing anywhere. The dog-and-ball demo the program has chased for months runs, fully neural, on the runtime, with no cheating.

What this round assembles

The comprehension thread had reached a clean result with an honest hole at the bottom of it. End to end, no backprop showed a gradient-free learner develop class codes from context and the binder generalize to a novel entity on them, and it named the three things it had not done: there was still no real language, no reader extracting structure from a raw stream, and no spoken answer. The generation thread had reached its own endpoint, a live conversation with Haiku, word-salad with real glimmers of relevance, a separate producer voicing real words but on hand-fed meaning codes, not reading raw text.

So the two threads named the same missing piece from opposite sides. Comprehension wanted a reader and a voice. Generation wanted real text in and a grounded loop. This round builds the join: one brain that reads raw characters, binds, comprehends, speaks, and is corrected, with nothing hand-parsed on the live path.

Nothing here re-implements an organ. Each Area class is imported from the script that validated it, and importing it registers it on the shared runtime so the brain resolves it by type. The fully-neural segmenter comes from the reading-path work, the union encoder and the binder from the runtime, the generator from the production work. The assembly is the result, not a rewrite.

The one brain: four organs as Areas

The brain is four Areas on the runtime's tick graph. The environment injects raw characters, the scene's referents with a fallible focus, and a goal referent to name. Every edge reads the previous tick, the runtime's one uniform rule, so the reading path is three hops deep.

The four organs:

• /brain/seg, the segmenter (HebbCharSeg). Raw characters in, chunk-ids out. It finds a boundary from a Hebbian char-transition signal, synapses plus a dip threshold, the way surprise carves a word. This is the fully-neural reader, with the last counting removed: no char-bigram dictionary, no hand-tokenizing.
• /brain/enc, the encoder (UnionEncoder). Chunk-ids in, the union of their fixed sparse SDRs out. It turns a word into the code the binder reads.
• /brain/assoc, the binder (HebbAssoc). The word-SDR and the scene's referents in, with the focus up-weighted. It writes one Hebbian matrix W and reads word to referent back out of it.
• /brain/gen, the mouth (HebbGenerator). A goal referent in, the named word out. It holds build-time references to the binder and the encoder so it reads their own learned state, the same shared-organ pattern the runtime already uses for its spelling lexicon.

The load-bearing fact is that all four phases run on the same instances. Comprehension reads a column of W (the word's units) and takes the argmax over the present options. Production is the dual on the same W, reading a row (the referent's units) and cleaning up over the chunk SDRs. Correction writes one more ordinary exposure into the same W. One matrix, read three ways.

The four phases, on the same brain

Observe and learn. Stream scenes through the reading path: a named referent, distractors, a fallible focus, and a raw-char utterance with spaces stripped. The segmenter segments, the encoder unions, the binder binds word to referent with the focus up-weighted. The message buffers clear between scenes; the learned state, the segmenter's synapses and lexicon and the binder's W, persists. One pass, no gradient, no batch.

Comprehend, held-out. The environment utters a known word and shows a new scene whose distractor set was never studied together, held out by a signature over the target and its distractors. The word goes through the real reading path to produce its SDR, and the binder's own W is read restricted to the present options. The brain points. It never sees the truth; the pick is scored. The control is a second brain trained with the word-to-referent contingency broken.

Speak. Inject a goal referent on the mouth, which reads the binder's own W in reverse and cleans up to the nearest learned chunk, which the lexicon spells. Two scores: open-vocab, where the mouth could blurt any learned chunk, and content with a silence self-check, where it keeps the produced word only if that word re-comprehends to the goal through the brain's own ear, else it stays silent. The comprehension-over-production gap is measured against open-vocab.

Correct. On a wrong point the environment recasts: it re-utters that word in a fresh scene with the correct referent in focus, through the brain's own raw-char reading path. This is an ordinary next exposure, Hebbian-updated like any scene, and it is a consequence, never a label or a target or a gradient. Corrected, recasting the failed word, runs against yoked, which earns the same recast budget but spends each one on a scrambled word, the same content with the wrong contingency. If contingent recast beats yoked on the words that erred, the loop taught, not the words.

What happened

The brain runs the whole loop in one foreground process, about nine seconds. The numbers, all on the same brain, with chance at 0.250 to point among four and 0.083 to name from the twelve-word lexicon:

Read comprehension first. The brain points to the meant referent 0.910 of the time on distractor sets it never studied together, while the shuffle control sits at 0.217, essentially chance. So the binding is the word-to-referent contingency won from co-occurrence, not a leaked alignment or a memorized scene, and it generalizes to new combinations.

Read the gap next. Comprehension only needs the right referent to win among a few present options, 0.917. Open-vocab production must pick the one right word out of the whole learned lexicon, carriers and content and over-segmentation fragments together, and it inherits all the segmenter's noise, 0.583, a +0.333 gap. This is the predicted asymmetry, the same comprehension-over-production gap the generation thread kept finding, now measured inside one grounded brain. The content production with the silence self-check recovers to 0.917 by naming with a content word and checking it through the brain's own ear, and where it cannot isolate a word it stays silent rather than blurting a wrong name.

Read correction last. None is flat: pure exposure does not move the undertrained brain, 0.472 before and after. Corrected lifts the mistaken words 0.472 to 0.674. Yoked, the same recast budget spent on scrambled words, reaches only 0.506. So the contingent recast wins by +0.169 on the words it targeted, three of four seeds. The loop taught, not the words, and the recast was an ordinary raw-char exposure-in-contrast, no label and no gradient.

The sample conversation

Every line is a real act through the runtime. Pointing reads the binder's W among the present referents; naming reads the same W in reverse and spells the chunk.

  [the room]  on the table: apple, cup, box, ball

  env  (points at apple):  "this apple"   [raw chars: "thisapple"]
  env  (points at cup):    "here cup"     [raw chars: "herecup"]

  env :  "where is the apple?"     brain (points): apple    correct
  env :  "where is the cup?"       brain (points): cup      correct
  env :  "where is the box?"       brain (points): box      correct
  env :  "where is the ball?"      brain (points): ball     correct

  env  (points at apple): "what is this?"  brain (says): "apple"   correct
  env  (points at cup):   "what is this?"  brain (says): "cup"     correct
  env  (points at box):   "what is this?"  brain (says): "box"     correct
  env  (points at ball):  "what is this?"  brain (says): "ball"    correct

The environment grounds two facts in raw chars it reads, then asks the brain to point, then asks it to name. All on the one brain, all neural.

What this means

The two threads are one architecture now. For months the program built organs in isolation and named the join it had not made. This round makes it. The same four organs on the runtime observe, comprehend, speak, and are corrected, and the same Hebbian matrix W is written by learning, read forward to comprehend, read backward to speak, and re-written by correction. Comprehension and production are not two systems; they are one matrix read in two directions, which is why the comprehension-over-production gap falls out of the geometry rather than being engineered in.

The faithfulness is the point, so it is checked, not asserted. The live path has no counting and no hand-tokenizing: the segmenter finds boundaries from a Hebbian char-transition signal, the encoder unions fixed sparse SDRs, the binder and mouth are one W, and a grep of the run confirms no transitional-probability segmenter and no bigram dictionary anywhere on the path. The whole loop is gradient-free, online single exposure, under a bounded memory budget. The four laws hold end to end.

The talkable brain is assembled and shown. One brain on the runtime, four Hebbian and SDR organs, that reads raw chars, binds word to referent, comprehends a held-out question (0.910 against a shuffle at 0.217), speaks a name (content production 0.917, a real comprehension-over-production gap of +0.333, silent where it cannot isolate a word), and is corrected by consequence (the mistaken word 0.472 to 0.674, beating a yoked recast by +0.169 over three of four seeds). Fully neural, no counting on the live path, gradient-free, online, no cheating. The comprehension-over-production gap and the contingent correction advantage are both the predicted, real effects. The integration the program kept pointing at is delivered on the runtime.

The honest bounds

These are the genuine limits, and they name the next work.

• The lexicon is small and synthetic. Twelve content words in a closed apple-and-cup world. The reading path uses real content strings, but the world is built to be parsed, not drawn from open text. The sharp claim is the assembled loop and the two effects inside it, not that this vocabulary is language.
• The twelve-word cap weakens the yoke. With about four err-words out of twelve, a random recast lands on one with probability about a third, so a single seed can tie corrected and yoked. The contingent advantage is therefore reported as the mean over four seeds, +0.169 with three of four wins, which is honest rather than a single cherry-picked seed.
• Held-out comprehension needs enough referents. The held-out distractor-set signatures are combinatorial, so a smaller cast exhausts them and the metric goes undefined. The default of twelve referents leaves held-out sets and keeps the conversation cast clean. This is a property of the combinatorics, stated plainly.
• Correction headroom lives in the binder, not the segmenter. An undertrained segmenter has no chunk-ids, so every point fails on a missing lexicon and a recast is pure noise. So the correction phase warms the segmenter to a solid lexicon first, then zeros only the binder's W and gives it a tiny binding dose, a cold listener with a warm ear. The recast stays an ordinary raw-char exposure; only the binding starts cold. A faithful split, and an integration choice worth naming.
• One content word is left un-isolated, about one in twelve. The cold-start segmenter does not always carve leaf (and on some seeds ball) whole, the same failure the organ scripts report, so it cannot be named and the silence self-check correctly defers. The brain is on par with the organ scripts here, not strictly better.

Lineage

Grew from two threads at once. From end to end, no backprop, the comprehension thread that proved the binder generalizes on learned codes and named the three things it had not done: no real language, no reader, no spoken answer. And from a conversation with Haiku, the generation thread that voiced real words in a live loop but on hand-fed meaning codes, with the comprehension-over-production gap visible as a producer that voices a neighbor of the word it meant. This round answers both: a reader on raw chars, a voice, and the gap measured inside one grounded brain.

Led to the open work the bounds name: a larger and realer lexicon, so the yoke and the held-out combinatorics stop being tight; correction headroom carried in the segmenter as well as the binder; and the move from a built apple-and-cup world toward open text the brain was not handed to parse. The organs are assembled and the loop is closed; the next swing is scale and realer language.

Thread: comprehension and generation, joined. The two tracks the program ran in parallel are one architecture now: one brain on the runtime that reads, binds, speaks, and is corrected in its environment, the same matrix read forward and backward, fully neural and gradient-free, with the comprehension-over-production gap and the contingent correction advantage both the predicted, real effects.