# 06 — Bounded-Growth Consolidation: Trained Encoder + Hypernetwork Adapters

*Stop pickling dense random matrices and raw traces; make persistent memory a compact, trained latent identity whose byte-cost stops growing.*

Status: ACCEPTED (2026-07-11, five-seed) | Thesis anchor: experiments.txt §5 (hypernetwork identity, `z_{t+1}=z_t+Δz`), §9 (experience autoencoder; `L = behavior_improvement + reconstruction_of_correction + compression_penalty + anti-overgeneralization + replay_consistency`) | Goal anchor: GOALS.md Goal 3 (organ tensor upgrades / metabolism loop closure) | Depends on / relates to: 01-correction-to-competence-benchmark (owns the byte metric), 05-metabolism-loop-closure (the consolidation path), 07-conversation-world-model-rl

> **Outcome (2026-07-11):** ACCEPTED (five-seed). Campaign 0d48130 (kaggle CPU-only, commit `0d48130`): `bounded_growth_m1_ratio=0.002079` across 5 seeds with **zero variance**. Structural footprints are bit-identical across seeds. `bytes_per_delta` spread ≤20 B: A0 18 B, A0b 20 B, A1 19 B, A2 18 B, A3 19 B. The M1 ratio (combined-footprint reduction) is well under the 1/10 threshold. Evidence: `../experiments_logs/2026-07-11_campaign_0d48130.md`.

## Problem

The organism stores experiences instead of metabolizing them, and it pays for it in bytes. On the eval-suite curriculum, `OrganismAgent` reports `memory_bytes_per_behavior_delta = 68772.0` versus `FastOnlyAgent`'s `12.0` (NOTES.md:253,256) — a ~5,700x spread for, by NOTES.md's own description, "matching FastOnlyAgent on forgetting/consolidation/identity" and adding only "a small transfer edge" (transfer 0.25 vs 0.1667; NOTES.md:256-260). The metric is `consolidated_size / max(1, successful_lessons)` where `consolidated_size = _memory_bytes(agent)` (the full `OrganismAgent.memory_bytes()`) and `successful_lessons` counts `fixed_after_correction` corrections (eval_suite.py:393-396; organism.py:482-495). NOTES.md:261 attributes the cost to "the hippocampus + immune + autoencoder pickled state."

Two of the dominant contributors are the exact organs this project owns, and both are honest about being prototypes:

- **ExperienceAutoencoder** is "an untrained random projection" (EVALUATION.md:36-38), scoring aggregate **0.203** (EVALUATION.md:14). The active `Δz` is tiny — `LATENT_DIM=32`, 256 bytes at float64 (autoencoder.py:24; EVALUATION.md:36) — but the *persisted* organ is dominated by `_A`, a dense `(RESIDUAL_DIM=28, NUM_SOURCES*MAX_VOCAB=1024)` Gaussian sensing matrix = **28,672 floats ≈ 229 KB** at float64 (autoencoder.py:118-123). Crucially, in the default correction flow `OrganismAgent` calls `experience_autoencoder.encode(episode)` — *not* `train_step` (organism.py:415-416) — so `_A` is never mutated and stays the column-normalized matrix that is deterministically regenerable from `seed=42` (autoencoder.py:348-350), yet `status(include_size=True)` pickles all ~229 KB of it anyway (autoencoder.py:608-610; common/bytes.py `mem_bytes`). (`encode()` does grow the small token-vocab dict as a side effect, but `_A` itself is untouched.)

- **IdentityHypernetwork** scored aggregate **0.001** in the original evaluation (EVALUATION.md:15), which described a fixed 14-entry `CONCEPT_VOCABULARY` that "does not include the 30 curriculum senses, so adapter retrieval fails completely" (EVALUATION.md:40-42; hypernet.py:22-37). That EVALUATION.md measurement predates the `grow_vocab` / auto-register fix now present in the code (hypernet.py:231-291, `_extract_first_concept` auto-grow at hypernet.py:310-327): `update_identity` now registers unknown sense tokens on the fly, so the hard "retrieval fails completely" blocker is removed, and the re-validated score moved to **0.006** (NOTES.md:126) — with NOTES.md attributing the residual low score partly to an eval-probe artifact (a single concept token compared against a multi-word sense label; NOTES.md remaining-gaps #1), not to the closed vocabulary. The live problem this project targets is the *growth shape* of the fix: `grow_vocab` appends one full `W` row (`input_dim = 4*latent_dim` floats) per new concept (hypernet.py:231-291), so the byte-cost grows linearly with the number of distinct corrections — the opposite of bounded growth (it is only re-bounded when the vocab exceeds `max_concepts=1000` and the oldest rows are pruned; hypernet.py:100-101,270-291). EVALUATION.md takeaway #3 (lines 52-53) prescribes "replace the fixed concept list with an open embedding layer."

The thesis is explicit that this should be bounded: "the system can have thousands of corrections, but the active agent only carries a compressed latent identity plus a small replay buffer" (experiments.txt §9, line 525). The north-star metric is `behavior_delta_per_byte_of_persistent_memory` (rl_pipeline_design.md:342); the eval suite measures its inverse (eval_suite.py:396). Today the organism violates the thesis: its footprint is a dense regenerable matrix plus per-concept rows plus pickled raw traces.

## Hypothesis

1. **Bounded growth is reachable on the controllable organs.** A trained compact encoder plus a trained concept-*embedding* hypernetwork can cut the combined serialized footprint of `experience_autoencoder + identity_hypernetwork` by **≥10x** versus the current random-projection / per-concept-row implementation, while reconstruction fidelity *rises above* the 0.203 random-projection baseline (EVALUATION.md:14) and the eval-suite behavior scores (transfer/scope/forgetting/identity) do **not** drop below the current `OrganismAgent` (NOTES.md:256).
2. **Most of the autoencoder bloat is serialization, not information.** Because `_A` is never trained in the default flow (organism.py:415-416), simply persisting `seed + Hebbian-deltas` instead of the dense matrix recovers a large fraction of the byte savings *with zero behavioral change* — separating "store less" from "learn better."

Falsifier for (1): if no trained condition beats 2x combined-byte reduction, or if compression drops `forgetting_score` or `identity_drift_score` below 1.0, the trained-adapter direction is closed. Falsifier for (2): if A0b (seed-regenerable) is *not* byte-identical in behavior to A0, the "never trained" assumption is wrong and must be re-derived.

## Why now / what unblocks it

- The metric already exists and is **not saturated**: unlike the headline accuracy metrics (forget/consol/identity pinned at 1.0 across runs — the documented saturation meta-problem), `memory_bytes_per_behavior_delta` spans 12 → 68,772 (NOTES.md:251-256) and is computed end-to-end by `eval_suite.py:396`. This project lives entirely on the un-saturated axis.
- Both target organs are pure NumPy with clean status/byte contracts (`status(include_size=True)["serialized_bytes"]`, common/bytes.py), so the experiment needs **no LFM2.5 driver** — the bloat is in organ serialization, not the LM. This sidesteps the cvec/prefix steering ceiling entirely (relates to 02/03/04).
- The mechanism is identified: the dense random sensing matrix is seed-regenerable (organism.py:415-416 never calls `train_step`), and the hypernetwork's per-concept-row growth is the named open-embedding fix (EVALUATION.md:52-53). Both are small, local replacements. Note the swap is *not* a pure config change: `config["experience_autoencoder"]` is passed positionally into the fixed `ExperienceAutoencoder` constructor and `config["identity_hypernetwork"]` is splatted as kwargs into the fixed `IdentityHypernetwork` constructor (organism.py:63-69) — those keys configure the existing classes, they do not accept a prebuilt/alternative organ. Injecting a trained replacement therefore means either replacing the constructed `agent.experience_autoencoder` / `agent.identity_hypernetwork` attribute after `OrganismAgent.__init__`, or a small constructor extension that accepts a prebuilt organ instance.

## Approach

Tied to thesis §5 and §9. Replace two prototype organs with trained-but-tiny versions and measure the byte/behavior tradeoff under matched-pair controls.

- **Trained compact encoder (§9).** Train an offline encoder that maps a correction episode → `Δz` minimizing the thesis-9 composite loss (reconstruction of the correction signal + compression penalty + anti-overgeneralization + replay consistency). Persist only the small trained weights, not a 1024-column dense random matrix. The decoder target stays the existing `decode()` field set (corrected_behavior_hint / failure_class / trigger_conditions / counterexamples; autoencoder.py:264-269) so reconstruction is scored on the same surface as today.
- **Seed-regenerable control (§9, cheap).** A no-training variant that persists `seed + Hebbian-delta sparse updates` and regenerates `_A` on load. Isolates "don't pickle the dense matrix" from "train a better encoder." (In the default flow there are zero Hebbian deltas because `train_step` is never called, so this control reduces to persisting only the seed.)
- **Concept-embedding hypernetwork (§5).** Replace the per-concept `W`-row vocabulary (which grows linearly per concept; hypernet.py:231-291) with a fixed-size shared concept embedding `E` so `adapter = HyperNet(z)` is constant-size in the number of concepts. Corrections update `z`, not the parameter count — exactly `z_{t+1}=z_t+Δz` with bounded footprint (experiments.txt §5).
- **Bounded-growth instrumentation.** Sample `agent.memory_bytes()` after every correction and fit the marginal byte slope; the thesis claim is that the slope flattens to ~0 after warmup, vs the current linear `grow_vocab` growth.
- **Per-organ decomposition first.** Before claiming whole-organism wins, measure each organ's `serialized_bytes` (organism.py `_module_bytes`, lines 554-588) to confirm how much of the 68,772 the two target organs actually own (NOTES.md:261 says hippocampus also dominates — see Risks).

## Success criteria

Behavioral and measurable; all on the eval-suite curriculum at a fixed seed.

- **PRIMARY — combined controllable footprint.** `serialized_bytes(experience_autoencoder) + serialized_bytes(identity_hypernetwork)` for the full trained condition (A3) is **≤ 1/10** of condition A0. (Discriminating: today ~229 KB autoencoder alone; not saturated.)
- **SECONDARY — whole-organism byte/delta.** `memory_bytes_per_behavior_delta` improves by **≥2x** vs A0's 68,772 (eval_suite.py:396). Reported, not gated above 2x, because the hippocampus also contributes (honest ceiling — see Risks).
- **GUARD — behavior preserved.** `transfer_score ≥ 0.25`, `scope_score ≥ 0.1667`, `forgetting_score = 1.0`, `identity_drift_score = 1.0` (must not fall below `OrganismAgent` A0; NOTES.md:256). The two `= 1.0` guards are floors against regression, not discriminating success axes (both are saturated for the current organism).
- **QUALITY — reconstruction.** Held-out reconstruction fidelity (eval_extended.py:432-437 `reconstruction_error` component, `1 - mean(reconstruction_error)`) **> 0.203** for the trained encoder (beats random projection; EVALUATION.md:14,36).
- **BOUNDEDNESS — growth slope.** Marginal `bytes / correction` for A3 over the curriculum **≤ 100 B/correction** after a 3-correction warmup (vs linear `grow_vocab` growth).

**Kill criteria.** (a) Best trained condition combined-footprint reduction `< 2x` → trained adapters do not pay for themselves. (b) Any compressed condition drops `forgetting_score` or `identity_drift_score` below 1.0 → over-compression causes catastrophic forgetting (the anti-overgeneralization term failed). (c) Reconstruction fidelity `≤ 0.203` → training did not beat the random projection. (d) Per-organ decomposition shows the two target organs own `< 30%` of `consolidated_size` → the bloat is the hippocampus; rescope to trace compression and hand off to 05-metabolism-loop-closure.

## Risks & open questions

- **The hippocampus may dominate.** NOTES.md:261 names hippocampus + immune + autoencoder together. If raw-trace pickling owns most of `consolidated_size`, compressing only these two organs caps the whole-organism win well under 10x. Mitigation: per-organ decomposition is step 0; the secondary metric is explicitly a ≥2x (not ≥10x) target, and kill-criterion (d) makes the handoff explicit.
- **`_A`-untrained assumption.** If any code path calls `train_step` during the eval (it appears not to; organism.py:415-416 uses `encode`), the seed-regenerable control A0b breaks. Measured directly by A0-vs-A0b byte-identity of behavior.
- **Compression vs scope.** `scope_score` is already low (0.1667; NOTES.md:256) and is the metric most likely to collapse under aggressive `latent_dim` reduction — the thesis anti-overgeneralization penalty is supposed to defend it, but the toy cortex's documented "two-senses-per-token" failure (Stage 2 fails 100%, NOTES.md:243) may bound scope regardless of encoder quality.
- **Open:** what `latent_dim` (8/16/32) maximizes `behavior_delta_per_byte`? Does the concept-embedding hypernetwork recover transfer, or — given `grow_vocab` already removed the hard retrieval blocker (NOTES.md:126) and the residual gap is partly an eval-probe artifact (NOTES.md remaining-gaps #1) — does the eval curriculum's small concept set make a fixed-size embedding indistinguishable from the (now-unbounded) auto-grown list except on bytes?
- **Open:** is "behavior delta" (the denominator, `fixed_after_correction`) stable across compression? If compression changes which lessons get fixed, the ratio confounds bytes with behavior — controlled by holding the curriculum seed and reporting the denominator separately.

## Prior evidence

- NOTES.md:251-261 — baseline table: `OrganismAgent` 68,772.0 B/Δ vs `FastOnlyAgent` 12.0 B/Δ; "Memory cost is dominated by the hippocampus + immune + autoencoder pickled state."
- EVALUATION.md:14-15,36-42,52-53 — ExperienceAutoencoder aggregate 0.203 ("Δz tiny … encoder is an untrained random projection"); IdentityHypernetwork 0.001 ("fixed CONCEPT_VOCABULARY does not include the 30 curriculum senses") — superseded in current code by the `grow_vocab` fix (re-validated 0.006, NOTES.md:126); takeaway to "replace the fixed concept list with an open embedding layer."
- autoencoder.py:24-31,118-123,531-573,608-610 — `LATENT_DIM=32`, `RESIDUAL_DIM=28`, `MAX_VOCAB=256`; `_make_sensing_matrix` = `(28,1024)` Gaussian (28,672 floats ≈ 229 KB float64); `train_step` Hebbian rank-1 on `_A`; `status(include_size=True)` pickles whole organ.
- organism.py:415-419,482-495,554-588 — correction flow calls `encode` (not `train_step`) and `update_identity`; `memory_bytes()` sums six organs via `_module_bytes` → `serialized_bytes`.
- hypernet.py:22-37,90,100-101,107-115,231-291,310-327 — fixed 14-concept seed vocab; `W = (output_dim, 4*latent_dim)`; `generate_adapters` = `W @ z`; `grow_vocab` appends one `W` row per concept (auto-invoked from `_extract_first_concept`), capped at `max_concepts=1000`.
- eval_suite.py:393-396,445-448 — `successful_lessons = fixed_after_correction`; `memory_bytes_per_delta = consolidated_size / max(1, successful_lessons)`; `raw_trace_size`/`consolidated_size = _memory_bytes(agent)`.
- eval_extended.py:406-443 — autoencoder eval: `compression_ratio` (raw-JSON `len(json.dumps(episode))` / latent `dz.nbytes`, which *ignores* the persisted `_A`; normalized as `min(ratio,50)/50`), `reconstruction_error = 1 - mean`, `mem_bytes(ae)`, aggregate = 0.5·compression + 0.5·reconstruction.
- rl_pipeline_design.md:342 — north-star `behavior_delta_per_byte_of_persistent_memory`.
- experiments.txt §5 (lines 307,508), §9 (lines 516-520,525) — hypernetwork identity (`z_{t+1}=z_t+Δz`, `adapter_weights = HyperNet(z_user,z_domain,z_style,z_mistakes)`) and experience-autoencoder loss / bounded-growth rationale.