I spent six months trying to make v2 work. Then I built a small thing on the side that worked better than v2 ever had. The decision that followed wasn't whether to change architectures. It was how fast.
Part 22 ended on a pattern I'd been seeing without quite seeing. PropertyCircuit and RelationalCircuit had each landed a capability the brain layer couldn't reach, at a fraction of the parameter count, in seconds of training, with zero impact on anything else in the system. The implications sat in the session notes for a couple of days while I ran the numbers in different ways trying to find a reason they didn't mean what they obviously meant.
I couldn't find one. The pattern was real. The reason it was real was structural. A monolith optimized for one thing tends to be worse at every other thing. A small circuit optimized for one thing tends to be better at that one thing than any general-purpose model would be, and the cost of building it is small enough that you can build a lot of them.
I sat down at my computer staring at the screen, running the design through my mind. I had been doing the engineering work in a collaboration for months. I held the design vision and the final say on what shipped. The conversation about v3 had to be the two of us together, because nether one of us would have noticed the pattern alone.
The conversation took most of a day. The output was a file in the v3 repo called TRUTH.md with ten rules in it. Two-way agreement required for any architectural change. No regex patterns in dispatch unless they used what Origin already understood. Sandbox before shipping. Trace impact before shipping. Honesty floor: Origin only says what it knows. Modularity all the way down. A few others.
The rules weren't aspirational. They were the patterns we'd already learned the hard way over fifteen blog posts of failures. We'd just never written them down in one place where they could constrain the next decision.
The architecture that came out of the conversation was different from v2 in shape, not just in degree.
v2 was an encoder followed by a dispatcher followed by a composer. The encoder produced a fired-concept set. The dispatcher routed based on patterns. The composer generated text. The brain layer sat downstream of the dispatcher as one of several intent handlers. The whole pipeline was a series of stages, each one trying to do its part of "understand this input and produce a response." When any single stage struggled, the whole pipeline struggled.
v3 was a fleet. The encoder still fired concepts. The dispatcher still routed. But what got routed to was a collection of small specialized circuits, each one with its own narrow vocabulary, its own training data, its own predict head, its own gradient flow. PropertyCircuit handled property assignments. RelationalCircuit handled subject-relation-object triples. CausalCircuit handled cause-effect chains. ChainReasoner composed across them when a question needed multi-step inference. Each circuit was thirty to fifty thousand parameters. Each one trained in seconds. Each one could be added, retrained, or retired without touching the others.
The brain layer didn't go away. It stayed for the kinds of compositional work that didn't fit cleanly into a single small circuit. But it stopped being the architecture's center of gravity. It became one expert among several, consulted when its capability matched the question shape, ignored otherwise.
The encoder didn't go away either. But its job got cleaner. v3's encoder fires a concept set. That's it. It doesn't have to produce dense activations across the full vocabulary. It doesn't have to balance against downstream prediction heads. It fires what it knows about the input and lets the circuits decide what to do with it. The vocabulary growth problem dissolves once the encoder is allowed to be sparse instead of dense.
The dispatcher's job got cleaner too. v2's dispatcher had been accumulating regex guards and intent priorities and exclusion lists for months because it was the only place to handle the gaps everywhere else. v3's dispatcher was a router. Look at the input's shape. Pick the circuits whose capabilities matched the question. Let them produce outputs. Let the composer turn the highest-confidence output into text. The dispatcher didn't need to be the safety net for everything because everything wasn't its responsibility anymore.
The composer's job stayed mostly the same, but with cleaner inputs. Where v2's composer had been stitching together responses from raw concepts and definitions and pre-written templates, v3's composer received structured output from circuits: the property, the relation, the effect concept, the chain trace. The composer's job became saying what the circuits had already produced, not figuring out what to say.
The whole shape was different in a specific way. v2 had been one model trying to do everything, with capability layers stacked on top of each other and dependencies running in every direction. v3 was a coordinated fleet of small models, each one with one job, with the coordination layer kept as thin as possible. The architecture that human cognition seems to use. Not because we were trying to copy biology. Because that pattern was the one that the engineering kept landing on whenever we let the data choose.
The transition wasn't a single commit. v3 already existed as its own repository because the encoder retrain work had needed separate infrastructure. The PropertyCircuit and RelationalCircuit had been built there. The TRUTH.md commit in May was the moment we wrote down that the new direction was permanent, but the architecture had been quietly forming for weeks underneath the v2 work.
v2 kept serving production while v3 came up. I'd been doing this kind of cutover for long enough to know that promising "we'll rebuild it cleanly next time" almost always meant either rebuilding it dirty later or never rebuilding it at all. v3 had to demonstrate it could carry production before v2 stepped down. That meant the modular circuits had to handle every capability v2 currently handled, which meant building more circuits, which was now cheap. Each new circuit was a hand-curated training set, a small Python file, a few hundred lines of dispatch wiring. The first one had been hard. The second one had been a copy of the first one with the vocabulary changed. The fifth one would take an afternoon.
The first month of v3 work was building. PropertyCircuit shipped. RelationalCircuit shipped. CausalCircuit shipped. A thalamus router that picked which circuit handled a given input, trained on small amounts of routing data. A chain reasoner that composed across circuits when multi-step reasoning was needed. The brain layer got rewired to use the new circuits as inputs instead of trying to be the whole reasoning stack itself. The encoder got retrained with a corpus deliberately shaped for sparse multi-label firing instead of dense softmax distribution.
The numbers came back better than v2 had ever been. Compositional reasoning jumped because each step of the composition could be handled by a circuit specialized for it. Property transfer climbed because PropertyCircuit was specifically designed for it. Identity and dialogue surfaces stayed clean because they were handled by separate dedicated heads that didn't have to balance against anything else. The frontier battery, which had been a diagnostic instrument for v2, became a target. Each missed bucket pointed at the next circuit to build.
I'm writing this from the v3 codebase. The brain layer is still there but the architecture is no longer organized around it. The encoder is sparser and sharper than v2's ever was. The circuit fleet handles capability gaps that v2 couldn't have approached without months of careful gradient surgery. The dispatcher is shorter than it was a month ago because most of its regex guards have been replaced by routing to circuits that handle the question shapes natively.
What v3 is, in one sentence: a coordinated fleet of small specialized models with a shared concept vocabulary and a thin routing layer. What that means in practice: the system doesn't try to learn everything in one model. It learns one thing per small model, and the small models work together. The reasoning is traceable. The capabilities are addable. The training is fast. The failure modes are localized.
What v3 isn't: a transformer-style language model. It doesn't generate tokens. It doesn't predict next words. It doesn't have a context window in the LLM sense. It doesn't run on a hundred-billion-parameter foundation model. It runs on a $1,800.00 dollar computer under a desk in Arizona, and the entire system, including the encoder and the brain layer and the circuit fleet and the composer and the dispatch routing, is small enough to fit comfortably on a consumer GPU with room to spare.
That last part keeps surprising people when I describe what v3 actually is. The standard mental model for AI in 2026 is that you need a lot of parameters and a lot of compute, and capability comes from scaling. v3 is the experiment that asks whether capability can come from architecture instead. The early answer, on the parts of the system that have been validated, is yes. The full answer will take a while. But the direction is set now. The fleet is the architecture. The architecture is the work.
v2 is retired. v3 is what comes next. Different in kind, not just in version number.
This could open up a lot of possibilities. If you want to help find out, I'm opening up beta testing to the first fifty people who reach out. This is a basic model. Please don't have high expectations. We're still building it and improving it every day. Come watch it grow. The first fifty testers get free access for life.
One guy. One GPU. One $1,800 computer in Arizona. Still building.
Origin is developed at Fallen Angel Systems with the Genesis framework — NVIDIA Inception member. (USPTO Application #64/016,973, #64/017,567). FAS Guardian defends production AI systems from prompt injection in under 3ms. FAS Judgement is the open-source attack console that finds the gaps. Defense. Offense. Creation.
fallenangelsystems.com | Judgement on GitHub | Guardian on GitHub
Questions or consulting inquiries: josh@fallenangelsystems.com