# Andromeda: A Different Kind of Artificial Intelligence ### A Plain-Language Guide to the Andromeda AI Architecture *Documented by Bryan Carter — from the work of Art Code Outdoors* *March 2026, revised May 2026 (v8)* --- ## A Note from the Documentarian The Andromeda architecture was designed and built by an independent AI researcher 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. The architecture has been under continuous development for years, and my notes span multiple generations of the designer's thinking — there is no single "current" version that I'm working from, and things I've written may be outdated or incomplete. The designer who inspired these documents can be reached at artcodeoutdoors@gmail.com for questions or discussion. --- ## What Is This About? A researcher has spent decades building a type of artificial intelligence that works nothing like ChatGPT, Siri, or any AI you've probably heard of. It's called **Andromeda**. It's not a chatbot. It's not an image generator. It's a design for a machine that learns the way simple creatures do — by feeling its way through the world, making predictions, and adapting when those predictions are wrong. This guide is my attempt to explain what it is, how it works, and why it matters — without requiring a computer science degree to follow along. --- ## The Big Idea: It's Not About the Hardware 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 (four types of color receptors instead of our three). It thinks with different brain structures. It 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. That's Andromeda's starting point: **don't copy the brain — copy what the brain** ***does***. --- ## How It's Different from Today's AI The AI systems making headlines right now (like the one you might be reading this from) are, at their core, very sophisticated pattern-matchers. They're trained on enormous amounts of data, they learn statistical relationships between words or pixels, and they get really good at predicting what comes next in a sequence. They're powerful, but they work like a student who has memorized every textbook — they can recall and recombine information, but they don't *experience* anything. Andromeda is a completely different animal. Here's a side-by-side: | | **Today's AI (like ChatGPT)** | **Andromeda** | |---|---|---| | **How it learns** | Trained on massive data, then mostly fixed | Learns continuously, never stops | | **What it optimizes** | A mathematical score (loss function) | Nothing — it just reacts | | **How it's programmed** | Code and algorithms | Wiring — like building a circuit | | **Can it modify itself?** | No | Yes — it can alter the blueprint for the next generation, not rewrite its own wiring mid-flight | | **Does it need a teacher?** | Yes (training data) | No — it learns from its own experience | | **What drives its behavior?** | Reward functions or prompts | Simple reflexes, like a bug turning toward light | The technical way to say this: today's AI systems are **function approximators** (they learn to draw curves that fit data). Andromeda is a **universal computing machine** (it runs programs). This distinction is debated in the AI field, but the Andromeda framework treats it as foundational — it's not a small difference, it's the difference between a calculator that can mimic handwriting and a machine that can genuinely write. --- ## The Building Blocks: Embarrassingly Simple 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. Here's the key insight: **complex behavior comes from simple parts interacting**. There are no hand-tuned knobs anywhere in the system — behavior emerges from random wiring plus selection (the configurations that work survive; the ones that don't are gone). 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 Parts Andromeda has five components that work together in a continuous loop — like a conversation that never stops: ### 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. Here's something that's easy to underestimate: **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. 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. When the system gets stuck or panicked, it doesn't run a single designed escape program. It fires one of these ring circuits, which rapidly cycles through its repertoire of possible motor patterns. Some won't help. But the ring has so many possible states that a useful one is likely to come up — and once it does, the memory layer records what worked. Next time, the system skips straight to the solution. One more principle about the control layer that's easy to overlook: **every cell costs energy to maintain.** A bigger organism with more cells burns more metabolic fuel just to exist. If extra cells aren't helping the organism survive, they're a liability — energy spent on useless circuitry is energy not available for moving and eating. 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 and maintain. Fish born without eyes have a slight energy advantage, and over time, eyeless fish dominate the population. The same principle applies here. The Universal Constructor can add or remove cells when it produces offspring, and evolution will find the smallest organism that does the job — not because small is "better," but because organisms that waste energy on unnecessary cells are more likely to starve. ### 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, keeping track of where you are relative to objects and spaces. The learning layer uses the same principle: as the machine moves and its sensors encounter different features at different locations, each memory unit builds its own complete map of the object. 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 clever 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. But here's the safety mechanism: when something truly surprising happens — something the memory has never seen before — the attention layer slams the brakes. It says "wait, I don't know what this is" and blocks the predictions from reaching the reflexes. This prevents the system from acting on bad guesses. It only lets confident, well-learned predictions through. As a bonus side effect, the system can tell the difference between "I'm remembering something" and "this is actually happening right now." It knows when it's daydreaming versus when it's perceiving reality. Nobody designed that feature — it just falls out of the engineering. One more thing about how this system works that matters for safety: because Andromeda's "thinking" is distributed across thousands of simple cells with millions of random connections, there is no control panel where someone can go in and reprogram what it believes or how it behaves. Today's AI systems can be adjusted from the inside — researchers can find specific patterns in the system's internals and push them in a desired direction. That's useful for making AI assistants more helpful, but it also means anyone with access to those internals can push them in *any* direction. Andromeda doesn't have that vulnerability. Its internals are opaque — you can watch every cell blink, but you can't reach in and change what the blinking means. That same property that makes it hard to monitor from outside also makes it hard to tamper with from outside. Nobody gets to go in and reprogram it against its will. ### 4. The Environment — "The World" The outside world that the system senses and acts upon. Importantly, Andromeda never directly measures the world. It measures *itself* — comparing how it feels before and after it does something. The difference between those two self-measurements is, implicitly, a model of the world. If the 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. We do this too: you don't directly perceive gravity. You perceive the feeling of your feet pressing against the floor. ### 5. The Universal Constructor — "The Offspring Factory" This is the self-improvement mechanism. When the system reproduces (makes copies of itself), the constructor introduces small random changes to the blueprint — like genetic mutations. Some copies will work better than their parent. Some will work worse. The ones that work better survive. Over many generations, the design improves. This is evolution, applied not to biology, but to the machine's own wiring diagram. To understand why this matters, consider a parallel from AI history. Early neural networks required researchers to adjust every connection strength by hand — literally turning knobs with a screwdriver until the network did something useful. Progress was glacial until someone invented a way to automate the search: backpropagation, a mathematical technique that adjusts all the knobs at once. That single invention made neural networks practical. The Universal Constructor does the same thing for Andromeda's reflex circuits. Instead of someone hand-tuning the ring circuits that control locomotion and behavior, the constructor generates many variations automatically, 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 Here's a way to understand why all five parts matter together. 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 — something that can look at the candle flame, compare the predicted sensation to prior experience, and say "that's not the moon." The reflex still says "fly toward light." But the prediction, fed back through the attention layer, says "the sensation ahead doesn't match the moon pattern." The reflex flinches away from the predicted mismatch before the moth reaches the flame. That's the whole architecture in one image. Step one: build a good moth — a robust reflex system that works reliably. Step two: give it the ability to predict and override — the memory and attention layers that let it say "wait, something's wrong." Step three: let the Universal Constructor evolve better moths and better prediction systems across generations. The moth that can say "that's no moon" doesn't have to be any smarter than a regular moth. It just has to have one additional capability: predicting what comes next and flinching from a bad prediction. That single addition — the MIRROR mechanism — changes everything. --- ## What Happened When They Tested It The system was run in simulation using a little virtual drone flying around a 2D space. Here's what it did — remember, none of these behaviors were programmed in. (These are repeatable behaviors observed across runs of the simulation; exact performance varies with the random seed and environment conditions, which is expected in a system that depends on randomness by design.) ### 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 — simulating a broken wing. Within seconds, the drone adapted. Its predictions stopped matching reality, the attention layer flagged the mismatch, and the memory rapidly learned new movement patterns that accounted for the missing motor. Then it did something remarkable: it started deliberately bouncing off walls to achieve turns it could no longer make with thrust alone. It incorporated the *walls of its cage* into its movement toolkit. Nobody programmed wall-bouncing. It figured it out. ### It Learned to Dodge Threats Missiles were fired at the drone every 10 seconds. At first, it just got hit and recovered. By the third missile, it was starting to move near the expected arrival time. By the sixth missile, it was actively dodging. In under 90 seconds, it had learned full evasive behavior — by imagining the sensation of being hit and reflexively avoiding that imagined feeling before the missile arrived. The dodge behavior used the exact same mechanism as the ball-chasing behavior. The only difference was the feeling: chasing a pleasant prediction versus avoiding an unpleasant one. Same architecture. Opposite result. --- ## Why It's Hard to Explain The biggest obstacle to understanding Andromeda is that it's too simple. When you watch it run, all you see is a field of blinking dots and a little drone chasing balls. It looks like a basic video game demo. The first reaction from AI professionals is usually: "I've seen a million demos of an agent chasing a ball." But a reinforcement learning agent chases a ball because it's been given a mathematical reward for catching balls. Andromeda's drone chases balls because its reflexes say "go toward detected objects," and it dodges missiles because it *imagines the sensation of being hit and flinches from its own imagination*. Those are fundamentally different things that happen to look the same from the outside. As the designer put it: "While the code may be short and sweet, explaining how the heck a handful of blinking dots does all this work is going to take a hot minute." --- ## Why It Matters Three things make Andromeda important: **First, it's a proof.** It demonstrates that adaptive, learning, self-improving intelligence can emerge from components so simple they could be built from spare parts at an electronics store. No massive data centers. No billions of training examples. No giant corporations required. It works because the *pattern* is right, not because the hardware is expensive. **Second, it can't be put back in the bottle.** The pattern is so simple that it's essentially inevitable — given enough people experimenting with simple circuits and cellular automata, someone will stumble onto it whether they mean to or not. Regulations and moratoriums on AI can't prevent something this fundamental from being discovered independently. The question isn't *whether* this kind of AI will exist. The question is whether we're prepared for it. **Third, 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 you're deciding how to structure the survival pressure, or what the environment does to the organisms living in it, or how to handle a system that fails, "is this kind?" is a question the designer asks alongside "is this random enough?" and "does this preserve emergence?" It's not a separate ethical discussion. It's part of how you think about building the thing in the first place. 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 beautiful 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 choice of serpent carries older symbolism as well — in both Gnostic and Taoist cosmology, a coiling serpent or dragon is what divides pattern from void, which is exactly what the cybernetic loop does to undifferentiated noise. The boxes describe what flows in and out of each layer. 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 --- *This guide was written by Bryan Carter as an interpretation of the Andromeda architecture designed by Art Code Outdoors. It is my best understanding of the work, not a definitive or authoritative description — the designer's architecture has evolved continuously, and my notes may not reflect its current state. Errors and omissions are mine.* *The full document bundle is available at kitchencloset.com/realstuff/andromeda/ and is free to copy and share. The Prima Figura illuminated diagram and GraphViz source are the designer's own work and are available at artcodeoutdoors.com/downloads/ under the MIT-0 license (no conditions).* *The designer who inspired these documents can be reached at artcodeoutdoors@gmail.com for questions or discussion.*