The current theory

An inspectable model of text

One repeated part, counting online under a bounded memory budget, composed by voting and stacked by level: a model of text that learns the way a brain reads. This page is the distilled signal, refined as experiments accumulate. The running journal lives in the blog.

This page is the distilled signal. The lab notebook holds every experiment, dated and cross-linked, the architecture spec is the standing, versioned description of what the code currently is, and the benchmark scorecard measures the locked model honestly against a SOTA transformer and the plain baselines both. This is what they add up to, refined as the work accumulates. When a finding shifts the theory, it is recorded in the changelog at the bottom.

The thesis

We are building an inspectable model of text out of one repeated part.

The part is a Column: an online associative counter. It watches a context, counts what follows, and predicts by looking the count up. Nothing else. No gradient descent, no backprop, no batch pass that revisits the data.

Columns compose by voting. Many Columns each guess from their own vantage, and a combiner reconciles them into one prediction. They stack by level: the boundaries one level finds become the symbols the next level counts over, so concepts and constructions build out of letters the way letters build into words.

The whole thing learns online, in a single pass, under a bounded memory budget. And it stays a document you can open and read: the counts, the discovered words, the concepts, all of it. The model is the notebook.

This is not a frozen function that memorized the statistics of text. It reads the way a person reads: it learns from every sentence as it arrives, it never retrains, and it is guided, at every fork, by how human cognition solves the same problem.

The four laws

Four rules hold across every experiment. They are not style. Each is a fact about how a mind works under real constraints.

1. Online, gradient-free learning, the way people learn. Each piece of data changes the system at the moment it arrives, in a single pass, with no gradient descent and no batch pass back over the data. This is the regime, not the mechanism: counting is the tool we have leaned on, but any update that learns on arrival without a backward pass is in bounds, and an offline sleep cycle that reorganizes what was learned is allowed. It sees a thing once, is changed by it, and moves on.
2. Bounded memory. A finite budget on every run. No unlimited tables, no keeping every context forever. The budget is what makes the project honest, and what forces generalization.
3. Fragile ideas get room to grow. A real idea almost always arrives weak. "No better than a bigram" is a normal first result, not a verdict. We judge by trajectory, check the other dials before shelving, and send shelved ideas to a graveyard with a reason, not a trash can.
4. Human cognition is the guide. Human intelligence is the only thing that reaches generality under exactly these constraints, so it is both the existence proof and the design oracle. When unsure, we ask not "what is optimal?" but "how does a person do this?"

How we work sets these out in full.

The substrate, validated

The substrate we have leaned on is small: counting, leaky accumulators, and online leader-clustering. These are the instances of the rule we have used so far, not the rule itself (anything that learns on arrival without a backward pass belongs here) but they have carried the program, so they are worth looking at closely.

What makes us trust it is that we did not invent it. Independent literatures in cognitive science, built by people who never spoke to each other, converge on exactly these primitives. NARS reasons from evidence counts. Usage-based grammar is construction frequencies. ACT-R activation is leaky-accumulated recency. Event-segmentation theory carves experience at surprise. ECAN, complementary learning systems, and ART all describe budgeted memory with consolidation and resonance. Dual-process theory names the two speeds. Each was reaching for how a mind handles its own corner, and each landed on counting, decay, and clustering. When that many roads end at the same three tools, the tools are probably load-bearing.

What we've established

Each of these is a post, and each closed a question.

• Surprise marks boundaries. Prediction error alone recovers word boundaries from raw characters, and the same signal one level up finds phrases. Where one word ends · Finding phrases
• Concepts and constructions earn their keep. Unsupervised words lower the cost of letters; counting token-and-type per frame turns a flat n-gram compositional. Words that lower the cost of letters · Grammar is just counting
• The right combiner is a calibrated geometric mean, frugal not exhaustive. A product of expert opinions beats a naive sum of every level, and validity-ordered take-the-best, which consults the most-valid cue, stops early, and ignores the weak channel, beats full pooling on accuracy, perplexity, and compute at once. The combiner sharpens by ignoring, not by blurring, and the pool itself must be normalized: an un-normalized product raises the consensus to the power of the summed confidences (about three over ten active columns) and over-sharpens, so a normalized blend that keeps every column, exponent about one, predicts a full bit per char better and beats hard winner-take-all at every scale. When voting made it worse · Less is more · The vote was too loud
• System 1 has a second thought. A metacognitive gate (calibrated confidence plus conflict) deploys a deliberate pass that overrides the fast answer only when it is wrong (+0.38 accuracy on conflict cases) and does no harm when it is right. Thinking slow, by counting
• Stability turns a habit into a concept. On mastery, not error, a construction is redescribed from an implicit count into an explicit, slot-addressable concept that answers queries the flat count cannot, the operands System 2 deliberates over. When a habit becomes a thought
• Confidence is calibratable for free. Split a count into hits and misses and the NARS truth value gives a calibrated (f, c) pair, ECE 0.280 to 0.027. How sure is a count?
• A dynamic gate beats a static pool. Routing among experts by confidence beats fixed pooling by 0.9 bits. One brain part, or many?
• Offset-keyed counting is attention. Counts keyed by relative position give attention with no queries, keys, values, or gradients, and it is not a bag of words. Attention, but counted
• Long-distance binding is in hand. Content-addressable cue retrieval binds a verb to its correct-number subject across a clause (99.96% where offset-attention's fixed position key tops out at 65%) and reproduces the human agreement-attraction illusion, because activation divides by the fan. Reaching back by the right cue
• The bounded-memory rule is empirically confirmed. Under a budget the mechanisms that vanish at unbounded scale return: consolidation flips −0.006 → +0.307 bpc as the cap tightens, a measured curve. Generalization is not optional; it is how a bounded model approximates the unbounded one. What survives a budget
• VSA reads structure back out of a sum, given the structure. Role-filler decode recovers subject, verb, and object at 100%, robust to eight bound pairs, when the roles are supplied; the blind resonator fails at affordable dimension. Supply structure, don't factor blindly. Reading structure back out of a sum
• Change transfers, and it is directional. A memory of trajectory rather than content transfers to unseen words and runs one way only. You can't write your signature backwards
• Non-forgetting holds under a budget. Stream three books one pass: the model forgets about 21 times less than a recency cache, with ART resonance protecting the context that recognized the input. Learning the new without losing the old
• Sleep consolidates and compresses. One offline replay pass cuts memory 37% and improves the rare tail, but over-dreaming goes generic and lossy, exactly as the literature warned. What an agent learns while it dreams
• Proximity is for similarity, not prediction. A meaning-map does not predict the next word, but poured into the counter it prices the unseen pairs, cutting their perplexity twenty-fold. Meaning is a map, not a road · Use the map to read

What survives scale

We re-ran every idea at 30 to 200 times the data (half a billion words, three billion characters) and the verdicts split clean.

More data subsumes any mechanism that merely re-predicts what local counts already know. A topic prior worth +0.34 bits/word at small scale fell to 0.0. If a clever piece only competes with counting on text it has already seen, enough data makes the counts win and the piece vanish.

The survivors do what counting cannot. Unseen generalization, discourse boundaries, calibration, direction, bounded-memory retention: these hold or grow with scale. Bayesian-surprise boundaries went F1 0.154 to 0.447 as the data grew.

And the twist: under a memory budget the vanished mechanisms come back. With infinite memory, more data makes the clever pieces redundant. But a budget means throwing most counts away, and the only way to stay good after throwing them away is to have generalized first. The budget re-elevates exactly the mechanisms unbounded scale had buried. What survives scale

Where we stand, measured

The honest scorecard lives on the benchmark page: the locked model put next to a large transformer and the plain baselines both, across four angles, refreshed on every architecture update. The one-paragraph read is this. On raw compression we sit near 2.1 bits per character on text8: above the no-skill ceiling, behind a plain order-six n-gram at every scale, and overtaken by a small gradient transformer once it has enough data, against a SOTA transformer's ~1.0. That gap is real and unspun. The fixed bank also plateaus past about a million characters (2.234 to 2.112 to 2.109, flat from a million on) while the n-gram keeps falling, the bounded-capacity limit made concrete. But the plateau is a fixed-capacity artifact, not a wall: a growable bank breaks it. Letting the substrate add longer-context voting columns when the held-out gain stalls, capped and pruning the least-used, the growable cortex keeps dropping where the fixed one flattens, 2.004 to 1.875 at ten million, growing 12 to 24 columns, near the n-gram's 1.829 because it does what the n-gram does. On the axes our regime is for the picture turns: on abstraction we sit at transfer CCGP 0.537, above the 0.484 backprop ceiling, with no gradient at all, and on continual learning the count substrate forgets about 21× less than a recency cache. Behind on raw bits but no longer plateauing there, even-or-ahead on abstraction and cheap continual learning, and honest that the non-forgetting win is the count organ's while the above-ceiling abstraction is the apical stack's. The locked config is fast, and stable in the ~1M-character window, though a 10M run reveals it drifts on a long fresh stream (held-out bits-per-char rises, the deep code collapses), an open continual-learning limit; re-reading a bounded corpus is a free prediction lever that sidesteps exactly that drift.

The architecture

The full, versioned spec (every layer of the code, how they connect, and why) lives on its own page: the architecture spec. What follows is the summary.

The model has two halves, matching the two speeds of cognition.

System 1, built. The parallel count substrate. Columns voting, instantly, to recognize a word or feel a topic shift. Everything above is System 1. It is fast, associative, and done. Its binding primitive is content-addressable cue retrieval: a dependent fires a feature bundle and the best-matching memory item wins, weighted by fan, reaching across a clause where a fixed position key cannot, and making the human interference error for the same reason.

System 2: the gate works; the workspace reaches multi-hop; selection is the open test. The metacognitive half is built and validated. A dual trigger (calibrated confidence plus conflict) fires a deliberate pass that overrides System 1 only when it is wrong (+0.38 accuracy on conflict cases, no harm otherwise, graceful to System 1 at zero budget). And the reasoning route it runs is now concrete: representational redescription promotes a mastered count into an explicit, slot-addressable concept; VSA decode reads those role-filler structures back out of a sum (100%, given the slots, never by blind factorization); the serial workspace manipulates them across cycles and reaches a multi-hop target that one-step deferral cannot. The route is redescription → VSA-decode → workspace. What is not yet proven is the workspace's focus-and-inhibition machinery: on a single deterministic chain it only ties a blind "apply-twice," because that machinery is built to select among competing chains, and no probe has given it any to select. Sleep still closes the loop, automatizing a proven System-2 chain back down into System-1 reflex.

The open frontier

The program has reframed itself around a developmental curriculum: one child-brain that lags an adult environment and catches up gradually, driven through staged, comprehension-tested stages by a real caregiver, the way a child acquires language. That curriculum has now reached its endpoint, and the three threads the program ran in parallel have converged: one gradient-free, online, bounded-memory brain that comprehends a simple grounded conversation, abstracts a concept through language, and speaks it back. All four developmental stages (G1 to G4) pass on the same brain; a production-side composer makes it speak the relation it comprehends; and the hardest problem, a transferable abstraction, is resolved in-bounds by the program's own thesis, the word. The earlier frontiers feed into it. The program has since done one more thing on this route: it read the two adjacent research programs closest to ours, an external biological-topology lab and Mitropolsky-Papadimitriou's Assembly Calculus, and adapted their machinery onto our gradient-free, online, grounded route, building a real learned, grounded grammar (learned word order for all six orders with the object-initial typological signature, recursion by a sequence-memory stack that closes our own prior recursion negative, and a learned grounded attachment parser that beats a hand-coded ungrounded one because the scene resolves what word order cannot), transferring two pieces of biological topology (cortical voting and thalamic role routing), and showing our language route does not erode at 10M continual exposure where an apical-credit route did. In each case our version matched or beat the source by adding the scene; the substrate, honestly, is theirs (Assembly Calculus, 2020), and our edge is the grounding. What stays genuinely open underneath the converged brain is one specific thing, transferable abstraction from perception alone, with no teaching signal and no language, and beyond it scale and a realer, open world. The open problems, each now sharper:

• Abstraction: settled, above the backprop ceiling. For months the program collected closed doors on abstraction: six gradient-free mechanisms (an Oja embedding, a predictive-coding stack, a shared-representation hierarchy, a pure-biology HTM voting cortex, temporal pooling, and top-down Hebbian feedback) each carved structure and compressed dimensionality but never built an abstract, factorized, generalizing space. Then the line ran to a verdict. A head-to-head isolated the cause: swap only the update rule in one fixed network, and the gradient builds the abstract space while the no-gradient rule compresses hard (PR 100→14) and loses abstraction. The missing ingredient is credit assignment, not wiring. A per-unit local signal cleared it: feedback alignment (fixed random feedback, no weight transport, biologically plausible) lifts the score to ~0.41, approaching the global-backprop oracle's ~0.49, while a broadcast scalar fails, so "credit assignment" sharpened to per-unit credit assignment. The keystone carried that per-unit credit down a real top-down apical pathway, gated by precision, and on a two-level stack the full fusion reached transfer CCGP 0.501, the first stack whose abstraction climbs with depth: priming and credit one mechanism, one precision read three ways. Then the line closed. Three swings ruled out a label-attractor shortcut (it compresses to PR 5.8 and scores below the raw baseline), factored diverse voting off as a prediction organ rather than an abstraction one, and scaled the fusion until it named the wall, stability. A four-sweep round solved it: forward-activation normalization is the stabilizer (stable everywhere the baseline, a gate-clip alone, and a dream-replay cycle alone all diverge), the four levers factor cleanly (stability ← normalization-plus-gate-clip; deep dimensionality ← breadth and dropout; abstraction ← per-unit apical credit at a precision-gain ≈ 0.2; prediction ← breadth at depth two and diverse views), and the winner, normalization-plus-gate-clip, gain ≈ 0.2, depth three, reaches transfer CCGP 0.50 to 0.55, above the 0.484 backprop ceiling, stable and seed-robust. The capstone meant to push it deeper ran and failed: breadth and normalization act on different axes of variance and do not add (the combine stays stable but collapses to dimensionality 1.17). So the architecture is locked at the depth-three winner, above the ceiling: abstraction does not climb past depth three by combining existing levers, and pushing deeper needs a genuine design change of uncertain payoff (we are already at the ceiling). The abstraction frontier is no longer a question of possibility or scale; it is closed, and the open value moved to generation. The attention track later offered the one untested hope, a transfer-CCGP lift to about 0.60 that, fed as the input to this per-unit-credit pathway, might carry it past the ceiling. Tested directly, it does not: measured on the gradient-comparable ruler at the stable scale, the attention representation abstracts no better than a plain context window (0.429 and 0.463 against 0.509 and 0.476, under the 0.484 ceiling on every seed), so its 0.60 was expressive dimensionality, not abstraction. The wall stays specifically a credit-assignment problem: a front-end changes what is read, not whether the credit pathway can carve an abstract code from it. The road past 0.484 is a change to the credit pathway itself (per-unit credit on a sparse substrate, or across time), now the only door left and tested as such. One crack has since reopened: the deep collapse that caps the stack at depth three is not structural. Two anti-collapse mechanisms now turn it back at small scale. Lateral divisive inhibition between columns at the same level takes the collapsed depth-four apex from rank one (dimensionality 1.61) to a real code (3.05) and lifts abstraction +0.16, where a vote alone leaves it collapsed: the missing degree of freedom was interaction within a level, not more breadth across levels, the first positive past the levers-not-additive wall. And replay reinstated at an interior altitude (Minsky's K-line) protects the deep code on a long fresh stream far better than replaying the raw input (deep dimensionality 5.04 against 1.99) with the lowest bits-per-char, while replaying at the top alone is too vague and replaying everywhere at once collapses. And the two compose: run on the drift stream together, inhibition alone loses dimensionality (the deep code collapses to rank one) and interior replay alone loses abstraction (its score fades below the ceiling), but both wires on hold the deep code high-dimensional and above the 0.484 ceiling at every checkpoint, stable, where neither half does. They act on orthogonal axes (across columns, and across time at an interior level), so they cover each other's failure rather than redundantly stacking, the first composition in the program that holds, at three million characters. The ten-million confirmation refines that to a partial mitigation: the bare config fully collapses (rank one, bits-per-char 4.120, abstraction 0.317 by seven million) while both wires keep the deep code alive (dimensionality 1.83, bits-per-char 3.694, stable), a real drift mitigation, but one that degrades at scale, abstraction slipping below the ceiling (0.429 against the three-million run's ~0.56). So the drift is mitigated, not cured: the deep code survives a long fresh stream where the bare config dies, and holding the protection above the ceiling at scale (a tuned replay reservoir, more seeds) is the open next step. And the substrate axis the architecture review named has now paid out: the empty 2×2 cell is filled. The cell was per-unit credit on a sparse code, where the literature said the collapse should dissolve; the first build abstracted then collapsed (the credit pathway drove the same few units to win), but adding the diversity machinery the brain uses turns that transient into a held result. Boosting and positive weights together hold deep transfer abstraction at the 0.484 ceiling to the last checkpoint on both seeds, with more than two hundred distinct winner-codes (against the dense reference's about forty) and the lowest bits-per-char of any arm, where boosting alone still collapses and a sign-only credit breaks the code. So a sparse substrate carrying per-unit credit holds stable abstraction, and the dense reference is no longer the only thing that does. Honest: it matches the ceiling, it does not exceed it, at eighteen thousand characters and two seeds with the scaled confirmations running. And then the two engines met on one substrate, and abstraction composed and exceeded the reference. The program had split into a count-native voting bank that predicts (low bits-per-char) and the sparse apical stack that abstracts, each doing one thing; the test gave the abstraction stack the prediction machinery (eight sparse columns, each on a different view, voted by the calibrated blend, the abstraction kept intact) and read out an honest trade-off. The abstraction half composes: the unified multi-view stack reaches transfer CCGP 0.520, above its own single-view 0.487 and above the 0.484 single-layer backprop reference (GRAD-1L), at higher dimensionality (PR 19.5) with no collapse, the highest abstraction the program has reached, gradient-free, the earlier capstone collapse not reasserting because k-WTA and boosting preserve the cross-stimulus variance the dense normalization destroyed. The prediction half does not: the unified stack reads 3.666 bits-per-char, barely below its single-view 3.753 and nowhere near the voting bank's 2.442, and the blended bits-per-char equals its own best single column, so the vote does nothing for prediction with neural columns (the count bank's win was count tables combining, not voting). So predict-and-abstract in one stack is still open: the synthesis kept and improved abstraction and did not import prediction. Honest: this is the single-layer reference (a multi-view backprop is the fair ceiling to recheck), at eighteen thousand characters and two seeds with the bits-per-char anchors scale-compressed. The path forward is to couple the readouts on the pooled error, or graft a count-native head onto the abstract code (one substrate, two heads). The second path ran, and it returned an informative middle that leans deep-negative. A count table keyed on the P0.5 abstract winner-set reads 2.578 bits-per-char at one hundred thousand characters, 0.8 to 1.0 below the stack's own readout (3.548): the abstract code does carry next-character signal, and one substrate can feed both heads, a real sub-win. But it stays about 0.45 bits behind the same count table on the raw context (2.141), and the gap holds across 5.5 times the data (+0.50 at eighteen thousand, +0.44 at one hundred thousand), while the same code's transfer CCGP is 0.499, above the reference. So the same code abstracts well and predicts worse, and the prize is not won. The mechanism is a tension in the representation itself: the abstract code is nearly unique per position (three to six counts per key even at seventy thousand positions), because the high rank that makes it abstract makes it almost never repeat, and a count table predicts by reuse. High rank gives good abstraction and poor count-reuse, so abstraction and prediction want representations in tension, and the two-stacks split has a root in the code, not just the wiring. The lever the diagnostic points at, untested, is a coarser, less-sparse code that might repeat enough to predict while staying abstract enough to keep its CCGP, a sparsity-versus-reuse sweet spot.
• Generation: open, with the first real building block in hand. With abstraction settled, generation is the program's open frontier: producing text, not just modelling it. It has two halves, and the internal half now has both a mechanism and a module. The mechanism is the birdsong loop, which teaches production with no listener: an agent babbles candidate utterances over the chunk-lexicon emission vocabulary, re-comprehends its own output to recover what it would understand, and corrects toward the meaning it intended, recovering a meaning 0.271 of the time against a chance of 0.042, about 6.5× chance and 8× its own open-loop and deafened ablations (all three guards fire: scramble the target and it collapses to exactly chance; let the self-output contaminate comprehension and an independent judge catches the private-code drift). The module is a separate learned inverse, the fix the comprehension-production wall named. The wall was that the locked reader recognizes ~296/500 words but produces ~64, and played back a specific word to the exact spelling only 2 times in 296: a recognizer reversed plays back the most common continuation, not the word you meant. So production is built as a separate map from a meaning to a sequence (the DIVA design), trained feedback-first by the birdsong loop. On the matched conditional task, produce one specific intended meaning across 300 meanings on a controlled vocabulary, the separate inverse recovers 82 where the reader run backwards recovers 2, and it wins in every frequency band including the rare tail (28 of 100 at the rarest, against 4) where the neuroscience said a separate inverse must win. The inverse learns it over training (recovery 0.060 → 0.417). Honest: recovery 0.417 is moderate, the vocabulary is controlled, and the matched task is conditional production, not the unconditional free-run number. And it carries to real words: the same organ pointed at the top 300 most-frequent DailyDialog words, nothing in the mechanism changed, produces 113 of 300 real words and recovers the intended one 0.317 of the time, against the reader run backwards at 45 and 0.090, real English (lady to ready, agreed to good, equipment to question), the first intelligible production on real conversation. The headline there is recovery, the live metric: the gap narrows from 41-to-1 on invented words to 2.5-to-1, because real onsets let the reader reversed complete to a plausible real word, so the number that matters is producing the intended meaning, where the separate inverse leads 3.5 to 1; and recovery 0.317 is moderate because the meaning code is a coarse form region, so the produced word is often a neighbor of the target. So the internal half is real: a working producer, trained on its own feedback, producing real dialog words. And it now holds a live conversation: the same producer, off the offline answer key and into a live exchange with a real Haiku partner (keyless, the logged-in claude -p), takes each turn through its one frozen comprehension pathway used both ways, comprehend the partner's turn into the meanings it knows, then produce the real words it can voice for them. Over fourteen exchanges every emitted word is a real dialog word (42 of 42), most turns share an exact word with the partner's turn (10 of 14), the partner stays on the cortex's topic almost every turn (12 of 13), and a few times a topic word threads across turns (the cortex says match, the partner reflects it, the cortex says it again, then dance the same way): a call and response that holds for a stretch, not isolated word-salad. The honest read is word-salad with real glimmers of relevance, the starting line for live dialogue, not a conversation that holds, and the production gap the offline round predicted shows live (the cortex comprehends the right region of meaning but voices a neighbor of the word it meant, so relevance runs ahead of recovery). By design, though, the loop only ever agrees with itself and a partner that mirrors it: it supplies fluency not a shared convention. The external half is the named next move: a referential game that sets a convention and anchors against private-code drift, scored on whether a listener recovers the referent and demonstrably changing the 99% slice rather than the dead 1%. The internal half is in the black; the external half is the falsifiable next swing. And the track now has a real-conversation baseline to move it against. The locked model streamed online over the whole DailyDialog training split (5.24 million characters) reads two ways. Dialog is a bounded, repetitive distribution it fits stably: held-out bits-per-char drops with data (3.767 to 3.549) with no drift, the mirror of the fresh-stream drift, and it sits 0.542 bits easier than the same model's text8 reference (4.090). But a long pass on the narrow register erodes general grammar: a minimal-pair grammar score falls from 64.8% at 200 thousand characters to 51.1% at the full split, word-order phenomena holding at 100% while agreement and the rest sink to chance. The free-run samples are gibberish with the right shape (correct spacing, the turn marker recurring, no words): the intelligibility starting line. A measured baseline, not a new mechanism, and the same specialization-versus-generality tension the drift theme carries, met from the narrow-register side. And then the comprehension thread and the generation thread converged into one brain. The pieces both threads kept naming as missing, a reader on raw text for comprehension, real text in and a grounded loop for generation, are the same join, and this round makes it: one brain on the runtime, four Hebbian and SDR organs as connected Areas (a fully-neural segmenter, a union encoder, a Hebbian binder, a generator), runs the whole loop, reads raw characters, binds word to referent, comprehends a held-out question, speaks a name, and is corrected by consequence. The load-bearing fact is that all four phases run on the same organ instances, and the binder's single Hebbian matrix W is written by learning, read forward to comprehend, read backward to speak, and re-written by correction, so comprehension and production are one matrix read two ways rather than two systems. Held-out referential pointing reads 0.910 (shuffle 0.217, chance 0.250); content production with a silence self-check 0.917 with 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); and correction by consequence, the environment re-uttering a misunderstood word with the right referent in focus, a consequence and not a label, lifts the mistaken word 0.472 to 0.674 where a yoked recast reaches only 0.506 (+0.169, three of four seeds). A grep of the live path confirms no counting and no hand-tokenizing, fully neural and gradient-free end to end, and the brain holds a grounded conversation, pointing to and naming apple, cup, box, and ball. The dog-and-ball demo runs on the runtime, with no cheating. Honest bounds: a small synthetic lexicon (twelve content words), the held-out test needs enough referents because the distractor-set signatures are combinatorial, and the correction headroom is held in the binder (a cold listener with a warm ear). The two tracks are one architecture now; the open work is scale and realer language.
• The developmental curriculum: reached its endpoint, all four stages on one brain. This is where the program now stands. The assembled organs are one brain that reads, binds, speaks, holds a working memory, and uses a top-down route, and the working memory earns something the talkable brain alone could not, resolving an ambiguous word read from raw chars by the discourse context it holds (1.000 with the working memory against 0.500 without, every control clean). And that one brain is given a childhood: a staged developmental curriculum (G1 to G4) with a real Haiku caregiver who speaks ahead of it, 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 leading production, the gap shrinking as exposure accumulates. All four stages pass on the same brain with their adversarial controls clean. G1 (one word) on the bare brain (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). G2 (two words and a property) on the same brain plus one faithfully added typed-store organ (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). G3 (morphology) generalizes a grammatical morpheme to held-out stems (referential 1.000, chance 0.333), and surfaces the load-bearing honest finding that the brain's forward transitional-probability segmenter cannot place a morpheme boundary (the affix is predictable, so the dip lands inside the stem, "walking" cut as "wal-king"), cracked by the same chunking principle one altitude down (a recurring detachable sub-chunk detector, -ing/-ed/-s all 10/10, zero over-peel). G4 (relations, negation, grade-two dialog) binds who-does-what-to-whom by role-filler binding with the role won from the perceptual scene (held-out relation QA patient 1.000, agent 1.000, predicate 1.000, negation 1.000), and sustains a contingent multi-turn dialog comprehended 12/12, so the brain understands a simple grounded conversation. And it speaks it: a production-side composer, the inverse of comprehension (unbind each role, name it, emit in a fixed role order), lifts whole-relation structure to 1.000 on held-out meanings where G4 alone was telegraphic at 0.000, and a whole-word prior lifts the surface form from 0.684 to 0.918, so in a live exchange "the cup is not gold" comes back as "cup not gold." The curriculum trains the whole brain, not ad-hoc per-stage organs. 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 a meaning, so perception precedes reference. The open edges are the mouth's last residual (segmenter over-cuts, upstream of the mouth), free word order (a later module), and a larger, realer lexicon.
• Deep transferable abstraction: resolved through language, in-bounds; still open from perception alone. The locked architecture reaches transfer CCGP above the backprop ceiling, but only with a per-unit credit signal that uses a teaching signal. A purely-unsupervised, gradient-free route to that abstraction was the program's hardest problem, and it is now resolved in-bounds by the program's own thesis, the word (and still open if the brain is denied language). The substance is the converging negatives, because they built the resolution. Six purely-perceptual unsupervised mechanisms all failed to build transferable abstraction, for one clean reason: a class is an equivalence over non-adjacent instances, and perceptual similarity, contiguity, and dynamics can only find adjacency (on a decorrelated code, same-class instances are near-orthogonal). A local predictive rule through time is a real ingredient that does not clear the bar: on character text at four seeds it ties the pure-local wall (0.344 against 0.342), and the only arm that rises is the one with the anti-collapse term removed (0.427, +0.085 over the wall), the point rather than a loophole, because the decorrelation must be weakened before the predictive pull can bind at all, and none clears the 0.451 credit-using value (an earlier two-seed read of 0.422 did not replicate). A faithful temporally-rich stream does not close the gap either: a binding-isolation probe stripping the static window of all class information reads 0.159 with time on and 0.159 with it off, both below chance 0.333. Slow pooling, space-and-time attention, and a CA3 attractor fail the same way (the attractor closing the purely-perceptual question, since its basins form by similarity and same-class items are near-orthogonal). The decisive diagnosis is that the decorrelation the substrate needs to stay high-rank fights the predictive pull that would bind same-class items. The resolution sidesteps the tension rather than fighting it: the WORD, won cross-situationally with no label, is the cross-instance integral that supplies the non-adjacent equivalence, and routing abstraction through the word-to-referent binder clears the wall. Held-out class-CCGP is without the word about 0.40 (the wall), with the word 0.87 on a synthetic stream (4/4 seeds) and 0.50 to 0.99 on the real grounded encoder (an honest operating-point curve, the lift growing with how reliably the class attribute is perceived), collapsing under word-shuffle, random-projection, and a floor control. No backprop, no internal credit, no counting; the constraint never relaxed, we used language. So the open direction underneath is the one place the word does not reach: transferable abstraction from perception alone, a dedicated binding mechanism that survives the decorrelation pressure, the next experiment the negatives motivate.
• Attention: bounded and complete, online and gradient-free. The newest direction, now a closed, bounded arc: learning where in the text each column looks. The per-column look-back offsets were hand-set; the work makes the offset an action, chosen online and rewarded by how well the column then predicts, the "motor is moving through text" idea made concrete. A count-based, gradient-free bandit over look-back offsets learns informative, diversified views, uses a content-relative word-jump, and beats resampling the offset at random (bits-per-char 3.797 against 3.872), and it does so only with one wire: lateral inhibition on the action space, the same diversity pressure that broke the deep representational collapse, carried from the code to the scan (without it every column collapses onto the single most recent character and prediction explodes). Context-free, that learned scan does not match the hand-set diverse views at scale (fixed 3.513, trailing by 0.284): with no context to condition on, a fixed spread is already good and free. So the next round put the context back, and it pays. A working memory one level up (a leaky char-distribution over the region plus the live word-phase) steers where each column looks, keyed into the offset bandit (one value vector per context bucket). At the right granularity, two buckets, the context-guided scan beats the hand-set baseline on prediction (3.022 against 3.101 bits-per-char, on all three seeds), flipping the context-free result. The robust win is abstraction: context-keying lifts transfer CCGP from 0.494 to about 0.60 and dimensionality from 19 to 32 at every granularity, where the context-free round left abstraction flat. And the policy is genuinely context-dependent (it looks in different places in different contexts, cross-bucket offset divergence 0.80 to 0.85 bits). The working-memory prediction prior hurts and is dropped, the win being attention-side. Then the capstone gave that working memory control over itself. Its fixed leak, which admitted a little of every character with no say over when, is replaced by a basal-ganglia-style Go/NoGo gate that fires on a model-update signal (how far the model's own pooled prediction moved step to step, not raw surprise) with an adaptive tail threshold, learned online and gradient-free with no reward. The gate beats the fixed leak (3.069 against 3.083 bits-per-char) and the hand-set baseline (3.101), and it beats both degenerate bounds, always-update (3.075) and never-update (3.114), so the win is the timing of the update, not the amount of theme motion. It fires 19% of the time, holds the theme about eight characters at a stretch, fires at or next to a word boundary three times in four, and the abstraction lift carries through (transfer CCGP 0.584). So the full stack, learning where to look, guided by context, holding the theme behind a learned gate, beats hand-set fixed diverse views, online and gradient-free. A final round bounded the arc by testing its two named open items at once: a deeper hierarchy of held states, and a gate that targets a fire-rate. Depth saturates at two guidance levels. A third nested level (a slower context steering the middle one, which steers the bottom one) is real and active, it routes the level below, yet at matched capacity it reads 3.096 bits-per-char against the two-level stack's 3.049, worse, at both scales: the extra bucket-splitting it needs costs more than its longer-range guidance gains. The self-calibrating gate is the keeper. Targeting a fire-rate rather than a fixed multiple, it reads 3.049 against the fixed-threshold gate's 3.072, beats the hand-set floor, and holds its fire-rate across scale where the fixed threshold drifts down, fixing the named under-fire. So the attention architecture is bounded: two levels of guidance with a self-calibrating gate is the sweet spot, and a third level does not pay off as built. One question that hung over the whole arc is now settled: the attention track's transfer-CCGP lift to about 0.60 sat on the vote-consensus probe, which inflates with dimensionality, not the gradient-comparable probe the 0.484 ceiling is drawn on. Fed verbatim as the input to the per-unit-credit readout (the one pathway proven to abstract) and measured on that ruler, the attention representation reads 0.429 and 0.463 against a plain context window's 0.509 and 0.476, under the baseline and under the ceiling on every seed, with a backprop oracle clearing the ceiling on the same input. So the 0.60 was expressive dimensionality, a richer code, not a more abstract one: the attention win is prediction and working memory, the abstraction wall stays credit assignment, and feeding one to the other does not combine them.
• The reasoning route: supply structure, don't factor blindly. The route is built: redescription mints the slots, VSA decode reads them (100% given structure; the blind resonator fails), the workspace reaches a multi-hop target one-step deferral cannot. What is untested is selection: the workspace's focus and inhibition are built to choose among competing candidate chains, and every probe so far is a single deterministic chain that gives them nothing to choose. The named next probe is competing-chains selection.
• The count-native selector: a closed negative. The metacognitive gate decides when to think harder, and it works on a word-prediction probe where conflict is selective and a deliberate pass helps. As a selector over learning modes on the character stream, it does not: a bank of self-calibrating critics with a selector reads 3.984 bits-per-char against the bare model's 3.920 and a replay-every-character policy's 3.618, last of the trivial fixed policies. The reason is precise. Only surprise is a selective signal at the character level, and it gates the harmful way to think (a deliberate re-read, which over-consolidates); the way to think that helps (replay) is monotone in dose, so always-on wins and a sparse trigger gives up the dose. The selective signal and the helpful action do not line up. So a count-native deliberate controller that picks when to think harder is hard for a named reason, not a vague one, and a winning controller would need actions whose payoff is not monotone in dose.
• The sharpening combiner: partly answered. We wanted a combiner that sharpens without blurring. Take-the-best is one: validity-ordered, early-stopping, sharpening by ignoring the weak cues. Cue retrieval is another: it sharpens long-distance binding by fan. What remains is sharpening at the discourse level, not just the next token.
• Discourse coherence: it will not yield to stacked state. We can detect a discourse boundary; we cannot yet predict with one, and the model still writes fluent local word-salad. The harder finding: three persistent-state mechanisms now all land on the same 0.9% backoff slice, and the boundary investigation sharpened it further: surprise carves only words, and meaning above the word yields weak, non-composing cracks, not crisp clauses or events. Coherence will not be crossed by bolting more persistent state onto a predictor whose every easy word is already decided locally. Whatever carries understanding across a long span must change the 99%, not rescue the 1%.

The honest stance

This is not AGI, and we will not pretend it is. It is a real, validated, online, inspectable, brain-grounded research program, one that publishes its negatives as carefully as its wins, because a closed door is information too.

Changelog of assumptions

The theory-shifting findings, dated. This is where future updates get appended.

• 2026-06-29 · Two adjacent research programs are adapted onto our gradient-free, online, grounded language route, and in each case our version matches or beats theirs by adding the scene: a real, learned, grounded grammar, biological topology that transfers, and a language route that does not erode at 10M where an apical-credit route did. Both an external biological-topology lab and Mitropolsky-Papadimitriou (Assembly Calculus) hit our abstraction wall and concluded the same thing: transferable abstraction needs an equivalence signal. They use apical credit and hand-set structure; we use language, the word won cross-situationally, the cleanest instance of their own framework. We adapted their machinery onto our route. The grammar (the headline), every piece composing the same organs, all gradient-free. Learned word order: all six constituent orders at 1.000 at high exposure (chance 0.167), the old fixed composer scoring 1.000 on SVO only; the typological signature present (object-initial harder, OVS/OSV 0.000 against others 0.750 at modest exposure, about 50 against 28 heard utterances to criterion) but honestly from a weak agent-before-patient salience prior (turn it off and all six acquire equally, the order still learned), ablation-confirmed, the order-shuffle control at chance 0.180. Recursion via a sequence-memory stack (the one first-class Assembly-Calculus operation we were missing, the one with their cleanest theorems): "the dog that chased the ball is big" attaches "big" to the dog, outer-attachment 1.000 with the stack against 0.000 ablated (a no-stack count baseline near chance), in comprehension and production, with a human-like depth ceiling (depth 1 1.000, depth 2 0.654, depth 3 0.588, tracking the proven capacity bound, a feature not a bug), the scaffold theorem reproduced at our scale (rehearsals halved, ratio 0.52 against 0.5). This is the recursive machine M-P only sketched and it closes our own prior recursion negative. Learned grounded attachment: a learned reader composing the router, the stack, and merge resolves prepositional-phrase attachment at 0.958 against a nearest-head baseline at 0.533 (the hard non-adjacent case 0.962 against 0.000 for every ungrounded arm), grounding load-bearing, every ablation and the shuffle collapsing it, a learned parser beating their hand-coded ungrounded one because the scene resolves what word order cannot. Biological topology transfers: multi-column cortical voting (hub 0.647 against single column 0.360, scaling cleanly 0.346 to 0.669 across 1 to 16 columns, shuffle at chance) and thalamic soft-competition role routing (noun 0.988, attribute 1.000, action 1.000, soft beating hard, which strands its early mis-routes). The honest route difference: hub-to-column lateral feedback is a null for us (best lift 0.003), because our word signal needs pooling for coverage, not the iterative consensus binding their object-id route needs; we report the null, not a fragile positive. Retention at scale (supporting, not headline): our language route is temporally stable where an apical-credit route eroded, held-out class-CCGP from 1M to 10M moving 0.348 to 0.353 (flat) and grounding 0.708 to 0.771 (improving), against the external 0.988 to 0.865 (-12%), because the word recurs and a homeostatic-leak bound holds a stable fixed point (a naive clip collapses to chance), so we do not need their metaplastic fix. Honest caveat: this was at a hard 16-way operating point (chance 0.0625) where the absolute abstraction margin is modest and the word-shuffle control is not fully clean (about 0.19, above the strict chance line), so the script's automated verdict even reads "erodes"; the temporal-stability comparison (flat to improving where theirs fell 12%, rank healthy) is the robust read, not the absolute margin, and we say so. The through-line is grounding, our edge: each adaptation beats its source by adding the scene or the caregiver. And the corrections, stated plainly: the SDR and Hebbian substrate is not ours (Assembly Calculus 2020, earlier than us, no longer pitched as our differentiator); only projection and sequences are proven in that calculus (merge and the rest are simulation, and so is our merge); and the depth and margin ceilings and the merge-decode crosstalk are real limits (the dependency readout 0.551 lags the decision 0.958; merge forgets old co-resident structures as one fabric saturates). Runtime untouched throughout; SDR, k-WTA, Hebbian, bounded, online, no backprop or counting or labels on the live path. Read
• 2026-06-28 · The biggest milestone of the program: one gradient-free, online, bounded-memory brain on our own recurrent runtime comprehends a simple grounded conversation, abstracts a concept through language, and speaks it back, the three threads converged and the hardest problem resolved in-bounds. This closes the three open ends of the developmental line at once, on the one assembled brain. It comprehends a conversation. The curriculum reaches its endpoint: G3 (morphology) generalizes a grammatical morpheme to held-out stems (referential 1.000, chance 0.333), and the load-bearing honest finding is that the brain's forward transitional-probability segmenter cannot place a morpheme boundary (the affix is predictable, so the dip lands inside the stem, "walking" cut as "wal-king"), cracked by the same chunking principle one altitude down (a recurring detachable sub-chunk detector, -ing/-ed/-s all 10/10, zero over-peel). G4 (relations, negation, grade-two dialog) binds who-does-what-to-whom by role-filler binding with the agent/patient role won from the perceptual scene, not handed in (held-out relation QA patient 1.000, agent 1.000, predicate 1.000, negation 1.000), and sustains a contingent multi-turn dialog comprehended 12/12. It speaks. G4 alone was telegraphic (structured production 0.000); a production-side composer, the inverse of comprehension (unbind each role, name it, emit in a fixed role order, the swap control proving the order tracks the role not an input position), lifts whole-relation structure to 1.000 on held-out meanings, and a whole-word prior lifts the surface form from 0.684 to 0.918 (the residual is one word per seed the brain genuinely never heard whole, the no-cheating constraint working), so live "the cup is not gold" comes back as "cup not gold." It abstracts a concept, via language, the project's hardest problem, resolved in-bounds. Six purely-perceptual unsupervised mechanisms all failed to build transferable abstraction, for one clean reason: a class is an equivalence over non-adjacent instances, and perceptual similarity, contiguity, and dynamics can only find adjacency (on a decorrelated code, same-class instances are near-orthogonal). Temporal prediction (LPL) ties the pure-local wall (0.344 against 0.342, the only rise being the no-decorrelation arm at 0.427, +0.085, the point because the decorrelation must be weakened before time can bind; an earlier two-seed read of 0.422 did not replicate); a rich temporal stream gives the binding-isolation probe 0.159 on, 0.159 off, both below chance 0.333; slow pooling, space-and-time attention, and a CA3 attractor fail identically (the attractor closing the purely-perceptual question). The decisive diagnosis: the decorrelation that keeps the code high-rank fights the predictive pull that would bind same-class items. The resolution is the program's own thesis, the WORD, won cross-situationally with no label, the cross-instance integral that supplies the non-adjacent equivalence: held-out class-CCGP without the word ~0.40 (the wall), with the word 0.87 synthetic (4/4 seeds) and 0.50 to 0.99 on the real grounded encoder (an honest operating-point curve, the lift growing with how reliably the class attribute is perceived), collapsing under word-shuffle, random-projection, and a floor control. No backprop, no internal credit, no counting; the constraint never relaxed, we used language. The richness lesson, honest: a full-vocabulary varied environment does not hurt the abstraction and the Mowgli case (no recurring co-occurrence) fails, but an impoverished fixed-context environment is pathological (it manufactures spurious structure that fools a naive read), so richness's payoff is unconfounding. The recurring lesson across the ladder: the developmental lag lives in construction complexity, the bottleneck is segmentation, perception preceding reference. Open edges, named: the mouth's last residual is segmenter over-cuts; free word order is a later module; the one place the word does not reach is transferable abstraction from perception alone (a dedicated binding mechanism that survives decorrelation, the next experiment); a couple of earlier results used two-seed reads that did not replicate (caught by the controls); and scale plus a real child-egocentric corpus (SAYCam, Vong) is next. Runtime untouched throughout. Read
• 2026-06-28 · The program is reframed as a developmental curriculum: one assembled child-brain, lagging an adult environment, is driven through staged comprehension-gated stages by a real caregiver, with the lag living in construction complexity and the bottleneck in segmentation, while deep transferable abstraction stays open. Two joins, on one brain. First, the validated organs are assembled into one brain with a working memory and a top-down route (a neural segmenter, a union encoder, a two-compartment binder, a working memory that latches the discourse topic, a generator): on the assembled brain held-out referential comprehension reads 0.983 against a shuffle at 0.276 (chance 0.250) and content production 0.932, and the working memory earns what the talkable brain alone could not, resolving an ambiguous word read from raw chars by the discourse context it holds, 1.000 with the working memory against 0.500 without it, with every control clean (gate shut 0.500, shuffle 0.500, apical with no bottom-up word drives nothing, None 100%). Second, that same brain is driven through a staged developmental curriculum (G1 to G4) with a real Haiku caregiver who speaks ahead of it, 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, the adult's lexicon is always a superset, both lags printed every run, the gap shrinking as exposure accumulates). G1 (one word) passes on the bare brain with nothing added: held-out pointing 0.828, the shuffle control 0.238 at chance (reference won cross-situationally, not leaked), a contingent recast beating a yoked one 0.827 against 0.481 (the loop teaches, not the words), and 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 (registered locally, runtime untouched, the role read off the perceptual channel rather than a word tag): typed color 0.807 and size 1.000 with wrong-class 0.000 where the untyped bag of the same facts confuses the classes at 0.437, corrected over yoked 0.557 against 0.083, and the construction lag (single-slot comprehension ahead of two-word production) positive across the whole climb up to +0.39. The curriculum trains the whole brain, not ad-hoc per-stage organs, and G3 (morphology) is in progress (no numbers reported). The recurring honest finding: the developmental lag lives in construction complexity (one word, then two, then morphology), and the catch-up bottleneck is segmentation, the child must isolate a word from the stream before it can ground a meaning, so perception precedes reference. And the deep, transferable-abstraction question is held open and honest, reported with the numbers and no breakthrough language. A purely-unsupervised, gradient-free route through time is a real ingredient that does not clear the bar: on character text at four seeds the plain predictive rule ties the pure-local wall (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, which is the point, not a loophole, because the decorrelation must be weakened before time can bind at all), and none clears the program's 0.451 credit-using value (an earlier two-seed read of 0.422 did not replicate at four seeds). A faithful temporally-rich stream does not close the gap either: the load-bearing binding-isolation probe, stripping the static window of all class information, reads 0.159 with time on, 0.159 with it off, both below chance 0.333, no temporal binding. The decisive diagnosis: 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, so the open direction is a dedicated binding mechanism, not more time. Runtime untouched; gradient-free, no counting, online single exposure, bounded memory throughout. Read
• 2026-06-28 · The whole loop closes on one brain: four Hebbian and SDR organs as connected Areas read raw chars, bind, comprehend a held-out question, speak a name, and are corrected by consequence, fully neural and gradient-free, one matrix W read forward to comprehend and backward to speak. The comprehension thread had named three things it had not done (no real language, no reader, no spoken answer) and the generation thread had reached a live conversation on hand-fed meaning codes; the two were the same missing join, and this round makes it. One brain on the runtime (cortexshell, cortexgraph) wires four validated organs as Areas: a fully-neural segmenter (HebbCharSeg, Hebbian char-transition synapses with a dip threshold, the last counting removed, no bigram dictionary) feeding a union encoder feeding a Hebbian binder (HebbAssoc, the matrix W), and a generator (HebbGenerator) that reads the binder's same W in reverse. The load-bearing fact is that all four phases run on the same organ instances, and the single W is written by learning, read forward to comprehend (act = W[:, word].sum, argmax over the present options), read backward to speak (wact = W[ref, :].sum, cleanup to a chunk), and re-written by correction, so comprehension and production are one matrix read two ways, not two systems, which is why the comprehension-over-production gap falls out of the geometry. The numbers, all on the one brain, chance 0.250 to point among four and 0.083 to name from twelve words. Comprehend: held-out referential pointing, choose the meant referent among distractors never studied together, 0.910 against a shuffle control at 0.217 (chance 0.250), so the binding is the word-to-referent contingency won from co-occurrence, not a leaked alignment or a memorized scene. Speak: content production with a silence self-check (keep the word only if it re-comprehends to the goal through the brain's own ear) 0.917, a real comprehension-over-production gap of +0.333 against open-vocab production, and where it cannot isolate a word the gate stays silent rather than misnaming it. Correct: the environment recasts a misunderstood word, re-uttering it in a fresh scene with the correct referent in focus through the brain's own raw-char reading path, an ordinary next exposure and a consequence, never a label or a gradient, lifting the mistaken word's comprehension 0.472 to 0.674, where a yoked recast (same budget, scrambled word) reaches only 0.506 and none stays flat at 0.472 (corrected over yoked +0.169 on the err-words, winning three of four seeds), so the contingent loop taught, not the words. And it holds a grounded conversation, pointing to and naming apple, cup, box, and ball, the dog-and-ball demo now fully neural on the runtime in about nine seconds. The faithfulness is checked, not asserted: a grep of the live path confirms no counting and no hand-tokenizing anywhere (no transitional-probability segmenter, no bigram dictionary), Hebbian and SDR end to end, gradient-free, online single exposure, bounded memory, the four laws holding the whole way. So the comprehension and generation tracks the program ran in parallel are one architecture now: one brain that reads, binds, speaks, and is corrected in its environment. Honest bounds, which name the next work: a small synthetic lexicon (twelve content words in a closed apple-and-cup world built to be parsed, not open text); the twelve-word cap weakens the yoke (about four err-words means a random recast lands on one with probability about a third, so a single seed can tie, hence the four-seed mean); held-out comprehension needs enough referents because the distractor-set signatures are combinatorial (the default twelve leaves held-out sets and keeps the conversation cast clean); the correction headroom lives in the binder, not the segmenter (warm the segmenter to a solid lexicon, then zero only W and give it a tiny binding dose, a cold listener with a warm ear, a faithful integration choice); and one content word in twelve is left un-isolated at cold start (the silence self-check defers rather than misnaming, on par with the organ scripts). The open work is scale and realer language. Read
• 2026-06-28 · End to end, no backprop: a gradient-free learner develops the class codes itself and the binder generalizes to a novel entity on them, learned-code CCGP predicting it at +1.00, so the hardest bet (gradient-free generalization) holds for this setting and the architecture learns its own codes. The previous round proved the binder generalizes to a novel entity given a class-structured code, with CCGP predicting it at +0.98, but turned the class-structure dial by hand (a prototype plus bit-flip), a stand-in for a learned cortex, so it showed only the binder half: if the cortex emits high-CCGP codes, then the binder generalizes. This round closes that caveat. A gradient-free learner develops the codes itself, from context, with no backprop anywhere: entities recur in class-indicative contexts, the learner accumulates each entity's context histogram online and reads a code as the sign of a fixed random projection of that histogram, count plus a random projection, the whole gradient-free kit. The binder then stores class-property bindings for known entities and must infer the property for novel entities coded from their own contexts. The dial is now the world, noise being the fraction of an entity's contexts drawn from the global pool instead of its class signature, zero meaning the classes are separable in context, one meaning the world is random with nothing to learn. Generalization is perfect (1.000) from a clean world out to noise 0.6, 0.767 at 0.8, and collapses to chance (0.217 against 0.200) only at noise 1.0 where the world is unlearnable, while a stored control that did store the novel entity's property stays near 1.000 throughout, so the collapse is a real failure to transfer, not a bug. Nothing is hand-fed: the codes are developed by counting contexts, and the property is never stored for the novel entity, so a right answer can only come from the structure the learner pulled out of the world. And the unifying result: the learned code's CCGP geometry tracks generalization end to end, correlation +1.00, more robust than the hand-set sweep, holding a step further out and failing only when the world itself is random. So the prior round's open antecedent is answered for this setting with a yes: the two engines and the binder are one system that learns its own codes, the cortex learning a high-CCGP abstract code, the hippocampus binding it, generalization riding on the geometry, with no hand-feeding and no gradient. The hardest bet the architecture rested on holds: gradient-free generalization through learned shared structure, the thing the Tolman-Eichenbaum Machine reaches only with backprop, won here with none, and the above-ceiling abstraction result is now load-bearing twice, it makes the binder generalize and a learner can develop a code with the property that powers it. Honest bounds, which name the next phase: the context world is synthetic (disjoint class signatures; real language is messier, with polysemy and overlapping sparse contexts); the learner is a context-histogram bag, not the apical abstraction stack, so this validates the principle (a gradient-free distributional learner can develop binder-ready codes), not that the stack specifically does it (wiring its learned codes in is the untested next step); and there is still no real language, no reader extracting role-filler structure from a raw stream, and no spoken answer, the three pieces still ahead. One seed, the plateau and the graceful step at 0.8 and the cliff to chance and the +1.00 correlation the structural reads. Read
• 2026-06-28 · Understanding, not lookup: the binder generalizes to a novel entity it was never told, and the cortex's CCGP geometry predicts when, correlation +0.98, so the abstraction engine is the generalization dial and the architecture is one system. Two rounds built a comprehension organ that answers and tracks truth, but every answer was about a fact the model was told, leaving open whether that is understanding or lookup. The test that separates them is generalization to the novel: store a class property for known members, then ask about a member never stored, where a right answer cannot be lookup. The instrument puts the condition on a dial, each class a prototype and a member that prototype with a fraction of its bits flipped, from flip 0 (members identical, strong class structure) to flip 0.5 (random, no structure), a stand-in for a cortex that has learned its classes. Store the property for twelve known members per class, then unbind a thirteenth, never bound member and clean up over the property codes. Generalization is perfect (1.000) from flip 0.00 through 0.30 and 0.850 at 0.40, collapsing to chance (0.217 against 0.200) only at flip 0.50 where the class structure is gone, while a stored control that did store the novel member's property stays 1.000 at every flip, so the collapse is a real failure to transfer, not a bug. The property the novel member never had is recovered from the shared structure of its class: understanding, not lookup. And the unifying result: the cortex code's CCGP geometry tracks generalization at correlation +0.98 (raw class separation a weaker +0.55), so the abstract-transfer structure of the code predicts whether the binder can answer about the novel. This is a correction of the record: six earlier rounds had measured CCGP against prediction and set it aside as "not our axis," and the gradient-free above-ceiling abstraction result sat genuinely novel and unused; CCGP was never the wrong axis, it was measured against the wrong job, and its job is generalization. So the two engines and the binder are one system: the cortex builds a high-CCGP abstract code, the hippocampus binds it, generalization rides on the geometry, the architecture's data flow now closed and measured end to end. Honest bounds: the class-structured codes here are hand-constructed (a prototype plus bit-flip), so this proves the binder half (if the cortex makes high-CCGP class-structured codes, the binder generalizes), and whether the abstraction stack can learn codes that good gradient-free on realer data is the genuinely open end-to-end bet; one geometry proxy stayed flat because it measures between-class-mean orthogonality, which the flip dial does not change (it degrades within-class spread), so CCGP and class separation are the faithful predictors here; a synthetic five-class world, one seed, the plateau and the cliff and the +0.98 correlation the structural reads. Read
• 2026-06-28 · The binder is a validated comprehension organ: typed, cortex-grounded, and truth-tracking, where the cheap strategy provably fails, and the next work is the reading-and-answering architecture, not more synthetic rungs. The first positive showed a gradient-free binder answering one binding question counting cannot, but one passing task is what a hash map does. So this round tested the binder across three more capabilities, each gradient-free, each under the same per-episode randomization control that pins any counting model at chance. Typed: with every entity holding a color and a size, "what color" returns the color and not the size, 1.000 on both classes, where an untyped bag of the same facts confuses the classes (wrong-class 0.504, a coin flip), so the per-class role is what makes binding typed. Cortex-grounded: binding the codes a real neocortex would emit (content-derived from the spelling) comprehends exactly as well as fresh random atoms, 1.000 against 1.000, so the neocortex-to-hippocampus flow (encode in the cortex, bind the cortical code in the hippocampus) works end to end; the honest part is that whether code similarity helps came back inconclusive, because distinct spellings project near-orthogonal (cosine 0.014) so there was no interference to measure, and the similarity payoff waits on learned semantic structure (the next phase). Truth: "is the box red?" gets a NO when the box is blue, even though the episode says "it is not red" first so red co-occurs with the box, the binder scoring 1.000 on the no-cases by retrieving the true color and comparing, where co-occurrence says yes to the negated color and scores 0.000 on the no-cases, the failure association predicts. So the binder is a comprehension organ, not a one-task demo: typed binding rules out "just remembers the entity," cortex-grounding rules out "only idealized atoms," negation rules out "association with extra steps," and the neocortical count engine provably cannot do any of the three. The honest forward-look, the north-star steer: every test here and last round is hand-parsed with hand-coded comparators, so the next work is the architecture, a reader that extracts the role-filler structure from the stream itself (the cortex's engines feeding the binder), generation of the answer, and realer language, not more synthetic rungs. We have built the missing organ; the job now is to wire it into a system that reads and answers on its own. Read
• 2026-06-28 · The pivot from compression to comprehension, and its first positive: counting is provably at chance on a binding task, and a gradient-free relational binder answers it. Six rounds on prediction had said the next symbol is a local game counting already wins, so the program changed the question. The goal is a brain-inspired cognitive architecture we can talk to, and the smallest version of talking to it is comprehension, not compression: say two facts, ask a question, get the answer ("here is an apple, it is green, here is a cup, it is blue, what color is the apple?"). A four-stream research fan-out converged on the finding that this is not a prediction problem but a variable-binding, one-shot relational-memory problem. Our two engines, the count predictor and the apical abstractor, are both the neocortex (slow, dense, structure over many examples); the step the task turns on, bind this entity to this property on a single encounter and read it back from a cue, is the job of the organ the brain runs in parallel and we lacked: the hippocampus (fast, sparse, content-addressable). The mechanism that fits all four rules (online, gradient-free, bounded, on the sparse codes we already emit) is vector-symbolic binding, the engineering form of the Tolman-Eichenbaum Machine: a statement binds, a question unbinds, the answer is cleanup. The instrument is the apple/cup task with one load-bearing control: the property is randomized every episode, so corpus-wide every entity is equally often every color, which makes any counting model provably sit at chance. The result, held-out QA accuracy against a chance of 0.250: counting is pinned at chance (the strongest co-occurrence reader 0.246, dead on the line); an exact dictionary scores 1.000 (the instrument is valid); the corrupt-store control collapses to 0.243 (the store does the work, not a leak); and the gradient-free VSA binder over random codes scores 1.000, clearing the roughly three-year-old binding bar (0.75 to 0.90) with room to spare. Capacity is graceful: eleven facts in one episode still 1.000 at full width, bending only at a tiny sixty-four dimensions to 0.884. This is the first positive of the neocortex-plus-hippocampus architecture: the gradient-free relational binder comprehends where the count engine provably cannot, the smallest thing we can talk to, working, in regime. Honest bounds: the fillers are random codes, not learned cortical codes, so this tests the binding mechanism, not yet generalization to novel entities (the next phase, where the abstraction engine's above-ceiling code becomes the generalization dial, and where the gradient-free constraint bites hardest); Stage zero, one, two only; one property class (color); typed binding, relations, negation, and novel-entity fast-mapping all untested up the curriculum ladder; one seed, the control and the collapse and the capacity falloff the structural reads. Read
• 2026-06-28 · The feedback seam is null for the next character: a coarse abstraction tag carries real information yet buys no prediction, so the cross-feed must be measured at the scale of meaning, not the next character. The rank-reuse tension said one shared code cannot be both abstract and count-reusable; the cortex's own answer (Bastos 2012, Larkum 2013) is to keep both codes and share information, not representation, through a coarse repeatable tag, the feedback arrow from the abstraction engine to the prediction engine. This builds that seam, count-only, the cheapest decisive leg: a count predictor on the raw context conditioned on a coarse abstraction tag, against the same machinery without it, on the identical text8 split, with a shuffled-tag control to separate the tag's information from mere count-splitting. The tag carries real information and still buys no prediction. A short-horizon tag, the abstraction stack's own deep code, beats its shuffle by up to 0.385 bits-per-char, so it is genuinely informative, but it is redundant with the order-six n-gram (it re-encodes the same six characters), so a soft coupling that never displaces a well-counted raw cell reaches break-even and no better: at a million characters the net is +0.001, exactly the baseline, never below it. A long-horizon tag carries almost no information: a recency-weighted gist over the characters outside the n-gram window beats its shuffle by about 0.013 bits, no better than a random tag, and conditioning on it only hurts (+0.06 to +0.10), and it does not help even at word-start positions, the least locally determined in the text (+0.05 to +0.11, no scale dependence). The unified finding: next-character prediction is an overwhelmingly local game that counting already wins, and information is not usable prediction gain, redundant where present and absent where new, the same prediction-versus-abstraction split the program keeps finding. So the conclusion is not that the coupling fails but that the ruler was wrong: the mutual loop is already half-built, because the abstraction stack's per-unit credit is the prediction error, so prediction already teaches abstraction, and the only missing arrow is the one shown null here for the next character. The cross-feed must be measured at the next word and the coherence of generated text, not the next character, and the soft-coupling mechanism is validated and ready for that scale. Honest bounds: the theme gist and the short-horizon code were tested, a sharper long-range signal (the previous word, a learned long-range code) untested; character bits-per-char only; the frozen abstraction substrate; two hundred thousand and a million characters, one seed, the slope the read. Read
• 2026-06-28 · Where we are: the program has built two engines, each strong on its own axis, and the architecture spec is at v2. A standing-back regroup. The run of rounds has converged on two engines. A prediction engine (the diverse-view count bank, the BLEND-NORM calibrated pool, grow-then-prune) reads the next character at the n-gram level, near 2.1 bits-per-char, count-native and gradient-free. An abstraction engine (the sparse apical stack: k-WTA, boosting, positive weights, per-unit precision-gated apical credit) builds a transfer-abstract code at or above the 0.484 backprop ceiling with no gradient at all, the genuinely novel result. Each is strong on its own axis; neither does the other's job. The recent wins got them there: P0.5's stable sparse abstraction (boosting plus positive weights, both needed), grow-then-prune breaking the bits-per-char plateau (1.875 at ten million vs the fixed bank's 2.109), BLEND-NORM's calibration fix (a full bit better than the over-sharpening pool), the learning-rate sweet spot (0.001, a U-shaped optimum), and the attention subsystem. The honest scorecard: a mile from a strong transformer on prediction (the n-gram level, in the right universe, not the frontier), the abstraction result the real prize. The deep open problem is that the two engines do not fuse: a count head on the abstract code pays a stable 0.45 bits-per-char tax, the rank/reuse tension, because the high rank that makes a code abstract makes it nearly unique per position and a count table predicts by reuse. One code cannot be both abstract and count-reusable. The bet to resolve it is the cortex's own answer: two coupled laminar layers (Bastos 2012, Larkum 2013) that keep both codes and share information, not representation, the abstraction engine's apical credit already a Larkum cell, with the cheap count-only first slice running. What comes after is the larger architecture: generation and production, learning by example. The architecture spec is re-versioned to v2 around the two engines, the dimensions, the tension, and the coupled-laminar next direction; the full v1 spec is kept at /architecture-v1/. Read
• 2026-06-28 · The locked learning rate is too aggressive: a gentler rate lets re-reading compound to a lower floor, so the global rate should be revisited. The re-reading round found repetition a modest prediction lever that flattened by the third pass. The hypothesis: that plateau is an artifact of the locked learning rate (0.005), too aggressive to let repetition compound. A sweep of the apical rate over one, five, and ten passes, everything else held to the re-reading config, confirms it. A gentler rate reaches a lower floor: at 0.001 the held-out bits-per-char reaches 3.637 against the aggressive baseline's 3.762, 0.125 bits better at matched exposure. The optimum is a U: 0.005 is too aggressive (it crams the slice on the first pass, then runs flat), 0.001 is the sweet spot, and 0.0005 is too gentle (it underfits, starting and plateauing highest). Repetition compounds under the gentle rate where the aggressive one stalls: the 0.001 curve descends smoothly across all ten passes (3.749 to 3.637), the 0.005 curve flatlines after the first re-read. No overfit, and the gentler rates hold a tighter generalization gap. The broader point reaches past re-reading: the rate that proved too aggressive is the apical stack's global learning rate, fixed by the architecture sweeps and used everywhere, so the locked value is likely too hot on every run, not just re-reading, and the global rate should be revisited. Honest bounds: a prediction lever only (transfer CCGP stays flat above the 0.484 ceiling, abstraction unmoved); the absolute gain is modest (about a quarter of a tenth of a bit); it is the apical learned stack, not our best predictor (the count voting bank near 2.1 is re-reading-invariant and has no rate to tune, so the headline does not move); a 200K slice, two seeds, one harness. Read
• 2026-06-28 · The rank-reuse tension: one substrate can feed both heads, but the abstract code pays a count-reuse tax, so abstraction and prediction want representations in tension. The last round named two paths forward; this takes the second, graft a count-native head onto the abstract code. A count table keyed on the P0.5 abstract winner-set predicts the next character, against the identical count machinery keyed on the raw context, on the same frozen substrate, from eighteen thousand to one hundred thousand characters. The result is an informative middle that leans deep-negative, and it carries a finding either way. The count head extracts real signal from the abstract code: counting on it reads 2.578 bits-per-char at one hundred thousand characters, 0.8 to 1.0 below the stack's own readout (3.548), so the abstract code carries next-character signal and one substrate can feed both heads, a real sub-win. But it stays about 0.45 bits behind raw context, and the gap holds with scale: counting on the raw context reads 2.141, and the abstract code trails it by +0.50 at eighteen thousand and +0.44 at one hundred thousand, stable across 5.5 times the data, not a small-data artifact, while the same code's transfer CCGP is 0.499, above the 0.484 backprop reference. So the same code abstracts well and predicts worse, and the prize (low bits and high abstraction in one representation) is not reached. The mechanism is a tension in the representation itself. The abstract code is nearly unique per position (three to six counts per key even at seventy thousand positions), because the high rank that earns the transfer CCGP makes the winner-set almost never repeat, and a count table predicts by reuse, so it must back off to coarser subsets. High rank gives good abstraction and poor count-reuse, so abstraction and prediction want representations in tension, and the two-stacks split has a root in the code, not just the wiring. Honest bounds: eighteen thousand to one hundred thousand characters and one to two seeds (absolute bits-per-char scale-compressed); the robust finding is the half-bit tax, stable across 5.5 times the data; the sub-win over the native readout is robust too; the deep-negative reading is leaned-toward, not closed, because the lever the diagnostic points at is untested. That lever: a coarser, less-sparse code (a smaller winner-set) that might repeat enough to predict while staying abstract enough to keep its CCGP, a sparsity-versus-reuse sweet spot. Read
• 2026-06-28 · A fair with-repetition axis on the benchmark scorecard: re-reading is the fair online analogue of the transformer's multi-epoch, and it does not move the headline. The gradient transformer in the head-to-head trains multi-epoch while our learned stacks see each character once, so the fair comparison gives the learned stacks multiple exposures the way the rule permits: re-reading a bounded slice, online, no reset. It helps the apical learned stack, held-out bits-per-char 3.86 to 3.76 with no overfit, and beats fresh data at matched compute. But the count models are re-reading-invariant (a count table is complete after one pass), so the n-gram and our ~2.1 voting bank are already single-pass-fair, the ~2.1 headline and the growth that breaks the plateau stand, and abstraction does not move. The benchmark scorecard now carries this as the with-repetition axis, referencing the existing re-reading result. Read
• 2026-06-28 · One stack, two halves: abstraction composes and exceeds the single-layer backprop reference, but prediction does not transfer via the vote. The program split into two engines that each do one thing: a count-native voting bank that predicts (many views pooled by a calibrated blend, low bits-per-char) and the sparse apical stack that abstracts (k-WTA with boosting, positive weights, and per-unit credit, at the 0.484 ceiling). The prize is one stack that does both, so this gave the abstraction stack the prediction machinery, eight sparse columns each on a different view, voted by the same blend, abstraction kept intact, three arms on the identical eighteen-thousand-character text8 slice, depth three, two-seed mean. The result is an honest trade-off. Abstraction composes, and it exceeds the reference. The unified stack reaches transfer CCGP 0.520, above its own single-view 0.487 and above the 0.484 single-layer backprop reference (GRAD-1L), at higher dimensionality (PR 19.5 against 8.1) with no collapse: the highest abstraction the program has reached, gradient-free. The earlier capstone collapse does not reassert, because k-WTA and boosting preserve the cross-stimulus variance the dense normalization destroyed, so diverse views add to the abstract code instead of flattening it. Prediction does not transfer. The unified stack reads 3.666 bits-per-char, barely below its single-view 3.753 and nowhere near the voting bank's 2.442, and the diagnostic is sharp: the blended bits-per-char equals the bank's own best single column, so the vote does nothing for prediction with neural columns. The voting bank's bits-per-char win is a property of count tables combining, not of voting, and sparse apical columns do not combine that way. So the prize, one stack low on bits and high on abstraction, is not won at this scale: the synthesis kept and improved abstraction and did not import prediction, and predict-and-abstract in one stack stays open with the obstacle named. Honest bounds: eighteen thousand characters and two seeds (the bits-per-char anchors scale-compressed at that size, the voting bank reaching about 2.1 only past two hundred thousand characters); the 0.484 is the single-layer reference, so "exceeds the ceiling" means it passes GRAD-1L, and a multi-view backprop is the fair ceiling to recheck before any claim of gradient-free past backprop; and the boosting-plus-positive-weights config is the only stable arm. The path forward, the diagnostic's two directions: couple the columns (train each readout on the pooled error so the vote is fit jointly), or graft a count-native head onto the P0.5 abstract code (the abstract sparse code as the context key for a count predictor, one substrate with two heads). Read
• 2026-06-28 · A growable substrate breaks the bits-per-char plateau: where the fixed bank flattens, the growable bank keeps dropping, scaling like the n-gram. The prediction calibration found a flat spot: our fixed twelve-column voting bank improves to about a million characters and then stops (2.234 to 2.112 to 2.109 bits-per-char, flat from a million on), while a plain n-gram keeps falling because it keeps growing, adding longer-context counts as data arrives. So the test: if the plateau is a fixed-capacity artifact, does a growable bank break it? This builds the grow-then-prune the program wanted, on the identical text8 split and the identical bits-per-char loop: add a longer-context voting column when the held-out gain decays, cap the count, prune the least-used. The result. The fixed bank plateaus and the growable bank does not. The fixed bank moves 2.112 to 2.109 past a million (a drop of 0.003, flat); the growable bank moves 2.004 to 1.875 (a drop of 0.129, still falling), growing 12 to 16 to 24 columns. At ten million the growable bank reads 1.875 against the fixed bank's 2.109, 0.233 bits ahead, and within 0.047 of the n-gram floor (1.829). It grew the right thing (progressively longer-context views, its longest span climbing from five to eight, the capacity the fixed bank lacks and the n-gram wins by), it correctly did not grow at two hundred thousand characters (too little data to saturate), and the cap held with the prune at ten million. So the plateau was a fixed-capacity artifact, and growth dissolves it: the growable bank restores the n-gram-like scaling slope by doing what the n-gram does. Honest bounds, kept: it reaches about the n-gram (1.875 against 1.829), not past it; it stays about 0.85 bits behind text8 SOTA near 1.0; and prediction is not our headline axis, so this does not move the home axes (abstraction, continual learning). The deliverable is the capability: a count-native, online, bounded substrate that keeps learning from data instead of saturating, the thing scale needs for abstraction too. One seed. Read
• 2026-06-28 · The prediction calibration: a plain n-gram beats us, the gradient transformer overtakes us, and our bits-per-char plateaus. Prediction is not our axis. Where does the model sit versus the field on raw next-character prediction? Three learners on the identical text8 slices and the identical bits-per-char loop, at three scales: a plain order-six backoff n-gram, a gradient char-Transformer (805K parameters, backprop, early-stopped), and our model (online, single-pass, gradient-free). The result, stated plainly. We plateau: 2.234 to 2.112 to 2.109 bits-per-char as the corpus grows from two hundred thousand to one million to ten million characters, flat from one million on, while the n-gram keeps falling (1.991 to 1.829) and the transformer keeps falling (2.074 to 1.938). Past about a million characters we do not turn more data into better prediction, and both baselines do. A plain n-gram beats us at every scale, and the gap widens with data (0.28 bits-per-char at ten million); on raw prediction a count table beats our voting machinery. The gradient transformer overtakes us by one million and pulls clear, scaling fastest from a worst-at-two-hundred-thousand overfit start. Against the cited ladder (no-skill 4.755, us about 2.1, a 2012 LSTM 1.54, Transformer-XL 1.08, text8 SOTA about 1.0, all bits-per-char on text8) we clear no-skill comfortably and are competitive at tiny data, but we sit about one bit behind the simple-gradient rung and are not closing it. So prediction is not the model's axis. Its bet is what the n-gram and the tiny transformer do not have: the abstraction the CCGP probe tracks (above the gradient ceiling), the online, bounded, gradient-free regime, and the attention, generation, and working-memory machinery. The plateau is the stability and bounded-capacity limit made concrete on a public yardstick, and it is what the sparse-substrate redesign targets. What is comparable is bits-per-char on text8; what is not comparable is MMLU and the knowledge frontier, where a character count learner does not compete. Read
• 2026-06-28 · The count-native System 2 does not beat fixed policies at the character level: a selector over learning modes loses, and we know why. The sharpest test of a count-native System 2, a controller that picks when to think harder, finished the comparison the bank-of-critics round ran out of GPU on. A bank of self-calibrating critics and a selector, against the trivial fixed policies, on the locked model over the drift stream. The selector loses, reading 3.984 bits-per-char against the bare model's 3.920 and the replay-every-character policy's 3.618, last of the four. The loss has a precise mechanism in three parts. The self-calibrating gate works and only surprise is selective: every critic tunes itself to the target fire-rate, but surprise holds it with the highest threshold, a real tail, while conflict and low precision hit the rate only by collapsing toward the bulk. The selective signal gates the wrong way to think: a deliberate re-read wired to the surprise tail inherits the harm of always thinking (the apex dimensionality dragged from 3.78 to 2.94). And the way to think that helps wants a dose, not a tail: replay is monotone in how much you do it, so always-consolidate wins outright and a sparse selectively-gated replay is worse than both heavy replay and none. So at the character level no count-native critic signal, used to gate a sparse intervention, beats the trivial fixed policies, because the one selective signal triggers the harmful mode and the helpful mode wants a dose. This closes a question the bank-of-critics round left open with a no, and sharpens the System-2 gap into a precise obstacle: the selective signal and the helpful action do not line up. Honest: the character level (a coarser grain makes conflict selective again), fifty thousand characters before the drift fully bites (a long sweep is the steelman, though replay's monotone benefit should still let always-consolidate win), and one seed. Read
• 2026-06-28 · A calibration fix for the voting pool, and Global Workspace ignition does not win for prediction. A test of Global Workspace Theory's ignition (broadcast the single winning column, all-or-none, rather than averaging every specialist) surfaced a calibration win the program needed. On the voting substrate at two hundred thousand characters, hard winner-take-all reads 2.600 bits-per-char against the product pool's 3.307, but only because it de-sharpens an over-confident pool: a normalized blend that keeps every column reads 2.314, better than both, and beats winner-take-all at every scale. The diagnosis is over-sharpening. The un-normalized product raises the consensus distribution to the power of the summed confidences (about three over ten active columns), which inflates the bits; normalize the exponent to about one and keep every specialist, and the pool predicts a full bit per char better. So ignition does not win for prediction, all-or-none access discards evidence the blend keeps, and the right pool is every specialist at the right temperature, confirming the calibrated geometric-mean pooling the main vote already runs. The honest correction: the experiments built on this substrate ran the un-normalized pool, so their absolute bits were inflated by about one, the within-experiment comparisons hold (every arm paid the same tax), only the absolute numbers were high, and the normalized blend is the corrected default. Read
• 2026-06-25 · A count model beat the gradient nets. A plain online counter beat two gradient-trained networks at predicting text, and counting became the substrate we leaned on. Read
• 2026-06-26 · The rule is the regime, not counting. Clarified: the first rule is online, gradient-free, continuous learning, the way people learn, where each datum changes the system on arrival in a single pass. Counting is the instantiation that won first, not the law; any online, local, gradient-free update qualifies (associative plasticity, accumulators, online clustering, binding), and an offline sleep cycle is allowed. What is forbidden is gradient descent and batch passes that revisit the data, nothing narrower.
• 2026-06-25 · Bits-per-char is the wrong axis for higher levels. One headline number was hiding the truth; we built a scorecard and now judge each level on the axis it can win. Read
• 2026-06-26 · Proximity is for similarity, not prediction. A meaning-map will not predict the next word, but it is the right representation for the unseen, so we keep it as a map and pour it into the counter. Read · Read
• 2026-06-26 · More data subsumes locally-competing mechanisms. Build what counting cannot, not what it already does. Read
• 2026-06-26 · Bounded memory re-elevates generalization, sleep, and retention. The budget reverses the scale verdict; the mechanisms that looked redundant are the ones a bounded mind needs. Read · Read
• 2026-06-26 · Everything built is System 1. System 2, a serial, capacity-limited workspace, is the next layer. (Superseded the same day by the System-2 round below.)
• 2026-06-26 · System 2 is real: a metacognitive gate that overrides System 1 when it is wrong. A dual trigger (calibrated confidence + conflict) deploys a deliberate pass: +0.38 accuracy on conflict cases, zero harm otherwise, graceful to System 1 at zero budget. The gate is the win; the serial workspace is parked for the multi-step task. Read
• 2026-06-26 · Redescription turns implicit counts into explicit, manipulable concepts. On stability, not error, a mastered construction is promoted to a slot-addressable concept that answers queries the flat count cannot, the operands System 2 deliberates over. Read
• 2026-06-26 · The right combiner is validity-ordered take-the-best, not full pooling. Consult the most-valid cue, stop early, ignore the weak channel: it beats full geometric-mean integration on accuracy, perplexity, and compute at once. The combiner sharpens by ignoring. Read
• 2026-06-26 · Bounded memory, refined: LFU for char-grams, no curriculum. The power law is the right shape of forgetting (it alone represents spacing) but LFU wins eviction for dense char-grams, so the power law is reserved for the sparse word and concept level. And growing the budget on a schedule is a no-op: only the final horizon matters, because a count learner cannot get stuck. Read · Read

The budget-binding-reasoning round

• 2026-06-26 · The bounded-memory rule is empirically confirmed. Under a budget the vanished mechanisms return: consolidation flips −0.006 → +0.307 bpc as the cap tightens, a measured curve. Generalization is not optional; it is how a bounded model approximates the unbounded one. Read
• 2026-06-26 · Long-distance binding by content cue, not position. Cue retrieval binds a verb to its correct-number subject across a clause (99.96% vs offset-attention's 65%) and reproduces the human agreement-attraction illusion, because activation divides by the fan. A new System-1 binding primitive. Read
• 2026-06-26 · VSA reads structure given the structure, not by factoring blindly. Role-filler decode recovers subject/verb/object at 100% when the roles are supplied; the blind resonator fails at affordable dimension. The reasoning route is supply structure, don't factor blindly. Read
• 2026-06-26 · Coherence will not yield to stacked persistent state. A third persistent-state mechanism (a typed situation model) lands on the same 0.9% backoff slice as the prior two. Whatever crosses the coherence frontier must change the 99%, not rescue the 1%. (Methodological: measure a top-down prior against a static prior, never against no prior.) Read
• 2026-06-26 · Power-law eviction wins at the word level. The sign flipped from the char-gram result, exactly as predicted: under non-stationarity and a tight budget, power-law (ACT-R) eviction beats LFU (−0.008, −0.006 bpw), by serving the present rather than protecting the past. Read
• 2026-06-26 · The System-2 workspace reaches multi-hop; selection is untested. The workspace reaches a two-hop target (acc 1.00) where System 1 and one-step deferral score 0.00, but on a single deterministic chain its focus-and-inhibition machinery only ties a blind "apply-twice." Its untested home is competing-chains selection. Read
• 2026-06-26 · Environment-as-memory is a cost arbitrage, not a free lunch. At equal budget a bounded-internal + external store loses to one bigger internal table (evidence fragmentation); it wins only when the page is cheaper than the skull (−0.23 bpc). Read
• 2026-06-26 · Phrase pooling is real but its addressing blurs the tail. Permutation-bound FlyHash addresses pool similar phrases (beats a floored literal on 67% of unseen-form probes) and keep order, but crosstalk loses the aggregate tail, so it belongs as a backoff layer under the literal table. Read

The acquisition-to-generation round

• 2026-06-26 · The cortex speaks (rough): production is comprehension read the hard way. A chunk lexicon supplies whole committed units as emission vocabulary; a coverage-competition producer says them +18.5 pts more well-formed than flat sampling and preserves frames 87.5% of the time. Generation is real but rough. The chunk lexicon is a segmenter and emission vocabulary, not a predictor. A contingent reply teaches more than the same words overheard cold (+0.45 bpc over the scrambled-timing control), and the win survives a live model: run against claude-haiku-4-5 through the logged-in CLI (no API key), contingency-ON beats the yoked control at 12/12 sweep settings. First support for the reactive-loop bet, now live-confirmed. The no-curriculum rule generalizes: a count learner needs no write-throttle and no structural curriculum, only enough final memory. Read · Read
• 2026-06-26 · A reader is not a speaker: communication is production read for its consequence. Reading selects a token for fidelity to the stream; producing selects it for its effect on a listener. The steering that adds (which utterance to repeat, and for whom) rides a count-native audience model: recipient design as the divergence between a speaker table and a listener table, scored on referential success, never on bits-per-char. Read

The abstraction round

• 2026-06-26 · Surprise carves words, not meaning above them. The purest form of the theory (concepts as the higher tiers of surprise boundaries) holds only at the lexical tier. Across ten variants on the node runtime: WORD = branching entropy is solid; phrase, clause, and topic yield only weak, ~±2-precise cracks from different signals (belief-shift, completion, cohesion). And three meta-negatives rule out the cheap fixes: the wins don't compose, scale isn't the unlock, a shared representation isn't the unlock. Crisp clauses and events need a genuinely different signal (real syntax) not better wiring, data, or representation. The node architecture itself is the quiet structural win: ten organs stacked with zero engine changes. Read
• 2026-06-27 · Gradient-free local rules carve and compress but do not abstract. A pure-biology HTM voting cortex traces only the back half of the brain's learning arc (sequence learning and dimensionality compression, with voting sharpening the late drop) but abstraction drops rather than rises, and scale does not save it (pure-biology). Temporal pooling builds stable, rising-timescale concepts and a top-down Hebbian signal settles and disambiguates the hierarchy, both real positives, and neither makes the space abstract (slower-and-from-above). Six convergent negatives from six different mechanisms. Read · Read
• 2026-06-27 · The abstraction wall was credit assignment, not topology. The six negatives pointed at one suspect; a head-to-head isolated it. Hold one architecture, the same data, and the same online single-pass regime fixed, and swap only the update rule: online backprop builds the abstract (higher-CCGP) space, while the no-gradient Oja arm compresses dimensionality hard (PR 100→14) and loses abstraction: the exact six-negatives signature, across three seeds. The missing ingredient is the gradient, the kind of credit assignment a local rule cannot do. The neuroscience agrees (Numenta dropped HTM for transformers on language; Lindsay 2017: Hebbian gives mixed selectivity, not the abstract code; Wutz 2018: abstraction is built top-down). The honest caveats hold: the gradient arm is the global-backprop oracle, one architecture, one probe, modest absolute scores. The open question flips from "is a gradient needed?" to "can a local gradient keep the win inside the online, local, bounded regime?" Read
• 2026-06-27 · A per-unit local signal clears the abstraction wall; a broadcast scalar does not. On the same harness, swap in two new hidden-layer rules. A broadcast neuromodulatory scalar (three-factor) lands on the no-gradient floor: one scalar everywhere can only scale an Oja step, not tell each unit how to change (Lindsay 2017). A per-unit local signal (feedback alignment, fixed random feedback, no weight transport, biologically plausible) drops bits-per-char 4.05→3.50 and lifts the abstraction score to ~0.41 within and on held-out transfer, approaching the global-backprop oracle's ~0.49. Transfer tracks within for every arm. So abstraction is reachable inside online + local + bounded, and "credit assignment" sharpens to per-unit credit assignment: a shippable learner comes into reach, where DC had only an oracle. Read
• 2026-06-27 · The abstraction wall has a constructive architecture: per-unit credit on a precision-gated top-down pathway, and abstraction climbs with depth. The keystone. Ride the per-unit credit down a real top-down apical pathway (the same wire that primes the level below) gated by precision for when it fires. On a two-level stack the full fusion reaches transfer CCGP 0.501, beating single-layer feedback alignment (0.408) and the raw baseline (0.339), approaching the backprop ceiling (0.537), and it is the first stack whose abstraction rises with depth (+0.178). The priming pathway and the credit pathway are one mechanism, one precision read three ways (attention gain, working-memory eligibility, per-unit credit amplitude). Honest caveats: the win is the full fusion not apical-alone (ungated apical sits below the baseline), it needed a stabilized learning rate, HEBB-2L's apparent rise is a degenerate-code artifact, still one architecture and one probe. The frontier reshapes from is it possible to scale, multi-attention, and stability. Read
• 2026-06-27 · Compression is not abstraction; prediction and abstraction factor; depth buys one altitude, then stability is the wall. Three swings after the keystone. A self-supervised label attractor compresses dimensionality harder than anything in the line (PR 5.8) but scores below the raw baseline on transfer (0.321 vs 0.339): the gradient-free shortcut ruled out, Barrett's own compression-is-not-abstraction caution reproduced. Different attended views make voting earn its keep (Monty's diversity requirement confirmed, same-view voting is worse than a single column) and win prediction when data is thin, but leave abstraction flat, so prediction and abstraction factor: prediction from diverse precision-weighted views, abstraction from per-unit apical credit. And scaling the fusion buys one extra altitude (depth-three apex 0.465 ≈ ceiling) then saturates; more data only raises divergence; the precision gate flips from hero to chief destabilizer at depth. The next wall is stability. Read
• 2026-06-27 · The abstraction architecture is LOCKED above the backprop ceiling. The sweep round closes the line. Stability is solved: forward-activation normalization holds the stack stable 19/19 where the baseline, a gate-clip alone, and a dream-replay cycle alone all diverge (a standalone-replay negative). The four levers factor and are complementary: stability ← normalization-plus-gate-clip; deep dimensionality ← breadth and dropout; abstraction ← per-unit precision-gated apical credit at a precision-gain ≈ 0.2; prediction ← breadth at depth two and diverse views. The winner, normalization-plus-gate-clip, gain ≈ 0.2, depth three, reaches transfer CCGP 0.50 to 0.55, above the 0.484 backprop ceiling, stable, seed-robust. And the capstone meant to push it deeper ran and failed: breadth and normalization act on different axes of variance and do not add (the combine stays stable but collapses to dimensionality 1.17, breadth preserves variance across columns, normalization destroys it across stimuli within each column). Abstraction does not climb past depth three by combining existing levers; pushing deeper needs a design change of uncertain payoff. The architecture is settled above the ceiling, and the open value moves to generation. Read

The generation round

• 2026-06-27 · Internal self-feedback teaches production with no listener. The first positive on the generation frontier, on a different axis from the whole abstraction line. The birdsong loop: an agent babbles candidate utterances over the chunk-lexicon emission vocabulary, re-comprehends its own output to recover what it would understand, and corrects toward the meaning it intended, with no listener. It recovers a meaning 0.271 of the time against a chance of 0.042: about 6.5× chance, 8× its own open-loop and deafened ablations (which sit at chance with zero coverage). All three guards fire: scramble the target and it collapses to exactly chance (0.042); let the self-output contaminate comprehension and an independent judge catches the private-code drift (recovery 0.122 yet the lowest self-error of any arm). The meaning code is a salience-weighted heard fingerprint, so the producer can't string-match. So self-practice teaches fluency and form, the internal half of generation. Honest: absolute recovery is modest (~0.27 on 24 meanings, a first cut), and by design the loop supplies fluency not a shared convention. The external half (a referential game scored on whether a listener recovers the referent, the anchor against private-code drift) is the named next move. The generation frontier turns from all-open to half-answered. Read
• 2026-06-28 · Production is a separate organ: a separate inverse beats the reader run backwards on the conditional task. The comprehension-production wall named its own fix, and this builds it. The locked reader recognizes ~296/500 words but produces ~64 and plays a specific word back to the exact spelling only 2 times in 296: a recognizer reversed returns the most common continuation, not the word you meant. So production is built as a separate learned map from a meaning to a sequence (the DIVA design), trained feedback-first by the birdsong loop, not the reader reversed. On the matched conditional task, produce one specific intended meaning across 300 meanings on a controlled vocabulary, judged by a frozen judge, the separate inverse recovers 82 where the reader run backwards recovers 2 (validity 0.300 vs 0.030, recovery 0.417 vs 0.083). It learns it over training (recovery 0.060 → 0.417 over 40 episodes) and wins in every frequency band including the rare tail (28 of 100 at the rarest, against 4), the novel/low-frequency axis the DIVA model flagged. Honest: this is the conditional task, not the unconditional free-run number (free generation reads 45/500 here), recovery 0.417 is moderate, and the vocabulary is controlled with a coarse heard-fingerprint meaning code. The wall's fix is real: production is reachable with a separate module trained on its own feedback, where the reader reversed is not a producer. The internal half of generation now has a working building block, not just a mechanism. Read
• 2026-06-28 · A baseline on real conversation: a bounded distribution fits stably, but narrow training erodes general grammar. The generation track's first measurement on real dialogue, and a measuring stick to move. The locked model streamed strict-online over the whole DailyDialog training split (5.24 million characters, single seed), then measured on held-out dialogue and a grammar battery. Two honest readings. Dialog is a bounded, repetitive distribution it fits stably: held-out bits-per-char drops with data (3.767 at 200 thousand characters → 3.549 at the full split) with no drift, the mirror image of the fresh-stream drift, and it is 0.542 bits-per-char easier than the same model's text8 reference (4.090): everyday talk plus repeated turn markers. But a long pass on the narrow register erodes general grammaticality: a minimal-pair grammar macro falls from 64.8% at 200 thousand characters to 51.1% at the full split, word-order phenomena holding at 100% while agreement, determiner-noun, and negative-polarity sink to or below chance. The free-run samples are gibberish with the right shape (correct space density, the turn marker recurring, no words): the intelligibility starting line. Honest: a single seed, the battery is a hand-built analogue not the published suite, the 64.8% → 51.1% is the within-experiment change (a separate count-band model scored 60.2%, context only), and the output is gibberish by design at this scale. A measured baseline, not a new mechanism, and the same specialization-versus-generality tension the drift theme carries, read from the narrow-register side. Read

Stress-testing the locked architecture

• 2026-06-28 · The empty 2×2 cell is filled: a sparse code holds stable abstraction at the ceiling, with boosting and positive weights together. The empty cell gave a partial answer (sparse plus per-unit credit abstracts, then the credit pathway collapses it). This runs the diversity machinery that answer named, as an ablation ladder over the collapse baseline, one piece at a time. The cure is two pieces and it takes both. Boosting and positive weights together hold deep transfer abstraction at the 0.484 backprop ceiling (0.485 and 0.489 across two seeds), to the last checkpoint on both seeds, with more than two hundred distinct winner-codes (208 and 225, against the dense reference's about forty) and the lowest bits-per-char of any arm (3.74 and 3.77). Two honest negatives come with it. Boosting alone still collapses (the signed weights let the credit drive a few units to always win, and homeostasis alone cannot overcome it); clamp the weights non-negative and then boosting keeps the winners spread, so the minimal sufficient pair is both, not either. And the textbook sign-only permanence credit breaks the code (it saturates the active-to-winner synapses), so the credit stays graded with diversity machinery around it. The substrate-artifact thesis holds in its amended form: k-WTA and the hypersphere support alone are not enough, but adding boosting and positive weights is. The dense reference is no longer the only stable abstractor. Honest bounds: it matches the ceiling, it does not exceed it; this is eighteen thousand characters, two seeds, with the depth-four run and the hundred-thousand-character confirmations and the bits-per-char plateau test running. Read
• 2026-06-27 · The empty 2×2 cell, tested: sparse + per-unit credit abstracts transiently, then the credit pathway collapses it. The substrate fix is partial. The architecture review found one box the program never filled: per-unit credit on a sparse (k-WTA) code, where the literature said the collapse should dissolve. Built as the minimal edit to the locked stack (replace the dense normalization with k-WTA plus the sparse-distributed-memory hypersphere support, mask the credit to the winners, hold everything else) it gives a real, partial answer. The sparse code does abstract: it climbs to the backprop ceiling (peak 0.469 averaged, 0.53 best seed), beating the no-credit control by +0.154. But it does not stay there: it is bistable, peaking then collapsing back to ~0.31, the deep code ending with only about four distinct winner-sets across four hundred stimuli. The diagnosis: the collapse is dual-cause: k-WTA bounds how many units fire and fixes the substrate, but the dense credit pathway still drives the same few units to win, so the rank-one collapse reappears as a winner-set collapse. k-WTA alone is not enough. So no pivot: the locked dense stack stays the stable abstraction reference, and the fix is more biological machinery aimed at the second cause: diversity-forcing homeostasis, positive weights without bias, sparse credit. The synthesis is alive, and unstable. (Updated above: the cell is now filled.) Read
• 2026-06-27 · Correction: 10M reveals drift; the "stable at scale" claim was a window, not the long run. Run the locked config ten times further (seven million fresh characters against a fixed held-out slice) and it does not stay itself: held-out bits-per-char bottoms near a million (3.549) then rises to 3.765 at seven million (forgetting the fixed distribution as it adapts to ever-new text), and the deep-level code collapses toward rank-1 (the runner's own check reads STABLE? False). So the million-character stability was a window; on a long fresh, non-stationary stream the locked config drifts. It is a continual-learning / non-stationarity limitation that only appears at scale, distinct from the abstraction wall, and it reconciles with the re-reading result (a bounded corpus stays stable precisely by avoiding this drift). Mitigations: re-exposure, a consolidation/sleep cycle, the count organ (~21× less forgetting), or a forgetting-aware rule. Read the correction
• 2026-06-27 · The locked architecture is stability-limited, not data-limited; fast, and stable in the ~1M window. A Metal-fast compiled build of the locked depth-three stack (the whole strict-online step fused into one GPU function, all state on-device, bit-identical to the reference) runs at about 6,400 characters a second (~3.5 to 10× the old rate). Run on a million characters it stays stable the whole way (no divergence, dimensionality never collapses, no NaN), with bits-per-char still dropping (3.90 → 3.63) while abstraction holds above the 0.484 ceiling but does not climb. So more data buys better prediction, not more abstraction: the data-side confirmation of the architecture line's diagnosis. (Corrected above: the million-character stability is a window, a 10M run drifts.) Engineering plus a scale check, not a new mechanism. Read
• 2026-06-27 · Re-reading is a free, rule-legal lever on prediction, not abstraction. Re-reading the same bounded corpus (five online passes, no reset; legal: re-reading is single-datum and gradient-free, not a gradient epoch) lowers held-out bits-per-char 3.863 → 3.762 with no overfit (the train-to-held-out gap stays flat) and leaves abstraction untouched. And 200K read five times beats a million fresh characters on held-out prediction (3.762 vs 3.987), ties on abstraction, because the fresh single pass drifts at depth three (mild forgetting of the fixed early held-out slice) while re-reading stays in a stable basin. So re-exposure's win is partly stability, not pure exposure. Exposure beats novelty for prediction, ties for abstraction; the abstraction wall is untouched by either. Read
• 2026-06-27 · The program has a benchmark scorecard. The locked v1 model measured across four angles (compression, abstraction, continual learning, efficiency) against a SOTA transformer (cited, multi-epoch + backprop) and the plain baselines we run (n-gram, LSTM, transformer, single online pass). Far behind on raw bits (3.90 vs ~1.0, behind the n-gram's 2.08), above the backprop ceiling on abstraction (0.537 vs 0.484, gradient-free), ~21× less forgetting on continual learning (the count organ's win, not the abstraction organ's). The scorecard is re-run and redrawn on every architecture update. The benchmark suite

The anti-collapse round

• 2026-06-27 · Lateral inhibition clears the collapse: the first positive past the levers-not-additive wall. The deep collapse that locked the architecture at depth three is not structural. Add the one degree of freedom the locked stack lacked, columns at the same level that see and suppress each other (lateral divisive inhibition), and the collapsed depth-four apex goes from rank one (dimensionality 1.61) to a real code (3.05) and abstraction rises +0.16 (0.315 → 0.473), with the lowest bits-per-char. A vote alone leaves the code rank one (1.46): the combiner is not the load-bearing piece. The missing ingredient was interaction within a level, not more independent breadth across levels, the exact degree of freedom the capstone combine lacked. With the laterals off it reproduces the locked collapse bit for bit. Small scale (18K, two seeds; the 100K confirm shared the GPU), seed-robust; whether it carries the deeper code above the ceiling awaits the longer run. Read
• 2026-06-27 · Replay protects the deep code best at an interior altitude (Minsky's K-line). On a long fresh stream the locked config drifts and the deep code collapses; replay is the strongest patch. Vary where the replayed configuration is reinstated, and there is a sharp interior optimum. Reinstating at an interior level protects the deep code far better than replaying the raw input (deep dimensionality 5.04 vs 1.99) and gives the lowest bits-per-char (3.582). Replaying at the top alone is too vague and craters the top's own abstraction (0.173); replaying everywhere at once over-consolidates and collapses. The second anti-collapse mechanism, on a different axis from lateral inhibition (across time, not across columns). The win is on dimensionality and prediction, not the abstraction ceiling; three million characters, not the full ten. Read
• 2026-06-27 · What it learns and what it can say back: a strong recognizer, a weak producer. Two probes, one wall. A coverage decoder on a controlled vocabulary: the model learns a stable code for 303 of 364 words at the first level, almost none higher (1 at the middle, 18 at the top), and the deep code collapses to a handful of distinct codes. A playback dump on a trained reader: it recognizes 296 words and produces 64 (a fifth of what it recognizes), and the learned codes play back as generic syllable stubs (2 of 296 to the exact spelling). Recognition is cheap; production is dear, and the playback dump is now a standing instrument for reading out what concepts the model holds. A wall, not a win, that measures the starting line the generation work has to move. Read
• 2026-06-27 · A bank of critics, partial: always-think hurts, and only surprise is a selective trigger. Minsky's critics-and-selectors, built count-native over the locked model. Firing a deliberate pass on every character hurts (bits-per-char +0.07, the apex collapses to rank one, stability fails), the case for a selector. And at the character level only the surprise critic is selective: conflict fires on a near-constant quarter of characters and low confidence on almost none, so the conflict signal that worked between words is noise between characters. A critic bank is meaningful only with calibrated triggers. Whether the selective bank beats every fixed policy is open: the heavy arms ran out of GPU. Read
• 2026-06-27 · The two anti-collapse mechanisms compose: the first composition that holds. Run on the drift stream at scale (three million fresh characters, the locked depth-three config), lateral inhibition alone lowers bits-per-char and lifts abstraction above the 0.484 ceiling but the deep code still collapses (dimensionality drops to rank one at two million characters); interior-altitude replay alone holds the deep code high-dimensional but its abstraction fades below the ceiling (to 0.292). With both wires on, the deep code stays high-dimensional (apex 3.75 to 5.80) and above the ceiling at every checkpoint (0.560 to 0.596), stable, bits-per-char bounded, where each half fails on a different axis. They reach on orthogonal axes (inhibition across columns within a level, replay across time at an interior level), so they cover each other's blind spot rather than redundantly stacking, unlike the capstone combine where two same-axis levers did not add. The drift, the open continual-learning frontier, now has a candidate fix. Honest: the trimmed three-million-character stream and one seed, the trajectory across checkpoints is the signal not any single noisy point, and a ten-million, multi-seed confirmation run is underway before this locks into the architecture. Read
• 2026-06-28 · The 10M confirmation refines the synthesis to partial mitigation. At ten million characters (seven million fresh, one seed) the compose is a real drift mitigation but not a cure: the bare config collapses to rank one (bits-per-char 4.120, abstraction 0.317) while both wires keep the deep code alive (dimensionality 1.83, bits-per-char 3.694, stable), yet the protection degrades, abstraction slipping below the 0.484 ceiling (0.429) where the three-million run held above it. The drift is reduced, not solved; it stays out of the locked core. Read

The attention round

• 2026-06-28 · The attention direction opens: learnable, gradient-free attention is real, but context-free it trails hand-set diversity. The program's new frontier: learning where each column looks. The per-column look-back offset becomes an action, chosen online and rewarded by how well the column then predicts (the "motor is moving through text" idea made concrete), learned by a count-based bandit, gradient-free and bounded, with a content-relative word-jump in the menu. Three arms over twelve columns, two hundred thousand characters, two seeds, differing only in offset selection: the learnable policy reads 3.797 bits-per-char against random's 3.872 (a gain of 0.076) and learns real structure (offset distribution non-uniform, mean KL from uniform 0.68 bits, 7 of 12 columns on distinct greedy offsets, the word-jump used). The load-bearing finding is the mechanism: pure local-predictive reward collapses every column onto the single most recent character (the same-view degeneracy, bits-per-char explodes), and the policy works only with lateral inhibition on the action space, the same diversity pressure that broke the deep representational collapse, carried from the code to the scan. Honest verdict: it beats random and learns informative diversified views, but context-free it does not match the hand-set diverse views (fixed 3.513, trailing by 0.284), because when context does not matter a fixed spread is already good and free. Caveats: one substrate (count columns, CPU), 200K and two seeds, the diversity weight the one sharp knob. The payoff is context-dependent attention (higher levels steering where lower levels look), the next experiment. Read
• 2026-06-28 · Context-guided attention pays: a higher level steering where the lower one looks beats the hand-set baseline, and lifts abstraction everywhere. The payoff the previous round named. A working memory one level up (a leaky char-distribution over the region plus the live word-phase) is keyed into each column's offset bandit (one value vector per context bucket), so the column learns in context X, look at offset Y. Eight columns, two hundred thousand characters, the mean of three seeds, swept over two/four/eight buckets. At the right granularity (two buckets) the context-guided scan reads 3.022 bits-per-char against the hand-set fixed's 3.101, on all three seeds, the prediction win the context-free policy could not reach (it trailed fixed by 0.284). The robust win is abstraction: context-keying lifts transfer CCGP from 0.494 to about 0.60 and dimensionality from 19 to 32 at every granularity, where the context-free round left it flat. The attention is genuinely context-dependent (cross-bucket offset divergence 0.80 to 0.85 bits, it looks in different places in different contexts). Honest: the prediction win is bucket-sensitive (more buckets aid abstraction but starve the bandit and lift bits-per-char), and the working-memory prediction prior consistently hurts (dropped, the win is attention-side). The next steps are a learned context partition that grows with the data and a top-down prior richer than a unigram. Read
• 2026-06-28 · The attention arc closes: a learned gate for when to update the working-memory theme beats the fixed leak, and the whole stack beats hand-set fixed views. The capstone, and the first module from the cognitive-architectures reading. The previous round held the context in a working memory that leaked at a fixed rate, with no say over when to admit new context and when to hold what it had. This round puts a basal-ganglia-style Go/NoGo gate in front of it, firing on a model-update signal (how far the model's own pooled prediction moved step to step, not raw surprise: the shift carves events where surprise carves words) with an adaptive tail threshold, learned online and gradient-free with no reward. Eight columns, two hundred thousand characters, the mean of three seeds, at eight context buckets. The gate reads 3.069 bits-per-char against the fixed decay's 3.083 and the hand-set fixed's 3.101, and it beats both degenerate bounds, always-update (3.075) and never-update (3.114), so the win is the timing of the update, not the amount of theme motion. It fires 19% of the time, holds the theme about eight characters at a stretch, fires at or next to a word boundary three times in four, and the abstraction lift carries through (transfer CCGP 0.584 against fixed's 0.494). The smaller scale agrees (fifty thousand characters, gated 2.979 against fixed-decay 3.050). Honest: the gate is inert below eight buckets (the theme band drops out of the bucket), a fixed threshold under-fires as the scale grows (a fire-rate target is the next fix), single substrate and trimmed scale. This closes the attention arc: learn where to look (context-free, trails fixed), then context-guided (beats fixed, lifts abstraction), then a gated working memory holding the theme (beats fixed at the payoff scale). The full multi-column learn-where-to-look, context-guided, gated-working-memory stack beats hand-set fixed diverse views, online and gradient-free. Read
• 2026-06-28 · Attention is prediction, not abstraction: the 0.60 CCGP lift was expressive dimensionality, and the wall stays credit assignment. The attention track lifted transfer CCGP to about 0.60, past the 0.484 backprop ceiling, but on the vote-consensus probe that inflates with dimensionality, not the gradient-comparable probe the ceiling is drawn on. So the test: feed the context-guided attention representation, verbatim, as the input to the per-unit-credit readout, the one pathway proven to abstract, and measure transfer CCGP on the ruler that matters. At eighteen thousand characters, where that readout is stable, two seeds: the attention input reads 0.429 and 0.463 against the plain context window's 0.509 and 0.476, under the baseline and under the 0.484 ceiling on every seed. A backprop oracle clears the ceiling on the attention input, so the feature is real signal; the gradient-free credit pathway simply does not abstract from it any better than from a raw window. So the 0.60 was a richer code, not a more abstract one, and the two tracks separate cleanly: attention wins at prediction and working memory, abstraction needs the credit pathway, and the credit pathway is unmoved by what attention feeds it. The road past the ceiling is not a richer input; it is a change to the credit pathway itself. Honest: the clean comparison is at eighteen thousand (a two hundred thousand run agrees on the verdict but the readout diverges there, a known limit), single architecture and probe family. Read
• 2026-06-28 · The attention architecture is bounded: two guidance levels is the sweet spot, and the gate that calibrates itself is the keeper. The honest ceiling that completes the track. The first three rounds built a two-level guide (a higher level steers where the lower one looks) gated on a fixed threshold; this round tests how far that climbs by adding a third nested level (a slower context steering the middle one) and a gate whose threshold targets a fire-rate rather than a fixed multiple. Capacity-matched arms, mean of three seeds. Two honest answers. Depth is a diminishing return: at two hundred thousand characters the three-level nested stack reads 3.096 bits-per-char against the two-level stack's 3.049, worse by 0.047, at both scales, even though the nesting is real and active (the slow context routes the middle level, cross-band divergence a full bit, and the middle level routes the bottom one). The extra bucket-splitting the third level needs costs more than its longer-range guidance gains. The self-calibrating gate is a keeper: at the same capacity it reads 3.049 against the fixed-threshold gate's 3.072 and beats the hand-set floor (3.101), and it holds its fire-rate at the target (about one fire in ten) at both fifty and two hundred thousand characters, fixing the previous round's named under-fire where the fixed multiple drifts down with scale. So the attention track has its ceiling and its refinement both: two levels of guidance with a self-calibrating gate, online and gradient-free, beating hand-set fixed views, and a third level that does not pay off as built. Honest: the depth verdict is read at matched capacity (not against the smaller-bucket arm, a fragmentation confound); the third level loses as built and could pay with a richer slow-context read or far more data; the gate-fix margin is modest at these scales and grows past them; one count substrate, fifty and two hundred thousand characters, three seeds. This completes the arc from learning where to look to a bounded, calibrated, two-level attention stack. Read

The generation track produces real words

• 2026-06-28 · The cortex holds a live conversation: word-salad with real glimmers of relevance. The generation track's endpoint, the first live read-speak-hear loop. The same separate-inverse producer, off the offline answer key and into a live exchange with a real Haiku partner (keyless, the logged-in claude -p, child register), takes each turn through its one frozen comprehension pathway used both ways: comprehend the partner's turn into the meanings it knows, then produce the real words it can voice for them, and send the reply back. Over fourteen exchanges, seed 0, every emitted word is a real dialog word (42 of 42), 10 of 14 turns share an exact word with the partner's turn, and the partner stays on the cortex's topic in 12 of 13 (comprehension peak 0.105 over 160 meanings, about seventeen times chance). The result worth seeing is what threads across turns: a topic word forms a call and response that holds for a stretch, the cortex says match, the partner reflects it, the cortex says it again (exchanges five through eight), then dance the same way (eleven through fourteen), a coherent multi-turn topic word rather than isolated word-salad. Honest: this is word-salad with real glimmers of relevance, the starting line for live dialogue, not a conversation that holds, and the production gap the offline round predicted is visible live (the cortex comprehends the right region of meaning but voices a neighbor of the word it meant, so relevance runs ahead of recovery). Caveats kept sharp: a single live session and seed (a live partner is not deterministic across runs), and the keyless claude -p is the project-aware agent not a bare model, so it breaks character about three turns in fourteen (a role reminder helped, and the cortex's child-like replies pull it back). The producer is real, the loop is live, and the glimmers are the honest first sign of dialogue. Read
• 2026-06-28 · The separate inverse produces real dialog words: the first intelligible production on real conversation. The controlled-vocabulary producer carries to real words. The same separate learned inverse, trained on its own feedback against a dialog-trained ear, is pointed at the top 300 most-frequent DailyDialog words instead of invented ones. Nothing about the mechanism changes; only the corpus and the meaning set do. On the matched conditional task, produce one specific intended meaning across 300 real words, judged by a frozen judge, the separate inverse produces 113 of 300 real words and recovers the intended one 0.317 of the time, against the reader run backwards at 45 of 300 and 0.090: 2.5 times the coverage and 3.5 times the recovery. The produced words are real English: lady to ready, helen to hello, agreed to good, equipment to question. The inverse learns it over training (recovery 0.037 → 0.317 over 40 episodes), and it wins recovery in every frequency band, four times over on the rare tail (20 of 100 against 5). Two honest nuances keep it the right size. The headline is recovery, not raw coverage: the gap narrows from 41-to-1 on invented words to 2.5-to-1 here, because real onsets let the reader reversed complete to some plausible real word and score on validity, so the live number is producing the intended meaning. And recovery 0.317 is moderate, because the meaning code is a coarse heard fingerprint, a form region not rich semantics, so a produced word is often a phonetic or semantic neighbor of the target rather than the target itself. Honest: a single seed, a form-based meaning code, the conditional task and not the unconditional free-run. The wall's fix carries from invented words to real ones: production is reachable with a separate organ trained on its own feedback, and the reader reversed is an onset-completer, not a meaning-producer. Read