I build organisations of AI agents — and the rules that keep them honest.

I run it from my phone. Three decisions are mine and only three: which idea gets built, design sign-off on anything a user will see, and the production deploy. Speed is protected; only the irreversible things are gated.

The product loop turns an idea into a signed-off design over days. The delivery loop turns a brief into merged code over hours. Neither loop can call the other, and no role inside one can call a role inside the other.

The implementer never reviews itself. It spawns a verifier and a breaker on a thin brief, without its own reasoning, so they cannot be reassured by it. The acceptance tester is blind to the repo altogether: it can only use the thing.

No agent calls another. A dispatcher wakes on a timer, reads state, applies a fixed table, spawns at most one thing, and exits. Intelligence lives in the nodes; the router stays predictable, which is what keeps the whole thing explainable.

Findings travel through files and the queue, never from one agent to another. One writer per file is what lets them run in parallel without colliding, which was the first thing that broke.

• 178merged PRs
• 9months
• 1human, with a day job

You say it and keep walking. You don't file it, tag it, or open the right list first. Two things, tangled in one sentence, is how thoughts actually arrive.

It finds a task with a deadline and a reminder in the same sentence, and files each where you have been working. Nothing structural is invented: a new project can only ever be proposed, never created behind your back.

Filing happens without asking because a mistake is one tap from undone. Every filing leaves a receipt that says where it went and why, with undo sitting next to it.

What needs you today, and where everything stands. The Tuesday flight is promoted because it is price-sensitive and due this week; the rest waits where it was filed.

• 11services
• 289Klines of TypeScript
• 40%of it is tests

A customer letter, a legal file, a form. It arrives as pixels, and a regulated decision depends on what it says.

Before a word is read, code checks that every required piece of evidence exists. A set comparison, nothing cleverer, and nothing that can be talked around.

The language model appears exactly once, to turn pixels into typed values, each with a confidence and the page it came from. It reads. It never decides anything.

The system of record is read through allow-listed, read-only queries. Reconciliation compares what was extracted against approved rules, and fails closed when they disagree.

Pass, fail, or send to a human. Every conclusion cites its page, so a reviewer can check the model's work in seconds rather than re-read the file.

• 2products running on it
• 4shared steps
• 0conclusions a model decides