I recently reconnected with an old friend. I thought this would be a great recap.
What I Actually Built
This is going to sound strange at first, but you knew me before I got sick, so you actually have a better reference point than most people do. Remember how I always worked? I never really looked at one thing at a time. I would look at the whole operation, figure out where information came in, where it went, what depended on what, what could break, what repeated, and then I would reorganize the whole thing until it ran like a machine. That was basically how I worked with catalogs, inventory, scanning, POS systems, scheduling, databases, whatever. I wasn't necessarily the person who knew every individual task better than everyone else. I was good at seeing the structure underneath all the tasks and making the structure work.
Apparently I never stopped doing that. When all of this AI stuff showed up, I thought I was testing it's safety for Bailey and learning how to use AI better. That isn't actually what happened. Over the last year I kept running into the same problem: the AI could do incredible work, but it was inconsistent. It could forget things, repeat work, confidently get something wrong, lose context, mix a theory with a fact, or produce something brilliant in one conversation and then have no reliable relationship to it later. So I started building around those failures.
At first I didn't have the right words for any of it. I was just fixing whatever broke. If the AI forgot something important, I built external state. If two pieces of work contradicted each other, I built reconciliation. If a theory started getting treated like a fact, I separated evidence from interpretation. If something needed to survive a new session, I created packets and state files. If one AI shouldn't be allowed to judge its own work, I used another role to verify it. If an operation could cause damage, I put a gate in front of it. If something wasn't proven, it couldn't just become "true." It had to stay open, get parked, fail, or eventually pass. If work crashed halfway through, the system had to know what happened and recover without pretending it had completed.
I kept doing that over and over, and eventually all those fixes stopped being fixes. They became a machine. The easiest way I can explain it now is that the AI itself stopped being the important part. The AI became more like a processor inside a larger system. One model could disappear and another could take its place. An API could change. A local model could replace a cloud model. Some jobs didn't need AI at all and could be handled by deterministic software. The machine could still exist because the intelligence of the system wasn't stored entirely inside one model.
The state was outside it. The rules were outside it. The evidence was outside it. The history was outside it. The authority was outside it. The verification was outside it. So instead of "ask an AI a question and trust the answer," it became more like "give a processor a bounded piece of work, preserve exactly what it used, record what it produced, test it, compare it against the existing state, and only then decide what the system is allowed to believe."
And the irony is that I had already spent a ton of time studying exactly these kinds of systems: classifiers, agent behavior, containment, context loss, verification, safety boundaries. I just didn't apply the same diagnosis to my own system. I went into repair mode. I kept trying to fix the AI. I thought maybe I needed better memory, a better platform, a different model, another API, more context, better prompts.
Now I can see that most of those things are secondary. The API is just a pipe. The model is just a processor. Neither one is the machine. The machine is the pattern: state + rules + routing + constrained operators + evidence + verification + authority. Once that exists, the processor can be swapped.