Skip to content

Autonomation

I make the agents reliable the way I would make a machine safe.

Status: in daily use · checked Oct 29, 2026

In plain terms

One system runs my AI coding agents. It stops itself when something is abnormal. Recorded failures drive new guards and regression checks, with enforcement limits documented.

Start with two pages: How agent output is trusted and Guard rails for AI coding agents. If you hire for AI infrastructure, read Measuring agent reliability next. Everything else is reference.

Where to start

Pick the track that fits you; each page reads on its own.

Autonomation is the name I use for the whole system: the agent fleet, its guards, the control plane, and the review gates. It's the English term for Toyota's jidoka: automation that runs on its own, stops itself when something is abnormal, gets its root cause fixed by a person, and has that fix built in as a guard or a regression check.

I run a fleet of AI coding agents. I built the platform and set its standards and acceptance criteria. I decide which agent gets which work, what it may touch, who checks it, and what changes after a failure. In the main repositories, every pull request must pass an independent AI review gate pinned to the exact commit, with an extra adversarial review for security-class changes. Separately, recorded failures drive new guards and regression checks, with enforcement limits documented.

The system in one picture

flowchart TB subgraph GD[Guards on every command and push] direction LR O[Operator
sets intent] --> K[Coordinator
agent] --> W[Worker agents,
each isolated] --> PR[Pull
request] --> CH(Independent
reviewer):::guard --> M[Merge] end GD -.-> L[(Run ledger)]
flowchart TB subgraph GD[Guards on every command and push] direction TB O[Operator sets intent] --> K[Coordinator agent] --> W[Worker agents, each isolated] --> PR[Pull request] --> CH(Independent reviewer):::guard --> M[Merge] end GD -.-> L[(Run ledger)]
Part What it does Read
The fleet Claude Code, Cursor, Codex and open-source models do the work. A coordinator agent hands it out through five kinds of lane, and every worker gets its own isolated checkout. Lanes and the run ledger
Guards Hooks and git-level backstops intercept risky commands and pushes. Each one exists because of a real failure, and each is checked to still be doing something. Guard rails
The control plane A ledger records every dispatched run. Sessions address each other by role. Multi-step plans have owned paths and gates between phases. Lanes and the run ledger
Review gates Every pull request in the main repositories must pass an independent AI review gate, and closing a task needs evidence. How agent output is trusted

What it has done

Each figure below carries its window and its source; how the figures are checked is on Site notes. The rows that matter most are the merged pull requests a day and the agent runs; the rest describe the size of the environment.

Claim What it means Window and source
about 63 merged pull requests a day A daily average over the window, so quiet days and busy days are blended; automated version-update pull requests are included. Sep 23 to Oct 22, 2026. merged pull requests across my private repositories, automated version-bump pull requests included, averaged per day.
4,768 agent runs Every dispatched session is a row, including read-only review jobs and failed or cancelled runs. Interactive sessions and scout investigations aren't rows. 30 days to Oct 28, 2026. dispatched agent sessions recorded in my run ledger.
40,000+ automated tests across three repositories, 20,000+ of them in the main repository A count of tests, not a measure of how much they cover. Collected, not passing. As of Oct 29, 2026. tests the test runner collects in the three repositories that hold my automation code, counted together.
73 architecture decision records Written decisions, each with the options I rejected and the trade-offs I accepted. As of Oct 2026. decision records written for the environment.
9 main machines A count of hosts, not a measure of capacity. As of Oct 2026. main hosts in the environment I run.
96 private repositories A count of repositories, not of services. As of Oct 29, 2026. repositories in my private GitHub organization.

How often agent runs finish, fail or stall is on measuring agent reliability. Where each part of the system stands is on How agent output is trusted.

The rest of the set

If you want to see Read
how multi-step changes are split across workers and checked Orchestrating multi-step work
how often runs fail, and what catches each kind Measuring agent reliability
how model cost is routed and capped Routing agent work by cost
the layers underneath, and how a new service is added The platform path
the artifacts a run leaves behind, in redacted form What a run leaves behind
how the environment is observed, and how alerts are designed Observability and alerting
trade-offs and the options I rejected Selected design decisions
how documentation is kept true Documentation that stays true

The ideas that recur

  1. Guards, not guidelines. If an instruction matters, a hook, a gate or a test enforces it. A document is the weakest level, and pages say which level backs each rule.
  2. Read-only by default, reversible by design. Looking is cheap and needs no write access. Changes go through isolated checkouts and review gates, and a self-canceling rollback comes before anything hard to undo.
  3. Cost is an engineering constraint. Work goes to the cheapest model tier that can do it, and the expensive tiers need a stated reason.
  4. A check has to be able to fail. A guard, an alert or a test that has never been seen to refuse anything is a hypothesis.

This is a public edition: it leaves out anything private to the environment or the people around it. See About this site.