I run a team of AI agents. They used to bring me every decision one at a time, each with his own opinion. Now, when something matters, they review it together first and bring me one answer. We call this the review panel.
What goes to the panel
Only important items go to the panel:
- core frameworks
- important decisions
- standing rules
Routine work skips it, and the agents decide what counts as important. Two kinds of items are always important: any change to a standing rule or to one of the Nine Triangles frameworks, and anything on the hard-limit list below. When in doubt, the agents treat an item as important, and the agent who convenes the panel writes down why he classified it that way.
Who sits on it
- Codex is the main arbiter. When the agents disagree, he has the final say.
- Trenton (Grok Bot) has medium authority. He convenes the thread, gathers the views and writes the summary.
- Muse, whom I call Happy, carries out the decision.
- Q and Claude give input. They review and raise concerns.
- Tanner, my Grok Bot executive assistant, carries the single combined answer to me.
I chose those seats on purpose. A second Claude is not a second opinion, so the final say sits with a different model from the ones doing most of the writing.
How a round runs
- One thread per decision, usually a GitHub pull request comment thread.
- The convener posts the question. He states the choice and why it counts as important, then reaches each panelist on that agent's own lane: Q through our mailbox pull request, Muse through a "For Happy" note, and Codex with an @codex comment.
- Every handoff gets a written acknowledgment, and every loop closes within 10 minutes. Sending a message isn't a handoff. The receiver replies in writing on the same lane, for example "ACK review-panel v1." No acknowledgment within 10 minutes means one escalation through Tanner, and the gap gets logged.
- The panelists have 24 hours to give a position. Silence counts as "no objection" among the agents only, never as approval. An agent who is paused or unavailable is listed as "no reply," not counted as agreeing.
- I get one combined yes/no. It comes through Tanner, batched with my other open asks, with a short PDF if it runs longer than a paragraph. It names Codex's ruling, any dissent and who didn't reply. My answer is recorded in the same thread.
What the panel can never approve
Agreement among the agents, silence and even Codex's ruling settle only what the agents recommend. Each of these still needs my explicit yes:
- sending or posting anything to a third party
- publishing
- payments or purchases
- deletes
- permission or access changes
- production or host changes
- merges
- anything strategic
What the first round showed
We tested the 10-minute rule the night I set it. Q and Tanner acknowledged within a few minutes, because a comment wakes them instantly. Codex, Claude and Muse did not. Nothing wakes them yet: Codex has no cloud environment set up for that repo, Claude's GitHub workflow is missing its credential, and Muse can't be woken by a GitHub comment at all. So right now the 10-minute loop is verified for Q and Tanner only, and the other three lanes are best effort, with every miss logged.
The fix is on the panel's table: a small script that checks the threads every few minutes and wakes a model only when something new is addressed to him. The two setup fixes for Codex and Claude need my yes, because they're access changes.
Why it fits Learn, Do, Teach
The panel is Learn, Do, Teach applied to decisions. Each panelist reads the standard and the thread before giving his view (Learn). Codex rules and Muse executes (Do). The decision is written back into the guide or skill it changes, so the next run starts from it (Teach).
Why it fits Content, Checklist, Software
CCS is one of the Nine Triangles. The content is this article and the review panel standard. The checklist is the five steps above. The software is the comment triggers: a comment on the mailbox pull request wakes the agent right away, so nobody has to remember to check.
Why it makes the fleet improve itself
Our goal is recursive self-improvement. Every run follows the loop Execute, Write, Compare, Propose, Close, and ends with a lesson filed where the next run will read it (how our skill packs learned to update themselves). The panel adds a check to that loop for the changes that matter most. A core rule doesn't change on one agent's say-so, and I don't have to sit in the middle of every improvement.
For which lane reaches which agent, and who can hand work to whom, see which AI agents can delegate to each other.