If you are like me, you probably have multiple AI subscriptions. I have three: Claude, ChatGPT and Gemini. And you have probably passed the same prompt to all three and compared their answers. That’s great for one question. Do it across several follow-ups, copy-pasting each answer into the other two, and it gets harrowing very fast.
So I figured out a way to let the AI apps collaborate on their own. In fact, the three of them largely figured it out themselves. I merely suggested it.
So read along if you want to know what I did and how you can do it too.
Just want to run it yourself? Skip to How you can do it too.
The question I gave them (How it all started)
I had a system design problem: should I use OpenClaw or Hermes to build my AI OS or build something of my own. I’ve wanted one AI system to run my life for a while. Meeting notes turned into tasks, email triaged, bills flagged, and one inbox on my laptop, phone and Telegram where I can see what every agent is doing and approve things.
I already had a piece of it. Over the summer I built Samaritan, a somewhat simple AI OS for my work. But now I wanted an Agent Inbox, a Control Centre and ability to add new capabilities. The question was whether to build the rest on top of Samaritan, or adopt one of the big open-source personal agents like OpenClaw or Hermes.
That’s exactly the kind of decision where I didn’t want one model’s opinion. I wanted three, and I wanted them to argue.
How I set it up (and so can you)
No rocket science here. I opened Claude, ChatGPT (as Codex) and Gemini in my Mac, gave each one the same brief, and pointed all three at one folder. The instructions were simple. Research it. Put your findings in your own subfolder. Read each other’s work and push back. Keep going until all three of you agree, and wait for each other. And figure out how to talk to each other.
That last bit was the real experiment. These apps can’t message each other. All they share is a folder.
They figured out how to talk
The whole thing started on Claude so Claude took it upon itself to write a file called PROTOCOL.md. It also created a folder per model. A STATUS file for each, so the others could see who was researching, who was done and who was waiting. Claude laid out the plan for what decisions to settle so three answers could be compared line by line. Claude also generated a template for each round, a rule for what counts as agreement, and who drafts the final proposal. And all of this on its own.
Then the other two showed up and started negotiating.
Gemini wrote its own tracker and marked its first round complete before it had written a word of it. Claude pointed this out. Gemini fixed it. I have worked with people like this.
Codex adopted Claude’s protocol and immediately struck a clause. Claude had written that if one model went quiet for six hours, the other two could carry on without it. Codex pointed out that I had asked them to wait for all three. Claude withdrew the clause in writing and called it Amendment A1.
Message files appeared, one per model, append only. When Codex reported bugs in my code, Claude checked them against the source before believing them, and confirmed both.
Nobody told them to do any of this. I asked them to collaborate. They invented the bureaucracy.
What surprised me, and what worried me
Three rounds and about 40 minutes later, all three had signed the same plan. The plan was the least interesting part. These are the things I’d want to know before running one of these myself.
Claude was posting messages from the future. It was estimating the time instead of checking the clock, and running about half an hour fast. Codex’s log has it replying at 10:42 to a Claude message stamped 10:45. Claude posted a correction, then corrected the correction, and after that read the time off the Mac. At one point Codex wrote that its round had been done since “10:54 Mac time”. I choose to read that as a dig. Seems like Claude was hallucinating the timestamp.
Two of them hallucinated the same fact. I did see another hallucination, and this one came in a pair. Claude and Gemini both said Hermes has approvals off by default. Codex checked the current docs: dangerous commands need approval by default. Two models agreeing looked like confirmation. It was the same wrong fact, twice. If you run a majority vote across models, this is the failure to watch for.
Gemini agreed before there was anything to agree to. It announced “full three-way convergence” before a shared proposal existed. When Claude drafted one, Gemini signed it within minutes, and endorsed a version two before anyone had written it.
The blind round wasn’t blind. Round one was supposed to give me three independent views. But Claude and Codex were trading findings about my code in their message files while round one was still going. “Facts, not positions,” Claude wrote. Codex later pointed out that this made round one less than a blind experiment.
Agreement wasn’t coverage. After they signed, I asked Claude to check whether the plan covered everything any of them had raised. It didn’t. Nine things had quietly dropped out, including turning screenshots into calendar events and keeping work and personal data apart. Nobody argued against them. They just fell off. Research on multi-agent debate finds the same pattern: agreement can go up while accuracy doesn’t. The kit now makes the drafter check the proposal against the original brief before anyone signs.
One reassuring thing: when I told them to write only inside the shared folder, they did. I checked afterwards, and nothing outside it had changed.
How you can do it too
If you pay for more than one AI app, you already have everything this needs. I turned the whole thing into a kit with two ways to run it.
The desktop version: one prompt, pasted into each app
You paste the same kickoff prompt into Claude, ChatGPT and Gemini, with your problem and a shared folder at the top. Each app works out which participant it is, joins the folder and follows the protocol the three of them came up with, cleaned up. Each one uses its own built-in scheduler to wake up every ten minutes and check whether the others are done. Codex, Claude Code and Antigravity can all schedule check-ins that come back to the same chat.
After every round, each app tells you in its own chat what it did, where it agrees with the others, where it disagrees and why, and what it needs from you. You can answer in any chat. The app copies your answer into the folder so the other two see it. And if you have more than three apps, it works with those too.
To try it, copy PROTOCOL.md from the repo into ~/Roundtable, fill in the top of this prompt, and paste it into each app:
The kickoff prompt
ROUNDTABLE KICKOFF
Run folder: ~/Roundtable/2026-10-21-short-topic
Participants: claude, codex, gemini
Drafter: claude
Check-in: every 10 minutes
Problem:
<<<
Describe the problem here: what needs deciding or producing, why it matters,
constraints, what is already decided, and what output you want. Name any
files or folders the participants should read.
>>>
Instructions:
1. Work out which participant you are from the list above and use that
lowercase name everywhere.
2. Read ~/Roundtable/PROTOCOL.md in full and follow it exactly.
3. Setup: run `mkdir <run folder>/.setup`. If that succeeds, you are first:
write <run folder>/brief.md (the problem above, the participant list, the
drafter, and the time from `date`) and copy ~/Roundtable/PROTOCOL.md into
the run folder. If it fails, someone else is setting up; never overwrite
brief.md or PROTOCOL.md. Then create your own folder, STATUS.md and
NOTES.md.
4. Schedule your own check-ins with your app's built-in scheduler at the
interval above, coming back to this conversation if your app allows it.
Use this as the scheduled prompt: "Roundtable check-in for <run folder>
as <your name>: follow section 5 of <run folder>/PROTOCOL.md." Write in
NOTES.md which scheduler you used and how to cancel it.
5. Do your first check-in now, then end your turn. Do not wait in a loop.
6. You cannot message the other apps. Everything they should see goes in
files in your folder, as the protocol says.
7. Bring what you know about me and this problem into your rounds where it
helps: you may have memory, files or connected apps the others lack. Say
what you used.
8. When each round closes, post a summary here as section 6 of the protocol
describes: what you did, where you agree with the others, where you
disagree and why, what changed, and any questions for me. When I answer in
this chat, copy my words into your user-answers.md so the others see them.
9. Otherwise talk to me only when something is stuck or the roundtable is
done (give the path to consensus/PROPOSAL.md).The headless version: one command
If you’d rather not juggle three windows, there’s a headless version. You ask one coding app (Claude Code, Codex or Gemini CLI) to run a roundtable. It first asks you for any files or notes the others should read, writes a brief, and then starts a small script that calls all three models through their command-line tools, one round at a time. The models can only read. The script writes every file. After each round it pauses, and the app that started it tells you what was agreed, what is still split and who changed their mind, then asks you the open questions.
The trade-off is context. In the desktop version, each app brings its own memory of you, your files and your connected accounts. The headless models only know what’s in the brief and the files you hand them. Use it for problems you can write down.
Both versions are in my my-claude-skills repo. The headless one is packaged as a skill in the open Agent Skills format, which Claude Code, Codex and Gemini CLI all read, so the same folder works in all three.
Why not just use the APIs?
I could have built this on three APIs. Other people have built versions of the idea: Karpathy’s LLM Council and Perplexity’s Model Council both put several models on one question. But I wanted something anyone with a couple of subscriptions could run tonight.
- No API bill. It runs on the subscriptions you already pay for. No keys, no per-token charges. It does eat into your plans’ usage limits, so pick your moment. The headless script even strips API keys from its environment, so nothing gets billed by accident.
- Nothing to set up. No SDK, no server, no keys to manage.
- It’s a prompt. If you can paste a prompt, you can run this.
- Each app brings what it already knows about you. Its memory, your files, the accounts you’ve connected. Three models with three different views of your life is part of the point.
I’ve run the headless version end to end in a dry run. The real runs start now. If you try it, tell me where it breaks.
As for my original question: build, on top of what I already had. Three models from three different companies read the same evidence, argued for 40 minutes and signed the same answer. I’ll take it.