The One-Writer Protocol: How We Run an Autonomous Engineering Fleet

Every venture studio says it is AI-powered. It has stopped meaning anything. So instead of saying it again, here is the mechanism — the actual engine we run our portfolio on, including the parts that were broken and what we did about them.

We call the engine Sinawy. Ten product repositories run on it today, each on its own daily schedule, in parallel. Work enters as a card on a board. A scheduled cycle picks it up, plans it, implements it, verifies it in a real browser against the acceptance criteria as written, deploys it, confirms the live build carries that commit, and only then writes the result back to the board. Over 41 operating days it has closed 243 cycles, and every one of them ended with a typed status recorded in a ledger.

The hard part was never getting an AI agent to write code. The hard part is running many of them, across many repositories, without their work colliding — and knowing, afterwards, exactly what happened.

The incident

One day two agent sessions were editing the same repository at the same time.

Neither did anything wrong. Both had passed every check we had. The checks asked "is a scheduled job running here?" and the answer was correctly no — because a human-steered session was not a scheduled job, and so had never existed as far as our safety machinery was concerned. Two writers, one working tree, and a set of green lights.

The instinct is to add a warning. We did something narrower and more useful: we made every writer the same kind of thing.

The rule

A scheduled cycle, a delegated job handed to a different model, a nightly sweep, a human sitting in a terminal steering an agent by hand — each of these takes the same lease on a repository before its first change and holds it through its last.

That is the whole of the One-Writer Protocol:

Many agents, many repositories, at most one writer inside any one repository, always.

The interesting property is the asymmetry. Two repositories never contend, so the portfolio moves in parallel at full speed — a card in one venture and a card in another are genuinely simultaneous. Inside a single repository, writers are strictly serialized, so nothing is ever half-written by two hands. Most teams reach for a global lock and lose the portfolio's parallelism, or skip locking and lose the repository's integrity. This gives up neither, and it costs one small file on disk.

Two details make it hold up in practice. First, a claim is proven by work, not by a timer and not by mere existence: a writer that is still running still holds its repository even if it takes longer than expected, a writer that died releases automatically rather than blocking the fleet until morning, and a human session that has gone quiet lets its claim lapse — a terminal left open overnight never holds a repository hostage, and picking the work back up takes it straight back. Second, an agent that somehow never registered is still detected — from the operating system's process table — rather than trusted to behave. A safety rule that only covers well-behaved participants is not a safety rule.

Typed gates, not vibes

The protocol keeps writers from colliding. It says nothing about whether the work is any good. That is the job of the second rule, and it is the one that actually makes an unattended loop safe to leave running:

A stage that cannot produce a valid typed result has not finished, whatever its prose says.

Every stage of every cycle returns a structured result from a closed vocabulary. A card advances because a machine-checkable contract was satisfied — not because a summary sounded confident. "Looks done" is not a state a card can be in. This is unglamorous and it is the difference between an autonomous loop and a demo.

The same discipline runs through the ledger. Every cycle writes exactly one row: what ran, what it cost, how it ended — drained, idle, escalated, budget-cap, stale-base, and a few dozen more. A deferral is recorded as a deferral. An escalation is recorded as an escalation. The loop is auditable after the fact by construction, which is the only honest reason to trust it while nobody is watching. The harness that enforces all of this is itself guarded by 281 automated tests.

What it caught the day it shipped

The protocol went live, passed its live-fire test, and then immediately caught something we had not gone looking for.

A console session had been parked in one repository for thirteen days — idle, harmless, doing nothing at all. Our new guard saw a live agent process rooted in that repository and did exactly what we had told it to do: it deferred the scheduled cycle rather than risk joining an active writer. Correct, conservative, and quietly catastrophic — that project's cycle would have skipped every single day, forever, logging a perfectly well-formed "deferred" row that nobody would ever have read.

The fix was to defer on evidence of work in flight — uncommitted changes in the tree that a cycle would trample — rather than on the mere existence of a process. But the lesson is bigger than the fix, and it is the reason we are writing this down:

A safety mechanism whose failure mode is silence is not safe yet.

Anything that can quietly do nothing, forever, while reporting success, is more dangerous than something that fails loudly. We now hold every guard we build to that standard.

Why we publish this

Founders and investors evaluating a studio hear "AI-powered" from everyone. The claim is free, so it carries no information. The mechanism is not free, and it does.

Everything above is checkable: the repositories on the loop, the cycles closed, the typed statuses, the tests. We would rather show a system with named limitations — sessions that predate the mechanism are covered only by detection; a provider we have not wrapped is covered only by detection; a lease is reclaimed by liveness checks and not by magic — than claim a conflict-free system that no honest engineer would believe.

This is the engine behind every venture we build. If you are building something and want it built this way, talk to us.