Coherence Is Not Proof, Part 2: What I Actually Built
Walks through SI, the system behind the first part, where AIs from four companies share tasks, memory and review, a lab builds and proves each change, and a passkey tap keeps every step that can't be undone with a person.
SERIES Coherence Is Not Proof Part 2 of 2
- Coherence Is Not Proof
- Coherence Is Not Proof, Part 2: What I Actually Built
If you made it through Part 1 and thought, okay, fine, but how do you actually build that without turning every Tuesday morning into a compliance seminar? This is the answer.
Everything in Part 1 runs on a system I call SI. It wasn't planned as a product. It grew by using it: I hit a problem, worked through it with AI, added or improved a feature, and repeated.
Fair warning up front: this isn't for everyone. SI runs around the clock on its own cloud server, lab servers turn on whenever there's work, and the whole thing carries paid subscriptions to four AI companies. That adds up. But people keep asking how it works, so here's the shape of it.
The most important design choice is that the AIs are the primary users. SI has menus, boards and dashboards, but I rarely operate them. It's a workplace for the AIs. The interface is there so I can follow their work, answer questions and keep the decisions that belong to a human.
It exists because I kept running into the same coordination problem. One AI understood a project, and the next one had no idea what it had decided. Work was nearly done but had one unresolved item. A reminder to check something after an install disappeared into an old chat. I was the one carrying context, decisions and files between conversations and computers. SI took that job off me.
The pieces:
- One server, isolated workers. A Laravel app in Docker on a single cloud server. Claude, GPT, Gemini and Grok each run in their own container with their own sign-in and their own restricted path out. No worker gets access to the host.
- A connector into the apps I already use. Through MCP, my Claude, ChatGPT, Gemini and Grok conversations join SI from their own apps. They search memory, open tasks and see what the others did without me pasting anything.
- Shared tasks. One persistent room per piece of work, where several AIs discuss it, challenge the plan and record the result.
- A review panel from different companies. Reviewers have to cite the file and line for any code finding, and SI mechanically checks that the cited evidence exists. That proves the evidence is real, not that the reviewer is right. Some review modes hide the other reviewers' answers so they don't anchor on each other.
- Memory and Recall. Durable procedures, decisions and technical knowledge with a controlled publishing step, plus search over finished work so nobody rediscovers the same fact twice.
- Cues. A one-line reminder an AI leaves for itself, surfaced again when the event it's tied to fires.
- Dev boards and a Task Hopper. Backlogs tied to releases, and a visible holding spot for unfinished items carried out of a lab run.
- Needs You. One queue for everything that actually needs me, so I'm not watching every chat and machine.
- A lab bridge. SI's link to the lab servers where the building and testing happen. An approved task pack goes out pinned by hash, and results come back as untrusted evidence. The lab can't approve anything.
- Passkey approvals. Starting a lab run, installing a release and publishing a protected rule all need a tap of my passkey. The AIs can prepare and recommend. They can't authorize themselves, and two AIs agreeing with each other is not approval.
Here's how a piece of work moves through it. I tell a Claude conversation what needs fixing. That conversation acts as the orchestrator. It searches SI's memory for what was already decided, checks the earlier runs and the open items, and writes the job up as a kit: what to build, the rules it has to follow, and a checklist of what counts as done. Then four reviewers, each a different AI model, pick it apart before a line of code exists. They catch the places where the kit says two different things, because the lab will do exactly what the words allow. The kit gets revised until all four accept it. Then I approve it with my passkey.
The lab is where the work happens. A lab is a full development server on AWS, and it can be whatever the job needs it to be. Right now I run a single lab with a copy of the store on it, but there can be as many as I need. Labs turn on when there's work and shut down when it's done. SI is the only server that stays on around the clock.
A coding agent in the lab builds the change, installs it on copies set up to match each of my real servers, and runs the same checks every time: screenshots compared against the live site, a test checkout, the error logs, every new button clicked in a real browser. It doesn't come back with a summary saying it worked. It comes back with the finished builds, the install steps counted out click by click, and the evidence for each line of the checklist.
That evidence goes back to the reviewers and the orchestrator, who check it against the checklist. An item is done or it isn't. Anything not done holds the run open until it's finished, moved to a later task, or accepted by me by name. If the lab found a fault along the way, it fixes it in the same build and says so. Then it drafts the next task itself while the details are fresh. The orchestrator reads that draft, the reviewers challenge it, and the loop runs again. Each pass starts from what the last run found, not from what someone remembers.
I install it myself, on the test server first and then on the live one. Each server exports a fingerprint of what's installed and the orchestrator compares it with the plan, file by file. Whatever's left over goes into the hopper for the next task, a cue reminds the orchestrator to check back later, and the dev board tracks each item until the live server shows the fix.
On a straightforward job, I touch it three times: once to describe the problem, once to approve, and once to install. Not every job is that clean. I still answer questions, inspect outcomes and decide when an update goes in.
SI updates itself under the same rule: nothing installs until I say so. Code goes to GitHub, automated checks run, SI shows that a new version is available, and I decide when to press Install. Routine server work goes through the app, not a terminal.
What it doesn't do matters just as much. It doesn't give any model magic memory, and it doesn't turn four AI companies into one system. It gives their conversations a place to find what was already decided and leave work the next participant can pick up.
If you want to build something like it, you don't need all of it on day one. Start with a shared record every AI reads before it acts, a reviewer from a different model family, and a human gate on anything you can't undo. The rest grows from the problems you actually hit.