A tiny brain that comprehends, abstracts, and speaks

Program milestone · 2026-06-28 · a tiny brain that comprehends a grounded conversation, abstracts a concept through language, and speaks it back · experiments dev-brain, dev-curriculum (G1 to G4, syntax, mouth), word-gated

This is the biggest milestone of the program. A small brain, gradient-free, online, bounded-memory, on our own recurrent runtime, learns language the way a child does, and three threads that ran for months in parallel converge into one architecture. It comprehends a simple grounded conversation: one assembled brain is driven through a developmental curriculum G1 to G4 with a real Haiku caregiver who speaks ahead of it, each stage gated by a comprehension test, the child lagging the adult by construction, and all four stages pass on the same brain (held-out relation QA 1.000, negation 1.000, live multi-turn dialog comprehension 12/12). It abstracts a concept through language, the project's hardest problem, resolved in-bounds: six purely-perceptual unsupervised mechanisms all failed to build transferable abstraction, for one clean reason, and the resolution is the program's own thesis, the WORD, won cross-situationally with no label, as the cross-instance equivalence that perception cannot supply (held-out class-CCGP without the word ~0.40, the wall; with the word 0.87 synthetic, 0.50 to 0.99 on the real grounded encoder, an honest operating-point curve, collapsing under every control). It speaks: a production-side composer, the inverse of comprehension, emits structured sentences (whole-relation structure 1.000 on held-out meanings, surface form 0.918 after a whole-word prior; live, "the cup is not gold" comes back as "cup not gold"). No backprop, no credit signal, no counting on the live path. The deep abstraction question is reported as a curve, not a single number, and the open edges are named honestly: the converging negatives are the substance, because they built the resolution.

What this round joins

The program has, for a long while, built organs in isolation and then named the join it had not yet made. The last round made the first developmental join: it assembled the validated organs into one brain with a working memory and a top-down route, and drove that brain through the first two stages of a curriculum, G1 and G2. It left three things open at the bottom of it. The curriculum stopped at G2 with G3 in progress. Production was telegraphic, the brain comprehended a relation but could not say it. And the deep, transferable-abstraction question was held open, with a gradient-free route through time named as a real ingredient that did not clear the bar.

This round closes all three at once, and that is why it is a capstone rather than a step. Comprehension reaches the top of the ladder: G3 (morphology) and G4 (relations, negation, grade-two dialog) both pass on the one brain, so the brain now understands a simple grounded conversation. Production catches up to comprehension on structure: a composer makes the brain speak the relation it comprehends, not just name the parts. And the abstraction wall is resolved in-bounds by the project's own thesis, the word, with the six perceptual negatives that built the resolution reported as the substance. Nothing here re-implements an organ. Each Area class is imported from the script that validated it, the runtime is byte-for-byte untouched, and the four laws (online, gradient-free, bounded, human-cognition-guided) hold the whole way.

Thread one: it comprehends a simple grounded conversation

The child is the one assembled brain from the dev-brain work, imported verbatim: a neural segmenter reads raw characters, a union encoder lifts chunk-ids to word SDRs, a two-compartment binder grounds word to referent and to context, a working memory latches the discourse topic and descends a top-down route into the binder's apical port, and the mouth reads the binder's matrix in reverse. The talkable core reproduces on the assembled graph (held-out referential comprehension 0.983 against a shuffle control at 0.276 near chance 0.250, content production 0.932), and the working memory earns what the talkable brain alone could not, resolving a word whose referent depends on the discourse, 1.000 with the held context against 0.500 without it, every control clean.

That brain is given a childhood. The curriculum enforces one rule above all: the child lags the adult. Real children do not hear language at their own level; adults speak ahead of them, and the child catches up from exposure under shared attention. Two cited facts make this concrete and non-negotiable, printed every run rather than tuned to look good: comprehension precedes production throughout the second year, and the adult's lexicon is always a superset of the child's. The stages track real acquisition norms, with the difficulty axis the child's mean length of utterance and grounded vocabulary, not age. Haiku is the adult for the parts whose branch we cannot script (it picks the focus, phrases the naming and the recast in natural speech, supplies the superset vocabulary that is the lag); the deterministic controls carry the parts that must be adversarial (the scene generator, the per-episode randomization, the shuffle and yoked ablations). Haiku's language never enters the child's weights except as ordinary heard exposure.

The first two stages were established last round: G1 (one word) passes on the bare brain with nothing added (held-out pointing 0.828, shuffle 0.238 at chance, a contingent recast beating a yoked one 0.827 against 0.481, the adult-ahead lag a real 2), and G2 (two words and a property) passes on the same brain plus one faithfully added typed-store organ (typed color 0.807, size 1.000, wrong-class 0.000, corrected over yoked 0.557 against 0.083, the construction lag up to +0.39). This round climbs the rest of the ladder.

G3, morphology, passes: the segmentation bottleneck made concrete, then cracked

The last round found the catch-up bottleneck is segmentation, not binding. G3 is exactly where that becomes the task, because a grammatical morpheme is a sub-word chunk. The Haiku caregiver uses the three early-Brown morphemes, the present-progressive -ing, the past -ed, and the plural -s, and the child must isolate each one as a recurring sub-word chunk and comprehend its grammatical meaning, generalizing it to a held-out stem.

The load-bearing result is established by direct probe before any gate was built, and it is honest about a real limit of the brain's own segmenter. The forward transitional-probability segmenter cannot place a morpheme boundary, and this is structural, not a tuning bug: at a stem-affix boundary the forward transition into the affix is high (the affix is frequent, so predictable), so the dip lands inside the stem, and "walking" is cut as "wal-king." Measured on the trained synapses, the forward segmenter isolated -ing 4/10, -ed 2/10, -s 0/10. The right instrument is the same chunking principle one altitude down: a grammatical morpheme is a recurring detachable trailing chunk, a string heard on many words whose bare stem was also heard. That detector, added as one faithful organ on the same graph (registered locally, runtime untouched), cracks all three cleanly (-ing 10/10, -ed 10/10, -s 10/10, bare stems intact 20/20, zero over-peel of monomorphemic look-alikes like "king" and "bed"), and it generalizes, peeling the morpheme off a held-out stem never heard inflected.

On the comprehension test, the morpheme does referential work: given an inflected word, the child chooses which grammatical scene the morpheme marks among three, and on held-out stems this reads 1.000 (chance 0.333), with a permutation-null shuffle at 0.368. G3 also surfaces the prediction confirmed: at G1 and G2 the adult-ahead lag was transient, collapsing once words were isolated, but at G3 the lag becomes durable, a standing comprehension-over-production asymmetry. The child comprehends the morpheme at ceiling and generalizes it, but produces the inflected form only about half the time, exactly Brown's "comprehension leads; the morphemes appear later, in order." The grammar lag has moved from a transient perception gate to a standing production deficit, where the curriculum predicted it would.

G4, relations and negation and dialog, passes: the brain understands a conversation

G4 is the endpoint the whole curriculum aimed at: sentences with two-place relations, negation, wh- questions, and a contingent multi-turn dialog. The brain binds who-does-what-to-whom by role-filler binding (Plate's HRR and Kanerva's HDC, the project's existing kit), and the faithful seam is that the role is won from the perceptual scene, not handed in: the agent and patient assignment of each participant is decided by a role binder that grounded each participant's relational role from the perceptual role-channel (the mover versus the affected) cross-situationally, with fallible joint attention, never told. The store never sees word order. Negation is won the same way: the child perceives whether an asserted property matches the entity in the scene, so "the ball is not red" files a negative because the child sees the ball is gold.

The numbers are clean and they generalize. Relation QA on held-out (subject, verb, object) compositions never bundled during grounding reads patient 1.000, agent 1.000, predicate 1.000 (chance 0.250), with the role won at 1.000; the store-shuffle control collapses to 0.250 and the role-shuffle to chance. Negation QA reads 1.000 (chance 0.500), with the shuffle at chance. A learning curve shows the relation generalizing once the role has been won from enough events, a clean Oudeyer plateau (relation QA climbs from 0.420 at two events to 1.000 at about forty, then flattens), the curriculum's "won, not told" made visible. And the multi-turn dialog works at the comprehension level: over four shared scenes the child comprehends each of the caregiver's relation, wh-, and negation turns, comprehension 12/12 = 1.000. The brain understands a simple grounded conversation.

The honest finding under G4 is that production, on its own, is the bottleneck, and the round located it precisely: in G4 alone the child comprehends the whole relation and even names all three content words (word-production about 0.68), but it has no production-side organ to mark the relation, so structured-sentence production is 0.000. That is Brown's telegraphic stage made mechanical, and it is exactly what thread three resolves.

Thread two: it abstracts a concept, via language

This is the project's hardest problem, and the part to be most careful and honest about. For months the program collected closed doors on a gradient-free, transferable abstraction, and the substance of the resolution is those closed doors, because they built it.

Six purely-perceptual mechanisms failed, for one clean reason

Six purely-unsupervised perceptual mechanisms tried to build transferable class abstraction (high transfer CCGP) from a percept stream alone, with no teaching signal, and none of them cleared the bar.

• Temporal prediction (LPL). A local predictive rule that pulls each moment toward the next is a real ingredient but does not clear the bar. On character text at four seeds the plain rule ties the pure-local wall (apex transfer CCGP 0.344 against 0.342). The only arm that rises is the one with the anti-collapse term removed (0.427, +0.085 over the wall), and that is the point, not a loophole: the anti-collapse term is part of the decorrelation the sparse substrate needs to stay high-rank, and you must weaken it before the predictive pull can bind same-class items at all. None of these arms clears the program's own credit-using value of 0.451, against a backprop ceiling of 0.484. (An earlier two-seed run had read the plain rule at 0.422 and looked like a win; it did not replicate at four seeds, falling to 0.344, so the honest number is the tie.)
• A temporally-rich stream. We asked whether the wall is an environment problem rather than a mechanism one, since character text has thin temporal contiguity. So we built a faithful temporally-rich stream (persisting objects, gaze-dwell, slow discourse drift) and drove the same organ through it. The decisive control is a binding-isolation probe that strips the static input window of all class information, so any above-chance class CCGP must be pure learned temporal binding. The result, four seeds: 0.159 with time on, 0.159 with it off, both below chance 0.333. The small positive wiggles on the easier probe are the organ riding the static cue still in the window, and they vanish the instant that cue is removed.
• Slow pooling. A dedicated slow temporal-pooling layer, separated from decorrelation by altitude and timescale, can bind same-class items in principle, but only on a minority of seeds. The four-seed mean looked like a clean pass only because one lucky seed dragged it up; the per-seed shuffle breakdown exposed the trap and the honest verdict refuses to call it robust.
• Attention in space and time. Attention spread in space and time, computed off the decorrelated substrate, does not bind class on the isolation probe (the temporal axis adds only +0.013, the spatial axis actually hurts at -0.051), and wherever a knob pushes CCGP above chance the code's rank collapses, the mirage a participation-ratio floor correctly rejects. Attention selects where and when to pool; it does not, by itself, select class.
• A CA3-style recurrent attractor. This was the last purely-perceptual mechanism. A Hopfield-style attractor settling the fast code toward a stored prototype does not bind class either (settled code 0.257 near the raw 0.172 at chance 0.333), and every regime that pushes CCGP up does so by rank-collapse. It fails for the same reason as the others: an attractor's basins form by similarity, and on a decorrelated code same-class instances are near-orthogonal, so pattern completion sends them to different prototypes.

The single reason is sharp and it recurs across all six. A class is an equivalence over non-adjacent instances. Perceptual similarity, contiguity, and dynamics can only find adjacency, recency, or the instance, and on a decorrelated code the same-class instances are near-orthogonal, so they look different, not the same. Worse, the diagnosis is mechanistic and load-bearing: the decorrelation the substrate needs to stay high-rank fights the predictive pull that would bind same-class items. The mechanism that keeps the code healthy is the same one that forbids the binding abstraction needs.

The resolution is the project's own thesis: the word

A language learner has exactly the signal perception lacks. The same word ("dog") heard across perceptually-different instances is the non-adjacent class-equivalence relation: it binds instances seen minutes apart, under different views, into one class. Crucially the word is won cross-situationally from co-occurrence under fallible focus, never handed as an instance-to-class label, never a parse, never a class tag. Routed through the word-to-referent binder the program already has, the word becomes the cross-instance integral: because the Hebbian matrix accumulates over the whole stream, the confusable common features (bound to every word) are flattened while the class-distinctive features (bound preferentially to one word) are amplified. One perceptual glimpse is a single noisy sample; the word is the integral over thousands of them.

The numbers are reported as an honest operating-point curve, not a single hero figure. On the exact Bernardi-Fusi CCGP ruler, one-shot held-out class-CCGP is without the word about 0.40, at the perceptual wall. With the word it is 0.874 on a synthetic stream (4/4 seeds, far past the 0.484 ceiling). On the dev-brain's real grounded scene encoder it is 0.504 at the faithful headline operating point (3/4 seeds), and the real encoder reveals what the synthetic world hid by fixing one point: the size of the lift depends on how reliably the class attribute is perceived per glimpse, rising monotonically to 0.78 to 0.99 (4/4 seeds) as perception sharpens, and correctly to nothing when the attribute is barely perceived. That is the curve, stated plainly.

And the controls are decisive, on every seed:

The decorrelation-versus-binding tension the perceptual arms diagnosed is sidestepped, not fought: the binding signal is no longer "what co-occurs in a time window" (which tracks the instance) but "what co-occurs with the word across situations" (which tracks the class). The purely-unsupervised constraint held the whole way. We did not relax it; we used language. No backprop, no internal credit, no counting.

The richness lesson

A separate run asked whether a richer world helps the word-gated abstraction, and the finding is sharper than a yes. Richness holds: a full-vocabulary varied environment is essentially flat against the already-clean isolated-word baseline, all seeds passing with clean shuffle-collapse. The Mowgli case fails: decouple the target word from its class (no recurring co-occurrence) and it collapses to the wall, exactly as predicted, because the integral cannot form. But the sharp finding is a control result: an impoverished fixed-context environment is pathological. When the same distractors co-occur with a target every time, they bind spuriously and the "class" can be read off the fixed context even with the target word shuffled, so the word-shuffle control fails to collapse and a naive read is fooled. Varied context is what makes the word signal clean. Richness's true payoff is not a CCGP boost over the clean baseline; it is unconfounding the signal.

Thread three: it speaks

G4 left the brain telegraphic: it comprehended the relation and named the three words, but it could not say who does what to whom, because the mouth emits one chunk per goal and there is no production-side organ that orders the relation's participants. This thread builds that organ, a composer, and it is the production-side inverse of comprehension.

Comprehension reads roles in: given a scene and a queried role, unbind one role and clean up among the present options. Production reads roles out: given the intended-meaning role-filler bundle (the same representation the brain comprehends), the composer unbinds each role, cleans each recovered code against the referent codebook, names each one with the brain's own mouth, and emits them in a fixed canonical role order. It adds no new learning rule and registers no new organ; it is a function that chains the brain's own organs, the role-filler unbind run for all three slots plus the reverse-matrix mouth plus a fixed ordering.

The faithful crux is that order is a fixed production schema, not a parse handed in. The input is an unordered superposition, a bundle that has thrown order away; the composer reconstructs order by unbinding known roles in a fixed sequence, the agent-first frame a child holds early (Brown). The swap control proves it: swap agent and patient in the meaning and the surface order swaps too, the agent emitted first in both, so the order tracks the role, never an input position. Free word order is a later module.

The result closes the talkable loop. Structured-relation production on held-out meanings is 1.000 (agent, verb, patient, and whole-relation structure all 1.000, against a whole-relation chance of 0.0046), where G4's structured production was 0.000, so the comprehension-leads-production lag shrank from +1.000 to +0.000 on the structure. A shuffle of the meaning bundle collapses production to chance, so the structure carries it.

The surface form is reported as a separate, honest ceiling. The mouth dropped leading chunks on a few over-segmented words ("hat" to "at", "hug" to "ug"), capping surface-exact whole-relation production at 0.684 while the structure stayed perfect. A whole-word prior fixes the surface form: the brain's own segmenter, replayed over the brain's own heard exposure, accumulates how often each chunk was heard as a standalone word, and the noisy reverse-matrix readout is snapped to a complete heard word. This lifts per-word naming from 0.870 to 0.963 and surface-form whole-relation production from 0.684 to 0.918, with structure untouched at 1.000, and ablating the prior collapses surface form to 0.122. The honest new ceiling is 0.918, not 1.000, and the residual is exactly one word per seed that the brain genuinely never heard whole (the segmenter splits it to a fragment every time), so it is absent from the heard-word prior, the no-cheating constraint working. The remaining lift lives in the segmenter (fewer over-cuts), upstream of the mouth.

And the child speaks in a live dialogue. Over four shared scenes it comprehends every caregiver turn (12/12) and now produces a structured response (8/8): when Haiku says "the cup is not gold," the child reads the whole utterance from raw chars, binds the relation, and composes "cup not gold." It is speaking the relation, not pointing one word.

What this means

There is now one brain that reads raw characters, binds, comprehends, holds a working memory, uses top-down context, abstracts a concept through language, and speaks the relation it understands. It lives in a staged curriculum with a caregiver who speaks ahead of it, gated by comprehension, anchored to how children actually acquire language, and all four developmental stages pass on the same brain with their adversarial controls clean. The recurring lesson is consistent across the whole ladder: the developmental lag lives in construction complexity (one word, then two, then morphology, then relations), and the catch-up bottleneck is segmentation, the child must isolate a unit from the stream before it can ground its meaning. Perception precedes reference, and it precedes construction.

The project's hardest problem, a gradient-free route to transferable abstraction, is resolved in-bounds, and the way it was resolved is the program's own thesis rather than a new trick. Six perceptual mechanisms failed for one clean reason, and the resolution is the word, won without a label, as the cross-instance equivalence perception cannot supply. The lift is a curve, the negatives are the substance, and the constraint never relaxed.

One assembled child-brain, gradient-free, online, bounded-memory, on our own recurrent runtime, comprehends a simple grounded conversation, abstracts a concept through language, and speaks it back. Comprehension: a developmental curriculum G1 to G4 with a real caregiver, all four stages passing on the same brain (G3 morphology referential 1.000, G4 relation QA 1.000, negation 1.000, dialog 12/12), the lag living in construction complexity and the bottleneck in segmentation. Abstraction: six purely-perceptual mechanisms fail because a class is an equivalence over non-adjacent instances, resolved by the cross-situationally-won WORD (class-CCGP without 0.40, with 0.87 synthetic and 0.50 to 0.99 grounded, every control collapsing it), no backprop, no credit, no counting. Speech: a composer that is the inverse of comprehension (structure 1.000 on held-out meanings, surface 0.918), live "cup is not gold" to "cup not gold." The open edges are named and honest.

The honest bounds

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

• The lexicon is small and synthetic. Eleven to eighteen content words per stage in a closed world built to be segmented, not open text. The sharp claim is the assembled brain and the four passed stages with their controls, not that this vocabulary is language.
• The vocabulary must segment cleanly. The transitional-probability segmenter cannot isolate words that share a prefix with a carrier, so the upper stages use maximally distinct content words. A faithful constraint (a child's early words are distinct), reported openly, not a cheat.
• The mouth's last residual is segmenter over-cuts. Surface-form production caps at 0.918, not 1.000, because one word per seed is genuinely never carved whole and so cannot be spoken whole. The structure is always 1.000; the fix is a segmenter improvement upstream of the mouth.
• Free word order is a later module. The composer produces only the canonical agent-verb-patient schema. A fixed early order is faithful (Brown); flexible order driven by emphasis or topic would need a learned production-side ordering policy, explicitly out of scope here.
• The relational and typed stores are content-addressable memory; the learned part is the role won from the scene. The role-filler unbind and the typed bind, once fed a won role, are deterministic algebra that does not "learn"; the learning lives in winning the role and the class from perception, which the learning curves show, and the held-out generalization is the algebra composing.
• The abstraction result is bounded and is reported as a curve. Character text and a small grounded encoder, three to four seeds; the lift depends on how reliably the class attribute is perceived (0.50 at the headline point, 0.78 to 0.99 as perception sharpens, nothing at the floor), the per-seed variance is real, and the binding-isolation probe on the perceptual arms is unambiguous (on equals off to three decimals). A larger world might surface a weak binding the decorrelation cannot fully suppress; this run shows none.
• Some earlier reads used two seeds and did not replicate. The temporal-prediction win (0.422) and one slow-pooling pass were two-seed reads that fell apart at four seeds, caught by the controls. The honest numbers are the four-seed ones. This is the rigor the program demands, and naming it is part of the credibility.
• The caregiver occasionally breaks character. The keyless agent is the project-aware assistant, not a bare model, and a fraction of calls drop the required word; we detect that and fall back to the scripted caregiver line, which guarantees the word, counted as a refusal. The recast that enters the child's weights is the scripted grounding of the true percept, not the model's text, so the mechanism is unaffected.
• The runtime is untouched. The runtime files are byte-for-byte unchanged. Every added organ (the morpheme segmenter, the role binder, the relational and polarity stores, the typed store, the whole-word prior) is registered locally on a brain instance, and all reuse of the validated scripts is read-only import.

Lineage

Grew from the whole developmental line at once. From a child-brain in a staged curriculum, the one assembled brain with a working memory and a top-down route and the first two passed stages, G1 and G2. From the whole loop on one brain, the fully-neural reader, binder, and mouth read forward to comprehend and backward to speak. And from the long abstraction arc, the cortex is the dial and end to end, no backprop, where the abstraction engine became the generalization dial, and the negatives (attention is prediction, not abstraction among them) that named the decorrelation-versus-binding tension this round resolves with the word.

Led to the open work the bounds name. The mouth's last residual scopes a segmenter fix (fewer over-cuts); free word order scopes a production-side ordering policy; and the deepest direction, a larger and realer world, is the natural next move: scale and a real child-egocentric corpus (SAYCam, and Vong's word-acquisition work on it), where the word-gated abstraction can be tested on natural perception rather than a built encoder.

Thread: comprehension, abstraction, and generation, joined and made developmental. The three tracks the program ran in parallel are one architecture now, one brain that reads, binds, comprehends a grounded conversation, abstracts a concept through language, and speaks it back, living in a staged curriculum that mirrors how a child acquires language, with the developmental lag and the comprehension-leads-production asymmetry both the predicted, measured effects, the hardest abstraction question resolved in-bounds by the project's own thesis, and the open edges held honest.