The AI operating estate I run my own practice on

The context

Most AI work I see is one person in one chat window, correcting the model by hand, one output at a time. That is where I started. What I run now is different in kind: a multi-project operating estate where several AI sessions work in parallel, a coordinator hands tasks to builder agents, and nothing ships until an independent check has tried to break it. I did not buy this. I built it, I operate it daily, and it is the clearest proof I can offer of the capability I sell.

The problem

A single configured assistant hits a ceiling fast. It forgets every correction when the session ends, it agrees with you when you need dissent, and it reports "done" on work it never verified. Run real volume through it, several projects, daily outputs, deadlines, and the failures compound: knowledge resets to zero every session, and the same mistake resurfaces a week later because nothing recorded the fix. Fan the work out across windows to go faster and you lose the one thing that made a single window safe, that you could see everything it did. Speed without control is just a faster way to ship errors.

What I built

An estate that treats AI output as a claim to be verified, never an answer to be trusted, and that keeps what it learns. Governance is a set of rules that are scripts, not documents, because a rule the model reads once and forgets is not a rule. Orchestration is a coordinator session that dispatches builder agents and adversarial reviewers, each pinned to the right model for its job. Compounding is the memory spine: session ledgers, append-only logs, and a weekly maintenance pass that turns every mistake into a permanent check.

How it works

Governance runs as code. My rules live in pre-publish gates: single scripts of roughly fifty pass-or-fail checks that run in under four seconds on every output and block anything that fails.

A gate confirms the day of the week, strips the punctuation my writing rules ban, and verifies every disclosure line before a file clears. The day a newsletter cover rendered "Thursday" on a Friday, I did not write myself a reminder to check dates. I added a line to the gate. That error cannot happen again. Any rule I can state as pass-or-fail is a script; everything else is a guideline, and I stopped pretending the two are the same thing.

Orchestration runs as a fleet. A coordinator session holds the plan and does none of the heavy lifting itself.

It dispatches builder agents, each pinned to a specific model for its task class: the deep-reasoning model for building and judgment, lighter models for mechanical passes. The builders write their work to disk and return only their conclusions, which keeps the coordinator's attention on the plan. I do not take a builder's word for anything. Every claim a builder makes, that a file is updated or a figure matches, gets checked with my own independent grep before it counts as true. A builder that says it verified something and a grep that proves it did are two different facts, and only the second one ships.

Then the part most people skip. Before anything important ships, I run it past an adversarial reviewer: a separate AI session whose only job is to refute the work, not polish it. Not "make this better." Find what is wrong, name the weakest claim, argue the other side. A model asked to help will agree with you. A model told to attack finds the crack you missed.

Underneath all of it sits reversibility. Every file is archived before it is overwritten, so every operation can be undone, and nothing is hard-deleted. The estate runs across several windows at once, so a shared ledger marks which session owns which files, and a session locks its work before it closes so two windows never collide. Off-machine backups run on a schedule, and a check screams if the last one is stale. The system is built to survive being operated fast and to recover when something breaks, because in production something eventually does.

The outcome

Errors that used to reach the page now get caught before they leave the machine, and the ones that slip through become permanent checks, so the same mistake cannot happen twice. A governance review that used to eat twenty minutes now runs in four seconds. Work that ran one window at a time now runs several in parallel without losing control of any of them, because every builder claim is independently verified and every shipment is adversarially reviewed. And the system gets smarter across sessions, because the ledgers and logs make yesterday's lesson today's default.

What travels

A governance review that used to take twenty minutes now runs in four seconds. A builder's claim does not ship until an independent grep matches it. A mistake that reaches the page becomes a permanent check, which is why the Friday cover cannot say Thursday again.

One of a set of engagement and systems case studies. If a problem like this is on your desk, start with a conversation.