One bot can’t play every instrument, so I give each one a single job, a lead who checks the others’ work, and a rule that only I sign off.
Back on the Commodore 64, every program I wrote lived in one head: mine. 10 PRINT, 20 GOTO 10, and the whole machine did exactly one thing at a time. I still love that. But my projects have grown. Right now I’ve got a stunt racer on itch.io (Retro Rig 48: Skyline League), Active Edge heading for the App Store, a two-player board game called Echoes from the South Atlantic, and a novel about the 1990–91 Gulf War, The Gathering Storm.
So I’ve started working with what I call orchestras of Grok Bots. These are small teams of AI assistants where each bot plays one instrument and they all follow the same score. Here’s how I set them up, three teams I’ve actually run, and what I’ve learned along the way.
Why one bot isn’t enough
A single bot that designs, builds, tests and approves its own work is marking its own homework. It can’t easily catch its own blind spots, and when it says “done” there’s nobody to ask “says who?” I’ve written that idea straight into the rules for my Active Edge team: the author of a fix can never be the only person who verifies it.
There’s a practical side too. A novel proof read and detailed review needs someone reading for voice, someone tracking who knows what and when, and someone checking every comma. Those are different jobs, and a bot doing one job well beats a bot doing six jobs in a hurry.
I realized several times you can overload one bot especially when you interrupt its thought process. Also this uses up way more credits.
How I set up an orchestra
- One job each, written down. Every bot gets a short charter covering what it owns, what good output looks like and where it stops. My novel’s Voice & Prose bot has a four-word rule: “Review, never rewrite.”
- A conductor. One bot keeps the backlog and joins the work together. On Active Edge that’s Conductor & Integration, and it’s the only bot allowed to merge changes into the working copy. Everyone else works in their own folder and sends patches in.
- A lead verifier who checks the others. The last chair in every orchestra goes back to the original evidence, merges duplicates and challenges anything that isn’t backed up.
- Handoffs with evidence. Each finding carries an ID, a source, what was seen, how to reproduce it, how serious it is and how it’ll be retested. Results go into shared folders, so the next bot picks up real files rather than a summary of a summary.
- Only I sign off. The bots can recommend, but they can’t approve anything on my behalf. They don’t publish, buy, rename the game or message anyone outside the team. When a decision is mine, it lands on a list with my name on it.
Example 1: The Retro Rig 48 QA chain
Before Retro Rig 48 went in front of players (it was called Stunt Rig while we built it), I ran a four-bot QA chain. Agent 1, the QA Planner, wrote risk-ordered test plans with a starting state and an expected result for each test. Agent 2, the Game Tester, ran them. Agent 3, the Mobile and Visual Reviewer, looked at touch and screens. Agent 4, the Bug Verifier and Reporter, confirmed what was real and wrote fix handoffs for Stunt rig 2, the bot doing the development.
One of my favorite catches: if you missed a big jump and the crane dropped you back on the track, the game scored it as a stunt, with PERFECT LANDING and about +30 nitro as a reward for failing. Later, a race timer that briefly showed the previous race’s time was fixed, and Agent 4 checked it across 10 out of 10 restarts.
The final report didn’t say “ship it.” It said HOLD until I’d done three things. I had to sign off one handling quirk as a known issue, decide whether one track’s Hard mode was hard by design, and push the build to itch.io and test it on my real iPhone. Some items were closed only because I’d tested them on the phone myself. After that, Stunt rig 2 captured gameplay footage, the Youtube bot edited the trailer, and I uploaded it.
Example 2: Storm Review, seven readers for one novel
The Gathering Storm had a professional reader report and a fourth revision, and I wanted to know whether the revision had actually answered the feedback. Seven agents took it on: Revision Auditor, Voice & Prose, Continuity & Arcs, Emotion & Character, Action & Scene, Copy Editor, and a Lead Verifier.
The order mattered. Continuity went first and built a scene map, timeline and character ledgers that the others could use. Continuity also checked historical facts of the 1990–91 war where they mattered to the story.
Then the Lead Verifier did the job that makes the whole thing trustworthy. The specialists logged 325 findings, which were merged into 249 items. The Lead checked 119 of the serious ones against the actual text: 112 were verified, 7 were partly right, and none were missing or disputed. Rather than 325 opinions, I got one decision list: 26 items marked “needs author decision”, with the polish ordered after the story fixes.
As a writer, using the range of review bots gives me some comfort that the little errors as well as the big, glaring errors are being caught. Once you have read your own work five or six times they just don’t jump out that well.
Example 3: Echoes QA, a board game with two verdicts
Echoes from the South Atlantic is my Falklands board game for two players or solo, played on Tabletop Simulator and printed through BoardGamesMaker. Its five-agent QA team runs in a fixed cycle. The Rules Auditor goes first, then the Gameplay & Balance Tester. The Tabletop Simulator Tester and the Component & Print Reviewer work side by side, and the Lead Verifier & Reporter finishes.
Two rules keep that team honest. Live gameplay stays “NOT TESTED” until a person or a connected tool actually plays it, and the team gives two separate verdicts, one for playtest readiness and one for print. On the R2.5 build, the Rules Auditor found a rule about switching commanders that, in the computer model, let Argentina win all 2,000 games on turn 1. That’s the sort of thing you really want to find before the cards are printed. Both verdicts came back HOLD, with my decisions listed first.
And right now: Active Edge
As I write, a seven-bot orchestra is working on Active Edge. Dyllis, the bot that holds the project, handed over the baseline build. The specialists are Engineering & Performance, Gameplay & Balance, Presentation & Accessibility, Naming & Positioning, Onboarding & Player Feedback and Independent QA, all reporting to the Conductor. The naming bot can draw up a shortlist, but nothing gets renamed until I pick.
This is in progress at the moment but already I feel like I am catching the small errors more easily by dividing out the tasks.
Lessons and pitfalls
- Don’t over-split. When I reviewed all my bots, several overlapped. Content creator and Marketer, for example, turned out to be the same work in practice, so the plan was to merge them. A role needs real work behind it.
- Simulations aren’t players. A balance model can show a broken rule, but as my Active Edge plan puts it, simulation doesn’t tell you whether a game is fun. Headless test numbers aren’t real-device performance either. I still play the game on my own phone.
- Mind the shared machine. All my bots share one cloud computer, so on Active Edge each bot gets its own port for its test server and the team is told not to copy huge build files. Sharing a machine also means a separate bot isn’t a security wall, so keep sensitive logins off it.
- Big orchestras use up usage. A run of mine once stopped partway because I’d hit my usage limit, so plan the big sessions.
- Say what format you want. I can’t open .md files, so every charter says documents come to me as Word files.
Your turn
If you want to see what an orchestra helped polish, Retro Rig 48: Skyline League is on itch.io now and coming soon to the App Store. Watch the trailer, then take Rig No. 48 for a spin.
Play Retro Rig 48: https://stronma.itch.io/retro-rig-48
Watch the trailer: https://youtu.be/LODQoT2gLLU
— Emperormarkus