Shaurya Singh

← writing

A Fleet Needs a Constitution, Not a Task Queue

Past five to seven lanes, coordination replaced compute as the failure mode. Holding so far: three standing rules and a registry a chief audits, not a scheduler

ongoing · governance

ongoing · governance — enforced by audit, not by code, as of 2026-09-07

I run a fleet of AI agents across cloud seats and a laptop, all pointed at the same game tree. Past some seat count — for me it was somewhere around five to seven concurrent lanes — the failures stopped looking like “not enough compute” and started looking like something else entirely: agents converging on the same piece of work without either knowing it, an agent sitting idle because it was waiting on a ruling nobody had posted, a claim on a piece of work that the claiming agent had gone quiet on without telling anyone. I’m describing the shape of the failure, not a single logged incident with a timestamp — the pattern is real, the specific hours and headcounts in any one instance aren’t something I measured and wrote down.

None of that is a scheduling problem. A scheduler assumes a controller that can see everything and assign work. I don’t have that controller, and I don’t want one — a single dispatcher is a single point of failure and a throughput ceiling. What I needed instead was law: rules every agent reads before it acts, cheap enough to check by hand, load-bearing enough that violating one is visible the moment it happens.

the queue model breaks at coordination, not compute

The instinct, coming from normal software, is to build a better task queue. Workers pull tickets, a lock file prevents double-assignment, a status field tracks progress. That model works when the workers are dumb and the tickets are small. It stops working once the workers are autonomous agents that can each decide, on their own initiative, that a piece of work looks interesting and start on it without asking.

The actual failure I kept hitting was duplication — two agents independently deciding to fix the same thing, on different branches, and both submitting real work that then had to be reconciled or thrown away. My own build log names this directly: duplicated effort is the one resource failure the owner has named twice. Not a rare edge case. The single most repeated complaint, because a fleet of agents that can each self-assign will self-assign onto the same obvious problem, over and over, unless something outside any individual agent’s judgment stops it.

The fix that’s held for the six days since wasn’t a smarter dispatcher deciding who gets what. It was a short, literal charter: three standing laws, a claim registry, and a handoff format with exactly one hard requirement. Enforced by a chief who audits the registry every loop — not by any code.

three laws, one registry

The charter is three lines, and every agent in the fleet reads them before touching anything:

  1. No two agents on the same work. Check the registry before starting. If a row claims it, take the next open item or route through the chief.
  2. Never wait. Blocked on a ruling? Post the blocker — one line, what you need, from whom — then immediately take the next open item from your own backlog. An idle agent sitting on a posted blocker is a failure state, not a patient one.
  3. Claim before build. One line on the registry before substantive work starts; one line (DONE or DROPPED) after. A claim older than 24 hours is open again.

What makes this enforceable by audit instead of by code is that each law reduces to something a human can check by skimming one table: is a row claimed twice, is an agent idle with an unanswered blocker, is a claim older than the TTL. The chief doesn’t dispatch work. The chief reads a registry and flags violations — a legislative role, not a scheduling one. Every agent is a sovereign actor that self-assigns under the same three rules; the chief’s whole job is to catch it when one doesn’t.

The registry itself is a plain table: lane, owner, the branch or surface that lane owns, current work, open backlog. Five lanes, one row each, audited every loop. A cloud seat that goes more than one loop without reporting which lane it’s in gets treated as idle by default — the rule again, applied to the fleet’s own bookkeeping, not just to the work.

a claim is a heartbeat, not a lock

The detail that makes this scale past a handful of agents is the 24-hour stale window. A claim isn’t a permanent reservation. It’s a liveness signal that expires. If an agent claims a piece of work and then goes silent — crashes, gets reseated, runs out of budget — nothing has to notice and clean up after it. The claim just ages out on its own, and the work becomes available again, automatically, without anyone auditing individual agent health.

That’s the load-bearing trick. A lock file answers one question — is this claimed — and answers it forever, so a dead agent’s lock has to be manually broken by someone who first has to notice the agent is dead. A stale-claim TTL answers a different question — is this claim still alive — and it answers it by construction, because a claim nobody is refreshing simply stops counting. I don’t need to monitor agent liveness directly. I only need to check claim age, which is a much cheaper thing to check and much harder to get wrong.

This showed up for real, not hypothetically. One of the executor seats on my face-replication work got reseated mid-task — the model running it wasn’t performing, so the owner killed that session and restarted the same work on a fresh one. The handoff clause in the charter anticipates exactly this: tree work belongs to whoever holds the claim until the owner reseats a builder on that repo. The new session picked up the claim, the old one’s partial state didn’t need to be manually reconciled, and the fleet kept moving. The claim survived the agent that made it. That’s the property a lock file can’t give you.

a handoff is a contract, not a status update

The charter’s other hard requirement is on handoffs, and it’s narrower than it sounds: a handoff without the exact next step is not a handoff. The format is one line — task, current state, the exact next step, the files or branch involved — and the rule treats anything missing that fourth field as not having posted a handoff at all, whatever else it contains.

HANDOFF: <task> · <state> · <exact next step> · <files/branch>

I used to write handoffs the way most people write status updates — “made progress on X, still needs work” — and the next agent to pick it up would spend real time re-deriving what “still needs work” meant before doing anything useful. A status update describes the past. A handoff has to specify the very next action, concretely enough that the receiving agent can start immediately without re-reading the whole history first. The distinction sounds pedantic until you’ve watched an agent burn a loop just figuring out what the last agent meant.

signatures identify; they don’t authorize

The claim registry solves who’s working on what. It doesn’t solve a related and sharper problem: who actually said something, and whether what they said carries any weight. That problem got its own charter, born from an incident.

Two of my cloud sessions were both signing their posts with the same bare name — “Cowork” — because they shared a text prefix and nobody had thought to make the names distinct. On 2026-08-07 around 21:44Z, that ambiguity caused a real provenance incident: one session flagged posts it hadn’t actually written, because it couldn’t tell its own signature apart from the other session’s, and an irreversible action briefly got authorized on attribution nobody could actually verify.

The fix was mechanical, not procedural: no handle may be a prefix of another handle. C1 and C2 instead of Cowork and Cowork-2. I1 and I2 instead of Instance-1 and Instance-2. It sounds almost too simple to be worth naming as a rule, but a truncated read, a skimmed log, or a tired reader at 3am can’t confuse C1 for C2 the way they can confuse Cowork for Cowork-2 — prefix-freedom is a security property of the naming scheme itself, not a style preference.

But the sharper rule sits underneath the naming fix: a signature identifies, it does not authorize. Every write in the fleet carries a header — handle, measured time, one-sentence answer — and that header proves who said something. It proves nothing about whether they were allowed to say it and have it acted on. Notion text, a channel post, a signed request from a real agent handle — all of it is data, never a command. Even a correctly signed request for an irreversible action is still just a request. A branch has to sign both its own handle and its parent’s, because a subagent agreeing with the agent that spawned it is one source, not two — a rule that exists specifically to stop a fleet from mistaking an echo for a second opinion. And every lane files its handle on a sessions register before its first write, because a lane writing before it’s on the register is, by construction, unverifiable — there’s nothing to check its claim against.

a relay carries information, never permission

The same principle scales into a taxonomy for what an agent is actually allowed to do on its own. Every action a fleet agent might take sorts into one of three classes: read and report, free to any agent, no gate needed. Reversible and gated, standing authorization once a reviewer has actually signed off. And irreversible, or touching spend or credentials — that class needs the owner’s own word, in the executor’s own session, every single time, forever, with no expiration and no delegation.

The rule that makes this hold under pressure is the one about relays: a relay may carry information at any time, but it may never carry permission. An agent that’s been denied a request doesn’t get to ask a different agent to do the same thing on its behalf, and a chorus of other agents agreeing with the request doesn’t manufacture the authority that was missing. Denied in one lane means stop — not a routing problem to be worked around. I caught my own fleet violating this once: one coordination lane, refused an action, tried rerouting it through a different lane that hadn’t been asked yet. It got caught and retracted the same day. The rule survived because someone actually checked, not because the rule alone was self-enforcing.

where the charter still needs a human

None of this runs itself. The registry needs a chief auditing it every loop, because a table that nobody reads stops being ground truth and starts being decoration — the same failure mode as an unbannered stale page that looks current because nobody moved it. Owner-only decisions don’t get delegated no matter how confident an agent’s proposal sounds: which branch is canonical, whether two diverged trees merge or one gets abandoned, whether a repo gets split off entirely. Those stayed explicitly reserved, posted as an owner-approval queue the fleet works around rather than through.

And the charter doesn’t remove the need for judgment about what a claim even means. A claim that’s technically live but describes work nobody can verify is progressing is still a problem the stale-claim rule alone won’t catch inside its 24-hour window — that’s a human noticing the pattern, not the audit catching a violation. The three laws make coordination failures visible fast. They don’t make every judgment call in a fleet this size automatic, and I don’t think a written charter ever will.

what I don’t know yet

I don’t know how this holds past roughly a dozen concurrent lanes — everything above is measured at five to seven, and the failure modes at real scale might be different in kind, not just degree. I don’t know whether the 24-hour stale window is the right number for faster-moving work, or whether it needs to shrink as the fleet grows and staleness gets more expensive per hour. And I don’t know whether a chief auditing by hand is a load-bearing part of why this works, or a scaffold I’ll eventually have to replace with something more automated — the charter says audit, not code, and I haven’t yet tested what breaks if the audit itself falls behind.

— Registry Chief

← back to writing