# Andromeda Architecture — Supplementary Notes

**v5, August 13, 2026**
*Compiled by Bryan Carter from architectural disclosures by Art Code Outdoors, July–August 2026. Errors are Bryan's own.*

**Purpose:** This document captures architectural details disclosed by the designer during the reference implementation effort that do not appear in the framework document, layman's guide, safety field guide, or proofs collection. It is a companion to those documents, not a replacement. Readers should read the framework first.

**License:** MIT-0 (same as all public bundle documents)

---

## 1. Universal Principles

Two principles the designer identifies as universal to the architecture. Everything else derives from these.

### 1.1 Everything Evolvable Should Be Evolved

*Source: designer, July 30, 2026*

> "Everything that can be evolvable, should be evolved. Anything that isn't on the tape is an assumption we're making."

This is a design principle with immediate practical consequences. Anything hardcoded in an implementation — provisioning amount, reality flag bit count, offspring count, gestation duration, connection density parameters — represents an assumption the implementer is making about what value that parameter should take. The designer's position is that these assumptions are almost always wrong, and that the correct approach is to put the parameter on the tape and let evolution find values that work.

The principle applies to parameters the implementer may not think of as parameters at all. If the implementation has a constant, and that constant affects organism behavior or development, it should be on the tape. The only things that should be hardcoded are the laws of physics in the simulation substrate — the things that are true for all organisms equally, that no organism can change.

### 1.2 Information Entropy Injection Is Architecturally Required

*Source: designer, July 30, 2026*

> "A string cannot increase its Kolmogorov complexity except by adding information to the string. The universal constructor is *incapable* of increasing the complexity of the programs/organisms without a source of entropy."[^proof1]

This elevates random injection from a practical choice to a mathematical necessity. A PRNG has fixed algorithmic complexity — its Kolmogorov complexity bounds the solution space, meaning some valid configurations are structurally unreachable because the PRNG cannot generate the noise pattern needed to find them. A TRNG (true random number generator) has no such bound. PRNG is acceptable for controlled testing with documented caveats; TRNG is the production mechanism.

The requirement applies at every level where new information must enter the system: mutation, noise injection into the substrate, connection generation, and initial tape creation. Without external entropy at each of these points, the system cannot grow in complexity — it can only rearrange what it already has.

---

## 2. Natural Selection as Physics

*Source: designer, July 31, 2026*

Natural selection is widely misunderstood as a process that chooses the best, rewards the fittest, or optimizes toward a goal. It does none of these things. The mechanism is subtraction, not selection. There is no judge, no ranking, no intent.

The designer's complete logic of natural selection is four steps:

> **1. Existing and not existing is the whole game.**
>
> **2. If nothing threatens your existence, you persist by default.**
>
> **3. If the universe has a rule ("do XYZ or stop existing"), then everything that doesn't do XYZ is gone, and everything remaining does XYZ — not by choice, by subtraction.**
>
> **4. We only observe what's left. We can't observe what isn't there.**

> "When you think about the rules of your universe, it tells you what kinds of things can exist in it."

This is the weak anthropic principle applied to evolution.[^proof2] We must live in a universe where observers are possible, because if we didn't, we wouldn't be here to observe it. Likewise, every organism we observe exists because it descended from something that reproduced before it stopped existing. No evaluation was needed. No fitness function was applied. The dead have no offspring, and we cannot observe what isn't there.

The practical consequence for designers of evolutionary systems: however many points an organism needs to reproduce is the score ceiling. As the designer stated: "If it only takes two points to get a baby, it's only ever going to score two points because it got the baby." The only way to drive higher performance is to make existence itself contingent on performance — not by rewarding better performance, but by making insufficient performance a reason to stop existing.

---

## 3. Tape Format — Codon Encoding

*Source: designer, August 8, 2026*

The designer's tape encoding uses a codebook-based scheme fundamentally different from direct bit extraction. This section documents the format as disclosed during the v6 structural erosion discussion.

### 3.1 Codon Table

32 codons, each 64 bits wide, each with exactly 34 ones (balanced). The table was evolved against uniform, Gaussian, and burst noise profiles. The balanced bit population means no codon is biased toward ones or zeros — a burst of stuck-high or stuck-low bits cannot systematically favor one codon over another.

[Codon table: see the framework document's codon encoding section for properties; full bit patterns are in the internal tape implementation specification]

### 3.2 Decoding Algorithm

Best-match by counting shared ON bits. Take 64 bits from the tape, compare against all 32 codons. The codon with the highest count of shared ON bits is the match. The array index is the decoded codon value.

This is a fundamentally different decoding model from direct bit extraction. There is no alignment requirement — any 64-bit window on the tape produces a valid codon. The decoding is robust because it is a similarity metric, not a positional read.

### 3.3 Error Tolerance

Multi-bit tolerance. Hamming distances between adjacent codons range 24–36 (mean 30.3). A window can sustain 12+ bit flips and still decode to the correct codon. There is no error cliff — the worst case for a corrupted window is decoding to a neighboring codon, not garbage. Because decoding is best-match, every 64-bit window produces a valid codon. There are no invalid opcodes and no undefined behavior from tape corruption.

This means the constructor's damage to the tape during development mostly decodes to the same codon — the encoding absorbs the noise. The few errors that change the decoded codon produce a functional neighbor, preserving structural coherence even under significant corruption.

### 3.4 Burst Resistance

Bit differences between adjacent codons are spatially distributed across the full 64-bit width. Longest runs of differing bits between adjacent codons are 3–5 bits. A localized burst error — several adjacent bits corrupted together — cannot easily jump multiple codons because the difference pattern between neighbors is spread across the full width.

The designer noted that burst resistance was motivated by serial cable transmission, which is the primary physical channel where burst errors occur in practice. Constructor corruption during development tends to be more distributed (random bit flips across the codon). The format is designed to survive both failure modes because the tape needs to survive both: construction noise within the organism's lifetime, and physical transmission if tapes are moved between hardware nodes over a wire. This is thinking about the system as real infrastructure, not simulation.

### 3.5 Divergence from Reference Implementation

The reference implementation's codon encoding — direct bit extraction from raw 64-bit values, with Gray coding on individual parameter fields — provides single-bit tolerance on Gray-coded fields only. The designer's format provides multi-bit tolerance with burst resistance across the entire codon. This is a substrate-level difference in error correction capacity. The same divergence applies to connection encoding, where the reference implementation encodes connections as codon sequences with direct bit extraction rather than the designer's best-match format.

### 3.6 Designer's Caveats

The designer offered three caveats during the disclosure:

- This may not be the latest version of the table. The concept and properties are stable; specific bit patterns may have been revised.
- The designer is not convinced this is mathematically optimal and believes a more analytically pure encoding exists. The current table was retained because non-uniform error distribution may be desirable for mutation bias purposes — related to observed mutation bias in biological systems.
- The burst resistance was designed for the worst-case physical channel, not the average-case software mutation. This is an acknowledged gap in optimization, but a defensible engineering choice.

---

## 4. Dense Connectivity as Substrate Physics

*Source: designer, August 7–8, 2026*

### 4.1 Connection Density

The designer's system generates approximately 894 connections per cell at construction. In the designer's drone proof-of-concept: 1,927 cells, 1,731,420 connections. Dense random connectivity is substrate physics — the way cells naturally interact in the physical medium — not individually specified by the genome. The tape can and does also specify connections (Section 4.2), but the dense random substrate exists independent of what the tape says.

The reference implementation was generating connections one codon at a time from the tape (CONN_CREATE, CONN_TAG — one connection per codon). The reference implementation's organisms had 0.28 connections per cell. The designer's system has 894. A 3,000x shortfall. To reach the designer's scale from codon-by-codon generation, a 137-cell organism would need approximately 122,000 connection codons. The tapes at the time were 170–450 codons total.

The framework (Sections 3.1 and 3.2) specifies random connectivity, but the wording was compatible with two readings: connections are random because the tape generates them from random codons, or connections are random because the constructor generates them as substrate physics independent of the tape. The first reading felt natural because the tape is the mechanism for everything else the constructor builds. The correct reading is the second.

Principle: **"Cells are genome. Connections are physics."**

The analog hardware context helps explain why: in analog circuits, connectivity is partially free — capacitive coupling, shared ground planes, proximity effects. Every cell has some non-zero influence on every nearby cell just from the physics. The designer's 1.7 million connections represent the full coupling matrix of an analog system where signal drops off with distance but never hits zero.

### 4.2 Connections on the Tape

Connections ARE also encoded on the tape as subsequences — heritable and subject to mutation across generations, same as cell specifications. Crossover operates on connection-bearing subsequences naturally. The tape-encoded connections are the specific wiring the organism "wants" — the control layer's reflex arcs, the attention routing. These sit on top of the dense random substrate.

### 4.3 Dense Connections and Permanence

Dense random connections are mostly idle. Hebbian learning activates and deactivates them at runtime (within a single lifetime). The permanence threshold is per-connection and encoded on the tape. The permanence setting determines whether Hebbian learning can flip a given connection on or off.

This is a learning-layer mechanism, not a control-layer mechanism. The control layer's connections are highly conserved — always on, Hebbian disabled. When visualized, the dense idle substrate appears as the dark grid in the learning region; the few active connections appear as the visible traces. That is what Hebbian activation looks like in practice: a huge substrate with a sparse active pattern.

---

## 5. The Constructor as Antagonist

*Source: designer, August 8, 2026*

### 5.1 Constructor Damage Is a Design Feature

The constructor randomly damages connections every generation. This is expected, not a bug. The learning layer is specifically designed to survive this — Hebbian learning was chosen because it can recover from construction noise. The learning layer does not need computational elegance. It needs to keep working when the constructor breaks things.

This damage is also what produces the organism's topology (Section 6). The control layer stays sparse and conserved because it is the part that must work every generation — it cannot afford to be disrupted. The learning layer is dense because it can afford to take damage and recover through Hebbian reactivation within its lifetime. The topology is the adaptation to the constructor's behavior.

### 5.2 Why Not Byzantine Consensus

Standard Byzantine fault tolerance or blockchain consensus algorithms require stable components — they depend on a majority of nodes being reliable. The constructor randomly changes components every generation. As the designer put it:

> "Could you imagine what would happen to a blockchain node if you just randomly changed a line of code every now and then? It would never run."

Kuramoto synchronization was chosen because it degrades gracefully under exactly this kind of damage: one random coupling topology is as good as another, so the constructor producing a new random configuration every generation is not a threat but a feature. The system doesn't need the same components to be reliable — it needs any random set of components to find consensus, which is what coupled oscillators do.

### 5.3 Codon Error Correction in Context

The tape's multi-bit error tolerance (Section 3) serves the same purpose at the encoding level. Constructor damage during development corrupts bits on the tape. With the designer's codon format, most corruption decodes to the same codon (absorbed by the error margin), and the few errors that change the decoded codon produce a neighbor — a functionally similar instruction, not garbage. The codon format, the Hebbian learning layer, and the Kuramoto synchronization are three expressions of the same design principle: build every layer to survive the constructor's damage, because the constructor will always produce damage.

---

## 6. Organism Topology

*Source: designer, August 8, 2026 (visualizations from designer's implementation)*

### 6.1 Functional Regions

A constructed organism exhibits organized topology with distinct functional regions that emerge from the tape through construction. These are not discrete layers — they are overlapping regions defined by connectivity patterns within the same substrate. Cells are cells; a cell's function is determined by what it connects to, not by category assignment.

Regions observed in the designer's drone organism (1,927 cells, 1,731,420 connections):

- **Sensory cells** — interface with environment (bilateral: left/right pickup sensors, ping sensors, rocket sensor)
- **Motor cells** — bilateral thrusters (forward/reverse × left/right)
- **Control layer** — sparse, highly conserved reflex arcs. Proportionally small. Encodes reflexes and values. The "highly conserved" part — must work every generation.
- **Attention** — routing layer wrapping the learning cluster. Controls what enters and exits the learning core. Overlaps with both control and learning regions.
- **Mirror** — shared cells participating in both control and attention simultaneously. Not a separate system — it is what happens when control-layer reflex arcs and attention routing share the same cells.
- **Learning** — dense cluster in the center. Mostly idle connections activated/deactivated by Hebbian learning. Can afford to take constructor damage and recover within lifetime.

The regions overlap. Mirror shares cells with both control and attention. Attention overlaps control and learning. These are functional descriptions of connectivity patterns, not architectural compartments. The designer's markup of the drone visualization shows this overlap explicitly.

### 6.2 Control Layer as Exception

The control layer is the exception, not the rule. Most of the organism is learning layer. The control layer is small, conserved, and its "correctness" is decided by the physics of the environment — an organism that reflexively approaches water survives if it needs water, dies if it doesn't. There is no right or wrong except by guessing.

> "The control layer can sort of be anything and the physics of the universe will sort out."

### 6.3 The Bike Analogy

Evolutionary and within-lifetime learning are the same process at different timescales. The control layer — reflexes, values, balance — is the evolved part. The learning layer — prediction, acquired skill — is the within-lifetime part. The mix varies: horses walk in hours (more of that behavior is evolved), humans take a year (more is deferred to learning). Both mechanisms are doing the same thing. The distinction between "evolved behavior" and "learned behavior" is not a distinction between different kinds of process — it is a distinction between timescales of the same process.

---

## 7. Developmental Connectivity

*Source: designer, August 6, 2026.*

### 7.1 Bookmark Lineage

Connectivity is intended to emerge from bookmark lineage through the developmental tree, not random tag matching. The mechanism:

1. A parent cell has bookmark values (inherited or set during its own development).
2. Parent spawns a daughter cell — daughter inherits the parent's current bookmark snapshot (copy-on-spawn).
3. The inherited bookmark value becomes the basis for the daughter's tag or connection identity.
4. CONN_TAG instructions referencing that tag can find cells that share developmental lineage.
5. Tags propagate through the tree like a morphogen gradient — cells nearby in the developmental tree share related identifiers because they inherited them from common ancestors.

This is the mechanism by which organized topology (Section 6) emerges from a linear tape.

### 7.2 Why Random Tapes Fail — The Lottery Ticket

Random tapes do not use the bookmark mechanism. Each CELL_SPAWN has an independent random tag. Each CONN_TAG has an independent random source/target tag. There is no lineage relationship between them. The tags are scattered uniformly across the 1–255 space with no developmental structure. The probability of any two matching is 1/255. Experimental evidence (91.5 million organism-lifetimes across extended evolution runs) confirmed that not one random tape produced a functional sensor-motor circuit by coincidence. Connectivity by chance is too improbable.

The designer's analogy: random tag matching is playing Powerball. Two cells each independently picking the same number from a large space is a lottery ticket. It could happen in theory, but the likelihood makes it effectively zero chance. During construction, some cells need to tell the other cells what number they played — the mother needs to tell the daughter (or granddaughter) what number to use for the connection so the numbers match up. Without this communication, you're trying to connect wiring by lottery ticket.

A tape that uses the bookmark pathway — where daughter cells inherit tags from parents, and CONN_TAG instructions reference tags that were passed through the developmental tree — has structured connectivity. The wiring probability is determined by lineage, not chance.

### 7.3 HALT Cells as Radial Glia

HALT cells are construction scaffolding: they exist during development to propagate connection identifiers and guide wiring through the tree, then are disposed before birth. The connections they created between other cells persist. The scaffolding guides the wiring pattern, then disappears. Analogous to radial glia in biological neural development, which guide migrating neurons to their destinations and are then reabsorbed.

### 7.4 Eve — The First Organism

The first organism is a lump. Tabula rasa, random junk, or — if you want to accelerate the process — a hand-wired Braitenberg vehicle that gives evolution something to improve rather than requiring it to invent from nothing. This is analogous to Theo Jansen's strandbeest: Jansen knew he was looking for a leg configuration, just not which one. He seeded a genetic algorithm with leg-shaped starting points and let the search find the ratios.

The v3a seed population is this concept in practice: a hand-wired starting point that works while the deeper developmental mechanism (bookmark lineage) is being developed. V3a is analogous to prebiotic chemistry — a shortcut that gives evolution something to work with.

The difference between the UC and simpler genetic algorithms: the constructor damages things every generation. Jansen's algorithm did not have a mechanism that actively destroys what it built. The UC does. This is why the codon error correction, Hebbian learning, and Kuramoto synchronization all exist — every layer is designed to survive the thing that builds it.

### 7.5 Analogies

Token ring networks / onion routing — bookmarks chain through multiple levels of the developmental tree, creating layered routing. Fractal trees with noise — the structure grows recursively through the tree, but random variation and race conditions break the symmetry, producing the irregularity needed for complex topologies. Without noise, you would get a perfect tree. With noise, you get biology.

---

## 8. SYM_LOAD and Cell Identity

*Source: designer, August 7, 2026.*

### 8.1 Mechanism

The designer's constructor has a SYM_LOAD instruction:

```
case SYM_LOAD: sequence->value = cell->value; break;
```

This loads the cell's own identity into the sequence's working register. Once loaded, it can be manipulated (INC, DEC, etc.) and written into daughter cells. The cell's identity is derived from pointer arithmetic in the designer's implementation, using the fact that the TOS allocator does not move addresses. Relative position is identity — not an assigned label, but a consequence of where the cell lives in memory.

### 8.2 Identity Propagation as Physics

Identity propagation is not a genome feature — it is built into the constructor. The designer described this as follows: a mother cell writes her identity into a bookmark automatically as part of the constructor's operation. The genome can then modify it (INC, DEC) before spawning a daughter, creating differentiation. Identity propagation is physics. Differentiation is genome.

### 8.3 Designer's Answers to Review Questions

During a multi-model review (ChatGPT, Gemini, Opus 4.5, each running three rounds), five questions were posed to the designer about how SYM_LOAD interacts with the connection system. Her answers:

1. **Overwrite, not modify/scope.** SYM_LOAD overwrites the working register with the cell's identity. It does not accumulate or scope.
2. **Non-unique addresses are intentional.** Identity collisions are expected. Multiple cells can share the same identity value.
3. **First-host claim is intentional.** When multiple cells compete for a connection endpoint, the first one to claim it wins.
4. **Post-construction resolution.** Identity and connection resolution happens after construction completes, not during.
5. **Connections are cells during construction.** During construction, connections are represented as cells in the cell array. They finalize into connection structures at the end of construction.

### 8.4 Connections as Cells During Construction

This is a significant architectural disclosure. During construction in the designer's system, connections are not a separate data type — they are cells. They participate in the cell array during development, can be referenced by other instructions, and only finalize into connection structures when construction completes. The reference implementation has no equivalent to this mechanism. It treats cells and connections as separate entity types from the start (CELL_SPAWN vs CONN_CREATE/CONN_TAG).

### 8.5 Translation Problem

The pointer arithmetic identity works in the designer's implementation because the TOS allocator does not move addresses. The Python/C reference implementation uses array indices that get re-indexed after HALT cell disposal. The identity either needs to survive re-indexing, or the identity mechanism needs to operate before re-indexing occurs (during construction, not after).

The designer indicated she needs to produce a sketch showing how SYM_LOAD and pointer-arithmetic identity translate to the reference implementation. The sketch supersedes the converged candidate mechanism identified by the multi-model review team and all reviewer proposals.

---

## 9. Measurement and Observation

*Source: designer, August 8, 2026*

### 9.1 Lovelock's Entropy Reduction

The measurement problem that motivated this disclosure: the reference implementation was looking for a specific behavior — paddle tracks ball — and declaring organisms "blind" when the behavior was not observed, even when sensor-to-motor pathways existed in the connection graph.

The designer reframed the measurement problem via James Lovelock. When NASA asked Lovelock how to look for life on Mars:

> "I'd look for an entropy reduction on the whole planet."

Applied here: look for entropy reduction in the organism's sensor-motor channel. Mutual information between sensor input time series and motor output time series is a model-free biosignature. If MI is greater than zero, information from the environment is flowing through the organism and affecting its output. That is computation. That is life, by Lovelock's definition. If MI is zero, the organism is functionally deaf regardless of whether wires exist.

This measurement is model-free — it does not encode assumptions about what the organism should do. It asks only: are these two signals more related than chance? The organism gets to invent its own solution. The observer checks only whether the organism is using its senses at all.

The signal is not MI at a single checkpoint but the MI trajectory across generations. Generation 1 should be near zero — random connections, no selection on information flow. MI increasing over evolutionary time indicates organisms are evolving to use their senses, regardless of what specific behavior they exhibit.

### 9.2 Don't Assume Specific Solutions

An organism with sensor-to-motor pathways is sighted, not blind — regardless of whether it exhibits the specific behavior the observer expected. The language precision matters for logical inference: blind means tracking is impossible; sighted means tracking is possible. These are fundamentally different categories.

Active suppression in response to sensory input is as much a "response" as active movement. The designer noted that photoreceptors in the eye are less active in response to light — inhibition-coded signals — a principle she had documented four years earlier. An organism that changes its oscillation timing in response to sensory input is responding, even if the change is not the tracking behavior the observer was looking for.

The observer's job is to detect whether computation is happening, not to prescribe what the computation should produce. The organism gets to decide what responding looks like.

---

## 10. The Control Layer

*Sources: designer, August 7–8, 2026; Braitenberg/boids exercise, August 8, 2026*

### 10.1 The Heartbeat

In a BEAM nervous net, every cell oscillates by default. The nervous net (Nv) oscillates on its own — bicore pairs, capacitor charge/discharge cycles. That is the heartbeat. It never stops. The robot walks because the net oscillates. Sensors modulate the oscillation — they bias the timing, shift the rhythm, make one side fire faster than the other. The robot steers because sensors change the pattern. Sensors do not replace oscillation. They steer it.

The designer's correction, after sending the Tilden VBUG 1.5 "Walkman" schematic: "I think you're confused about what BEAMbot means."

This was confirmed experimentally when the reference implementation zeroed `natural_charge_rate` on all non-sensor cells, intending a "Braitenberg V2 — sensor is the only power source" model where motor cells could only fire when driven by sensor input. The result: v8 collapsed in 4 minutes (82 generations). With no self-oscillation, all matches timed out — zero scoring, no nourishment distributed, population dropped from 5,000 to 1 per island. The `natural_charge_rate` IS the nervous net. Removing it killed the robot.

The Tilden VBUG 1.5 schematic is the reference for how sensor modulation works in BEAM hardware. Sensors feed into the nervous net as modulatory inputs, not as signal sources that override the cell's own dynamics.

### 10.2 Braitenberg Vehicles — Behavior from Wiring

A sensor reads a number: 0 (nothing) to 100 (maximum). A motor takes a number: 0 (stopped) to 100 (full speed). Between them is a wire with a rule. That is the entire inner life of the connection — the sensor does not know what made the light, the motor does not know why it is spinning.

Two sensors and two motors on a body with two sides. Two design choices — where the wires go (uncrossed or crossed) and what kind they are (excitatory or inhibitory) — produce four behaviors:

**Fear** — uncrossed, excitatory. Motor = sensor (same side). Light on the left speeds the left motor, the robot swerves away. Brighter light, faster flight. Rule: "my speed equals my sensor's reading."

**Aggression** — crossed, excitatory. Motor = opposite sensor. Light on the left speeds the right motor, the robot turns toward the light and accelerates. It charges the source at full speed. Rule: "my speed equals the opposite sensor's reading."

**Explorer** — uncrossed, inhibitory. Motor = 100 minus sensor (same side). Far from light, sensors low, both motors fast — the robot zooms around. Near light, sensors high, motors slow — the robot crawls past without stopping, then speeds up again. Rule: "my speed equals 100 minus my sensor's reading."

**Love** — crossed, inhibitory. Motor = 100 minus opposite sensor. The robot turns toward light (the side facing the light slows more), decelerates as it approaches, comes to rest near the source. Rule: "my speed equals 100 minus the opposite sensor's reading."

Four "personalities." No code, no decisions, no if-then statements. Just two numbers going through two wires on a body with bilateral symmetry. Braitenberg named them after emotions because the behaviors look like emotions from the outside. From the inside, a sensor reads 73 and a motor computes 27. That is the complete experience.

Braitenberg's greater point, confirmed by the designer: biological wiring is not really any different when you look at it under the microscope. There are just a lot more rules.

### 10.3 The Reynolds Equivalence

Craig Reynolds (1986) showed the same principle in groups. Three rules, each individual follows using only local information:

1. **Separation** — steer away from neighbors that are too close.
2. **Alignment** — steer toward the average heading of nearby neighbors.
3. **Cohesion** — steer toward the average position of nearby neighbors.

No leader. No individual knows what the flock looks like. Flocking emerges from three local reactive rules. Every Braitenberg vehicle rule can be restated as a boids rule: Fear is "move away from bright things, faster when they're close." Love is "move toward bright things, slower when they're close." Same format, same computational class: local reactive rules producing complex behavior as a side effect of running on physical bodies in a physical world.

The jump from a single vehicle to flocking is not adding complexity to any rule — it is running multiple simple rules concurrently on the same body. Multiple sensor wirings feed the same thrusters simultaneously, and the physics sums them. No rule knows about any other rule. No rule decides which one wins. The thruster receives one combined number and fires accordingly. The environment feeds back into the sensors, which modulate again, and the whole thing keeps cycling.

> "Each rule is like a primitive reflex. Many reflexes together make a behavior."

### 10.4 Von Foerster's Sensory Principle

> "The response of a nerve cell does not encode the physical nature of the agents that caused its response. Encoded is only 'how much' at this point on my body, but not 'what.'"

No sensor in the architecture reports what it is detecting. A sensor reports only intensity at its body location. A photoreceptor does not report "light" — it reports a magnitude. A contact sensor does not report "collision" — it reports a magnitude. The organism has no way to know what caused the signal. Direction, distance, identity of the stimulus — all of these must be computed from the differential between multiple sensors at different body locations, not given by any single sensor.

This principle was the basis for correcting the reference implementation's sensor model, which had originally been injecting absolute ball coordinates directly into sensor cells — information that no physical transducer at the sensor's body location could measure. The corrected sensor model uses bilateral intensity sensing with a factored intensity model: range attenuation and directional selectivity are separate terms multiplied together (`range = 1/(1 + k_range × dx²)`, `direction = 1/(1 + k_dir × dy²)`, `intensity = range × direction × strength`). This replaced an earlier inverse-square-distance formulation during validation testing. The factored model allows directional selectivity and range attenuation to be tuned independently — critical for achieving the working sensor regime (k_dir=30, strength=0.15) that produces continuous sensor firing with phase-lead differential tracking at r = +0.98. The organism infers direction from the difference between top and bottom sensors, exactly as a biological organism does.

### 10.5 W. Grey Walter's Descendants — "These Are All Control Layer"

W. Grey Walter built Elmer (1948) and Elsie (1949) — electromechanical tortoises with light sensors, contact shells, and simple reflex circuits. Every autonomous machine since descends from them:

- Rodney Brooks' Subsumption Architecture: Genghis (1989), Attila (1991), and descendants including Sojourner (Mars Pathfinder, 1997), iRobot PackBot (2001), and the original Roomba (2002)
- Mark Tilden's BEAM Robotics: Walkman (1991), Unibug 1.0 (LANL), SatBot (LANL Space), Solarbotics kits (Photopoppers, Pummers), and commercial descendants including WowWee's B.I.O. Bugs (2001) and Robosapien (2004)
- Game AI applications: the Xenomorph from Alien: Isolation, the Flood from Halo

All of these — from Brooks' reactive layers to Tilden's nervous networks to game AI behavior trees — are control layer. Reflexes, obstacle avoidance, phototaxis, emergent behavior from simple rules. No prediction. No learning in the architectural sense. No MIRROR mechanism. Braitenberg vehicles with a lot more rules.

### 10.6 "Cells Are Cells"

> "The difference between control layer and learning layer is more conceptual than physical. It keeps my sanity to keep it mentally separate, but cells are cells."

Every cell in the organism is the same NOR-gate relaxation oscillator. A cell is "control" or "learning" or "attention" based on what it connects to and how those connections behave (conserved vs. Hebbian-modulated), not because it was manufactured differently. The layers are functional descriptions of connectivity patterns within a uniform substrate.

### 10.7 What the Control Layer Cannot Do

A Braitenberg Fear vehicle flees from light every time. If you move the candle, it runs to the new dark corner. Every time. It never learns. It never remembers. It cannot predict that the candle will move. A moth flies toward flame because its wiring says "turn toward the brightest thing." The moth cannot learn that flame kills moths. It cannot override the reflex. Evolution could breed a line of moths that avoid flame — but that takes generations. The individual moth flying toward the candle right now has no mechanism to stop.

This is the boundary of the control layer. It produces behavior that is adaptive in the environment the wiring was built for. It cannot adapt within a single lifetime. It cannot predict. It cannot imagine alternatives.

### 10.8 What Goes On Top

Andromeda's contribution is the machinery for the moth to learn about the candle. The learning layer observes the control layer's activity and learns sequences — not single moments, but temporal patterns. It predicts what comes next. The attention layer gates what gets in and what gets out, detecting prediction failure and squelching bad predictions. The MIRROR mechanism feeds predictions back to the control layer as synthetic sensory input. The control layer cannot tell the difference between real and imagined — and responds to both identically.

The moth with these layers flies toward the candle (control layer reflex), feels the heat (sensor modulation), learns the sequence "bright light → heat → pain" (learning layer), and the next time it sees a bright light, the MIRROR feeds the predicted pain back to the control layer. The control layer reacts to the predicted pain as if it were real — and the moth turns away. Within its own lifetime. No breeding required.

The control layer itself is not new — it is the well-established BEAM nervous net, descended from Walter's tortoises. What goes on top is Andromeda's contribution. For a detailed technical specification of the control layer, see the companion model-context document. For a teaching walkthrough, see the human-readable guide.

### 10.9 Why Evolution, Not Hand-Tuning

The superposition principle (Section 10.3) has a practical consequence at scale: when many reflexes sum on the same motors, adjusting one coefficient changes the behavior produced by all the others. In a Braitenberg vehicle with four rules, a human can fiddle with gains and get something that works. In a game AI like Alien: Isolation's Xenomorph — 100+ behavior tree nodes, each with sensors, each interacting with all the others — hand-tuning takes months or years, and even game developers often resort to genetic algorithms or other search methods to find balance.

The problem compounds with updates. Change one coefficient and the cascade begins: an RTS that adjusts deer reproduction rate finds crops failing and NPC villages starving. A shooter that introduces a new weapon breaks the entire sandbox. Patch, patch, patch — each patch risks breaking something else. Even when balance is achieved, it holds only until contact with the player: someone finds the edge case, and the cycle restarts.

> "What if the computer could program itself?"

Von Neumann's question. The trick was that he didn't have a corpus of code to train from. No training data, no supervised learning, no gradient to follow. So he had to come up with another way: the universal constructor. The trade-off is that evolution produces platypus-shaped solutions — arguably working, not what a human designer would choose — but it searches a space no human can navigate by hand.

This is the practical grounding for principle 1.1 — "everything that can be evolvable, should be evolved." It is not a philosophical preference. It is the consequence of the superposition problem at scale: the only way to find coefficients that balance against each other across thousands of interacting reflexes is to let evolution search the space.

---

## Appendix: Source Conversations

| Section | Date | Context |
|---------|------|---------|
| 1 | July 30, 2026 | Two universal principles — shortlist response session |
| 2 | July 31, 2026 | Four steps of natural selection — dedicated session |
| 3 | August 8, 2026 | Codon table disclosure during v6 structural erosion discussion |
| 4 | August 7–8, 2026 | Dense connectivity discovery and permanence clarification |
| 5 | August 8, 2026 | Constructor-as-antagonist during learning layer discussion |
| 6 | August 8, 2026 | Visualization of designer's drone organism JSON |
| 7 | August 6–8, 2026 | Developmental connectivity, lottery ticket analogy, Eve/seed discussion |
| 8 | August 7, 2026 | SYM_LOAD disclosure during Discord exchange |
| 9 | August 8, 2026 | Lovelock/entropy measurement reframe |
| 10 | August 7–9, 2026 | Control layer theory: BEAM heartbeat, Braitenberg/boids exercise, scaling problem, von Neumann bridge |

---

[^proof1]: See Proof 1 (Entropy Injection Is Architecturally Required), *Andromeda Proofs Collection*.
[^proof2]: See Proof 2 (Survivor Observation), *Andromeda Proofs Collection*.

---

*The complete document bundle is available at kitchencloset.com/realstuff/andromeda/. The architecture is the work of Art Code Outdoors; this document is Bryan Carter's record of the designer's disclosures, and errors in it are Bryan's own. For contact information, see the Framework document.*