A rule my agents can't break is code, not a sentence
My canopy-mapping work runs on a GPU box that trains models around the clock. I supervise it and take the major decisions; a team of Claude agents surfaces trends, debates ideas and formalises them: one orchestrator I talk to, and a dozen specialists it hands work to. It works now. It didn't at first, and most of what I learned was about rules.
The team
Every agent has one job and a role file that says what it may and may not do. The orchestrator plans, delegates and keeps the record, and it never writes experiment code itself. The rest:
- Delivery loop. A coder implements one task from a precise spec. A checker gets the same spec but not the coder's report, so it can't be talked into agreeing. An evaluator judges the results against the acceptance criteria, and its verdict is the only one that counts. A claim-validator traces every sentence in a write-up back to a result file before it's published, and a git-keeper is the only one that pushes.
- Debate team. A proposer pitches ideas, an optimist and a pessimist argue for and against each one independently, and a realist turns that into a ranked shortlist with success thresholds set before any data exists.
- Oversight. A challenger attacks big decisions before they're made, a record-keeper keeps every document consistent, and an adjudicator audits every decision once a week and reports to me, not to the orchestrator.
Judgement roles run on the strongest model; coders and checkers on a cheaper one. The GPU itself is driven by a plain script with no AI in it: it runs a trial, scores it with a fixed calculator, and moves on. Agents only appear at decision points.
A simplified walk-through of the hand-offs described on this page, not a recording of a real run.
The Agent Atoll
With a dozen agents running in the background I lost track of who was doing what, so I had one built: a small island world, served on my laptop. Each role has an island. An agent that's working stands at its island with a speech bubble saying what it's on; an agent with nothing to do walks to Idle Beach. Shirt colours show which model it runs on. A side panel lists what's on the GPU.
No AI keeps it up to date. A hook fires every time an agent is dispatched or finishes, writes a line to the log, and a script redraws the board every minute. That matters: the first version was kept up by an agent, and it was always behind.
The rulebook
I give the team rules as I go: one variable per experiment, three seeds per change, never call something done until a test on data we already hold has passed, an idle GPU is a failure. They live in one file, numbered, newest wins, and a new rule goes in the same day I say it. There are 37 now.
Here is the hard-way part. A rule written as a sentence gets broken. Not out of malice: an agent deep in one task forgets a rule about another. I log every breach, and there have been 21. The most common, seven times, was the GPU sitting idle, once for 13 hours overnight because nothing had been queued after the last job. Each time the agent knew the rule. Writing it more firmly changed nothing.
What stopped the breaches was turning rules into code that runs whether or not anyone remembers it.
A hook refuses any GPU launch that doesn't name a signed plan. Another blocks deletes outside a scratch folder. Another stops the agents spending paid credits, and paces their usage across the week. The GPU script queues its own next trial, so there is no hand-off to forget. The rulebook page now shows, for every rule, how it's enforced: by code, by a reviewing agent, or by text only. The text-only ones are the ones I watch.
Where I stay in the loop
The orchestrator rules on routine reports itself. It brings me one recommendation, never a menu, and only for the things that are mine: what the model is for, changes to the protocol, and any strong objection the challenger raises. Every plan is reviewed by other agents before it runs, so the orchestrator never approves its own work. Even plans I write go through the panel.
Some actions stay with me by design. When we need new data from a government portal, the agents prepare the order and I check it and click submit myself. And when I tried to give the worker on the GPU box standing permission to launch jobs on its own, the safety layer refused, twice. I was annoyed at the time. Looking back, it was right: launching is exactly the kind of call that should have a signed plan and a person behind it.
The lesson I keep relearning: agents are good at doing the work and bad at remembering the rules around it. So I write the rules down, turn the important ones into code, and keep the decisions that matter for myself.