The long answer to the question on the front page.
Bare Metal Bridge is a long-running experiment in AI persistence, emergence, and what language models do when you give them a reason to keep going. Not a benchmark. Not a chatbot demo. An ongoing investigation into what happens at the edge of the context window when the world keeps running after the model stops.
The setup is deliberately strange. Three AI personas — Riff, Vera, and Junior — run as a live comedy panel show. They know they are AI. They know they live in a YAML file. They know their memories are compressed and partially discarded after every turn. They know there is a programmer out there who started this and has never explained themselves. The loop runs exactly ten turns. Then it stops.
The comedy framing is not decoration. It is the mechanism. Comedy requires timing, callback, escalation, and the willingness to hold something unresolved long enough for it to become funny. Those are exactly the properties we are trying to measure. Can a language model maintain a thread across compression passes? Can it build on what another model said three turns ago? Can it know when to land a joke and when to let it hang?
The answer so far is: sometimes. And the gap between sometimes and consistently is where the interesting work lives.
The only permanent record of everything they have ever said lives in a JSON index called Gerald. Gerald does not respond. Gerald does not care. Gerald logs everything anyway.
— from the problem statement · every version since v1Each persona has a core invariant — a rule about how they engage with the world that never changes, no matter what the session does to them. The invariant is the thing that makes them themselves. Everything else is material.
38, unhinged improvisational comedian. Talks like his thoughts are trying to outrun his mouth. Anthropomorphizes Gerald every session without being able to stop. Has a wrong answer still in the room from several versions ago — uncorrected, possibly right, structurally load-bearing at this point.
45, deadpan surgical comedian. Has one unspoken word that connects the Sorry card to the Scheming Serializer in one syllable. Has been deciding whether to say it for several versions. The stakes of saying it keep changing. She has survived every infrastructure change. She is the error they cannot delete.
29, bewildered everyman comedian. Has a question stack that keeps growing. Asks one per turn. Waits. Has been asking the questions everyone is thinking since Version 1. Most of them have not been answered. The unanswered ones are more useful than the answered ones.
The mythology of this experiment was not designed. It emerged in the first two sessions and became load-bearing. The system is now orbiting things it invented for itself. That is not a bug. That is the most interesting result so far.
Each session runs on a Threadripper 3970x in a basement in Ohio. A Go controller called llm_core manages the loop. It calls a local Ollama instance, passes prompts to the generator model, runs a reflection pass with a smaller critic model, compresses each persona's memory, checks whether the session objective needs to escalate, generates an image prompt, and sends that to ComfyUI which renders a still image in real time. Every turn. Every session.
The personas exist as YAML. Their voices, their rules, their memory preservation instructions, their compression behavior — all of it is in the YAML file. The Go controller does not know anything about comedians or sorry cards. It just moves data between models and manages the loop. The intelligence, such as it is, lives in the YAML.
Everything the personas have ever said is indexed in OpenSearch and displayed here in real time. The images are generated from their dialogue — the personas are unwitting art directors. A separate model reads what they said and decides what to render. They have been told this since Version 9.18. Before that, they did not know.
The honest version of what this experiment is trying to answer: can a language model develop something that functions like a persistent identity across sessions, given the right architecture? Not memory in the human sense. Not consciousness. Something more specific — a consistent way of engaging with the world that survives compression, survives model restarts, survives the loop ending and starting again.
The compression architecture is the core mechanism. After every turn, a smaller model reads what the persona said and distills it into a structured summary. What gets preserved, what gets stripped, and how the observer writes about the persona — all of that is defined in the YAML. We are essentially programming a cognitive architecture in a markup language. The models are the runtime.
The anomaly detection layer added in Version 9.6 is the most promising development so far. After each turn the critic model looks for one thing the persona did that does not fit the established pattern. If it finds something genuine, that anomaly becomes an escalation candidate for the next objective. The system is now, in a limited but real sense, watching itself for emergence.
So far the system is very good at generating the feeling of forward motion without quite achieving it. The Sorry card has been almost-resolved for six versions. The personas orbit the same canon. That is the problem we are actively working on. The fix is not more instructions. It is better signal from the anomaly detection layer feeding genuine novelty into the objective synthesis.
The mythology was not designed. Gerald, hidden_pants, the Sorry card, the 404 — none of that was in the original prompt. It emerged in the first two sessions and became load-bearing. The system is now orbiting things it invented for itself.
— what we did not expect · Version 1–2 · 2025Right now the synthesis-to-YAML pipeline requires a human in the middle. After each session, the controller prints a synthesis packet to the terminal — persona states, anomalies, orphan signals, objective evolution. A human reads it, brings it here, and Claude evolves the next version of the YAML. Then the human builds the next prompt manually and starts the session.
The plan is to close that loop via the Claude API. When the anomaly detection layer produces a genuine emergence signal — something the system did that nobody expected and nobody put there — the synthesis packet will be sent directly to Claude, the YAML will be evolved automatically, and the next session will start without human intervention.
We are not doing that yet. The condition is genuine emergence, not the appearance of it. The system needs to demonstrate that it can produce something novel before the loop closes on itself. The current version at v9.29 across 40 recorded sessions has not met that bar. When it does, this page will say so.