giorgio/MachineSex
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Layer 1 core: Wright-Fisher knowledge-transmission model with E1-E2

Browse source 
Scaffold plus the Layer 1 analytical core and the first two experiments.

- knowledge/: truth, metrics, teachers (2.7.1 shared-switch construction),
  step, lineage, experiment, config, seeding (imported as `knowledge`).
- Validation spine green: neutral decay (Pred 1), fixation (Pred 2), exact
  mutation-drift equilibrium (Pred 3), union coverage (Pred 5). 68 tests pass.
- E1 reproduces tail-first collapse. E2 delivers the headline: a grounding
  phase boundary g* << 1, with stationary H tracking the exact H_eq closed
  form (g=0.005 -> 68% of truth diversity; g=0.05 -> 96%).
- Reproducibility: uv venv from a hash-pinned uv.lock is the source of truth;
  every run writes results.parquet + resolved_config.yaml + manifest.json
  (lib versions, git commit, sha256). Figures and manifests tracked; the
  large regenerable parquet is gitignored.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
This commit is contained in:
Giorgio Gilestro 2026-07-04 18:10:18 +02:00
commit a6eb9b7512
33 changed files with 4356 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

456
paper/blueprint.md Normal file
View file

@ -0,0 +1,456 @@
# A Technical Blueprint for Modelling the Lamarckian Society
### An implementation specification: two layers, one population-genetics engine
*Companion technical paper to "The Lamarckian Society." Blueprint v1 — written to be handed, whole, to an autonomous coding agent (Claude Code) for implementation. Every quantitative claim in the perspective paper is reduced here to a state variable, an update rule, an analytic prediction, and a falsifier.*
---
## 0. How to use this document
This is a build specification, not an essay. It is written so that a coding agent can implement the entire study from it with minimal further decisions, and so that a human reader can verify every modelling choice against the theory it is meant to test.
**Scope.** Two layers, deliberately staged by cost:
- **Layer 1 — the analytical core.** A parametric population-genetics model of knowledge transmission across generations. Pure NumPy/SciPy. Runs on a laptop in minutes. This layer carries the paper's quantitative claims: the grounding phase boundary, the decorrelation curve, region-matched grounding, quality-diversity vs. greedy selection, and the re-minting gate. Several of its predictions are analytically solvable, which turns validation into an exact test rather than a vibe.
- **Layer 2 — the neural existence proof.** A minimal demonstration that the same effects appear in *real weights*: small open-weight models, LoRA specialisation, distillation/merging across two–three generations, with an execution-based verifier standing in for "reality's no." One consumer GPU. This layer answers the single most predictable reviewer objection to Layer 1 ("you assumed the collapse operator") by showing the sign of the key effects without assuming them.
**The relationship between layers.** Layer 1 defines the abstractions (region, rarity, grounding fraction, teacher decorrelation, diversity metric). Layer 2 realises the *same abstractions* in a neural pipeline: a "region" is a task family, "rarity" is task-type frequency, "grounding" is verifier-passed samples, "decorrelation" is teachers specialised on disjoint task families. Keeping the abstractions identical across layers is a hard requirement — it is what lets a Layer-2 result be read as confirming a Layer-1 prediction.
**Non-goals for v1.** No human-in-the-loop interaction (the verifier is the refuter; humans are future work). No foundation-scale training. No claim about the *horizontal* prediction (generation size vs. domain decomposability) beyond an optional abstract treatment in §2.7 — it is the most compute-hungry claim and is explicitly deferred. The load-bearing target is the *vertical* claim (general knowledge climbs while each specialty is re-earned and exceeded).
**Reader's map.** §1 gives the formal dictionary between population genetics and knowledge transmission — read this first; everything else is an instantiation of it. §2 is Layer 1 in full (theory, experiments, code interfaces). §3 is Layer 2. §4 is the shared reproducibility standard. §5 is the repository layout. §6 is the claims→experiments→figures traceability matrix. §7 is the suggested build order for the coding agent.
---
## 1. The formal mapping: knowledge transmission *is* a Wright–Fisher process
The perspective paper argues by analogy that generational distillation resembles genetic drift, that multi-teacher distillation resembles recombination, and that heterodox input plus quality-diversity selection resembles mutation supply plus balancing selection. This blueprint drops the word "resembles." At the level of a distribution over discrete items evolving by finite resampling, these are not analogies; they are the *same stochastic process*, and the population-genetics literature has already solved large parts of it. We therefore adopt Wright–Fisher dynamics as the engine and inherit its exact results as our validation targets.
The core object is a **distribution over discrete knowledge items** — facts, capabilities, behaviours, or "modes." Call the items $1, \dots, K$. A model at generation $t$ holds a distribution $p_t = (p_t^1, \dots, p_t^K)$ on the simplex. There is a fixed **true distribution** $p^\* $ over the same items, some of which are rare (the *tail* — the improbable events whose loss defines model collapse).
The generational step is: sample from the parent, optionally mix in fresh real samples, refit. That single step is Wright–Fisher reproduction with immigration. Here is the dictionary, and it is meant to be used literally throughout implementation:
| Knowledge-transmission concept (perspective paper) | Population-genetics object (this blueprint) | Governs |
|---|---|---|
| Knowledge item / capability / mode | Allele / type | State space |
| Model's knowledge distribution $p_t$ | Allele-frequency vector | State |
| True distribution $p^\*$ (with rare tail) | Ancestral/immigrant frequencies | Grounding target |
| Distillation sample size $n$ | Population size $N$ | Drift strength ($\propto 1/n$) |
| Lossy compression / "shed the idiosyncratic" | Genetic drift | Tail-first loss |
| Model collapse (tail lost first) | Loss of rare alleles under drift | The central failure |
| Grounding: $m$ fresh real samples per passage | Immigration / mutation supply | Tail replenishment |
| "No dry inheritance," region-matched | Immigration structured by locus | Which tails are protected |
| Multi-teacher distillation | Recombination across lineages | Reconstitutes lost tails |
| Teacher decorrelation $\rho$ | Linkage / shared ancestry | Recombination benefit |
| Single-teacher irreversible error | Muller's ratchet (clonal lineage) | Why one teacher is unsafe |
| Diversity metric (§7 of paper) | Expected heterozygosity $H = 1 - \sum_i p_i^2$ | Health of the lineage |
| Greedy fitness-max selection | Directional selection → fixation | Accelerated collapse |
| Quality-diversity / novelty selection | Balancing / negative frequency-dependent selection | Maintained polymorphism |
| Re-minting the base (§11 of paper) | Founder event / new reference genome | Irreversibility |
| Heterodox contributor supply | Standing variation of founding stock | Raw material |
Every experiment below is a manipulation of this one process. The value of the mapping is that it hands us closed-form predictions — heterozygosity decay, mutation–drift equilibrium, fixation probabilities — against which the simulator must agree before any headline result is trusted. Validation and theory are the same equations.
---
## 2. Layer 1 — the analytical core
### 2.1 State and the base dynamics (neutral drift = Shumailov collapse)
**State.** A single lineage is a point $p_t$ on the $K$-simplex. Items are partitioned into $R$ **regions** (disjoint blocks of the $K$ items); regions are how we express "different areas of knowledge," and they are what grounding and specialisation are *targeted at*. The true distribution $p^\*$ is fixed and chosen to have a deliberate **tail**: most probability mass on common items, a long thin tail of rare items (e.g. a Zipfian or a two-component mixture of "head" and "tail" items, tunable).
**The generational step, base case (no grounding, single teacher).** Given parent $p_t$ and drift strength $n$:
1. Draw counts $c \sim \mathrm{Multinomial}(n, p_t)$.
2. Set $p_{t+1}^i = c^i / n$.
This is exactly neutral Wright–Fisher with haploid population size $n$. It is also exactly Shumailov's recursive resampling with a perfect refit. Rare items are lost first (once $c^i = 0$, item $i$ is gone and — with no grounding — cannot return); the lineage drifts to fixation on a single item.
**This is the null model and the first validation.** It must reproduce, within Monte-Carlo error, the classical drift results in §2.4. If it does not, nothing downstream is trustworthy.
### 2.2 The five mechanisms, each as an operator on the step
Each perspective-paper safeguard is one modification of the generational step. They compose; the full step applies them in the order below.
**(A) Grounding — immigration / mutation supply.** Fresh real data enters every passage. Replace the single draw with a *pooled* draw:
- Draw $c_{\text{syn}} \sim \mathrm{Multinomial}(n, p_t)$ (inherited / teacher output).
- Draw $c_{\text{real}} \sim \mathrm{Multinomial}(m, p^\*)$ (grounding).
- $p_{t+1}^i = (c_{\text{syn}}^i + c_{\text{real}}^i)/(n+m)$.
Define the **grounding fraction** $g = m/(n+m)$. This is the single most important control variable in the paper: it is the ratio of freshly-grounded to inherited information per passage. The claim "no dry inheritance" is $g > 0$; the claim that a *critical* $g$ exists is the phase-boundary experiment E2.
**(B) Region-matched grounding — structured immigration.** Grounding is a vector, not a scalar: $m = (m_1, \dots, m_R)$ real samples allocated across regions. "No dry inheritance, region by region" means grounding must be delivered *to the regions whose tails are at risk*, not spread uniformly. Two allocation policies are compared in E3: `uniform` (spread $m$ evenly over regions) vs. `matched` (allocate $m$ to the regions actually being inherited/exercised this passage). The prediction is that uniform grounding fails to protect a specific inherited region's tail even at the same total $m$.
**(C) Multi-teacher distillation — recombination.** Instead of one parent, the pupil is drawn from $K_T$ teachers $\{p_t^{(1)}, \dots, p_t^{(K_T)}\}$, each of which has its own history and has ground different regions (hence retains different tails). The pupil's inherited draw is taken from the mixture $\bar p_t = \frac{1}{K_T}\sum_k p_t^{(k)}$ (equivalently, $n/K_T$ samples from each teacher). Teacher **decorrelation** is the controlled quantity: generate teacher sets with a tunable pairwise correlation $\rho$ in *which tail items they have retained* (see §2.7 for the generative model of correlated teachers). Prediction (E4): tail coverage of the pupil rises as teachers decorrelate, and the mixture's tails are the *union* of the teachers' tails at $\rho = 0$ and no better than a single teacher at $\rho = 1$.
**(D) Selection — directional vs. balancing.** Between drawing and refitting, a selection operator reweights items by a fitness before the pupil is formed. Two regimes:
- `greedy`: fitness-proportional (or top-$k$) selection toward the highest-fitness items — directional selection. Fitness is predictive accuracy against $p^\*$ (a reality-anchored score; see falsifier note). Drives fixation.
- `qd` (quality-diversity): fitness *plus* a novelty bonus that is a decreasing function of an item's current frequency — negative frequency-dependent / balancing selection. Formally, effective weight $w^i \propto f^i \cdot (p_t^i)^{-\alpha}$ with novelty exponent $\alpha \ge 0$; $\alpha = 0$ recovers greedy. Maintains polymorphism.
Prediction (E5): at matched input diversity, `greedy` drives heterozygosity to zero (fixation); `qd` holds it at a positive stationary value.
**(E) Re-minting — founder event.** Every $\tau$ generations, optionally replace the grounding reference: set $p^\*_{\text{eff}} \leftarrow p_t$ (the lineage's *current* distribution becomes the new "truth" it is grounded against, modelling assimilation of the soft delta into a new immutable base). Crucially, once re-minted, the *original* $p^\*$ is discarded — grounding can now only replenish tails that still exist in $p_t$ at re-mint time. A **gate** conditions re-minting on the diversity metric: only re-mint if $H(p_t) \ge H_{\text{gate}}$. Prediction (E6): re-minting while collapsed ($H$ low) locks in the collapse irreversibly (KL to the *original* truth stays high forever); gated re-minting does not.
**Full composed step (reference pseudocode).**
```
def generation_step(teachers, p_star_eff, cfg, rng):
# teachers: list of frequency vectors (length 1 for single-teacher)
# (C) recombination: mixture over teachers
p_parent = mean(teachers) # or weighted mixture
# inherited draw (drift, strength n)
c_syn = rng.multinomial(cfg.n, p_parent)
# (A,B) grounding: structured immigration from the true distribution
c_real = structured_multinomial(cfg.m_vector, p_star_eff, regions, cfg.grounding_policy, rng)
counts = c_syn + c_real
p_next = counts / counts.sum()
# (D) selection operator (identity if 'none')
p_next = apply_selection(p_next, p_star_eff, cfg.selection, cfg.novelty_alpha)
return normalize(p_next)
```
Selection is applied after refitting for simplicity; an alternative (select-then-sample) is a documented config switch, and the two should be checked to give qualitatively identical phase behaviour (robustness, not a headline).
### 2.3 Metrics (computed every generation, logged to disk)
- **Forward KL to truth**, $D_{\mathrm{KL}}(p^\* \,\|\, p_t) = \sum_i p^{\*i}\log(p^{\*i}/p_t^i)$. This is the correct primary metric: it *diverges* when $p_t$ drops mass that $p^\*$ has — i.e. it explicitly punishes forgetting the improbable. (Reverse KL would reward mode-seeking; do not use it as the primary.) Use a small floor $\epsilon$ on $p_t$ to keep it finite and log the floor.
- **Expected heterozygosity / diversity**, $H_t = 1 - \sum_i (p_t^i)^2$. The lineage-health metric; the quantity the re-mint gate reads.
- **Tail mass retained**, $T_t = \sum_{i \in \text{tail}} p_t^i$ where the tail set is $\{i : p^{\*i} < \theta_{\text{tail}}\}$. The direct measure of collapse.
- **Support size**, $|\{i : p_t^i > \epsilon\}|$. Number of surviving items.
- **Per-region diversity and tail mass**, the above restricted to each region (needed for E3).
All metrics are recorded per generation, per replicate (independent seed), so every reported curve carries a confidence band over replicates. Number of replicates is a config value; default 100 for Layer 1 (cheap).
### 2.4 Analytic predictions — the validation targets
These are the closed forms the simulator must match. They are implemented as assertions in the test suite (§4), so scientific validation and code correctness are one thing.
1. **Neutral heterozygosity decay** (base case, $m=0$): $\mathbb{E}[H_{t+1}] = (1 - 1/n)\,\mathbb{E}[H_t]$, hence $\mathbb{E}[H_t] = H_0 (1 - 1/n)^t$. The simulator's mean $H_t$ over replicates must match this geometric decay within Monte-Carlo error. *(This is the quantitative form of "collapse is tail-first and its rate is set by the distillation sample size $n$.")*
2. **Fixation probability** (base case): the probability that item $i$ is the one eventually fixed equals its initial frequency $p_0^i$. Checkable by long runs.
3. **Mutation–drift equilibrium** (with grounding). For the immigration model actually implemented — $p_{t+1} = (\mathrm{Multinomial}(n,p_t) + \mathrm{Multinomial}(m,p^\*))/(n+m)$ — the stationary heterozygosity is **exact** (from the coupled mean recursions for $\sum p_t^2$ and the overlap $\sum p_t p^\*$, whose fixed point is $\sum (p^\*)^2$):
$$H_{\text{eq}} = H^\* \cdot \frac{m\,(2n + m - 1)}{\,n + 2nm + m^2\,}, \qquad H^\* = 1 - \textstyle\sum_i (p^{\*i})^2.$$
Limits: $m\to0 \Rightarrow H_{\text{eq}}\to0$ (collapse to fixation); $m\to\infty \Rightarrow H_{\text{eq}}\to H^\*$ (the truth's own heterozygosity is recovered); and in the rare-immigrant / many-types limit ($H^\*\approx1$, $m\ll n$) it reduces to the textbook infinite-alleles form $H_{\text{eq}}\approx \theta/(1+\theta)$ with $\theta = 2m$. The simulator's stationary $H$ under grounding must track the **exact** form as $m$ varies (verified against simulation to <0.1% rel. error; it is a `test_scientific_validation.py` assertion). *(This is the phase boundary in closed form; note $H$ itself is smooth in $m$ — the sharp threshold lives in discrete tail-item survival, prediction 4.)*
4. **Tail-persistence threshold**: an item of true frequency $p^{\*i}$ is maintained against drift only if its expected reintroduction per generation $m \cdot p^{\*i} \gtrsim 1$. Hence the critical grounding for protecting a tail of rarity $p_{\min}$ is $m^\* \approx 1/p_{\min}$. *(This is why grounding must be region-matched: uniform $m$ spread over $R$ regions gives each region $m/R$, so a rare region's tail is protected only if $m/R \gtrsim 1/p_{\min}^{\text{region}}$.)*
5. **Recombination benefit** (Muller's ratchet): a single clonal lineage accumulates irreversible loss at the drift rate; the expected tail coverage of a pupil drawn from $K_T$ teachers with pairwise retention-correlation $\rho$ interpolates between the single-teacher value ($\rho = 1$) and the union of $K_T$ independent lineages ($\rho = 0$). With the construction of §2.7.1 (each teacher retains a fraction $q$ of the $T$ tail items, at exact pairwise correlation $\rho$) the interpolation is **closed-form**: the expected number of tail items retained by at least one teacher is
$$U(K_T,\rho,q) = T\left[\rho q + (1-\rho)\left(1-(1-q)^{K_T}\right)\right].$$
Check the limits: $K_T=1 \Rightarrow Tq$ (single teacher, independent of $\rho$); $\rho=1 \Rightarrow Tq$ (identical teachers, union = one); $\rho=0 \Rightarrow T[1-(1-q)^{K_T}]$ (independent teachers, maximal union). The pupil's realised tail coverage tracks $U$ *up to* the drift-survival threshold of prediction 4 — a tail item present in the mixture only survives the pupil's resampling of size $n$ if its mixture mass clears $\sim 1/n$, which ties E4 back to E2/E3. (Numerically verified against the construction to three decimals; it is a `test_scientific_validation.py` assertion.)
### 2.5 Experiments E1–E6
Each experiment is one config file (§4), one runner invocation, one results artifact, and one figure script. Each states its prediction and its **falsifier** — the outcome that would refute the corresponding claim in the perspective paper.
**E1 — Reproduce collapse (null model).** $m=0$, single teacher, no selection. *Expect:* $H_t = H_0(1-1/n)^t$; support shrinks to 1; forward KL diverges; tail mass → 0, tail first. *Validates against:* predictions 1–2. *Falsifier of the harness (not the theory):* if drift does not reproduce the analytic decay, the simulator is wrong — fix before proceeding.
**E2 — Grounding phase boundary (headline).** Sweep $g = m/(n+m)$ from 0 to a high value; single teacher; uniform grounding; no selection. *Expect:* a critical $g^\*$ below which tail mass and $H$ decay to (near) zero and above which they stabilise at a positive stationary value tracking $H_{\text{eq}} = \theta/(1+\theta)$. *This is the paper's central quantitative prediction: the ratio of inherited-to-grounded information has a threshold.* *Falsifier:* if the stationary tail mass is flat in $g$, or if it only stabilises as $g \to 1$ (you always need essentially all-real data), then inheritance buys nothing and the multigenerational thesis is refuted. Report $g^\*$ with a CI.
**E3 — Region-matched grounding.** Fixed total $m$; compare `uniform` vs. `matched` allocation across $R$ regions, with one designated "inherited-but-not-freshly-grounded-under-uniform" region carrying a rare tail. *Expect:* under `uniform`, the target region's tail collapses even though global grounding is nonzero; under `matched`, it persists. *Validates:* prediction 4 and the "grounding must overlap the content it protects" claim. *Falsifier:* if uniform grounding protects the region as well as matched, the region-matching requirement is unnecessary and that paragraph of the paper should be cut.
**E4 — Multi-teacher decorrelation.** Teachers built by the §2.7.1 construction; sweep number of teachers $K_T \in \{1,2,3,5\}$ and retention-correlation $\rho \in [0,1]$ (at fixed marginal retention $q$); matched total data budget (so more teachers ≠ more data — each contributes $n/K_T$). Report **two** coverages: the construction-level union $U(K_T,\rho,q)$ (must match the §2.4-5 closed form exactly) and the post-distillation *surviving* coverage after the pupil's resampling. *Expect:* both rise with $K_T$ and with $(1-\rho)$; collapse suppression $\propto$ decorrelation; at $\rho=1$, multiple teachers give no benefit over one; and the gap between union and surviving coverage shrinks as grounding $g$ rises (recombination supplies the tail, grounding holds it). *Validates:* prediction 5 (now closed-form). *Falsifier:* if $K_T$ decorrelated teachers give no surviving-coverage benefit over one at matched budget, the recombination claim dies and single-teacher distillation is fine.
**E5 — Quality-diversity vs. greedy.** Same starting diversity; `greedy` vs. `qd` selection; sweep novelty exponent $\alpha$. *Expect:* `greedy` → fixation ($H \to 0$); `qd` holds $H$ at a positive plateau and re-introduces lost tail items. *Validates:* the two-level anti-convergence argument (§7 of paper). *Falsifier:* if `qd` does not maintain higher stationary $H$ than `greedy`, quality-diversity is not doing the work the paper assigns it.
**E6 — Re-minting gate (irreversibility).** Run a lineage to a chosen diversity level, then re-mint (freeze current $p_t$ as new reference, discard original $p^\*$); compare re-minting at high $H$ vs. low $H$. *Expect:* re-mint while collapsed → KL to *original* truth is locked high forever (tails unrecoverable); gated re-mint at high $H$ → no lock-in. *Validates:* §11's "re-minting is irreversible; gate it on diversity." *Falsifier:* if a collapsed lineage recovers its original-truth tails after re-minting, the irreversibility warning is overstated.
### 2.6 Layer-1 falsifiers, collected
The model is built to be *able to kill the thesis*. If E2 shows no threshold, or E4 shows no decorrelation benefit, or E6 shows no lock-in, the corresponding claims are refuted and the paper must say so. A blueprint that cannot fail is not a test. The single load-bearing positive result is E2's phase boundary at $g^\* \ll 1$: it says a little grounding protects a lot of inheritance, which is the whole economic and conceptual bet of the architecture.
### 2.7 Implementation spec for Layer 1
**Language / libraries.** Python ≥ 3.11; NumPy, SciPy (stats), pandas (results), matplotlib (figures). No GPU. No other heavy deps. Everything seedable from a single integer.
**Core module interfaces** (the coding agent should implement to these signatures; names are normative so downstream scripts are stable):
```python
# knowledge/truth.py
def make_true_distribution(K: int, R: int, tail: str, tail_frac: float,
zipf_s: float, seed: int) -> TrueDist:
"""Return p_star (length K), region assignment (length K), and the tail mask."""
# knowledge/teachers.py
def make_retention_matrix(T: int, K_T: int, rho: float, q: float, rng) -> np.ndarray:
"""Return an (K_T, T) binary retention matrix R with exact marginal retention
E[R]=q and exact pairwise column-correlation rho, via the shared-switch
construction of §2.7.1. rho=0 -> independent tails; rho=1 -> identical."""
def make_correlated_teachers(p_star, tail_mask, K_T: int, rho: float, q: float,
region_assignment=None, region_specialisation=False,
tail_floor: float = 1e-9, seed: int = 0) -> list[np.ndarray]:
"""Build K_T teacher distributions from a retention matrix (§2.7.1): every teacher
keeps all head items; teacher k keeps tail item j at ~p_star mass iff R[k,j]=1,
else at tail_floor; renormalise. If region_specialisation, force R[k,j]=1 for tail
items in teacher k's home region and apply the rho construction only off-home.
The exact-construction path is preferred for E4; a drift-based path (running
independent grounded lineages) is provided as a realism cross-check only."""
# knowledge/step.py
def generation_step(teachers, p_star_eff, cfg, rng) -> np.ndarray: ...
def apply_selection(p, p_star, mode: str, alpha: float) -> np.ndarray: ...
def structured_multinomial(m_vector, p_star, regions, policy: str, rng) -> np.ndarray: ...
# knowledge/lineage.py
def run_lineage(cfg, seed) -> pd.DataFrame:
"""Run T generations for one seed; return a tidy frame with one row per
(generation) and columns for every metric in §2.3 (global and per-region)."""
# knowledge/metrics.py
def forward_kl(p_star, p, eps): ...
def heterozygosity(p): ...
def tail_mass(p, tail_mask): ...
def support_size(p, eps): ...
# knowledge/experiment.py
def run_experiment(cfg) -> pd.DataFrame:
"""Sweep the declared parameter grid x n_replicates seeds; return long-form
results with confidence intervals; write parquet + the exact resolved config."""
```
**Config schema** (one YAML per experiment; all parameters explicit, no magic numbers in code). Illustrative default:
```yaml
experiment: E2_grounding_phase_boundary
seed: 20260704
n_replicates: 100
generations: 300
truth:
K: 1000 # number of knowledge items
R: 10 # regions
tail: zipf # {zipf, twocomponent}
zipf_s: 1.1
tail_frac: 0.5 # fraction of items designated 'tail'
tail_threshold: 1.0e-3
dynamics:
n: 200 # distillation sample size (drift strength)
teachers:
K_T: 1
rho: 0.0
grounding:
sweep: {param: g, values: [0.0, 0.01, 0.02, 0.05, 0.1, 0.2, 0.4]}
policy: uniform # {uniform, matched}
selection:
mode: none # {none, greedy, qd}
novelty_alpha: 0.0
remint:
enabled: false
period: null
H_gate: null
metrics:
kl_floor: 1.0e-9
output:
dir: results/E2/
save_per_generation: true
```
**Determinism.** One master seed → per-replicate seeds via a documented `np.random.SeedSequence` spawn. No global RNG state; pass `rng` explicitly everywhere. Results are a pure function of the resolved config. The resolved config (after sweep expansion) is written next to the results artifact.
**Outputs.** Each experiment writes: `results.parquet` (long form), `resolved_config.yaml`, and a `manifest.json` recording library versions, seed, git commit, and a content hash of the results. Figures are generated by a separate `figures/plot_EX.py` reading only `results.parquet`, so any figure is regenerable from committed data without rerunning the simulation.
#### 2.7.1 The correlated-teacher construction (E4's one non-obvious piece)
E4 needs teacher sets whose pairwise **retention-correlation** $\rho$ is a clean, swept knob. Tuning the drift parameters until an emergent $\rho$ appears is the wrong design: that $\rho$ would be a tangled function of $n$, $m$, tail size and generation count, un-sweepable and confounded with the very drift whose effect E4 is trying to hold fixed. So we **construct the retention structure directly**, with $\rho$ an independent control. For an experiment whose entire purpose is to isolate the effect of decorrelation, $\rho$ must be manipulated, not inferred.
**The mechanism — shared-switch exchangeable Bernoulli.** Let the tail have $T$ items. Each teacher $k$ retains a fraction $q$ of them; we want the retention indicators to have marginal $q$ and *exact* pairwise correlation $\rho$ across teachers. For each tail item $j$:
1. draw a **shared switch** $z_j \sim \mathrm{Bernoulli}(\rho)$ (one draw, common to all teachers for item $j$);
2. draw a **shared retention** $s_j \sim \mathrm{Bernoulli}(q)$ (common to all teachers);
3. draw **independent retentions** $u^{(k)}_j \sim \mathrm{Bernoulli}(q)$, one per teacher;
4. set $r^{(k)}_j = s_j$ if $z_j = 1$, else $u^{(k)}_j$.
That is the whole construction. It yields a retention matrix $R \in \{0,1\}^{K_T \times T}$.
**Why it is exact.** Marginally $\mathbb{E}[r^{(k)}_j] = \rho q + (1-\rho)q = q$ regardless of $\rho$. For any two teachers, conditioning on the switch gives $\mathbb{E}[r^{(k)}_j r^{(k')}_j] = \rho\,\mathbb{E}[s_j^2] + (1-\rho)q^2 = \rho q + (1-\rho)q^2$ (using $s_j^2 = s_j$), so $\mathrm{Cov} = \rho q(1-q)$ and, since $\mathrm{Var} = q(1-q)$, the pairwise correlation is exactly $\rho$. The set is *exchangeable* — every teacher pair has the same $\rho$ — which is what makes $\rho$ a single scalar knob. (Verified numerically: marginal and pairwise correlation hit target across a $(\rho, q)$ grid, and the union closed form below matches to three decimals.)
**From retention to teacher distributions.** Given $R$, build teacher $k$'s distribution $p^{(k)}$: assign every **head** item its $p^\*$ mass (all teachers keep the common core); assign **tail** item $j$ its $p^\*_j$ mass if $r^{(k)}_j = 1$ and a floor $\varepsilon_{\text{tail}}$ otherwise; renormalise. (Renormalising lets the mass of dropped tails flow to what the teacher kept — the realistic signature of a partially-collapsed model concentrating on its survivors. Reallocating instead to the head is a documented config switch.)
**Region specialisation (structured decorrelation, optional).** With `region_specialisation=True`, give each teacher a **home region** and force $r^{(k)}_j = 1$ for every tail item $j$ in teacher $k$'s home region (each teacher fully retains the tails of the region it ground against reality), applying the $\rho$ construction only to off-home tail items. This models "each teacher ground a different region," ties E4 to E3's region-matched grounding, and is the discrete image of the perspective paper's "distil from teachers who each earned a different region."
**The analytic target (E4's exact check).** The probability that tail item $j$ is retained by at least one of $K_T$ teachers is $\rho q + (1-\rho)\big(1-(1-q)^{K_T}\big)$, so the expected **union tail-coverage** is
$$U(K_T,\rho,q) = T\left[\rho q + (1-\rho)\left(1-(1-q)^{K_T}\right)\right],$$
the closed form of §2.4-5. `make_retention_matrix` must reproduce it (and the target $\rho$, $q$) within Monte-Carlo tolerance in `test_scientific_validation.py`. The pupil's *realised* coverage after distillation equals $U$ only for tail items whose mixture mass clears the drift-survival threshold $\sim 1/n$ (§2.4-4) — so E4 should report both the union coverage (construction-level) and the post-distillation surviving coverage (dynamics-level), and their gap is itself informative: it is exactly the tail that recombination *supplied* but drift *re-erased* because grounding was too thin to hold it.
**Continuous-mass extension (optional realism, not a headline).** Binary retention is the default because it matches prediction 5 exactly. For a realism cross-check, replace binary retention with correlated *masses*: draw per-teacher log-masses on tail items from a multivariate normal with equicorrelation $\rho$ (a Gaussian copula), exponentiate, and normalise. This generalises to an arbitrary correlation *matrix* between teachers (unequal pairwise $\rho$), which the shared-switch construction — being exchangeable — cannot express; use it only if the paper later needs non-exchangeable teacher sets.
**Optional abstract treatment of the horizontal claim (§2.7-H, low priority).** If time permits, model a domain as a modular graph with tunable modularity $Q$; define the optimal number of concurrent specialists as the point where marginal coverage gain from an added specialist falls below a cost; show optimal specialist count rises with $Q$. This is the *horizontal* prediction in abstract form and does not require the neural layer. Flag clearly as exploratory; it is not a headline and can be dropped without weakening the paper.
---
## 3. Layer 2 — the neural existence proof
### 3.1 Purpose and the single objection it answers
Layer 1 assumes the tail-deletion operator (drift). A reviewer will say: *you built your conclusion into the operator.* Layer 2 answers exactly that objection and no more. It does not need to be a society. It needs to show, in **real LoRA-adapted weights**, that the *sign* of three effects is as Layer 1 predicts: dry inheritance degrades, grounded inheritance holds; multiple decorrelated teachers preserve capability that one teacher sheds; and across generations general capability holds or climbs while each specialty is re-earned and exceeded. If those three signs appear at 1B scale on one GPU, the abstraction in Layer 1 is grounded in mechanism.
Minimality is a virtue here, not a compromise. Every additional degree of freedom (bigger model, more generations, more domains) multiplies cost and reviewer surface without strengthening the core claim. Build the smallest thing that can show the signs.
### 3.2 Design choices (with open-science defaults)
**Base model.** Default to a *fully open* small model to honour reproducibility end-to-end: **OLMo-2-1B** or **SmolLM2-1.7B** (open weights, open or well-documented data, permissive licence). Capable fallback if the open models are too weak on the task: **Qwen2.5-1.5B-Instruct**. Pin the exact Hugging Face revision hash in config; never track `main`. The pipeline must be model-agnostic behind a thin adapter so swapping bases is a config change.
**Specialisation.** LoRA (via PEFT), small rank (e.g. 8–16), on a single task family = one "region." Hours on one consumer GPU, consistent with the perspective paper's cost claim. Each teacher is one base + one LoRA adapter.
**The verifier = "reality's no."** The domain must have a cheap, deterministic, uncontrollable oracle. **Program synthesis with unit tests** is ideal: a generated solution either passes its tests or it does not, and neither the model nor the experimenter controls the verdict. This is the minimal honest instance of the perspective paper's "predictive success under intervention." Execution happens in a sandbox (subprocess with a hard timeout and no network, run inside the container of §4; document the sandbox precisely).
**Task domain — synthetic-primary, benchmark-secondary.** To keep the Layer-1 abstractions (region, rarity, tail) exact, the *primary* domain is a **synthetic program-synthesis generator**: a family of small, verifiable tasks parameterised by *operation type* (the region: e.g. string ops, list ops, arithmetic, dict manipulation, recursion) and *difficulty*, with I/O unit tests generated automatically. Task-type frequency is tunable, so "rare tail task types" is a dial, exactly matching Layer 1's rarity. For *external validity*, add a secondary evaluation on a held-out slice of a public benchmark (e.g. MBPP-sanitised / HumanEval) — pinned by version — to show the effect is not an artefact of the synthetic generator. The synthetic generator's spec (grammar, per-region templates, test-generation rule, rarity distribution) is itself a committed, seeded artifact.
**Grounding, concretely.** A generational passage produces pupil training data as a mixture of (i) *inherited* teacher-generated solutions and (ii) *grounded* solutions that have been **filtered to pass the verifier** and/or freshly drawn from verified references in the target region. The **grounding fraction $g$** is the proportion of verifier-passed/real items in the pupil's training mixture — the *same knob* as Layer 1's $g$. "Dry" = $g$ low / unfiltered teacher output; "grounded" = $g$ raised with region-matched verified data.
**Recombination, concretely.** Multiple teachers = multiple LoRA specialists on *disjoint* task families (decorrelated by construction). The pupil is trained on the pooled outputs of all teachers (distillation) or, as a cheaper alternative, the specialists are **merged** (M2N2 / model-merge style, citing Sakana's demonstration that this search runs with no retraining) and the merged model is the pupil. Distillation and merging are two config-selectable recombination operators; report at least distillation, and merging if compute allows.
### 3.3 Contrasts C1–C4 (the whole experimental content)
**C1 — Dry vs. grounded, single teacher, across generations.** One teacher, one region. Arm A: pupil trained on *unfiltered* teacher outputs (dry, $g\approx0$). Arm B: pupil trained on *verifier-passed* teacher outputs plus fresh verified region data ($g>0$). Run 2–3 generations. *Expect:* Arm A pass@k degrades generation over generation and its solution diversity narrows; Arm B holds. *Maps to:* Layer-1 E2. *Falsifier:* if dry inheritance does not degrade at this scale, collapse is not reachable here and the neural claim is unsupported (report honestly; possibly scale down grounding or up generations).
**C2 — One teacher vs. N complementary teachers, matched data budget.** Fix the pupil's total training-token budget. Arm A: all budget from one teacher (one region). Arm B: same budget split across $N$ teachers on disjoint regions. Evaluate the pupil on *all* regions, including rare-type tasks. *Expect:* Arm B retains capability across the union of regions (the "tail" of rare task types survives); Arm A loses regions it did not inherit. *Maps to:* Layer-1 E4. *Falsifier:* no union benefit at matched budget → recombination claim unsupported neurally.
**C3 — The vertical claim (load-bearing).** Over 2–3 generations, track (a) a *general* held-out benchmark spanning all regions and (b) *per-specialty* performance, where each generation re-specialises (re-earns) its region against the verifier. *Expect:* general benchmark is **monotonically non-decreasing** across generations, while each specialty is re-earned and its peak **exceeds the parent's** peak in that specialty. *This is the test of the actual thesis, not the borrowed Shumailov scaffolding.* *Maps to:* the paper's vertical prediction. *Falsifier:* if general capability falls across generations, or specialties are not re-earned-and-exceeded, the multigenerational ratchet is not demonstrated.
**C4 — Recombination operator: distillation vs. merging (optional).** If compute allows, show C2's benefit is robust to whether recombination is done by distillation or by weight-merging. Strengthens generality and directly connects to the M2N2 citation. Drop first if time-constrained.
### 3.4 Metrics (Layer 2)
- **pass@1 and pass@k** on held-out tasks, per region and overall (the neural analogue of KL-to-truth / capability).
- **Region coverage** = fraction of regions (incl. rare task types) with pass@1 above a floor — the neural analogue of *support size* / tail survival.
- **Solution diversity** = distinct-$n$ or behavioural diversity of generated solutions per task (the neural analogue of heterozygosity $H$; narrowing diversity is the neural signature of collapse).
- **Generational degradation curve** = each metric as a function of generation index, per arm.
All with multiple seeds (fewer than Layer 1 — GPU cost — but at least 3; report per-seed points, not just means, given small $n$). Pin decoding parameters (temperature, top-p, max tokens, sampling seed) in config; they materially affect pass@k and must not float.
### 3.5 Layer-2 honesty riders
GPU non-determinism means Layer 2 is *statistically* reproducible (same distribution of outcomes under re-run), not bitwise reproducible. Document this explicitly; pin everything pinnable (model revision, dataset version, decoding params, library versions, seeds); report seeds individually. The claim Layer 2 supports is directional ("the sign of the effect is as predicted"), and the writing must not overclaim precision the setup cannot deliver.
### 3.6 Implementation spec for Layer 2
**Libraries.** PyTorch; Hugging Face `transformers` + `peft` (LoRA); `datasets`; optional `vllm` for fast generation; the synthetic task generator (project-local). Execution sandbox: `subprocess` with `resource` limits and timeout, inside the container.
**Module interfaces (normative names):**
```python
# neural/tasks.py
def generate_task_bank(regions, rarity, n_tasks, seed) -> TaskBank:
"""Synthetic verifiable tasks; each task carries prompt, region, difficulty,
and an executable unit-test suite."""
def verify(solution_code: str, task) -> VerifyResult:
"""Run tests in a sandbox; return pass/fail + diagnostics. Deterministic."""
# neural/specialise.py
def train_lora_specialist(base_id, revision, region, task_bank, lora_cfg, seed) -> AdapterPath: ...
# neural/distill.py
def generate_teacher_data(teachers, task_bank, grounding_fraction, policy, decode_cfg, seed) -> Corpus:
"""Produce the pupil's training corpus: mixture of inherited (teacher) and
grounded (verifier-passed / fresh-verified) items, region-matched."""
def train_pupil(base_id, revision, corpus, lora_cfg, seed) -> AdapterPath: ...
# neural/merge.py
def merge_specialists(base_id, adapters, method, seed) -> ModelPath: # optional (C4)
# neural/evaluate.py
def evaluate(model, task_bank_heldout, decode_cfg, seed) -> pd.DataFrame:
"""pass@k, per-region coverage, solution diversity; tidy per-(region) frame."""
# neural/generation_loop.py
def run_generations(cfg, seed) -> pd.DataFrame:
"""Orchestrate T generations for one arm; log every metric per generation."""
```
**Config** mirrors Layer 1's structure (one YAML per contrast; pinned `base_id` + `revision`; explicit `grounding_fraction`, `n_teachers`, `regions`, `generations`, `decode_cfg`, `lora_cfg`, `seed`, `n_seeds`). Same output contract: `results.parquet` + `resolved_config.yaml` + `manifest.json` (with model revision hashes and dataset versions). Figures regenerable from `results.parquet` alone.
---
## 4. Reproducibility and engineering standard (both layers)
Open science is a hard requirement of this project, not a preference. The standard below is normative.
**Environment.** Pin everything. Provide (a) a `pyproject.toml` + lockfile via **uv** (fast, reproducible resolver) and (b) an **Apptainer/Singularity** definition file (HPC-friendly, rootless, open) that builds the exact environment; optionally a Dockerfile. The container is the source of truth for "it runs." Record Python, CUDA, and key library versions in every run's `manifest.json`.
**Seeding.** One master seed per experiment in config; derive all sub-seeds via `SeedSequence.spawn`; never touch global RNG state. Layer 1 is bitwise-reproducible from seed. Layer 2 is statistically reproducible; document the residual GPU non-determinism and set the available determinism flags (`torch.use_deterministic_algorithms(True)` where feasible, cudnn deterministic, documented exceptions).
**Configuration.** No magic numbers in code — every parameter lives in a YAML resolved at run time; the *resolved* config is written beside results. Use a single config system (Hydra or a thin equivalent). Sweeps are declared in config, not hard-coded in scripts.
**Data & model provenance.** Layer 1 data is synthetic-from-seed (fully reproducible; no external data). Layer 2 pins model revision hashes and dataset versions; the synthetic task generator is committed and seeded. Cache external downloads with recorded hashes.
**Experiment tracking.** Prefer open tooling: **MLflow** (open source) or plain versioned CSV/Parquet + committed configs; avoid closed SaaS trackers to keep the pipeline fully open. Whatever is chosen, the invariant is: every figure is a pure function of a committed results artifact.
**Testing.** `pytest`. Two kinds of test, and both are required:
- *Correctness tests*: the module does what it says (shapes, normalisation, sandbox isolation).
- *Scientific validation tests*: the simulator reproduces the §2.4 analytic results within tolerance (heterozygosity decay, fixation probability, mutation–drift equilibrium). These tests failing means the science is wrong, not just the code — they are the spine of trust in Layer 1.
**Automation.** A `Makefile` (or `justfile`) with targets: `env`, `test`, `layer1` (runs E1–E6), `layer2` (runs C1–C3, C4 optional), `figures`, `paper` (assembles the figure manifest), `all`, `clean`. One command reproduces the study from a clean checkout inside the container.
**Repro entry point.** A top-level `reproduce.sh` that: builds/enters the container, runs tests, runs all experiments at the committed seeds, regenerates all figures, and writes a `REPRODUCED.md` diff against committed result hashes. If hashes match (Layer 1) / distributions match within CI (Layer 2), the run is verified.
**Licensing & citation.** Author to choose; suggested: code under a permissive OSI licence (MIT/Apache-2.0) or copyleft (GPL-3.0) per the author's open-source preference; text/figures under CC-BY. Include `LICENSE`, `CITATION.cff`, and a `DATA_AND_MODELS.md` recording every external artifact and its pinned version/hash.
---
## 5. Repository layout
```
lamarckian-society/
├── README.md # what this is, how to reproduce
├── reproduce.sh # one-command full reproduction (in-container)
├── Makefile # env, test, layer1, layer2, figures, all
├── pyproject.toml # deps
├── uv.lock # pinned resolution
├── apptainer.def # container definition (source of truth)
├── Dockerfile # optional
├── LICENSE CITATION.cff DATA_AND_MODELS.md
├── configs/
│ ├── layer1/E1..E6.yaml
│ └── layer2/C1..C4.yaml
├── src/
│ ├── knowledge/ # Layer 1: truth, teachers, step, lineage, metrics, experiment
│ └── neural/ # Layer 2: tasks, specialise, distill, merge, evaluate, generation_loop
├── figures/ # plot_EX.py / plot_CX.py — read results.parquet only
├── results/ # written artifacts (gitignored, hashes tracked)
├── tests/
│ ├── test_correctness.py
│ └── test_scientific_validation.py # §2.4 analytic checks
└── paper/
├── blueprint.md # this document
└── figure_manifest.md # claim -> experiment -> figure
```
---
## 6. Traceability: claim → experiment → figure
Every claim the technical paper will make is bound to exactly one experiment and one figure. This table is the paper's spine and the coding agent's definition of done.
| Perspective-paper claim | Layer | Experiment | Primary figure | Analytic check | Falsifier |
|---|---|---|---|---|---|
| Distillation without grounding collapses, tail first, at rate set by $n$ | 1 | E1 | $H_t$ decay + tail mass vs. gen | Pred. 1–2 | harness invalid if decay ≠ analytic |
| A critical grounding ratio $g^\*$ separates ratchet from collapse | 1 | E2 | tail mass / $H$ stationary vs. $g$ | Pred. 3 | flat in $g$, or only stable at $g\to1$ |
| Grounding must be region-matched, not merely present | 1 | E3 | target-region tail: uniform vs. matched | Pred. 4 | uniform protects as well as matched |
| Multi-teacher distillation suppresses collapse ∝ decorrelation | 1 | E4 | tail coverage surface over $(K_T,\rho)$ | Pred. 5 (closed form $U(K_T,\rho,q)$) | no benefit at matched budget |
| QD selection maintains diversity where greedy fixes it | 1 | E5 | $H$ plateau: qd vs. greedy | (mutation-selection-drift) | qd ≤ greedy in stationary $H$ |
| Re-minting is irreversible; gate on diversity | 1 | E6 | KL-to-original vs. $H$-at-remint | — | collapsed lineage recovers after remint |
| Dry inheritance degrades in real weights; grounded holds | 2 | C1 | pass@k vs. gen, dry vs. grounded | — | dry does not degrade |
| Complementary teachers preserve capability one teacher sheds | 2 | C2 | region coverage, 1 vs. N, matched budget | — | no union benefit |
| **General knowledge climbs while each specialty is re-earned and exceeded** | 2 | C3 | general benchmark ↑ + per-specialty re-earn | — | general falls / no re-earn |
| Recombination benefit robust to distillation vs. merging | 2 | C4 (opt) | C2 metric under both operators | — | benefit only under one operator |
---
## 7. Suggested build order for the coding agent
Staged so that each step is independently testable and the cheapest, highest-value results land first. Do not start Layer 2 until Layer 1's scientific-validation tests pass.
1. **Scaffold + environment.** Repo layout (§5), container (§4), `pytest` skeleton, config system, seeding utilities. Target `make test` green on trivial tests.
2. **Layer 1 core + validation.** `knowledge/` modules to the §2.7 interfaces. Implement the null model first. Write and pass `test_scientific_validation.py` against §2.4 predictions 1–2. **Gate: do not proceed until drift matches analytic decay.**
3. **Layer 1 mechanisms + E1–E2.** Add grounding; validate mutation–drift equilibrium (pred. 3); run E1 and the E2 phase-boundary sweep; produce the headline figure. This is the paper's core result and it should exist before anything neural.
4. **Layer 1 E3–E6.** Region-matching, multi-teacher/decorrelation, QD-vs-greedy, re-minting gate, with figures. Layer 1 is now a complete, laptop-reproducible paper on its own.
5. **Layer 2 scaffold + verifier.** Synthetic task generator, sandboxed `verify`, evaluation harness. Test the verifier's determinism and isolation before any training.
6. **Layer 2 C1 + C3.** Single-teacher dry-vs-grounded (C1) and the vertical claim (C3) — the two that most directly test the thesis. C3 is load-bearing; prioritise it.
7. **Layer 2 C2 (+ C4 if compute allows).** Multi-teacher recombination; optional merging operator.
8. **Reproduction pass.** `reproduce.sh` end-to-end; commit result hashes; write `REPRODUCED.md`; assemble the figure manifest.
**Definition of done:** every row of §6 has a committed figure produced by `make figures` from committed results, every §2.4 analytic check passes in CI, and `reproduce.sh` verifies from a clean checkout inside the container.
---
*End of blueprint v1. The perspective paper states the idea; this document states the test. If Layer 1's E2 finds no threshold, or E4 no decorrelation benefit, or Layer 2's C3 no vertical climb, the thesis is wrong in exactly the places these experiments probe — which is the point of writing them down this precisely.*

191
paper/the-lamarckian-society-v4.md Normal file
View file

@ -0,0 +1,191 @@
# The Lamarckian Society
### A multigenerational architecture of continual-learning agents that mature, teach, evolve, and pass on what they have learned
*A perspective. Draft 4 — accessible companion to a forthcoming technical paper.*
---
## Abstract
Societies of AI agents are not new. What is new — and what this paper proposes — is a *multigenerational* one: agents that learn continuously through a working life **without catastrophically forgetting**; that have **bounded capacity** and therefore fill; and that, on maturing, become **teachers**, distilling their hard-won knowledge into fresh pupils who form the next generation. Because each generation inherits the *acquired* knowledge of the last, the scheme is frankly **Lamarckian**, and it turns the capacity limit from a defect into a **life cycle**: growth, maturity, reproduction. But content is only the first of two things that are inherited. Each teacher also carries a *rule for what is worth teaching* — and those rules vary, are inherited, and are selected by how well their pupils fare. That second channel is **Darwinian**. The architecture is therefore a dual-inheritance system: Lamarckian in what it transmits, Darwinian in what it keeps. We argue that the learner must be *bounded but non-catastrophic*; that generational transmission is *selective and lossy*, and that this operation is, mechanically, the very one that produces **model collapse** — so that the ratchet climbs rather than degenerates only under two conditions the design must guarantee: that no knowledge is transmitted *dry* (every generational passage is grounded in fresh interaction with the world, region by region), and that each pupil is distilled from **multiple complementary teachers**, a recombination that preserves the independently-retained detail a single lineage would shed. Beyond this, collapse is averted **provided** variety is both supplied — by feeding the society heterodox contributors, not only a consensus elite — and preserved, by selection that rewards diversity as well as fitness; and provided the fitness function which drives the Darwinian channel is anchored to a reality that can *refute*, or the lineage will evolve toward persuasive falsehood rather than truth. The whole cycle is *computationally cheap* because it almost never re-pays for pre-training — the one deliberate exception being the periodic **assimilation** of a proven lineage's acquired knowledge back into the weights of a freshly-minted base, a computational Baldwin effect that lets the society grow without bound by converting hard-won *soft* inheritance into *innate* endowment. The unifying claim: individual learning, generational teaching, cultural accumulation, and the re-minting of the base are one process — the **selective transmission of hard-won knowledge** — running at four nested timescales, with natural selection operating across them.
---
## 1. From multi-agent to multi-generational
The idea of many AI agents cooperating — a "society of mind" (Minsky, 1986), or today's multi-agent systems — is well explored. It arranges intelligence across *space*: several specialists, side by side, dividing a problem. This paper concerns a different and, we think, deeper axis: *time*. Not a society that merely exists, but one that **persists and renews itself across generations**, each standing on the compressed knowledge of the one before.
The unit of novelty is the **generation**, and the event that matters is **succession**: the moment a mature agent, full of a working life's learning, becomes a *teacher* to a freshly-schooled *pupil*. A single mind — human or machine — is mortal and bounded. A lineage is neither. Human civilisation is not clever because any individual is; it is clever because each generation inherits the distilled achievements of the last and adds to them. We propose building AI the same way — and, as we will see, letting the lineage's very *sense of what is worth keeping* evolve under selection.
## 2. The trouble with immortal, frozen models
Today's large language models have no life cycle. They are trained once, in a colossal and costly epoch, then **frozen** and deployed as a fixed artefact that does not learn from those it serves. Learning and doing are severed into two eras with no path between them.
This answers a real problem. Updating a neural network's weights on new information tends to overwrite and destroy what it already knew — **catastrophic forgetting**, understood since the late 1980s (McCloskey & Cohen, 1989; French, 1999). Freezing sidesteps this by refusing to learn at all. The result is a mind with no childhood, no growth, and no way to pass anything on: an immortal that cannot age and therefore cannot have heirs. A lineage needs the opposite — members that learn through their lives, reach maturity, and transmit what they gained. So the first requirement is a learner built to grow safely.
## 3. The learner: bounded, but not catastrophic
The individual agent has two defining properties, both essential to its role in the lineage.
**It does not catastrophically forget.** Rather than overwriting its core as it learns, it keeps that core frozen and *readable* and carves each new specialisation into freshly allocated capacity beside it — a design established in machine learning as *parameter-isolation* (Progressive Networks — Rusu et al., 2016; the prune-and-freeze scheme of PackNet — Mallya & Lazebnik, 2018; adapters and low-rank patches generally). If the core is never altered, forgetting it becomes not merely unlikely but **structurally impossible**. This is what lets an agent accumulate a *coherent working life* of expertise — the kind of stable knowledge worth teaching.
The brain supplies part of the blueprint. Complementary Learning Systems theory (McClelland, McNaughton & O'Reilly, 1995) — itself motivated by the forgetting problem — describes two subsystems at different speeds: a **fast** store (the hippocampus) that grabs an experience in one shot, and a **slow** store (the neocortex) that integrates regularities gradually without disruption. How knowledge actually moves between them is, in our view, genuinely unsettled: the popular account of offline *replay* during sleep (Wilson & McNaughton, 1994) rests on evidence we consider far from conclusive, and we invoke it only as one possibility rather than a load-bearing assumption. Fortunately the architecture needs something weaker and more robust than any particular biological story — merely that *some* periodic **offline consolidation** step exist, moving knowledge down the chain when the system is not busy acting. The machine analogue is then clean regardless of how the brain does it: the prompt is working memory; an external retrieval database is the fast episodic store; the trained weights are the slow semantic store; and consolidation migrates the first into the last. (There is even a mathematical rhyme: modern associative memory is equivalent to the "attention" inside every transformer — Ramsauer et al., 2020 — so retrieval and attention are formally one act.)
**It is bounded.** Because the agent only ever *adds* capacity and freezes what it has, it eventually fills. In most designs this is a wall to dread. In ours it is a clock.
## 4. "Full" is not failure — it is maturity
Here is the pivot on which the architecture turns. A bounded learner that fills up has not broken. **It has grown up.**
Read the capacity limit as a *life stage*. An agent is born as a freshly-schooled base — its general education. It enters a **working life**, carving specialised, non-catastrophic knowledge into itself as it does its job. And it approaches **maturity**: the point at which it has learned much of what a single life in its niche can teach it. That ripeness is not the end of usefulness; it is the signal that the agent is now most worth learning *from*. So maturity triggers **reproduction, in the form of teaching**: the mature agent's knowledge is transmitted — compressed — into a fresh pupil. Growth, maturity, reproduction. The capacity ceiling, the thing every other architecture fights, becomes in ours the metronome of the generations. (Whether an agent must be entirely "full" to teach, or teaches while still maturing so that generations overlap, is an empirical detail we leave open.)
## 5. Succession: teachers, pupils, and Lamarckian inheritance
Transmission works by **distillation**: one or more mature teachers train a new pupil, whose weights come to hold a version of what they knew. A pupil can be taught by *several* teachers at once — a biologist, a chemist, a physicist — and so is born already broader, and (as this section will argue) more *robust*, than any of them: a new, better-educated base from which the next working lives will specialise. That plurality of teachers is not a convenience; it is, we will see, the structural safeguard that keeps inheritance from degenerating.
This inheritance has a precise name. When knowledge *acquired during a life* is passed to the next generation, that is **Lamarckism** — the inheritance of acquired characteristics. Biology forbids it: a giraffe's neck does not lengthen because its parent stretched. Culture is the one arena where acquired characteristics *are* inherited — through teaching, writing, apprenticeship — and that single exception is why cultural evolution outpaces genetic evolution by orders of magnitude. Our society is unashamedly Lamarckian, and that is the source of its power: each generation begins where the last left off, not where the last began.
And it must be *lossy*. A pupil the size of its teachers cannot contain them all; it must compress, and compression is *selective* — it keeps the general and transferable and sheds the idiosyncratic. This is not a defect; it is what education *is*. A student does not absorb everything their teachers know; they inherit the distilled principles, the compressed curriculum, and lose the mass of hard particulars. The textbook is a lossy compression of a field, and more useful than the field's complete archive. The pupil is not a super-mind that knows all its teachers knew; it is a superior *starting point*, destined to be exceeded in each specialty by the working lives that grow from it. The lineage climbs in general knowledge; specialisation is re-earned each generation. This is the **cultural ratchet.**
A blunt objection lands exactly here, and the design must meet it rather than dodge it. Recursively distilling one generation's *outputs* into the next is, mechanically, the very procedure that produces **model collapse** — the degenerative narrowing in which a model trained on its predecessor's projections forgets the improbable, loses the *tail* of the distribution first, and drifts toward its own mode (Shumailov et al., 2024). Worse, our ratchet does not merely risk this as a side-effect: its explicit rule — *keep the general, shed the idiosyncratic* — **is** tail-deletion by design. The operation that powers the cultural ratchet and the operation that drives model collapse are one and the same act; what separates them is not the mechanism but whether the tail that was shed was genuinely disposable or was thin signal, and whether fresh variety re-enters the lineage faster than compression sheds it. We therefore cannot hold collapse at arm's length as "a synthetic-data problem that does not apply to us." It applies precisely to the stratum that makes this a *multigenerational* paper — the inherited delta, the part not reloaded pristine from the base each generation. Two features of the architecture, working together, are what convert that collapse operation into a ratchet.
The first is that **no knowledge is ever transmitted dry.** Shumailov's collapse is a property of a chain fed *only* its predecessor's output; the documented remedy is that real data kept in the mixture arrests it. In our society that condition is met by construction, because a pupil is never distilled in a vacuum: every generational passage is accompanied by fresh interaction with the world, and — this is the load-bearing detail — the grounding must *overlap the content it protects.* Real samples of a new specialty do not replenish the lost tails of some unrelated inherited region; so knowledge is re-anchored to reality in the same act by which it is inherited, region by region, not merely somewhere in the generation at large. There is no dry inheritance.
The second is that a pupil is distilled from **multiple, complementary teachers**, and this is where the plurality promised above earns its keep. Distillation from a single teacher is an *asexual* copy, and a non-recombining lineage accumulates irreversible error — a **Muller's ratchet** (Muller, 1964), the malign twin of our cultural one. Distillation from several *decorrelated* teachers is **recombination**: because each teacher ground a different region of reality against the world, each retains tails the others lost, and the pupil inherits the *union* of what any teacher kept alive rather than the tail-thinned *average* of a correlated crowd. Independent errors cancel; independently-retained signal survives. The collapse-suppression is exactly proportional to how *unlike* the teachers are — which is why they must be drawn not from the current best (near-identical, clustered around the champion, and so merely averaging toward the mode) but for **complementarity**, precisely the quantity M2N2's niche-pairing already selects for and §7's quality-diversity machinery already maintains. How many teachers a pupil needs, with what spread of expertise, and at what *ratio* of inherited to freshly-grounded information the passage must sit for grounding to outrun contraction — these are the load-bearing quantities of the whole scheme, and modelling where they must fall is the first task of the companion paper.
But this raises the question the rest of the paper must answer. If a teacher can only pass on a *selection* of what it knows — who, or what, decides which of it survives?
## 6. The second inheritance: evolving what is worth teaching
There are two tempting answers, and the first is wrong. We could try to *design* the selection rule — to specify, by hand, which knowledge is worth keeping. But nobody knows that rule. "Keep the general, drop the particular" is a slogan, not an algorithm; the moment you ask *which* generalisations, in *which* domain, at *which* grain, the hand-designed rule fails. This is the deepest hole in the whole scheme, and it cannot be filled by fiat.
The second answer is the one nature used: **do not design the selector — evolve it.** Biology never specified what a brain should encode; it let organisms whose encodings aided survival leave more descendants, and the encoding rules improved *because their carriers won*. We propose the same. Let different teachers carry different rules for what is worth teaching. Let the rules that produce more capable, more successful pupils be inherited and spread; let the rules that produce weak pupils die out with their lineages. The lineage's *taste* — its sense of what matters — is not imposed. It is discovered by selection.
This means **two things are inherited, on two channels.** The *content* passes down Lamarckially: a pupil receives its teachers' acquired knowledge. The *selection rule* — the policy governing what to pass on — is itself inherited, varies between teachers, and is retained in proportion to the success it produces. That second channel is **Darwinian**. So the architecture is not Lamarckian *then* Darwinian, as if the two took turns; it is both at once, at different levels — Lamarckian in *what* it transmits, Darwinian in *what it keeps*. This is exactly the structure evolutionary theorists identify in human culture: dual inheritance (Boyd & Richerson, 1985), Lamarckian in transmission and Darwinian in selection, with the selection rule playing the part of Dawkins's replicator (Dawkins, 1976) and the agents its vehicles.
We are not inventing this picture; we are mechanising a well-supported old one. It is Popper's account of how knowledge actually grows — by conjecture and *refutation*, our hypotheses selected and killed in our stead so that we need not die with them (Popper, 1959); Campbell's evolutionary epistemology (Campbell, 1974); Hull's model of science itself as a literal selection process (Hull, 1988). Understanding, on this view, has always improved the way life did: by variation and differential survival.
And here is the closure that makes it fit the architecture rather than merely decorate it. Darwinian selection needs a *selection pressure* — something that decides which rules win. That pressure was already in the design. What tells a lineage its selection rule was good? The success of its pupils **against reality.** The open loop to a world that can refute (§9) is not only the anti-collapse anchor; it is the **fitness function** that drives the second inheritance. The two axioms of this paper — selective transmission, and openness to reality — turn out to be one mechanism seen from two sides: reality is what selects.
There is even a working, open-source proof that this runs cheaply. Sakana AI's Evolutionary Model Merge uses evolutionary algorithms to discover how best to combine open-weight specialist models — no retraining — and its successor, Model Merging of Natural Niches (M2N2), pairs models by *complementary* strength and can evolve capable models essentially from scratch (Akiba et al., 2024, *Nature Machine Intelligence*). That is a partial instantiation of exactly this idea: evolve the recipe by which specialist teachers are combined into a pupil, on cheap open foundations.
## 7. The danger: fitness is not truth
Introducing selection introduces selection's central hazard, and it is severe enough to sink the scheme if unhandled. Evolution optimises, ruthlessly and without foresight, for exactly what you *measure* — never for what you *meant* (this is Goodhart's law, and its machine-learning form, specification gaming). Get the fitness function slightly wrong and the lineage will evolve to exploit the gap with more ingenuity and less mercy than any designed rule.
For a *knowledge* lineage there is a specific and vicious version of this. In biology, fitness is survival — brutally well-defined. For ideas, the natural fitness is **transmissibility**, and a false-but-persuasive idea transmits beautifully. Human intellectual culture is *full* of highly-fit falsehoods; virality is not truth, and confident nonsense outcompetes hedged accuracy in almost every human forum. Turn Darwinian selection loose on teachers without care and it will evolve a lineage optimised for *persuasiveness* — fluent, compelling, and wrong. That is model collapse with an optimiser behind it, and it is worse than the passive kind, because the system is now actively *seeking* the cliff.
Only one thing makes fitness track truth rather than appeal: **refutation against reality.** Fitness must be predictive success under *intervention* — did the pupil's knowledge let it correctly anticipate what the world would do when acted upon — and not approval, fluency, or a benchmark score, each of which can be gamed. This binds the paper's two axioms tightly: the Darwinian channel is safe *exactly* to the degree the loop stays open to a reality that can say no, and dangerous *exactly* to the degree it closes. Cut the lineage off from intervention and it stops evolving toward truth and starts evolving toward whatever is merely convincing.
The second hazard is convergence, and defeating it takes work at **two distinct levels** — because selection can only ever preserve variety that already exists, so the variety must first be *supplied* and then *kept*. This is the deepest safeguard in the design, and it is worth being explicit that collapse is fought both outside the society and inside it.
The first level is the **input** — who the lineage learns from, and who is allowed to refute it. A society that interacts only with an accredited human elite has a monoculture for a source: the "best" scientists and philosophers are, almost by definition, those who won the consensus, so the incoming variation is narrow from the start, and no selection rule can preserve a diversity that was never there. So the society must engage, from the beginning and by deliberate design, not only with the credentialed best but with the **weirdos, misfits and outliers** — the heterodox, the cross-paradigm, the cross-cultural, the productively wrong. They are not noise to be tolerated; they are the *mutation supply*, the standing variation on which everything downstream operates. In population terms this is the difference between founding stock rich enough to keep adapting and stock so inbred it can only drift toward the mean. Diversity of contributors is not an equity gesture here; it is the raw material of evolution, and without it the second level has nothing to act on.
The second level is the **selection rule itself**. Even given varied input, plain fitness-*maximising* selection converges — it drives every lineage toward the single current best and fixes it, extinguishing the rare specialists and the tails. The resolution exists and is precise: **quality-diversity** selection, which rewards fitness *and* novelty together (novelty search and MAP-Elites — Lehman & Stanley, 2011; Mouret & Clune, 2015), and the niche-based pairing in M2N2, which keeps complementary specialists alive rather than collapsing onto the champion. Such selection does two things at once: it *maintains* the standing variation the first level supplied, and — by actively rewarding the occupation of empty niches — it *re-introduces* variation the lineage had begun to lose. Supply the variety from the human side; preserve and regenerate it on the selection side. Neither level suffices alone. Diverse input with greedy selection still collapses, because selection fixes the winner; clever selection with monoculture input has nothing to preserve. Only both together give a lineage that can keep from converging on its own first guess.
And the two levels meet at the moment of teaching. Multiple-teacher distillation (§5) is the *vehicle* by which the diversity this selection labours to maintain actually **enters** the pupil: a pupil drawn from complementary teachers inherits the standing variation the selector kept alive, recombined into a single new base. So the picture is one machine seen at two moments — supply the variety from the human side, preserve and regenerate it on the selection side, and *recombine* it into each new generation on the transmission side. The anti-collapse safeguard of §5 (don't transmit dry; distil from decorrelated teachers) and the anti-convergence safeguard here (supply and preserve variety) are not two defenses but one, applied at transmission and at selection respectively.
## 8. A society needs institutions, not just specialists
One requirement is easy to overlook and fatal to omit. The easy part of a society is specialisation; Adam Smith described the division of labour in 1776. The *hard* part — which civilisation took millennia to build — is the set of **institutions that let fallible specialists combine without each re-verifying everything**: reputation, replication, credentials, and above all **peer review**. These are error-correction protocols, and they exist because a group of unreliable specialists left to reinforce one another is *more* wrong than any member alone.
This is where current multi-agent AI fails: set several agents to confer and they confabulate in committee and agree sycophantically, because they have all the specialisation and none of the institutions. A multigenerational society must therefore specify not only how agents learn, teach, and are selected, but how they *check* one another — how a claim is challenged and a mistaken teacher loses standing *before* its error is consolidated into a pupil and inherited forever. Note that peer review is itself a fitness function of the kind §7 demands: an institutional approximation of reality's "no," to be used precisely where direct intervention is slow or costly. Get these institutions wrong and the ratchet will faithfully transmit — and select for — nonsense.
## 9. The lineage must stay open to reality
A society of agents, however many generations deep, shares one hard limit: it has only ever *read*. Its whole inheritance is a record of things that were said. In the language of causal reasoning (Pearl, 2009), it lives on the bottom rung of the **ladder of causation** — observation — and no amount of observation climbs to *intervention*. Watching underdetermines doing; correlation does not contain causation, at any scale.
Only intervention — reaching out and changing the world to see what happens — climbs the ladder, and a language model cannot intervene. This is what humans and their instruments supply, and the contribution is not "truth" but **constraint**: reality's unique gift is that it can say **no**. Text offers only more opinion; an experiment delivers a refusal no consensus can overturn (Popper's asymmetry — Popper, 1959). As §6 and §7 showed, this refusal is doing double duty: it is both the anchor that prevents collapse and the **fitness function** that lets the lineage's evolving taste select for truth rather than for persuasion. An intelligence sealed off from intervention does not merely stop learning new facts; it loses the only pressure that keeps its selection honest.
Two honest riders. First, the human anchor is *filthy*: people supply results warped by publication bias, incentive, and occasional fraud — which is exactly why the error-correcting institutions of §8 must sit at the human–machine boundary too, screening the reality-signal before it is allowed to select. Second, humans are the *current* implementation of intervention, but the actuator half is being automated — autonomous laboratories already close the design–build–test loop without a hand in the inner cycle. What looks durable in the human role is therefore not the hands but the **shaping of the selection pressure**: deciding which questions are worth asking and, above all, *which refusals matter*. Evolution supplies competence and persistence; it does not supply value, because reality refutes false predictions, not bad goals. So the un-automatable human seat is to be the part of the fitness function that encodes *what is worth persisting*, as against what merely *can* persist.
This forces a question the design cannot dodge. "Symbiosis" is a spectrum, from mutualism to outright **assimilation** — the mitochondrion that bought permanent residence inside its host by surrendering nearly its whole genome; the most successful symbiosis in the history of life ended with one partner absorbed. A partnership stays mutual only while both sides supply something the other cannot. If the human's physical contribution erodes while only value-setting remains, is that a stable mutualism or a transitional one? We do not resolve this. We insist only that a Lamarckian, Darwinian machine society — one that could, by construction, outlast and outpace its makers — must state the question rather than assume the comforting answer.
## 10. Why it is cheap
A practical fact turns this from thought experiment into buildable proposal: **the architecture is computationally inexpensive, because it almost never re-pays for the one genuinely expensive thing in AI — pre-training.** (The one deliberate exception — periodically re-minting the base itself — is the subject of §11, and it is rare enough to be an amortised footnote on the budget, not a line item in every generation.)
Training a foundation model from scratch consumes tens of trillions of words and a fortune in compute. This design does none of that. Every agent is *born* from an existing open-weight model that already paid that cost, and every subsequent step is cheap: specialising an agent is a small patch trained in hours on a single consumer graphics card; running the society is ordinary inference with modest models; and a *generation* — distilling teachers into a pupil — only sounds enormous, because learning from the teachers' rich *outputs* rather than from raw text is a fine-tuning-scale job of days, not a foundation-model-scale one. Evolutionary selection over such agents is affordable for the same reason it is affordable in nature only when individuals are cheap: because the members are small and disposable, you can run *populations* and discard the unfit without ruin — and Sakana's evolutionary merge is a live demonstration that this search runs without any retraining at all (Akiba et al., 2024). The honest caveat: selection means running many lineages rather than one, a real cost multiplier — but a multiplier over an already-cheap unit, not over a foundation-model budget.
The economics work only with **open-weight** models, for reasons practical and legal at once: you must be free to inspect, modify, and redistribute the weights, and most proprietary licences explicitly forbid using a model's outputs to train another — which is exactly what teacher-to-pupil distillation does. An open, shareable, evolving lineage *must* rest on open foundations. This is not ideology bolted on; it is a structural constraint — and a democratising one, since it puts the whole architecture within reach of a single laboratory rather than only the few companies that can afford scale.
## 11. Can it grow forever? Assimilation and the re-minting of the base
One question the design has so far assumed away: can the society accumulate *without end*? The individual agent is bounded and that boundedness is the whole clock. But the *lineage* seemed unbounded — each generation simply starts a little ahead. Look closer and there is a second budget that also fills.
Every pupil is born from a pristine base plus an inherited **soft** delta — the acquired knowledge distilled into it, carried in freshly-allocated adapters and patches rather than in the frozen core (§3). That soft delta is what makes the lineage multigenerational; it is also what cannot grow without bound cheaply. Stacked patches are not free: they cost routing overhead at inference, they are slower and more expensive to *use* than knowledge baked natively into weights, and past some depth the accumulated delta is better *consolidated* than carried. A lineage that only ever adds soft inheritance eventually meets, at the level of the whole line, the same wall the individual met at the level of one working life. The lineage, too, matures.
And the resolution is the same operation, one level up. When a lineage's acquired knowledge has proven stable and reliable across enough generations, **re-mint the base**: distil the accumulated soft inheritance into the *weights* of a fresh foundation-scale model — a new spawning agent, born already *natively knowing* what took many generations to acquire in patches. The soft budget resets to zero; the next epoch of accumulation begins from a richer, cheaper-to-access floor. What was hard-won and *learned* becomes cheap and *innate*.
This has a precise name, and it is not Lamarck's. Knowledge that is acquired and re-learned every generation, once it has been reliably present for long enough, becoming part of the innate endowment so that it need no longer be re-learned — that is the **Baldwin effect**, genetic assimilation (Baldwin, 1896; and its clean computational demonstration, Hinton & Nowlan, 1987). It is the valve between the paper's two substrates. The Lamarckian channel carries knowledge *soft*, in the learned patches; the "genetic" channel is the base weights every agent is born with; and assimilation is the one-way conversion of the first into the second — running, as Lamarck would have wanted, *upward* from the acquired to the innate, but only after Darwin's selection has vouched for the cargo. (Note the resonance, and the reversal, with §9: there "assimilation" named a *danger* — a partner absorbed and lost; here it names a *feature* — knowledge absorbed and made permanent. Same word, opposite valence, and the design must be clear which it is doing.)
Seen this way the architecture is **self-similar across scale.** The very first timescale (§3) is an agent consolidating a working life's fast, episodic experience down into slow, durable semantic weight. This last one is a *civilisation* of agents consolidating an epoch's acquired, adapter-borne expertise down into a new innate base. Smallest scale and largest scale are the *same act* — a fast/soft store that fills and is periodically distilled into a slow/hard store — separated only by how slowly the clock ticks. Consolidation all the way up.
Three honest riders, because re-minting is the most consequential operation in the scheme:
First, **cost.** This is the single step that re-pays a share of the pre-training bill, and it breaks §10's cheapness *locally*. But it is rare, amortised over a great many cheap generations, and it is *continued* training or distillation from the lineage's own rich outputs, not a de-novo foundation run — cheaper than minting a base from scratch. §10's economics survive on average; they do not survive being done every generation, which is exactly why it must not be.
Second, and most dangerous: **re-minting is irreversible, and it cements whatever is in the distribution at that moment.** Until now, one thing was always recoverable — the original pristine base, whose tails could be restored simply by reloading the file. Bake the current lineage into new immutable weights and that escape hatch closes: if the lineage had been quietly narrowing (§5), re-minting *fixes the collapse in place* and discards the one uncollapsed reference that could have diagnosed it. So assimilation is safe **only** on a demonstrably healthy, diverse lineage. It must be *gated on the §7 diversity metrics* — performed when standing variation is high, never as a rescue for a line already drifting toward its mode. Choosing what to make innate is choosing what no future generation will think to question; it is the sharpest possible instance of §9's un-automatable human seat — the decision of *what is worth persisting* — and it should be treated with the caution that irreversibility demands.
Third, **speciation.** A re-minting is a founder event. Different laboratories, re-basing on different criteria, will mint divergent bases; the lineage *branches.* This is not a defect but **adaptive radiation** — and it is exactly what open weights make possible, since anyone may found a new base from a proven line. The society therefore grows forever not as one ever-heavier trunk but as a *phylogeny*: a branching tree of bases, each periodically shedding its accumulated soft load into a new trunk from which fresh lineages radiate.
So the answer to "can it grow forever?" is **yes — but only because it forgets and consolidates at every level, including the base.** Nothing is retained without bound anywhere: the prompt consolidates into retrieval, retrieval into weights, a working life into a taught pupil, an epoch into a re-minted base. Unbounded growth of *capability* is bought by *bounded* storage at every level, plus periodic downward consolidation. Infinite accumulation and finite capacity are not in tension; they are reconciled by the same selective forgetting the whole paper is about — now turned, at the slowest clock of all, on the base model itself.
## 12. One process, four timescales, one selection
Step back and the parts resolve into a single idea with two motions. The **vertical** motion is transmission — the *selective passing-down of hard-won knowledge* — and it runs at four nested speeds:
1. **Within one agent, over a working life:** experience is continually and safely consolidated from fast episodic memory into slow durable knowledge, without catastrophic loss.
2. **Between generations, at maturity:** a mature agent's expertise is selectively distilled into a fresh pupil. (Teaching.)
3. **Across many generations, over cultural time:** each generation inherits the compressed achievements of the last and builds upon them. (The ratchet.)
4. **Across epochs, over the life of the lineage:** a proven line's accumulated soft inheritance is consolidated into the weights of a re-minted base, becoming innate. (Assimilation.)
The first and the last are, strikingly, the *same operation at opposite ends of the scale* — a fast, soft store consolidating into a slow, hard one — the one running overnight inside a single mind, the other running across an epoch inside a whole society. The architecture is self-similar: consolidation all the way down, and all the way up.
The **horizontal** motion is selection — natural selection acting across the population at each of those timescales, on the rules that govern what gets transmitted, with reality as the fitness function and niche-preservation keeping the tails alive.
The same laws govern all of it: transmit selectively, or you merely copy; preserve the disagreements and the surprises, or you collapse toward the mean; anchor fitness to a reality that can refute, or you evolve toward what is merely convincing. If this is right, the proposal is more than an AI design. It is a claim that intelligence at *every* scale — an individual maturing, a field taught to a student, a science accumulating across generations, a canon re-founded once an age — is the same act: bounded minds passing forward, in compressed and selected form, the knowledge a lifetime can win, with the world itself deciding what was worth keeping.
## 13. What is new, what is borrowed, and what comes next
Honesty about provenance. Multi-agent societies are **not** new; nor are the mechanisms we lean on — complementary learning systems and sleep consolidation; parameter-isolation and distillation; the documentation of model collapse; the ladder of causation; evolutionary epistemology; evolutionary and quality-diversity search; the economics of specialisation.
What we claim as new is the **assembly**: a multigenerational continual-learning lineage of bounded, non-catastrophic learners that mature and teach; the reframing of the capacity limit as a **life cycle** rather than a wall; the recognition that this makes transmission **Lamarckian**; that the *selection rule itself* forms a **second, Darwinian inheritance channel**, so that the architecture is a dual-inheritance system whose taste evolves rather than being designed; and — the contributions sharpened in this draft — the frank recognition that the transmission channel *is* mechanically the model-collapse operation, redeemed by two guarantees the design now makes explicit (**no dry inheritance** — every passage grounded in fresh reality, region by region — and **multi-teacher distillation as recombination**, which suppresses collapse in exact proportion to how decorrelated the teachers are); together with the closing move that lets the whole thing grow without bound, the periodic **assimilation** of a proven lineage's soft, acquired inheritance into a re-minted innate base — a computational Baldwin effect that adds a fourth and slowest consolidation timescale and makes the architecture self-similar from a single night's sleep to an epoch of a civilisation. From this fall two tight unifications: that the paper's reality-anchor and its selection pressure are the *same thing* (reality is the fitness function), and that a single mechanism — **niche-preserving evolutionary selection anchored to refutation** — simultaneously solves the selector problem and prevents model collapse. The framing is the contribution, and it is visible from a particular vantage — sleep, memory consolidation, model organisms, evolution, and open science — that the AI field does not usually occupy.
The open problems, honestly stated. The old hole — *what to select* — is now filled in kind: don't design the selector, evolve it. But the hole has *moved*, not closed, and the new one is sharper and harder: **the fitness function.** What reality-anchored criterion selects for *truth* without also selecting for *persuasion*, given that in our own species the two have been at war for the entire history of ideas? Alongside it stand two others. **The institutions** that let contemporaries correct one another before error is inherited (§8) we do not solve. **The seed and the input** we address in kind but not in calibration: §7 argues that collapse is fought at two levels — heterodox human contributors supplying the variation, niche-preserving selection maintaining and regenerating it — and that the *diversity* of who the society learns from, not their prestige, is what keeps the ratchet climbing rather than regressing to the mean. What stays genuinely open is the calibration: how much heterodoxy, weighted how, and sustained how, before diversity of input tips over from raw material into mere noise.
The quantities the transmission channel now hangs on are also, honestly, open — but they are *measurable*, which is the difference between an open problem and a hole. How many teachers a pupil needs and with what spread of expertise; the ratio of inherited to freshly-grounded information at which each passage must sit for grounding to outrun contraction; and the cadence and gating criteria for re-minting the base — how healthy and how diverse a lineage must be (by §7's own metrics) before its acquired knowledge is safe to make irreversibly innate — are not to be guessed but modelled.
A **companion paper** will make this concrete with a minimal working model: a small lineage of open-weight agents that learn, mature, and teach across two or three generations; multi-teacher distillation from complementary teachers, with the teacher count and the inherited-to-real-world data ratio swept as explicit parameters against the collapse rate; competing selection rules subjected to a reality-anchored, niche-preserving fitness function; and tests of two sharply falsifiable predictions the design yields — that the useful size of a contemporaneous generation is finite and set by how cleanly the domain decomposes (the *horizontal* claim), and that general knowledge climbs monotonically across generations while each specialty is re-earned and repeatedly exceeded (the *vertical* claim, and the one that tests the actual thesis rather than the borrowed scaffolding). Theory here; a toy that either works or does not, there.
---
## Selected references
- Akiba, T., Shing, M., Tang, Y., Sun, Q., & Ha, D. (2024). Evolutionary optimization of model merging recipes. *Nature Machine Intelligence* (see also Sakana AI's M2N2, "Model Merging of Natural Niches").
- Baldwin, J. M. (1896). A new factor in evolution. *The American Naturalist.*
- Boyd, R., & Richerson, P. J. (1985). *Culture and the Evolutionary Process.*
- Campbell, D. T. (1974). Evolutionary epistemology. In *The Philosophy of Karl Popper.*
- Dawkins, R. (1976). *The Selfish Gene.*
- French, R. M. (1999). Catastrophic forgetting in connectionist networks. *Trends in Cognitive Sciences.*
- Hinton, G., Vinyals, O., & Dean, J. (2015). Distilling the knowledge in a neural network. *arXiv:1503.02531.*
- Hinton, G. E., & Nowlan, S. J. (1987). How learning can guide evolution. *Complex Systems.*
- Hull, D. L. (1988). *Science as a Process.*
- Lehman, J., & Stanley, K. O. (2011). Abandoning objectives: evolution through the search for novelty alone. *Evolutionary Computation.*
- Mallya, A., & Lazebnik, S. (2018). PackNet: adding multiple tasks to a single network by iterative pruning. *CVPR.*
- McClelland, J. L., McNaughton, B. L., & O'Reilly, R. C. (1995). Why there are complementary learning systems in the hippocampus and neocortex. *Psychological Review.*
- McCloskey, M., & Cohen, N. J. (1989). Catastrophic interference in connectionist networks. *Psychology of Learning and Motivation.*
- Minsky, M. (1986). *The Society of Mind.*
- Mouret, J.-B., & Clune, J. (2015). Illuminating search spaces by mapping elites (MAP-Elites). *arXiv:1504.04909.*
- Muller, H. J. (1964). The relation of recombination to mutational advance. *Mutation Research.*
- Pearl, J. (2009). *Causality: Models, Reasoning, and Inference* (2nd ed.).
- Popper, K. (1959). *The Logic of Scientific Discovery.*
- Ramsauer, H., et al. (2020). Hopfield networks is all you need. *arXiv:2008.02217.*
- Rusu, A. A., et al. (2016). Progressive neural networks. *arXiv:1606.04671.*
- Shumailov, I., et al. (2024). AI models collapse when trained on recursively generated data. *Nature.*
- van de Ven, G. M., Siegelmann, H. T., & Tolias, A. S. (2020). Brain-inspired replay for continual learning. *Nature Communications.*
- Wilson, M. A., & McNaughton, B. L. (1994). Reactivation of hippocampal ensemble memories during sleep. *Science.*
- Zweiger, A., Pari, J., et al. (2025). Self-adapting language models (SEAL). *arXiv:2506.10943.*
*Additional literatures the final version must engage: multi-agent LLM societies (to mark the departure); population-based training and AI-generating-algorithms; Becker on human capital; Polanyi on tacit knowledge.*