Adapting two labs into a grounded grammar

Program milestone · 2026-06-29 · two adjacent research programs, adapted onto our gradient-free, online, grounded language route, and beaten by adding the scene · experiments learned-word-order, merge-bind, sequence-stack-recursion, learned-dependency, multicolumn-voting, role-factored-routing, retention-scale

We read two adjacent research programs hard and adapted their findings onto our own route: gradient-free, online, grounded, learned through language. The headline is a real, learned, grounded grammar, every piece composing the same organs, all without a gradient. The child learns word order, all six constituent orders (1.000 at high exposure, chance 0.167), with the typological signature that object-initial orders are harder reproduced honestly from a salience prior and confirmed by ablation. It does recursion: a sequence-memory stack carries an interrupted constituent across an embedded clause, so "the dog that chased the ball is big" attaches "big" to the dog, 1.000 with the stack against 0.000 with it ablated (a no-stack count baseline sits near chance), in comprehension and production, with a human-like depth ceiling. This is the recursive machine the Assembly-Calculus line only sketched, and it closes our own prior recursion failure. It resolves attachment that word order cannot: a learned, grounded dependency reader scores 0.958 against a nearest-head baseline at 0.533, because the scene disambiguates where the surface string is identical, a learned parser beating their hand-coded, ungrounded one. Underneath, two pieces of biological topology transfer: multi-column cortical voting (hub 0.647 against a single column 0.360, scaling cleanly with columns) and thalamic role routing (noun, attribute, action at 0.988, 1.000, 1.000, soft competition beating hard). And, framed as supporting work, our language route does not erode at 10M continual exposure (held-out abstraction flat, grounding improving) where an apical-credit route eroded 12%, so we do not need their metaplastic fix. The through-line is one word: our edge is grounding. The honest corrections are stated plainly: the substrate is not ours, only two of their operations are proven, and the ceilings and crosstalk are real.

Two labs, one wall, two routes

For a long while the program has been stuck against one wall: a gradient-free route to transferable abstraction, the ability to treat two perceptually different instances as the same class. We have read the two research programs closest to ours, and the striking thing is that both of them hit the same wall and reach for the same kind of fix.

The first is a biological-topology lab: cortical columns, a voting hub, thalamic routing, learning driven by an apical-credit teaching signal. The second is Mitropolsky and Papadimitriou's Assembly Calculus, which is, mechanism for mechanism, the same family as our own substrate: sparse assemblies, k-winners-take-all, Hebbian plasticity on random connections, bounded memory. Their algebra of operations (project, associate, merge, sequence memory) is a real contribution we do not have a proof for, and they arrived at the shared substrate in 2020, earlier than we did. We concede that plainly: the substrate is not our differentiator.

What unites the two labs is the conclusion. To build transferable abstraction, you need an equivalence signal, a way to say two things seen minutes apart, under different views, are the same. The first lab supplies that signal as apical credit, a per-instance teacher. The second supplies it as hand-set structure, role areas and a hand-coded parser program. We supply it as language: the same word, heard across perceptually different instances, won cross-situationally from co-occurrence with no label. The word is the cleanest instance of their own framework, the equivalence relation handed by the world rather than by a teacher or a tree. So the three programs are complementary, not duplicative, and the work of this round is to adapt each lab's finding onto our route and ask, honestly, whether our grounded version matches or beats it.

It does, in each case, and the reason is the same each time: the scene and the caregiver.

The headline: a real, learned, grounded grammar

The grammar is one pipeline of organs, each adapted from the Assembly-Calculus line and each composing the others. Read forward, it takes a sentence to meaning; run in reverse, it speaks. Nothing in it uses a gradient, a backprop step, or a count table on the live path. Every organ is registered locally on our runtime; the runtime files are byte for byte unchanged.

Learned word order, with the typological signature

Our earlier production composer spoke structured relations but emitted them in a fixed agent-verb-patient order, a schema we coded by hand. That was the honest weakness. Mitropolsky and Papadimitriou's 2025 acquisition model has a learned role-to-order composer that acquires word order from grounded exposure and predicts that object-initial orders should be harder, mirroring their cross-linguistic rarity. We adapted it: the child now learns which order its caregiver uses, online, Hebbian, with no hand-set order and no parse handed in.

The mechanism is one new organ, a Hebbian map from each role's sparse code to an ordinal-slot code. As the child hears a token in a given position that it has comprehended as filling a given role, it bumps the role-to-slot weight. The order is read off the child's own comprehension, never supplied. At high exposure (120 heard utterances) the child produces held-out meanings in the caregiver's order at 1.000 for every one of the six constituent orders (SVO, SOV, VSO, VOS, OVS, OSV; whole-relation order chance 1/6 = 0.167). The old fixed composer, the thing this replaces, scores 1.000 on SVO only and 0.000 on the other five.

The typological signature is present, and we are careful about where it comes from. At a modest exposure (20 heard utterances), agent-first orders are mastered (SVO 1.000, SOV 1.000, VSO 0.667) while object-initial orders are still at the floor (OVS 0.000, OSV 0.000). Object-initial orders need about 50 heard utterances to reach criterion against about 28 for the others. This matches the cross-linguistic fact that object-initial languages are vanishingly rare. The honest part: the gradient is not emergent from the grounding. It comes from a weak agent-before-patient salience prior (the Greenberg "subject precedes object" universal) plus fallible position attention; object-initial orders must overwrite the prior, so they take more evidence. Turn the prior off and all six orders acquire at the same rate, the order still learned, the typological gradient simply gone. So the claim is precise: the learned-order mechanism is the contribution, and the typological gradient is what that mechanism does when it carries the standard subject-first prior. An order-shuffle caregiver (a different random order every utterance) gives the child no stable signal and its production sits at 0.180, chance.

Recursion, by a sequence-memory stack: the keystone

This is the piece we are most pleased with, because it closes a door we ourselves had measured shut. Our prior recursion experiment found center-embedded agreement stuck at chance, for a stated reason: a windowed count learner has no stack. The Assembly-Calculus parser papers admit the same gap from the other side: their parser needs "a stack of activation records" for center-embedding and never built one, and the follow-up notes "no mechanism for this memorization was proposed." The one first-class Assembly-Calculus operation we were missing is exactly the sequence-memory operation (Dabagia, Papadimitriou, Vempala 2023), and it happens to be the operation with their cleanest theorems.

We built it as a push and pop stack of activation records: an assembly chain on a fixed random forward fabric, grown by bounded multiplicative Hebbian rehearsal with the plasticity clamped from above (the sequence-memory regime is the opposite of projection; too-fast plasticity destroys the chain), and popped by replaying the top link through pattern completion, a noisy reconstruction rather than a stored copy. Each constituent on the stack is itself a sparse assembly built by merge, our adaptation of the Assembly-Calculus merge operation. Hearing "the dog that chased the ball is big" as a stream, the listener builds the outer subject "the dog," pushes it when "that" embeds a clause, processes "chased the ball," then pops to resume and attaches "is big" to the dog, the outer subject, not the recency-salient ball.

The result is decisive at depth one and causal. Outer-attachment goes from chance (about 0.51 on the no-stack baseline) to 1.000 with the stack, and the inner relation is recovered from inside the embedded clause at 1.000. Ablate the stack (the same organ, save and restore removed) and outer-attachment collapses to 0.000, below chance, because without the stack the property always attaches to the inner object, the windowed-learner recency failure exactly. Production runs the same wiring in reverse, opening the outer subject, descending into the clause, and popping to resume the outer predicate on the outer subject, structure-correct at 1.000 with the stack against 0.000 ablated. A no-leak shuffle (decouple the property's referent from the outer subject) collapses outer-attachment to chance, and the replayed assemblies stay real sparse codes (mean active equal to k, participation ratio well above one).

And the depth ceiling is human-like, on purpose. Outer-attachment is 1.000 at depth one, 0.654 at depth two, 0.588 at depth three: a graceful degradation toward chance that mirrors how people parse depth-one relative clauses effortlessly, struggle with depth-two center-embedding, and largely fail depth three. This tracks the proven capacity bound for the sequence operation and the bounded-memory rule the program holds itself to: the deeper the nest, the more outer subjects contend for the same replay, so the outermost is diluted. A correct brain model should fail deep center-embedding; an unbounded stack would be the un-brainlike result. We report the curve faithfully rather than pruning on the deep miss. We also reproduced the theorem-2 "scaffold" prediction at our scale: a two-way-wired copy area halves the rehearsals to criterion (ratio 0.52 against the predicted 0.5), a genuine small-scale check of the bound's form.

Learned grounded attachment: the scene resolves what word order cannot

Their 2021 parser builds dependency structure with hand-coded per-word inhibit and disinhibit actions, a fixed symbolic program, the least biological part of their stack. We do not adopt the actions. We take the opportunity their reader cannot: resolve attachment ambiguity from the grounded scene.

The hard case is the classic prepositional-phrase attachment, where the surface string is identical in both readings. "The dog chased the ball in the box": does "in the box" attach to the dog (a locative of the chasing) or to the ball (a modifier of the object)? Word order gives no answer, and the nearest-head baseline always attaches the phrase to the last head, the classic error. Only the scene tells you. Our reader composes three organs we had already built (the thalamic role router to mark the modifier, the sequence stack to hold the non-adjacent candidate head, and merge to bind the dependency) plus one small learned organ: a bounded Hebbian reader of a per-scene grounded cue, the same shape as our role binder. Its trust in the grounded cue grows only when the cue actually predicts the demonstrated head.

The reader scores 0.958 against a nearest-head baseline at 0.533 (chance 0.50), per-seed 0.987, 0.967, 0.919. Grounding is load-bearing: with the scene 0.958, with word order alone 0.533, the whole lift is the grounded cue. On the hard non-adjacent case (the truth is the head adjacency necessarily misses), the grounded reader resolves it at 0.962 while every ungrounded or ablated condition sits at exactly 0.000, because they can only ever reach the nearest head. The ablations are clean: remove the stack and the non-adjacent case collapses to 0.000; remove the router and the reader defaults to nearest-head; decouple the scene from the sentence and trust never forms, attachment falling back to the baseline. This is a learned, grounded parser beating a hand-coded, ungrounded one. The roles, too, are discovered from how each token behaves, never a part-of-speech label (entity, action, modifier all routed at 1.000).

Biological topology on our route

Two findings from the topology lab transfer cleanly to our language route, and one does not, which is itself informative.

Multi-column cortical voting transfers. Adapting the Thousand-Brains idea, we built many word-gated columns, each seeing only a partial, noisy view (about 20% of the bits), voting through a thalamic hub. The hub reaches 0.647 held-out class-CCGP against a single column at 0.360 (and beats even the best single column), and the consensus rises cleanly with column count (0.346, 0.536, 0.633, 0.669 at 1, 4, 8, 16 columns), with the shuffle control flat at chance throughout. The single-column code is near rank one; pooling raises the rank to a real distributed consensus. The win is biological topology riding on our word equivalence signal, not their apical-credit teacher.

Thalamic soft-competition routing transfers. A thalamic gate routes each token to its role-specialized store, with the role discovered from behavior rather than a label. Soft competition routes the three roles at 0.988, 1.000, 1.000 (noun, attribute, action), false-function 0.006, and beats a hard one-hot gate, whose noun route plateaus around 0.87 and never recovers because a wrong early commitment locks in (the correct store gets zero plasticity and can never confirm). Soft competition spreads the early mass so the right route wins. The shuffle collapses routing to chance.

The honest route difference: lateral feedback is a null for us. The topology lab found that hub-to-column lateral feedback sharpens their apical-credit binding (their 0.583 to 0.833). For us it does not help (best lift 0.003), and we report that rather than cherry-pick a fragile positive that did not replicate. The reason is mechanistic and specific to our route: our vote is already a soft distributed code in a shared word space, so a single averaging step is the consensus; re-voting under a consensus prior amplifies the common core as much as the distinctive bits, with no signal to separate them within one instance. Our word equivalence signal needs pooling for coverage, not their iterative consensus binding. Their object-id route, which must iteratively settle on a discrete identity, genuinely benefits from the lateral loop. The analogy holds where the mechanisms align and breaks where they do not, and the break is the finding.

Retention at scale: supporting, and honestly bounded

This is supporting work, not the headline, and the framing matters. The topology lab found that an apical-credit grounding route learns well (506 of 512 referents at 1M exposures) but erodes under long continual exposure (443 of 512 at 10M, a 12% drop, catastrophic forgetting). The question we could finally afford to ask: does our language-grounded route also erode at 10M, or does the recurring word hold it stable?

Run as one continual single pass with no reset, no replay, no batch, snapshotting at 200k, 1M, 5M, 10M, our in-bounds learner (a homeostatic multiplicative leak, the bounded rule that preserves the graded co-occurrence ratio the class signal lives in) is temporally stable where the apical-credit route eroded. Held-out class-CCGP from 1M to 10M moves 0.348 to 0.353 (a delta of +0.005, flat), and per-referent grounding accuracy moves 0.708 to 0.771 (it improves), against the external route's 0.988 to 0.865 (a delta of -0.123). The mechanism is the one the question anticipated: the word recurs every time its class appears, so the bounded weights settle at a stable fixed point the recurrence continually refreshes, where a self-generated apical target ages and drifts. A sharp side result fell out: this stability is a property of the right bounded rule, not of any bound. A naive saturating clip collapses the signal to chance, because a hard ceiling flattens the graded ratio once both same-class and other-class synapses saturate. So the in-bounds way to bound the language binder is a homeostatic leak, not a clip, and we do not need their metaplastic-engram fix to keep the language signal from eroding.

The honest caveat is large enough to state up front. This was run at a hard 16-way operating point (CCGP chance 0.0625), where the absolute abstraction margin is modest: with-word CCGP about 0.35 sits above the without-word baseline (about 0.28) but the word-shuffle control (about 0.19) does not fall all the way to the strict chance line, so the shuffle control is not fully clean at this point and the script's automated verdict, which keys on that strict test, even reads "erodes." The robust, defensible read is the temporal-stability one: across 1M to 10M the curve is flat to improving where the comparison route fell 12%, and the rank stays healthy (participation ratio about 2.9, no collapse mirage, which a clip would show). That erosion-versus-stability comparison is the result; the absolute margin at this aggressive operating point is not, and we say so. The 10M tail for the failure-mode arms was still completing as a background job; the decay arm, the one that carries the claim, reached 10M on all three seeds.

The through-line, and the honest corrections

The through-line is one word, and it is the program's own thesis rather than a new trick: grounding is the edge. Each adaptation matched or beat its source by adding the scene or the caregiver. The learned dependency reader beats a hand-coded one because the scene disambiguates. The recursion stack is more robust than the raw sequence-memory fidelity because a clean grounded lexicon helps the cleanup. The voting and routing wins ride on the cross-situationally-won word rather than an apical teacher. The retention stability holds because the supervisory invariant lives in the world (the recurring word), not in a self-generated internal target that ages.

And the corrections, stated plainly, because honest framing is the credibility of the program:

• The SDR and Hebbian substrate is not ours. Sparse assemblies, k-winners-take-all, Hebbian plasticity on random connections, bounded memory: this is the Assembly Calculus (2020), arrived at independently and earlier. We have stopped pitching it as our differentiator. What is ours on this route is the grounding, the caregiver, the developmental staging, and the composition of these organs into a grounded grammar.
• Only two of their operations are proven; the rest are simulation. Within the Assembly Calculus, projection and sequence memory carry real convergence and capacity theorems. Merge, association, and pattern completion are simulation results, not closed-form theorems, in the source papers. So when we say we adapted "their merge," we mean we adapted a simulation-validated operation, and our merge inherits that status. We claim the form of the sequence theorems at our scale (the scaffold halving), not their constants.
• The ceilings and the crosstalk are real limits. The recursion depth ceiling is real (depth two and three degrade), and where exactly it bites depends on a modeling knob we tuned so the human-like curve appears in the depth-one-to-three range; we report the shape, not a parameter-free prediction. Merge's bound is real: holding many structures in one area forgets the oldest toward chance as the shared fabric saturates, and reading a bound dependency back out (0.551) lags the attachment decision (0.958) for exactly that reason. The retention margin is modest at the hard operating point, as above. The word-order surface form is mouth-capped around 0.70 by a carried-forward segmenter limit, orthogonal to the order itself.

What this means

The program now has a learned, grounded grammar that composes one set of organs, all gradient-free, all on our untouched runtime: roles won from behavior, a sequence-memory stack for recursion, merge for binding, and a learned word-order map, read forward to comprehend and in reverse to speak. We built it by reading two adjacent labs that hit our wall, adapting their findings onto our route, and in each case improving on the source by adding the scene. We closed our own recursion negative with the one Assembly-Calculus operation we were missing, reproduced a real typological prediction honestly, and showed our language route resists the continual-exposure erosion that an apical-credit route suffers. The substrate we share with them; the grounding is ours.

The honest bounds

• The grammar is toy-scale and synthetic. Small closed vocabularies (a handful of subjects, objects, verbs, preps, landmarks), N about 2000, k about 50 per area. The mechanism, learned grounded composition of gradient-free organs, is what these results are about, not the scale.
• The recursion stack is decisive only at depth one. Depth one is exactly 1.000 because only the outer subject is on the chain (no competitors injected); the capacity ceiling at depth two and three is where the bounded mechanism's limit shows, and the exact depth at which it bites is a tuned knob, faithful to the proven bound but not a parameter-free claim.
• The typological signature is engineered into a prior, not emergent. Object-initial is harder because of a weak, theory-motivated salience prior plus fallible attention. With the prior off, all six orders acquire equally fast. The learned-order mechanism is the contribution; the gradient is what it does when it carries the standard subject-first prior.
• The retention abstraction margin is modest at a hard operating point, and the shuffle control is not fully clean there. The robust read is temporal stability (flat to improving from 1M to 10M where the comparison route fell 12%), not the absolute margin. We report the operating point rather than hide it.
• Merge and the dependency readout carry real bounded-memory crosstalk. Merge forgets old co-resident structures toward chance as the shared fabric saturates; the dependency readout (0.551) lags the decision (0.958) for the same reason. These are the honest "graceful but bounded" walls, not failures of the mechanism.
• Lateral feedback is a measured null for our route. We gave it several faithful gradient-free forms; none lift our route, for a clear mechanistic reason. We report the null rather than a fragile positive that did not replicate.
• The runtime is untouched. Every organ (the order map, the sequence stack, merge, the role router, the grounded attacher, the voting columns and hub) is registered locally on a brain instance; the runtime files are byte for byte unchanged, and all reuse of validated scripts is read-only import.

Lineage

Grew from two reading threads and one prior milestone. From the deep read of Mitropolsky and Papadimitriou (the Assembly-Calculus line), the operations we adapted: merge, the sequence-memory stack, the learned role-to-order composer, and the dependency reader we rebuilt without their hand-coded actions. From the biological-topology lab, the voting hub, the thalamic routing, and the apical-credit erosion result we tested our route against. And from a tiny brain that comprehends, abstracts, and speaks, the grounded brain, the won roles, and the composer this round upgrades from a fixed order to a learned one.

Led to the open work the bounds name. Richer sentences with more than two candidate heads and nested modifiers for the attachment reader; wiring the grammar organs onto the dev-brain's raw-character reading front end; holding the retention margin above the strict bar at scale (a tuned reservoir, more seeds); and the deepest direction, a larger and realer world (a child-egocentric corpus), where the grounded grammar can be tested on natural perception.

Thread: adaptation, made grounded. Two adjacent programs hit our abstraction wall and reached for an equivalence signal; we supplied it with the word, won from the world, and adapted each lab's machinery onto that route, beating the source each time by adding the scene. A real, learned, grounded grammar that composes one set of gradient-free organs, with its ceilings, its crosstalk, and its modest margins held honest.