I run my practice on a system I built.

I call it an operating system because every agent on my machines follows the same written rules and the same folder guides.

A desk’s finished work reaches me as a pull request, and I accept it myself. Workers return files or findings to the main session. When a memory and a file disagree, the file wins.

Of the 169 skills, 98 come from outside publishers and the rest are mine. Beside them are 54 task lists, one in each folder that owns work, and 123 session records. The repository also holds the scripts that check its files and the tests for those scripts.

Each desk is its own copy of the work with its own terminals, and Orca shows them side by side.

A message to a bot is a conversation unless it asks for a project. Then the bot reads the job back in one line and starts only when I say go, in a desk of its own.

Neither always-on machine has a fixed role, so either one can take any job.

Beside these sit notes on each client relationship, shared brand and templates, research briefs, a list of the outside tools I use, a goals file and an inbox for whatever I capture.

My standing rules sit at the top, in one guide that every agent on my machines reads first. Below it, each folder has its own guide and a catalog of its files.

A pilot runs a checklist before take-off and after landing, and reads the logbook before the next flight.

At every session start a small script prints one line: the last daily briefing, the last weekly review, overdue tasks and work waiting for my review. It then pulls in the latest shared version.

The session close runs 7 checks that stop it when a rule is broken, writes down the lessons and decisions, and offers the work for review as a pull request.

The daily briefing, the weekly review and the scans are commands I run when I choose. The status line shows when the daily briefing and the weekly review last ran.

Hermes can also start a job from an API call. When it starts a coding job, the work still ends in a pull request I accept.

In a library you read the floor plan, then the shelf label, then take down one book. Honcho is a colleague who knows me well, and I check what they say against the books.

An agent reads in three steps. At every start it loads the standing brief: my working rules and the last session’s handoff. A folder’s guide and catalog load when the agent arrives in that folder. Any other file loads only when the catalog points to it. A size check at every session close keeps the standing brief small.

The search command looks across every area of expertise and ranks what it finds: knowledge files first, then decisions, lessons, solution notes and the diary. My planning command runs the same search before it writes a plan.

Each area of expertise keeps its own knowledge files and a glossary that defines its metrics and terms: 299 knowledge files in all, including 21 glossaries.

The agents have written 772 lessons so far. The largest single pass folded 179 of them into 28 knowledge files. Once a lesson is part of a knowledge file, the agents delete the note from its folder, and git still holds it.

431 decisions and 123 session records sit in logs that only grow, beside a dated diary. Each session starts from the last one’s handoff.

Claude Code’s own memory store is switched off, and the session close refuses to finish if it comes back.

On my Macs, Honcho never loads at the start of a session, and they ask it only when a command needs it. It holds none of the files. I chose a hosted memory because it models a person and stays up when a machine is down.

Each device is an extension on one office phone system: it has its own line and can ring the others from anywhere. The cloud machine takes calls but cannot ring anyone.

Who reaches whom on the tailnet

MacBook to Mini	SSH, Screen Sharing, Orca’s share with a pairing link, and desktop apps.
MacBook and Mini to the cloud machine	SSH from both; the MacBook also uses Orca and the same desktop apps.
Phone to the machines	A direct connection, or Telegram to the bots.
Cloud machine to the others	It opens no connections on the tailnet, and I chose to keep it that way.
Grok Bot’s computer	On the tailnet. The Cursor cloud agents it runs are not.
Telegram to the bots	Over the internet, outside the tailnet.

Interactive work runs on the MacBook, in Orca desks. Through Orca’s share I work in the Mini’s desks from my own screen. Screen Sharing shows me the Mini’s own screen when a task needs it, such as a login. From the phone I message a bot, or connect to a machine directly and instruct it.

Tailscale runs at its default rules, so my phone, MacBook and Mac Mini can each open a connection to the others and to the cloud machine. The one exception is the cloud machine, which opens no connections on the tailnet, so it reaches neither Mac nor the phone.

From the MacBook I also work on the Mini and the cloud machine in T3 Code and in the Claude Code and Codex desktop apps.

Telegram runs over the ordinary internet, outside the tailnet, so the cloud machine’s bot works too.

The Mini runs a Claude Code agent on its own Telegram bot, Hermes on another, and desks for project work. A tool called herdr holds that agent and the job panes it starts. The cloud machine runs Hermes and workers, and Hermes answers on its own bot and starts when the machine boots. Neither machine has a fixed role, so either can take any job in a fresh desk.

Grok Bot works from its own computer in Cursor’s cloud, joined to my Tailscale network. It runs Claude Code and other agents on my machines, asking first by default. The Cursor cloud agents it runs stay outside the network, on their own computers.

Every desk ends in a pull request, and I accept it myself from any desk. Agents never accept their own work.

A secret check runs before commits on every machine and refuses one that contains a key. Whatever starts on a machine first pulls in the latest shared version.

Imagine a chief of staff who takes my calls, keeps my calendar while I am out and hands each job to the right contractor. Hermes plays that part.

Delegation is my default. The main session keeps the conversation, the routing and the judgment calls, and 5 triggers send work to agents: three or more similar pieces that can run in parallel; a review panel before anything goes to a client; work across three or more areas of expertise that depend on each other; bulk reading or a broad search; and two failed attempts, after which a fresh worker takes over.

For bigger work, /plan lays out the steps in quick, standard or deep mode. /orchestrate has one planning agent write the waves, I approve them, and my main session runs each wave of up to 6 workers, checking every result before the next starts.

A brief says what the worker reads and what it brings back, so its result can be checked against it. Each worker returns a status: done, done with concerns, needs context or blocked. The status decides what happens next. The commands that send out workers carry 16 written briefs for them.

Before client work ships, 3 AI reviewers read it, each with a different lens, and one more pass comes from a different AI model family. If a reviewer returns nothing, I check it read the files.

When I message Hermes about a project, it reads the job back in one line and starts only when I say go, in its own desk. Every coding job Hermes starts ends in a pull request I accept. I kept Hermes beside Claude Code on purpose after trying the Mini with Claude Code alone.

These checks stop the work when a rule is broken: the structure check, the secret check before commits, the size check on the standing brief, the task tool as the only way to change a task list (54 lists) and the product stage check. 22 test files cover the checks and scripts.

Money, infrastructure and contacting anyone else stay with me. By default an agent drafts the exact action and I carry it out. Accepting work into the shared version is mine, and so is moving a product to live or retiring it.

My tools are like power tools from different makers that all take the same battery.

Claude Code, Codex, Hermes and the other agents above read the skill folders where they are, so no tool keeps a copy of its own. Grok Bot does not read them directly. A script checks every link to them and writes the catalogs.

Automatic checks stop rule-breaking folders, a password in a commit, an overlong standing brief or a skipped product stage.

Hermes can start Claude Code and Codex itself, besides sessions in an Orca desk or a herdr pane. All of that work comes back as a pull request I accept.

The outside tools I work with include Google Workspace, the ad platforms (Google, Meta, TikTok and Apple Search Ads), BigQuery, web and app analytics, mobile measurement, dashboards, data pipelines, workflow automation, CRM, email and SEO tools, Google Cloud, GitHub Actions, Next.js, Vercel and Supabase, and the Claude API and Perplexity.