A child-brain in a staged curriculum

Program milestone · 2026-06-28 · a developmental child-brain in a staged curriculum · experiments dev-brain, dev-curriculum

The program has, for months, built organs in isolation and then named the join it had not made. This round makes two joins at once. First, it assembles one child-brain on our runtime: a neural segmenter, a union encoder, a two-compartment binder, a working memory with a top-down route, and a generator. It reads raw characters, binds a word to a referent, speaks a name, holds a working memory of the discourse, and uses top-down context to disambiguate a word whose meaning depends on the topic. Gradient-free, no counting, online single exposure, bounded memory. On the assembled brain: held-out referential comprehension 0.983 against a shuffle control at 0.276 (chance 0.250), content production 0.932, and a working-memory benefit that is clean against every control, context-dependent disambiguation 1.000 with the working memory versus 0.500 without it. Second, it puts that one brain into a staged developmental curriculum with a real Haiku caregiver, anchored to cited child-acquisition norms, each stage gated by a comprehension test, the child's vocabulary and comprehension lagging the adult by construction (comprehension leads production). 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 versus 0.481, the adult-ahead lag a real 2 (adult 11 nouns, child comprehends 9, produces 0). G2, two words and a property, passes on the same brain plus one faithfully added typed-store organ: typed color 0.807 and size 1.000 with a wrong-class rate of 0.000, corrected over yoked 0.557 versus 0.083, and the construction lag (comprehension ahead of production) positive across the whole climb, up to +0.39. The curriculum trains the whole brain, not ad-hoc per-stage organs. G3, morphology, is in progress. The recurring honest finding: the developmental lag lives in construction complexity (two words, then morphology), and the catch-up bottleneck is segmentation, perception precedes reference. And the deep abstraction question is still open, reported here as honest open science with the numbers: a purely-unsupervised, gradient-free route to transferable abstraction through time is a real ingredient but does not clear the bar, because the decorrelation the substrate needs to stay high-rank fights the predictive pull that would bind same-class items. The next move is a dedicated binding mechanism, not more time.

What this round assembles

Two threads had each reached a clean endpoint with an honest hole at the bottom. The comprehension thread, in the whole loop on one brain, wired a fully-neural reader, a binder, and a mouth into one brain that read raw chars, bound, comprehended, spoke, and was corrected, all on the runtime. The acquisition thread, across counting cannot bind and the comprehension slices, built and validated the organs a developing brain needs: a fast content-addressable binder, a working memory, a top-down apical route. What neither had done was put a single brain through a life, a staged curriculum in which an adult speaks ahead of it and it catches up the way a child does.

So this round builds the join in two steps. It assembles the validated organs into one brain with a working memory and a top-down route, and it shows that working memory earns something the talkable brain alone could not. Then it drives that same brain through a developmental curriculum with a real caregiver, gated by comprehension, with the lag a child shows made mechanical. 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 assembly is the result, not a rewrite, and the runtime is untouched.

The one brain, and what its working memory earns

The assembled brain is a cyclic tick graph on the runtime. The reading path (segmenter to encoder) feeds a two-compartment binder: the word drives the basal compartment, the held discourse context modulates the apical one. The binder's output climbs to a working memory that latches the discourse topic with a leaky accumulator, and that topic descends back through a thalamus gate into the binder's apical port. The mouth reads the binder's matrix in reverse. Every edge reads the previous tick, so the loop is genuinely recurrent.

The talkable core reproduces on this assembled graph (the two-compartment binder, apical off, basal-only readout): held-out referential comprehension 0.983 against a shuffle control at 0.276 near chance 0.250, and content production 0.932 against chance 0.091, means over seeds 0, 1, 2, 7. The binding is the contingency, not an artifact, and the brain still reads, binds, and speaks.

What the working memory and top-down route earn is the part the talkable brain alone could not do: resolve a word whose referent depends on the discourse. A shared ambiguous word, read from raw chars, has its basal binding split about evenly across topics, so the word alone is at chance. Each topic owns unambiguous content words that the brain reads and binds, pulling the working memory toward a topic, and only the held top-down topic resolves which referent the ambiguous word means.

The benefit is +0.500 over the no-context arm, and every control lands where a real mechanism should. The discourse context the working memory accumulated, descended through the top-down route, is what resolves the word. This is the smallest honest demonstration that the brain uses what it is holding, not just what it is hearing.

The staged curriculum, on that same brain

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. Comprehension precedes production throughout the second year (a child understands far more words than it produces). And the adult's lexicon is always a superset of the child's. So the curriculum holds two lags by construction, printed every run, not tuned to look good: the adult produces more than the child comprehends, and the child comprehends more than it produces. A word enters the child's comprehension only after enough grounded co-occurrence under joint attention, so the gap is real and it shrinks as exposure accumulates.

The stages track real acquisition norms, with the difficulty axis the child's mean length of utterance and grounded vocabulary, not age:

• G1, one word, naming, anchored to the twelve-to-eighteen-month one-word stage. The caregiver names the focus in short here-and-now speech; the child grounds nouns word to referent and points among distractors.
• G2, two words, a property, anchored to the vocabulary spurt and the first two-word combinations near two years. The caregiver describes a scene's properties; the child binds an entity to a property within a scene and answers what color or size.
• G3, early grammar, anchored to Brown's middle stages, function words and morphemes appearing in order. In progress this round.
• G4, sentences, relations, a grade-two register, the open end of the ladder.

The split of labor is principled. Haiku is the adult for the parts whose branch we cannot script: it picks what to talk about, phrases the naming and the recast in natural speech, supplying 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, the count baselines. Haiku's language never enters the child's weights except as ordinary heard exposure, the same channel any caregiver utterance rides.

G1 passes on the bare brain, nothing added

The child reads a noun from raw chars through the segmenter, the binder grounds the word to a referent, and it points among distractors. The organs used are exactly the bare assembled spine: the segmenter, the encoder, the binder, the mouth. Nothing is added. Means over seeds 0, 1, 2, 7:

Reference is won cross-situationally, not leaked: the shuffle control sits at chance. The contingent recast teaches where a yoked recast does not, the Goldstein-Schwade yoke, on the brain's own binder. And the lag is real: the child comprehends nine of the eleven nouns the adult uses and produces none, because it is observe-dominant early in life.

The honest finding under G1 is that the lag is gated by segmentation. On the one brain, comprehension failure early in life is dominated by words the child has not yet isolated from the speech stream, not by weak binding. The learning curve shows it: pointing is 0.000 at ten scenes, climbs through 0.905 at forty, and saturates to 1.000 by eighty, as the segmenter snaps to full coverage. The gate dose sits mid-climb on purpose, so the lag is visible. The catch-up bottleneck is the brain's own segmenter: it must isolate a word before it can attach a meaning. Perception precedes reference.

G2 passes on the same brain plus one added organ

The bare binder grounds a word to a referent and to a context, but it is not a typed property store. So typed color and size questions, with the wrong-class control, need a typed store added as an organ on the same graph. It is added faithfully: a new typed-store Area, registered locally with the runtime untouched, doing the in-scene typed binding the binder cannot, with the role read off the perceptual channel the percept arrived on, not a word tag. The child's own reading spine still grounds the property words; the added store does the typed binding. Means over the same seeds:

Typing is not free: the untyped bag of the same facts confuses the classes at a coin-flip, while the typed store keeps them separate, with the role being the perceptual channel rather than a word label. And the construction lag is the developmental asymmetry made mechanical: single-slot comprehension leads two-word production across the catch-up climb, then both saturate together.

The honest finding under G2 is that the construction complexity is where the lag now lives. G1's lag was about isolating a single word; G2's lag is about combining two. And the segmentation constraint recurs: the property words must isolate cleanly, so the curriculum uses maximally distinct color and size words, a faithful constraint (a child's early words are distinct), reported openly. The catch-up bottleneck stays segmentation; the developmental lag has moved up to construction.

A sample exchange, on the one brain

[turn 1] scene = {cup, cat, leaf, key}  (caregiver focus: cat)
  CAREGIVER: here is the cat do you see it
  child reads raw chars, hears 'cat'  ->  points at (unsure)   [the lag in action]
  CAREGIVER (recast): look, there is the cat by the window
                      -> the child re-grounds 'cat' as ordinary exposure, not a label

[turn 2] scene = {cat, dog, hat, key}  (caregiver focus: key)
  CAREGIVER: what a pretty key you found
  child reads raw chars, hears 'key'  ->  points at 'key'      [right]

Turn one's unsure point is the lag: at the gate dose, the word is not yet committed, so the binder gives no confident referent, and the recast gives it one more grounded moment. The curriculum trains the whole brain (the segmenter, the binder, the mouth, and the added typed store), not a fresh organ per stage.

The honest abstraction question, still open

Alongside the developmental work, the program kept chasing a harder prize: a purely-unsupervised, gradient-free route to transferable abstraction, the kind of code that lets a class generalize to a held-out member. The metric is transfer CCGP. The standing bar is the program's own per-unit-credit arm at 0.451 (declined here because it uses a teaching signal), against a backprop ceiling of 0.484. The pure local-Hebbian wall sits near 0.34. The bet this round tested: can time clear it, a local predictive rule (LPL) that pulls each moment toward the next, with no teaching signal at all?

The answer is an honest negative with a decisive diagnosis. Time is a real ingredient, but it does not clear the bar, and the way it falls short is the finding.

On character text, four seeds, the plain predictive rule ties the pure-local wall (apex transfer CCGP 0.344 against 0.342): no win. The only arm that rises is the one with the anti-collapse term removed: the no-BCM variant reaches 0.427, +0.085 over the wall. That is exactly the point, not a loophole. The BCM term is part of the decorrelation machinery the sparse substrate needs to stay high-rank, and you have to weaken it before the predictive pull can bind same-class items at all. None of these arms clears the 0.451 credit-using value. (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.)

We then asked whether the wall is an environment problem rather than a mechanism one. Character text has thin temporal contiguity (adjacent characters are usually different classes), while the rule earned its abstraction on vision, where an object persists across many frames. 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: strip 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 organ did not pull same-class referents together. The small positive wiggles on the easier probe are the organ riding the static cue still present in the window, not transfer abstraction built from time, and they vanish the instant that cue is removed.

The diagnosis is mechanistic and it is the load-bearing result. The predictive pull only has a path to bind different referents into one code at the saccade tick, where the previous code is a different referent's. But every other tick, the substrate's boosting and decorrelation push codes apart to keep the population high-rank, which is exactly what the sparse substrate needs and what prevents a rank-one collapse. These two forces oppose each other, and at any predictive rate that keeps the code usable, the decorrelation wins. The mechanism that keeps the code healthy is the same mechanism that forbids the binding abstraction needs. Richer time gives the predictive term more same-class adjacencies to act on, but it still cannot out-pull the decorrelation, so more contiguity does not help. This converges with the offline arm above: both say the gap is a missing binding step, not missing time.

So the open direction is named, and it is not more time. It is a dedicated binding mechanism that survives the decorrelation pressure: a slower altitude that pools over a whole fixation, a predictive pull gated on segment boundaries, or a recurrent attractor that pulls same-context codes together after the decorrelated front end, so binding and high rank stop competing. That is the next experiment this negative motivates. No breakthrough is claimed here. Time is necessary and not sufficient, with the numbers, and the wall is sharpened, not crossed.

What this means

The developmental framing is now real, not a sketch. There is one brain that reads, binds, speaks, holds a working memory, and uses top-down context, and it lives in a staged curriculum with a caregiver who speaks ahead of it, gated by comprehension, anchored to how children actually acquire language. Two stages pass with their adversarial controls clean, on the same brain, with the developmental lag a measured fact rather than a knob. The curriculum trains the whole brain, and where a stage needs a new organ (the typed store at G2), it is added faithfully and the runtime stays untouched.

The recurring lesson is consistent across both stages. The developmental lag lives in construction complexity: one word at G1, two words at G2, morphology ahead at G3. And the catch-up bottleneck is segmentation: the child must isolate a word from the stream before it can ground its meaning. Perception precedes reference, and it precedes construction. This is the shape a child's acquisition has, falling out of the brain rather than being engineered in.

The deep abstraction question is still open, and that is stated plainly. A gradient-free route to transferable abstraction through time is a real ingredient that does not clear the bar, because decorrelation and binding are in tension. The next move is a binding mechanism, not more time. The program publishes this negative with the numbers, because a sharpened wall is information too.

One assembled child-brain (held-out comprehension 0.983, production 0.932, working-memory disambiguation 1.000 with context versus 0.500 without) is driven through a staged developmental curriculum with a real caregiver, gated by comprehension, anchored to child-acquisition norms, with the child lagging the adult. G1 (one word) passes on the bare brain (pointing 0.828, shuffle 0.238, corrected 0.827 versus yoked 0.481, lag 2); G2 (two words and a property) passes on the same brain plus one added typed-store organ (color 0.807, size 1.000, wrong-class 0.000, corrected 0.557 versus yoked 0.083, construction lag up to +0.39); G3 is in progress. The lag lives in construction complexity and the catch-up bottleneck is segmentation. The deep, transferable abstraction question stays open: time is a real ingredient (the no-decorrelation arm rises +0.085 over the wall) but does not clear the 0.451 credit-using bar, because the decorrelation that keeps the code high-rank fights the predictive pull that would bind same-class items. The next move is a dedicated binding mechanism, not more time.

The honest bounds

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

• The lexicon is small and synthetic. Eleven to twelve content words in a closed world built to be segmented, not open text. The sharp claim is the assembled brain and the two 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 G2 uses maximally distinct color and size words. A faithful constraint (a child's early words are distinct), reported openly, not a cheat.
• The binder bootstrap is inherited. The two-compartment binder will not learn its basal map unless an apical signal is present, so grounding teacher-forces a constant context with the gate open and the readout stays genuinely basal-only. This is a documented integration choice, not a runtime change.
• The caregiver occasionally breaks character. The keyless agent is the project-aware assistant, not a bare model, and about two of fifteen 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 abstraction result is bounded and negative. Character text and a small rich stream, four seeds; the effect sizes are small and the per-seed variance is large, but the binding-isolation probe 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, and it tests the exact existing rule, not the binding candidates it motivates.
• The runtime is untouched. The runtime files are byte-for-byte unchanged. The added typed store is registered locally on a brain instance, the same pattern the working-memory organ uses, and all reuse of the validated scripts is read-only import.

Lineage

Grew from two threads at once. From the whole loop on one brain, the comprehension assembly that read raw chars, bound, comprehended, spoke, and was corrected, but ran one brain through a flat episode list rather than a life. And from the acquisition slices, counting cannot bind and typed, grounded, and true, which built and validated the fast binder, the typed store, and the truth-tracking the curriculum's gates reuse. This round adds the working memory and the top-down route, shows they earn context-dependent disambiguation, and drives the assembled brain through staged, comprehension-gated developmental stages with a real caregiver and the child lagging the adult.

Led to the open work the bounds name. The curriculum continues at G3 (morphology) and toward G4 (relations, negation, grade-two dialog), with the lesson that the lag lives in construction complexity and the bottleneck is segmentation now a standing prediction to test up the ladder. And the deep abstraction direction is sharpened, not closed: a dedicated binding mechanism that survives decorrelation (a slower pooled altitude, a boundary-gated predictive pull, or a recurrent attractor after the decorrelated front end), the next experiment, because more time will not do it.

Thread: comprehension and generation, joined and made developmental. The two tracks the program ran in parallel are one architecture now, one brain that reads, binds, speaks, holds a working memory, and is corrected, 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, and the deepest abstraction question held open and honest.