How does inherited information stay meaningful?

The genome as a generative program

A few things seemed settled early. A genome shouldn't encode raw weights. Hundreds of millions of independent numbers make mutation destructive and recombination meaningless. Instead it should go through a developmental step:

The genome would hold compressed developmental information: architectural motifs, growth rules, connectivity patterns, learning and plasticity rules, memory organization, intrinsic-reward coefficients, developmental schedules. Modularity, reuse and conditional expression let a small description build a large network without the combinatorial explosion of specifying every connection.

The hard parts are all in the details:

• What's in the schema? Architecture templates, plasticity gates, memory limits? How many parameters are enough before evolution becomes noisy again?
• How much work does the interpreter do? It does most of it. Too weak and nothing interesting can be expressed. Too strong and evolution becomes irrelevant. There's little theory here. It's empirical.
• How do you mutate a rule without breaking it? We need mutations that are mostly local and non-lethal, with occasional radical jumps that still produce something that runs.

Our ambition went further than initial conditions. We didn't just want evolved learning rates or weight scales. We wanted a genome that encodes increasingly good initial structure, a non-trivial starting graph that makes the newborn learner unusually good at learning.

When evolution stops seeing the genome

One concrete version of this is a CPPN, a small network that outputs a connection weight given the coordinates of two neurons. Its parameters generate a much larger network. We tried it: evolve the generator, express it into an MNIST classifier, train briefly, and select on how well it learned. (See Experiments.)

That raised a subtle question. Suppose the generator has two parts: shared generator weights θ, and a per-individual genome z that's fed into it. Why not optimize both, training θ heavily so the genome only has to steer it?

The problem we worked out is a collapse of evolutionary credit assignment. If z is cheap and fast to optimize within a lifetime and θ is slow and expensive, almost all selection pressure flows into z. Offspring succeed because of what they optimized, not what they inherited. The fitness differences attributable to heredity shrink toward zero, and evolution stops seeing the genome at all. Worse, it's self-locking. As θ drifts, the meaning of z shifts, recombination becomes destructive, and every new generation has to re-optimize z from scratch, which keeps θ invisible.

Evolution didn't discover calculus. It discovered brains that can learn calculus.

Evolution needs intergenerational persistence of advantage. If winning comes mostly from within-lifetime optimization, evolution is bypassed. Biology avoids this partly because development is slow, learning is constrained and plasticity has costs. Escaping a collapsed system usually takes something external: a reset, fitness shaping that rewards the genome's contribution, temporarily switching off plasticity, or architecturally separating what z can express. That's the same timescale separation problem seen from the other side.

Recombination without garbage offspring

Working synthesis

Weight-level crossover between two independently trained networks is essentially broken. Two networks can compute the same function with their neurons in completely different orders, so averaging them destroys both. Recombination has to happen at the level of modules, rules or generators, or after some way of aligning the two networks. One research topic we wrote down is a cheap "handshake" that lets two agents align their permuted pathways locally before merging. Work on permutation alignment, such as Git Re-Basin, suggests this is possible in some settings.

Biology is instructive here, and it isn't magic. In crossing over, homologous chromosomes pair and swap segments. Offspring are usually viable because genomes are organized into compatible blocks, gene regulation is robust, development buffers variation, and selection removes most bad combinations early. Dominance isn't a "stronger gene". It describes how two alleles' products interact, and many traits are neither simply dominant nor recessive. The lesson for engineering: recombination works because of modularity plus robustness plus selection, not because swapping is safe.

NEAT solves gene alignment with historical "innovation numbers" and protects new structure through speciation, but at a small scale. HyperNEAT compresses with CPPNs, but recombination semantics can drift. Neither gives us what we wanted:

• Emergent mate choice. Compatibility signals, mating calls and partner reputation that agents develop for themselves, instead of a hand-coded genomic-distance metric.
• Costs that enforce selectivity. If offspring are expensive and failed offspring are wasted, agents should become choosy without a rule telling them to. Ideally parents would also have reason to protect their offspring.
• When sex pays. When does cloning dominate and when does recombination win? That probably depends on how fast the environment changes, what offspring cost, and the pressure for diversity.

Protected heredity, and whether it can emerge

Hypothesis

The most interesting argument in this whole line of work started with a radical proposal. Give each agent energy that drains over time, let every action (thinking, communicating, remembering, reproducing) cost energy in proportion to its computational cost, and let a parent's own policy decide how to construct its child. There would be no fixed genome, no imposed mating rules, no hard-coded mutation rate. Agents might start by producing near-copies of themselves. Then they might learn to compress what they pass on, because smaller encodings are cheaper. Eventually they might share that encoding with partners, in a form of sexual reproduction nobody designed.

The first objection is real. Darwinian evolution needs locality: small heritable changes should cause small changes in the phenotype. If the program that runs is the same as the program that's inherited, and either can rewrite the other, a single change can alter what everything means, including the reproduction logic. Modern biology keeps a firewall. DNA is read by machinery rather than executed. Development acts like a slow, redundant compiler that absorbs mutations. And the genetic code itself is effectively frozen.

The counter-objection is also real, and it changed our view. Biology has no external genome-processing oracle either. Polymerases, repair enzymes and recombination machinery are all encoded in the genome itself. Early life was much closer to self-modifying chemistry, with high error rates and no clean separation between program and execution. So the accurate statement is subtle:

Biology emerged from something close to a self-modifying system, but cumulative evolution only became possible after heredity became protected.

That makes the real research question this: how do you build a self-modifying system in which protected heredity can emerge, and is likely to? What we've worked out so far:

• Pressure toward compression can emerge without being hard-coded, if reproduction cost and copying errors both grow with the size of what's inherited. But "inheritance has a measurable size" is already a proto-bottleneck.
• Pressure toward modularity appears when offspring can partially fail, when parts get recombined, or when development happens in stages that fail independently.
• The fragility gap is the main obstacle. Early heredity-protection mechanisms are expensive and fragile, and they lose to fast, sloppy replicators. Before protection exists, protection is a liability. In biology, transitions like this looked more like catastrophic filters than gradual tuning.
• Side channels defeat it. If a parent can cheaply patch its child after birth, selection routes around heredity entirely and no genome-like bottleneck forms.
• Pressure only acts through a bottleneck. "Anything is allowed and selection will find the right abstractions" doesn't work. "The environment imposes costs and failure modes that make a bottleneck the cheapest stable solution" might.

We also predicted what would emerge quickly in an unconstrained world: minimal self-replicators, degenerate reproduction strategies, no meaningful sex, and intelligence not winning early. Those are the things an environment would have to make unprofitable. We tested a tiny version of the compression hypothesis, and it didn't go as expected. See Experiments.

The error catastrophe

That experiment's population went extinct because it crossed the error threshold, which made this one of our concrete research topics:

Related questions: should mutation rates evolve? Should they differ across regions of a genome? Should stable modules become protected? Should highly exploratory lineages coexist with conservative ones?

The cost of a generation

Then we ran into the constraint that reshaped this whole line of work. Suppose a phenotype is a large neural network that has to live in a real, non-simulated environment for a day or two before its fitness means anything. Suppose a participant can afford to run only 10 to 20 of them at a time. Then even with ideal selection pressure, getting useful emergent structure from a genome might take an enormous number of generations. And each generation spends compute killing agents that were working fine. If the result is a slightly better initialization, we could have spent the same compute training one larger conventional model for longer.

Working synthesis Evolution is competitive mainly when:

• The search space is discontinuous. Topology, architecture or discrete structure matters more than fine weight values.
• Evaluation is cheap. You can run many fast, simulated trials. Two days per individual makes evolution unusable.
• It evolves slow variables. Architecture priors, hyperparameters, learning rules and inductive biases, not billions of weights.

Ways to make it viable: don't evolve things that take days to evaluate; triage with a fast proxy fitness; share experience across agents; separate the heavy model from the small evolving component; and make a generation shorter than a life. Our current framing:

Use evolution as a slow meta-search over learning biases and resource policies, while shared data and gradient learning do most of the work of building competence.

This is why Rubedo's next practical step set reproduction aside for a static population of learning agents (see Agents). We didn't abandon heredity. We decided it was the wrong place to spend scarce compute first.

What we don't know

• What should constitute a genome, and what the developmental interpreter should look like.
• How recombination can preserve functional structure at scale, and whether mate choice can emerge without a designed distance metric.
• How lifetime learning can become cumulatively heritable without collapsing credit assignment onto the inner loop.
• Under what conditions protected heredity emerges from self-modifying replicators rather than being destroyed by them.
• Whether any of this can be made cheap enough to compete with simply training bigger models.