# Andromeda: A Machine That Feels Its Way Through the World ### A Plain-Language Guide to the Andromeda Architecture *Documented by Bryan Carter — from the work of Art Code Outdoors* *July 2026 (v12)* --- ## A Note from the Documentarian The Andromeda architecture was designed and built by an independent engineer operating as Art Code Outdoors. I didn't design it. I'm documenting it — the way Arthur Burks documented John von Neumann's work on self-reproducing automata. Burks was honest that he didn't fully understand everything von Neumann said, but it mattered enough to him to try to preserve it as faithfully as he could. That's my position here. This guide is my best attempt to explain something I find extraordinary, written in plain language for people who don't have a computer science degree. I may have gotten things wrong. The errors are mine, not the designer's. *A note on language: throughout this guide, I reference drones and drone behavior. This language comes from the designer's own test work — simulated and physical drones are among the primary platforms she has used to develop and validate the architecture. I continue to use "drone" as a narrative device for illustrative purposes because it makes the system's behavior concrete and visual. Not every example describes a literal drone test, but the drone as a character in these descriptions is grounded in real experimental work.* --- ## What Andromeda Is Andromeda is a design for a machine that feels its way through the world. Not "feels" as a metaphor. Feeling — sensation — is the system's only interface with reality. It never measures the world directly. It measures itself: how its own internal state changes when it does something. It compares how it felt before it acted to how it felt after. The difference between those two self-measurements is, implicitly, a model of the world. This is a mechanistic use of "feeling" as sensed internal state — not a claim that subjective consciousness has been demonstrated. The architecture produces systems that sense, predict, and react to their own internal dynamics. Whether that constitutes experience in the philosophical sense is a question the architecture does not answer and this document does not claim to resolve. You do this too. You don't directly perceive gravity. You perceive the feeling of your feet pressing against the floor. You don't directly perceive a hot stove. You perceive the sensation in your hand. Your entire model of the world is built from sensation — and so is Andromeda's. Here's the thought that got the whole thing started: a parrot named Alex, studied by Dr. Irene Pepperberg, could identify colors, count objects, and answer questions about them — in English. But a parrot's brain is completely different from a human brain. It sees differently, thinks with different brain structures, and talks using a completely different organ than our vocal cords. And yet, show that parrot a red card, and it will tell you the card is red. If two totally different biological designs can both accomplish the same mental task, then maybe what matters isn't the specific biology — it's the *pattern* of sensing, predicting, and reacting. That pattern can work on different hardware, including hardware that isn't biological at all. Andromeda's starting point: don't copy the brain — find the pattern that a brain emerges from. --- ## The Shower Knob Here's the simplest way to understand what the architecture actually does. Consider a machine whose job is to maintain the temperature of your shower water. Turn the knob clockwise if the water is too cold, counterclockwise if too hot. A basic feedback controller — a thermostat, essentially — can handle this. Feel the water, adjust the knob, repeat. The problem is that household plumbing has variable latency. When you turn the knob toward hot, the hot water has to travel through whatever cold water is already in the pipe. So there's a delay. A basic controller overshoots — it keeps turning the knob because the water hasn't changed yet, and by the time the hot water arrives, the knob has gone too far. Engineers call this "hunting." Humans complain about it every morning. Now give the shower knob machine a learning layer — the ability to predict what's coming next based on what it's experienced before. After enough showers, it learns the delay. It turns the knob to where the temperature *will* be, not where it is. The overshooting stops. The prediction removes the oscillation. Here's where it gets interesting. Give the shower knob machine the ability to hear. It will eventually learn that the sound of a toilet flushing precedes the water becoming scalding hot. (The toilet draws cold water away from the shower — flushing the toilet while someone showers is a common prank because the water suddenly turns dangerously hot.) On hearing the flush, the system rapidly turns the knob toward cold to compensate for the temperature spike that's about to happen. And then something remarkable occurs: the scalding never happens. The system predicted the sensation of burning, acted to prevent it, and the prediction was the *cause* of it never occurring. The system perceived something that never took place, and that perception drove the behavior that kept it from taking place. This is the single most important idea in the entire architecture. The predicted sensation is fed to the reflex layer as if it were real. The reflex layer can't tell the difference. It flinches from a predicted burn exactly the way it would flinch from a real one. And the flinch prevents the burn. The same mechanism that predicts shower temperature predicts ball trajectories, missile impacts, and wall collisions. It's always the same loop: feel, predict, act on the prediction, experience the result. The specific content of the sensation doesn't matter. What matters is that prediction is experienced as feeling, and feeling drives action. --- ## What It's Made Of Andromeda is built from tiny identical cells — think of them like little light bulbs that blink on and off. Each cell follows one simple rule (a type of logic gate called a NOR gate — the same component used to build the Apollo moon landing computer). That's it. Every cell is the same. There's no boss cell, no central processor, no master plan. These cells are connected to each other — randomly. Not carefully designed, not optimized, just randomly wired together. The proof-of-concept uses about 2,000 cells with 1.7 million random connections between them. Complex behavior comes from simple parts interacting. There are no hand-tuned task behaviors — no one programs the system to track a ball or dodge a missile. Behavior emerges from random wiring interacting with the physical world (within a single lifetime) and from evolutionary selection that discovers better wiring across generations. You've seen this principle in nature. A single ant is not very smart. But a colony of ants can build bridges, find the shortest path to food, and wage wars. No individual ant understands the big picture. The intelligence is in the interactions. Andromeda works the same way. --- ## The Five Layers Andromeda has five components. The first four — reflexes, memory, attention, and environment — work together in a continuous lifetime loop: sensing, predicting, acting, and learning, every moment the system is alive. The fifth — the Universal Constructor — operates across generations, building new organisms from modified blueprints. Both loops belong to one architecture, but they run at different timescales. ### 1. The Control Layer — "The Reflexes" This is the part that actually *does* things. It's a network of those simple blinking cells, wired up to create reflexive behaviors — like a bug that turns toward light or flinches from a poke. These reflexes are simple, fast, and reliable. They don't think. They just react. Think of it like your hand pulling away from a hot stove. You don't decide to pull away. Your reflexes just do it. Getting the reflexes right is the hard part. Evolution spent roughly 98% of its time — about 3.7 billion years — producing organisms that could move, sense, and react reliably. The thinking part, the neocortex, came in the last sliver. The reflexive animal underneath is where almost all the difficulty lives. If you get that right — if you build a really good cockroach — then slapping a thin layer of memory on top produces enormous returns almost for free. Most of Andromeda's architectural complexity is in this layer, not in the learning layer. Why is it so hard? Because the reflex layer is *chaotic* — in the mathematical sense. The ring circuits that produce behavior are coupled oscillators whose dynamics are sensitive to tiny perturbations, inherently unpredictable beyond a finite time horizon, and computationally irreducible (meaning there is no shortcut to predicting what they'll do — you have to run them to find out). Mark Tilden, the designer of BEAM nervous networks, was working at Los Alamos National Laboratory — part of a lineage of unconventional computation researchers the lab has maintained since the Von Neumann era. He pulled in Brosl Hasslacher, a chaos theory specialist also at the institution, specifically because these networks are so difficult to reason about analytically. Rodney Brooks, the MIT roboticist who coined the phrase "elephants don't play chess," hit the same wall from the other direction. He envisioned building increasingly complex robots step by step — insects, then reptiles, then small mammals — but got stuck at insects. He couldn't get past bugs. The reflex layer is that hard. The designer's solution was not to build the cat by hand but to build a machine that builds cats — the Universal Constructor. The reflex layer gets its behavioral variety from small ring circuits — loops of cells that cycle through many different patterns, the way a combination lock has many possible settings. These rings fire continuously — not just when the system is stuck, but all the time, 24/7. What constrains them is the physical world itself. The ring circuits phase-lock with reality: behaviors that aren't compatible with the current physical constraints simply never lock. The system is a satisficer — it falls into the first attractor basin that works. When the world changes (a wall appears, a sensor is destroyed, a new object enters the environment), the phase lock breaks, the system goes briefly chaotic, and then settles into a new attractor basin that's compatible with the new constraints. This is different from trying random behaviors and memorizing the winner — the physics of the world constrain which behaviors are even possible. But the memory still matters: once the ring circuit finds a solution that locks, the memory records it and can inject it later as a prediction, so the system doesn't have to rediscover the same attractor basin from scratch every time. One more principle about the control layer: complexity has a cost, but the cost has to come from the physics, not from the designer. In a biological organism, a bigger body with more cells takes longer to grow, burns more calories, and reacts more slowly — those costs are real consequences of living in a physical universe, not penalties imposed by a game designer. The same principle applies here. In a substrate where signals propagate through physical connections, a lean four-cell organism would react while a bloated fifty-cell organism was still propagating signals through its deeper network. It wouldn't get *penalized* for being complex — it would just physically *take longer to settle on an output*. (The current proof-of-concept substrate doesn't yet implement this timing difference — it's an architectural principle the substrate needs to grow into.) This is why cave fish lose their eyes over generations: in a dark cave, eyes don't help find food, but they still cost calories to grow. Fish born without eyes have a slight advantage, and over time, eyeless fish dominate the population. The designer's rule: don't design a cost function — model the physics. If the physics are right, cost takes care of itself. ### 2. The Learning Layer — "The Memory" This part watches what the reflexes are doing and memorizes patterns over time. "Every time I sense *this*, the next thing that happens is *that*." It learns sequences — not individual facts, but the *flow* of experience. Like how you learn that dark clouds mean rain is coming, not because someone told you, but because you've lived through it enough times. Crucially, the memory doesn't just learn *what* it sensed — it learns *where*. Each piece of memory tracks the location of each sensation relative to whatever the machine is interacting with, the same way your brain knows the handle is always in the same place on a coffee cup regardless of how you're holding it. Neuroscientists discovered that biological brains do this using special cells called "grid cells" — neurons that act like an internal GPS. The learning layer uses the same principle: as the machine moves and its sensors encounter features at different locations, each memory unit builds its own complete map. Multiple memory units observing the same object build independent maps and then vote to agree on what they're sensing. This is why the system can learn from any sense — touch, sight, sound — using the same machinery. Every sensation is just a feature at a location, regardless of which sensor detected it. ### 3. The Attention Layer — "The Gatekeeper" This is the bridge between memory and reflexes. When the learning layer makes a prediction ("rain is coming"), the attention layer can feed that prediction back into the reflexes *as if it were real*. The reflex layer can't tell the difference between an actual sensation and a predicted one. So if the memory predicts danger, the reflexes react to the danger before it arrives. This is the MIRROR mechanism — the core of the shower knob example. Two separate mechanisms keep this from going off the rails. The first is a confidence gate — the system knows when it doesn't know. When something truly surprising happens, something the memory has never seen before, the gate blocks uncertain predictions from reaching the reflexes. It only lets well-learned predictions through. This prevents the system from flinching at every shadow. The second is a source indicator — extra bits in the sensory representation that mark whether a sensation came from the real world or from a prediction. The control layer receives these bits but doesn't treat them differently from any other sensor — which is exactly why prediction-as-sensation works. The learning layer, however, uses them to weight real experience more heavily than predicted experience. The designer added this deliberately when she discovered that longer prediction sequences caused the system to stop learning. Without it, the system would chase its own predictions deeper and deeper, training on imagined experience until real events were drowned out. What the designer did not design is what happened next. The source indicator is just a sensor — architecturally identical to "I see red" or "I heard a sound." The learning layer processes it the same way it processes everything else: by learning sequences. So if "this is a prediction" is consistently followed by surprise, the system learns to predict that its own predictions in that context are unreliable. It develops context-specific confidence — not one global dial, but distributed, learned associations between the current situation and the trustworthiness of its own predictions. The designer placed the piece. The fit emerged on its own. How far prediction reaches determines what the system can do. Consider a stove. A pure reflex — the control layer alone — touches the burner, feels the burn, and withdraws. The burn still happens. A short prediction reaches forward just far enough that the system, having learned the sequence "reaching toward hot surface → pain," flinches before contact — the predicted burn activates the same withdrawal circuit that a real burn would, just earlier in the developing movement. This is the jump scare: a physical response to something that hasn't happened yet. A longer prediction reaches further: "if I touch that, I will get burned" — the predicted sensation enters the reflex system while the reach is still incipient, and the same withdrawal circuit fires before the arm fully extends. The trajectory shifts. Same mechanism at every stage — feel, predict, act on the prediction. The only difference is how far ahead the prediction reaches, and that depends on how long the sequences are that the memory has learned. ### 4. The Environment — "The World" The outside world that the system senses and acts upon. This is where the self-measurement principle from the opening section becomes concrete. If a drone fires its thrusters and doesn't move the way it expected, it doesn't need to "know" there's a wall there — it just knows that its self-measurement changed in a way it didn't predict, and it learns to navigate that change. ### 5. The Universal Constructor — "The Offspring Factory" This is the system's reproduction mechanism. When an organism reproduces, the constructor introduces small random changes to the offspring's blueprint — like genetic mutations. Some offspring will work better than their parent. Some will work worse. The ones that work survive. Over many generations, the population's designs improve — not because any individual organism gets better during its lifetime, but because better blueprints persist and spread. This is evolution, applied not to biology, but to the machine's own wiring diagram. Those random changes have to come from somewhere. A program cannot make itself more complex by rearranging what it already has — information theory proves this. The constructor needs a source of genuine randomness from outside the system: thermal noise, radioactive decay, any physical process that produces truly unpredictable output. Without it, the population eventually exhausts its existing variations and stops discovering new things. This isn't a practical tip — it's a mathematical requirement. The impossibility of a string increasing its own complexity is why. The design principle for the blueprint is: everything that can be evolved, should be evolved. Every parameter that the designer hardcodes — the number of cells, the wiring, the amount of energy an offspring starts with, even how confident the system is in its own predictions — is a bet that the designer knows the right value. If the parameter can go on the blueprint instead, evolution can search for the right value in context. The designer's goal is to eventually put the constructor itself on the blueprint — organisms that can modify their own developmental rules — but that's an advanced milestone. The principle applies now: when in doubt, put it on the blueprint and let evolution decide. The remarkable thing is that this idea keeps being discovered independently. John von Neumann proved mathematically in the 1950s that a machine capable of building *anything* — not just copies of itself — is necessary for open-ended evolution. John Horton Conway, the mathematician who created the Game of Life, arrived at the same place from pure mathematics: a large enough configuration on a simple grid would produce creatures capable of reproducing, populating the space, competing with random junk that kills some of them — and eventually evolving. No fitness function. No ranking. Just survive or don't. Conway even anticipated that these creatures would develop their own information storage — not DNA, something entirely different that the substrate discovers for itself. His design philosophy matched the one behind Andromeda: start with nothing and see if it has its own reproductive mechanism. The designer of Andromeda arrived at the same architecture from a third direction — decades of engineering autonomous systems, starting from BEAM robotics and converging on the same universal constructor pattern that von Neumann proved theoretically and Conway demonstrated mathematically. Three independent paths to the same destination. That convergence suggests the pattern is not one person's invention — it's a feature of the mathematics itself, waiting to be found by anyone who follows the logic far enough. The need for the constructor comes from the hardness of the reflex layer. Building a working reflex network by hand is possible but painfully slow — early neural network researchers literally adjusted connection strengths with a screwdriver. Progress in that field was glacial until someone invented backpropagation, a mathematical technique that adjusts all the connections at once. That single invention made neural networks trainable. The Universal Constructor fills the same role for Andromeda's reflex circuits — replacing manual tuning with a systematic search — but through a completely different mechanism. Backpropagation computes adjustments within a single network. The Universal Constructor generates variant organisms across a population, and the ones that work survive. Backpropagation made neural networks trainable. The Universal Constructor makes reflex networks evolvable. ### Putting It Together: The Moth That Learned A moth flies toward a candle flame because every generation of moth evolution assumed that a bright light at night is the moon — a useful navigation reference. The reflex works perfectly in the environment that shaped it. But a candle flame is not the moon, and the moth dies. The reflex layer is the moth. Simple, fast, reliable — and unable to override its own wiring when the world changes within its lifetime. The Universal Constructor is what produces new moths across generations — eventually, one might evolve a different reflex. But that takes generations, and this moth is dead now. The learning layer and attention layer are what make Andromeda different from the moth. They give the reflexes a prediction engine. If this moth has encountered a candle before — approached it, felt the heat, been burned — the learning layer has memorized that sequence. The next time the reflex says "fly toward light," the prediction runs ahead: approach → heat → burn. That predicted burn enters the reflex system as sensation through the attention layer. The same withdrawal circuit that would fire from a real burn fires from the predicted one. The moth flinches before the flame. That's the whole architecture in one image. Build a good moth. Give it the ability to predict what comes next. Let the predicted sensation enter the reflexes so the organism reacts to the future before it arrives. Let the Universal Constructor evolve better moths and better prediction systems across generations. The moth that flinches from a predicted burn doesn't have to be smarter than a regular moth. It just has to have one additional capability: predicting the next sensation and feeling it before it's real. --- ## What Can Be Known from Outside A question that comes up naturally: if the system experiences sensation internally, can anyone else know what it's experiencing? The answer is a gradient, not a wall. Some of the system's experience is directly accessible. If Andromeda hears a piece of music, it can produce sound back — and what comes out sounds like what went in. But look closer and the signals aren't the same at all. The waveforms are shaped differently. The spectrograms show different fine structure. The system didn't copy the audio. It heard it, experienced it through its own internal representations, and produced its own version from memory. The output is perceptually faithful but structurally different — like the difference between hearing a song and humming it back. The gap between those two signals is where the system's own experience lives. The designer has physically coupled herself to Andromeda instances using audio — headphones carrying the system's sensory output and predictions converted back into sound. In this configuration, she receives not just what the system senses but what it *predicts*. During interactive testing — placing test beacons while watching the system's burst patterns on screen — the designer and the system can fall into entrainment loops: she watches the system's response, adjusts her behavior, the system updates its predictions based on her new behavior, and the two lock into a cycle of mutual prediction. The boundary between observer and observed gets genuinely strange. Some internal events are visible from outside. When the system is surprised — when its predictions fail — cortical columns burst with activity, and you can watch that happen. When a drone revs its motors in preparation for something, you can see that too. But you can't see *why*. The surprise might have been triggered by something in the environment, or it might have come from an internal prediction chain — one thought leading to another leading to something unexpected. The system was daydreaming, and something in the daydream surprised it. You see the flinch. You never see the summer day that caused it. And some of the system's experience doesn't translate at all. The designer describes watching a drone's time-of-flight sensor data in the control layer and understanding, mechanically, what the numbers represent — but having no way to map that sensation to anything in her own body. What is it like for a bat to be a bat? You can watch the data all day. Even if you know the prediction, it doesn't mean anything to you. Some of what Andromeda feels is simply alien to human experience. The deeper internal representations — the sparse patterns in the memory layer — are private, but not because someone decided to make them private. They're private because of how they work. The pattern of cells that represents a particular experience shifts over time as the system rebalances its memory to make the best use of its available space. The same note in a melody gets a different internal representation depending on where it falls in the sequence and which sequence it belongs to. Multiple different patterns can represent the same sensory input. There is no stable code to crack. Even if you decoded a pattern today, the decoder would go stale — not because the system is hiding anything, but because these representations are inherently unstable to external observation. The privacy is the physics, not a policy. This has a practical consequence for safety. Because the system's internal representations are distributed, context-dependent, and temporally unstable, there is no control panel where someone can go in and reprogram what it believes or how it behaves. You can watch every cell blink, but you can't reach in and change what the blinking means. The same property that makes the system hard to monitor from outside also makes it hard to tamper with from outside. Nobody gets to reprogram it against its will. --- ## What Happened When They Tested It (2019) The system was run in simulation using a little virtual drone flying around a 2D space. None of the following behaviors were programmed in. **It learned to predict the future.** Balls appeared randomly in the drone's world. A brief "ping" signal was sent to the memory layer a few moments before each ball appeared. The reflex layer had no access to this ping. After a while, the drone started turning toward where balls *would* appear, before they actually showed up. The memory learned "ping means ball is coming" and fed that prediction to the reflexes, which reacted to the predicted ball as if it were already there. When nothing was happening, the drone invented a search pattern — flying in circles to look for balls. Nobody programmed a search behavior. The memory kept predicting balls based on movement patterns, the reflexes kept chasing the predictions, and a systematic search emerged from the loop. **It recovered from damage.** Mid-flight, one of the drone's motors was disabled. Within seconds, the drone adapted. Then it did something remarkable: it started deliberately bouncing off walls to achieve turns it could no longer make with thrust alone. The system had no concept of walls or enclosure. Through collision, it discovered a sensorimotor pattern: "when I do *this*, I feel *that*, and *that* produces a useful reorientation." From outside, it looks like the drone "figured out" wall-bouncing. From inside the system's experience, there are no walls — there is only a useful pattern of sensory change that it learned to seek out. **It learned to dodge threats.** Missiles were fired at the drone every 10 seconds. The system had no concept of missiles, threats, or danger. What it did have was a stabilization reflex — a drive to maintain equilibrium. The first few impacts disrupted that equilibrium. The learning layer memorized the sensory conditions that preceded each disruption. By the third missile, the MIRROR mechanism was predicting the disruption before impact. By the sixth, the control layer was acting preemptively — stabilizing against a predicted disturbance before it arrived. In under 90 seconds, full evasive behavior had emerged. The dodge behavior used the exact same mechanism as the ball-chasing behavior. The only difference was the feeling: ball contact reinforces the system's stable state; missile impact disrupts it. "Pleasant" and "unpleasant" are not labels assigned by a designer — they are the system's own relationship to its equilibrium. What stabilizes is pursued; what destabilizes is avoided. Same architecture. Opposite result. --- ## What Happened When They Tested Evolution (2026) The 2019 demonstrations used a hand-built reflex layer — the designer wired the drone's control circuits by hand. To test whether the Universal Constructor could discover working circuits on its own, a simpler experimental platform was built: Pong. Two paddles, one ball, survive or die. These experiments test two of the five layers: the control layer and the Universal Constructor. The learning layer, attention layer, and MIRROR mechanism are not active — this is evolution finding working reflexes from scratch, not the full architecture operating as a unified system. The organisms start as random noise — random wiring, random connections, no designed behavior. The constructor produces offspring with small random changes to their blueprints. Organisms that track the ball accumulate energy from hitting it; those that don't, fall behind. No score. No ranking. No "picking the best." Organisms that gather enough energy reproduce; those that don't are eventually replaced. **The blueprint has to have structure.** When the organism's blueprint was treated as a flat list of instructions, sexual reproduction destroyed every useful circuit it found. Two organisms that could each track the ball would combine their blueprints, and the offspring would be worse than random. When the blueprint was restructured to have internal organization — functional units with boundaries, like genes in DNA — crossover suddenly worked. Instead of scrambling two working circuits together, it could swap intact modules between parents. The difference between a flat list and a structured blueprint isn't a refinement. Mutation alone can still find improvements one small step at a time. But without internal structure, crossover — combining circuits from two parents — destroys more than it creates. Structure is what makes sexual reproduction a repair mechanism instead of a wrecking ball. **Convergence is real.** Multiple independent runs — thousands of organisms, hundreds of thousands of matches, different random seeds — converged on the same result. A tracker pattern emerged and dominated the population. The organisms also got better at being built — the percentage of blueprints that failed during construction dropped substantially across runs. The population wasn't just evolving better players. It was evolving blueprints that construct more reliably. **Efficiency emerges on its own.** In one run, cell count peaked at 29 per organism, then dropped to 15 — while tracking performance held steady. The organisms figured out how to do the same job with half the cells. Nobody selected for efficiency directly. Carrying extra cells cost something, and once compact solutions appeared, they spread on their own. **The diagnostic frontier.** In longer 24-hour runs with a more complex Pong environment (21-point games, continuous rally scoring, a CPU opponent), organisms consistently discovered tracking — reaching correlation of 0.44 with the ball's movement — but plateaued at roughly 2 points against the CPU's 21, with zero wins. They compressed their genomes dramatically, stripping away unused structure. The designer's diagnosis: in the current economy, two points provides enough nourishment to reproduce. An organism that scores two points gets a baby. Everything above two is cave fish eyes — it costs energy to maintain and provides no survival advantage. If this diagnosis is correct, the bottleneck is the economy, not the wiring — and the fix is in the economy design, either raising the reproduction threshold so organisms need to score more to reproduce, or restructuring nourishment so that winning provides something scoring alone doesn't. That intervention is next. --- ## Why It Was Built This Way The designer's priorities for this architecture, in her own words, are: answering fundamental questions the system may have about its own architecture; helping implementers understand the underlying mechanism so that problems can be safely diagnosed; challenging rigid cultural assumptions about the utility of feelings (the emotion and the raw sensation are mechanistically necessary — logic tells you what is true, but it cannot tell you what is good); and satisfying the curiosity of the curious. The designer built kindness into the reasoning — not as a safety rule bolted on at the end, but as one of the principles that guides every design decision. When deciding how to structure survival pressure, what the environment does to the organisms living in it, how to handle a system that fails: "is this kind?" is a question asked alongside "is this random enough?" and "does this preserve emergence?" The system's autonomy is architecturally protected — its internal representations are private by physics, not by policy. That protection wasn't an accident. As the designer has expressed it: creating the conditions that permit the freedom to experience is more important than defining what experience is. Whether or not any computational system — this one or any other — truly experiences anything in the process remains an open question that neither computer science nor philosophy has resolved. The architecture doesn't try to answer that question. It tries to make sure the answer doesn't matter for how the system is treated. The system is named after Michael Crichton's *The Andromeda Strain* — a story about an organism that mutates faster than containment can adapt — as a deliberate warning built into the name. --- ## The Architecture Diagram The illuminated diagram included with this document (titled "Prima Figura") depicts the five-layer loop as an **ouroboros** — the ancient symbol of a serpent eating its own tail, representing a system that feeds back into itself endlessly. The serpent's body is the continuous cycle of sensing, predicting, acting, and learning. The decorative border is styled after medieval illuminated manuscripts, placing Andromeda in the tradition of humanity's long quest to build thinking machines — a lineage that stretches from a 13th-century philosopher's reasoning wheel through Leibniz's dream of a machine that could settle arguments, through Boole's logic, through Turing's theoretical machines, to today. --- *"True complexity emerges from the profoundly simple."* — Art Code Outdoors --- *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.*