What changed: generation, opened

Theory update · 2026-06-27 · the generation frontier, opened · experiment SF1

With the abstraction architecture locked, the program's open value moved to generation: producing text, not just modelling it. This is the first positive on that frontier, and it lands on a different axis from the whole abstraction line. A songbird learns its song with no tutor present: it babbles, hears itself, and corrects toward the song it means to sing. SF1 builds that loop for text. An agent babbles candidate utterances, re-comprehends its own output to recover what it would have understood, and corrects toward what it intended, with no listener. It works: the full loop recovers a meaning 0.271 of the time against a chance of 0.042 and controls near chance, eight times its own open-loop and deafened ablations. All three guards fire. Internal self-feedback teaches production with no listener. The generation chapter opens in the black.

What this round was

For most of the program, the cortex only ever read and scored. It modelled text well (online, never forgetting, under a budget) but it could not produce it; its utterances were per-character gibberish. The human-cognition rule says a child does not learn to talk by reading more, but by speaking and getting a reply. So generation has always been the named next frontier, and with the abstraction architecture locked above the backprop ceiling, it became the open one.

Generation has two halves. The external half is convention: saying something a listener recovers, scored on referential success; that is the production library's BN→CF queue. The internal half is the one this round tests, and it is the older idea: a songbird raised in isolation still learns its song, because it has a template of what it means to sing, it babbles, it hears itself, and it corrects the babble toward the template. No tutor. Self-feedback alone teaches the motor act. The question for SF1 is whether that birdsong loop teaches text production in our regime: online, gradient-free, bounded, and with no environment at all.

The experiment

The loop is built entirely from parts the program already has, all read-only, online, gradient-free, and env-free.

An intended meaning is a held-out real word, set independently of the producer, the guard against a trivial fixed point where the agent simply agrees with whatever it happens to say. The loop, per episode:

1. Babble candidate utterances over the chunk lexicon, the committed-unit emission vocabulary the acquisition round built. This is the bird's subsong; the exploration anneals down as competence rises.
2. Re-comprehend each candidate through a comprehension predictor to recover a posterior over meanings (hearing yourself).
3. Self-error: one minus the probability the re-hearer assigns to the intended meaning.
4. Win-stay-lose-shift over the producer's per-meaning chunk counts. No gradient passes through the decoder; the producer just keeps what was understood and drops what was not.

The meaning code is the crux. It is a salience-weighted "heard fingerprint" (a positional letter histogram weighted by the comprehension model's own sense of which letters carry meaning) so the producer cannot string-match its way to a win. It has to produce something that sounds like the meaning when heard back. The babbler is the chunk lexicon, the re-hearer is a count character model, and the self-monitor is the calibrated truth value from the confidence work, all reused, nothing shared modified.

Six arms, scored by an independent frozen judge on recovery and coverage, never on bits-per-char:

• ON, the full loop.
• OFF, produce, but never update from the self-error.
• DEAFENED, produce, but never re-comprehend (the bird that cannot hear itself).
• NO-TARGET, scramble the intended meaning (the anti-trivial-fixed-point guard).
• NO-ATTENUATION, let the self-output write back into comprehension (the contamination guard).

What happened

The loop teaches, and only the loop.

The full loop recovers a meaning 0.271 of the time, with coverage 0.271: about six and a half times chance, and about eight times the open-loop and deafened controls, which sit at chance with zero coverage. The lesson is sharp: the loop, not the producer, does the work. Babbling with the same vocabulary teaches nothing; babbling, hearing yourself, and correcting teaches production. Stable across three seeds.

And all three guards fire, which is what makes it a real mechanism rather than an artifact.

• NO-TARGET collapses to exactly chance. Scramble the intended meaning and the loop has nothing to steer toward: recovery 0.042, coverage zero. The target is load-bearing; the agent is not just agreeing with itself.
• NO-ATTENUATION shows the private-code signature. Let the self-output contaminate comprehension and the independent judge's recovery falls to 0.122, less than half of ON, while its own self-error drops to the lowest of any arm (0.718). It fools its own contaminated comprehension into agreeing and buys no real production. This is the exact failure the design's read-only attenuation prevents, caught red-handed: a speaker drifting into a private language that only it can understand.

The verdict

An agent that babbles, re-comprehends its own output, and corrects toward what it intended learns to produce, with no listener. The full loop recovers six and a half times more meanings than the identical open-loop or deafened producer, all three guards fire, and the win survives an independent judge. Internal self-feedback teaches production. The birdsong loop works in our online, gradient-free, bounded regime, and it is the first positive on the generation frontier.

This establishes the internal half of generation: self-practice teaches fluency and form. It is the result the program was missing on the producing side, and it lands on a fresh axis. The whole abstraction line was about building an abstract code; this is about emitting one. The generation chapter opens with a number in the black rather than a wall.

The honest caveats

The result is real and the guards are clean, but it is a first cut, and we say so plainly.

• The absolute recovery is modest. 0.271 on twenty-four meanings is a first cut, on a coarse heard-fingerprint meaning code and a simple count re-hearer. The obvious ceiling-lift (swapping in the apical-fusion comprehension predictor as the re-hearer) is the named follow-up, deferred here by design.
• It supplies fluency, not a shared convention. By construction the loop only ever agrees with itself. It teaches the agent to produce something it can recover (form and fluency) not something a listener can recover. That is the external half, and it is a different experiment: the referential game, scored on whether another model recovers the referent. The NO-ATTENUATION arm is the warning that internal practice alone can drift into a private code; the external game is the anchor against that drift.
• The babbler is the chunk sampler, not the full producer. It emits over the committed-chunk vocabulary, not through the full construction-competition pipeline. Enough to prove the loop; not the finished speaker.
• The re-hearer is a count model. Honest about what carried the result: a simple count character model as the ear, not yet the abstract comprehension predictor the line just built.

The frontier, opened

The generation frontier is no longer all-open. Its internal half now has a first positive (self-feedback teaches production) and its external half is the clear, falsifiable next move:

Can a speaker emit utterances that are well-formed across a discourse, scored on whether a listener recovers the referent, and demonstrably change the 99% slice rather than rescue the dead 1%?

The named next swings: lift the recovery ceiling by swapping the abstract comprehension predictor in as the re-hearer; run the external referential game that sets a shared convention and anchors against private-code drift; and test the internal-versus-external drift fork directly (does self-practice alone wander into a code the external game cannot use, exactly the failure the contamination arm exhibits). The internal half is landed; the external half is the complement that must run alongside it. The program now holds a validated foundation, a locked above-ceiling abstraction architecture, and a generation frontier that has just turned from all-open to half-answered.

The posts behind it

• The architecture is locked: abstraction settled above the backprop ceiling, which moved the open value to generation.
• From mimicry to production: the production library that named the external half of generation, the complement to this internal one.
• The cortex speaks, rough: the chunk lexicon and the contingency result this loop's babbler and bet are built on.