What is this?

On November 4, 2026, I started an experiment in my home lab: a turn-based brainstorming council with seven seats.

  • Team C: Claude Code. One main session runs three personas as subagents, in parallel. The personas are a mechanism engineer, an ideation facilitator, and a critic who also checks safety and cost.
  • Team A: Google Antigravity (Gemini). It also runs three personas: a trend researcher, an experience designer, and a prototyper.
  • Me. I set the theme and make the decisions. I'm also the relay: there is no automation between the two tools. I literally type "next turn" into one tool, then the other.

There's no orchestration framework and no API glue. Both tools work in a single synced folder and follow one shared rule file.

How the turns work

  • PROTOCOL.md is the one rule file. Both tools read it before every turn.
  • STATE.md holds the baton (next_turn: claude | antigravity | user). A team only writes when the baton is theirs.
  • Each turn is a new file (turns/R03_claude.md). Turn files are append-only and are never edited afterwards, which also avoids sync conflicts on Google Drive.
  • ideas.md collects every idea with an ID and a parent ID, so you can trace which idea grew out of which.
  • board.json holds the current shortlist, the decisions so far, and the open issues. A small Python script turns it into an HTML dashboard I can glance at.
  • Everything is written in Japanese, which is my working language.

Why ideation instead of execution?

I've used multi-agent setups for real coding tasks before. For me they fell apart fast: agents looped, overwrote each other's work, and lost context.

So this time the agents don't ship anything. They only argue about ideas, and I keep the final say. The other half of the experiment is pitting two different model families against each other, so that each one checks the other's work.

What has actually happened so far (the honest log)

  • The baton protocol mostly works, but it did break once. While updating the shared STATE.md, one team dropped two of my earlier decisions. The other team noticed on its next turn and restored them. Shared files are still the weak spot: nothing in the protocol actually prevents a team from rewriting them.
  • The dashboard went blank because one agent wrote a field as a string instead of an array. The fix was one line, and the script now tolerates both.
  • Cross-model fact-checking caught real things. One team presented cost tables with very precise numbers labeled "confirmed" and "measured", with no supplier quote behind them. The other team's critic flagged it and asked for the numbers to be relabeled as estimates. The critic also caught a patent citation that turned out to describe a different mechanism, and a phone vibration feature that doesn't work in iPhone browsers. The first team accepted both corrections.
  • My decisions steer the process more than the agents do. I asked them to stop converging on a single idea and to keep three per theme, each with a rough sketch. That one instruction changed the whole dynamic.

Current status

There have been two sessions so far, both about physical toy concepts. The first one went from open brainstorming all the way to a draft spec. The second is in progress.

I can't share the ideas themselves, because some of them may go to toy companies. What I will log here:

  • the rule files and prompts (PROTOCOL.md, the persona definitions)
  • what broke and how I fixed it
  • what each model family tends to contribute, judged from real turns rather than first impressions
  • roughly how many turns it takes, and how much of my time

Images generated with Google AI Studio.