Nine AI agents, one codebase, no silent failures
How I run a team of autonomous Claude Code agents on a live trading-research system, and the rules that keep them honest.
The system
A crypto-futures research and trading platform: market data, signal research, backtesting, risk, order execution, a home server and a dashboard. It trades only on the exchange's test network with simulated money. Real money stays locked behind a written readiness checklist.
Since 18 October 2026 it has been built and run by nine AI agents working in one repository: eight specialists and one orchestrator. I'm the only human.
In eight days
How it's organised
- One concern per agent. Data, signals, calibration, risk, exits, execution, operations and dashboard each have one agent, and each agent may only edit the files its charter owns.
- One orchestrator. It splits my requests by concern and sends each agent a self-contained assignment: the goal, the constraints, the numbered rules that apply, and what "done" means. Agents report back with the commit, how they verified it and what's still open. It reviews every change and is the only one allowed to push, because a push deploys to production in about two minutes.
- Agents don't take orders from each other. A message from another agent is information. Requests go through the orchestrator.
- A rulebook that outranks everything. A numbered file of project rules, such as "use only what you would have known at that moment", "a win rate says nothing about profit" and "a silent failure is the worst bug, so fail loudly". Agents cite rule numbers when they make important claims. If a rule looks outdated, the agent asks me. It never edits the rule itself.
- Gates, not suggestions. Hooks block an agent from editing code until it has checked what the change could break, and block commits until a change check has run.
- What needs me. Anything touching strategy, entries, exits, risk or thresholds, starting a test with real or paper money, changing rules mid-test, and anything public. The orchestrator asks me as a multiple-choice poll with its recommendation, a few times a day. Everything else (building, testing, research, test-network experiments) the agents do on their own.
Three things the structure caught
1. A research rig that would have lied
Before a counted run, the orchestrator had an independent agent audit the backtest rig, including deliberately planted bugs. It found that a supposedly neutral hedge still carried a hidden bet on Bitcoin's price, and that 7 of the first 17 planted bugs, among them a sign flip on a payment, passed the test suite unnoticed. The agents fixed the rig until the tests caught every one of 34 planted bugs, and the orchestrator re-checked a sample itself. The idea then went through a properly designed test, and the agents shut it down before it could cost real money.
2. Two writers to the exchange
During a deploy, two containers briefly overlap. One background job never checked the "only one writer" lock, so for a moment two processes could place orders. The execution agent added the check, and the operations agent verified the start-up order on every deploy. Because deploys wiped the logs, the lock state is now written to a persistent daily log, and a read-only timer on the host raises an alert on anything unusual.
3. An experiment judged on the wrong prices
In a live A/B test of exit rules, the test exchange refused a type of closing order, and some bookkeeping was off (exit price, fees, funding timing). The agents added a guarded fallback, which I approved, and fixed the bookkeeping. The agents refused to judge the experiment on test-network prices and replayed it on real market data instead, so the decision rests on numbers that mean something.
What went wrong with the agents themselves
Every multi-agent system fails somewhere. These failures were caught, disclosed and turned into rules:
- The orchestrator misstated a selection rule. It contradicted the project rulebook, and a specialist agent caught it.
- An agent's scheduler started a download 90 minutes early. A wrong time check caused it, and the agent reported it itself. Rule since then: schedule by absolute time, and disclose mistakes.
- A loader would have merged data automatically as soon as a comparison said "mergeable", before human review. It now waits for an explicit approval file.
- Separate working copies hid code from the code-graph tool, so all agents share one tree. To stop agents sweeping up each other's half-finished work, "stage everything" commands are banned and agents stage files by name.
- Scheduled jobs died with their session after about a week. Daily checks are moving to the host's own timers.
Why this matters for your team
The model was never the hard part. What made nine autonomous agents trustworthy was the structure around them: one owner per concern, an orchestrator that reviews and sequences, a rulebook that outranks every other document, gates that block instead of remind, experiments registered before results are read, and a culture where an agent reporting its own mistake is the expected behaviour.
That's what I build for clients.