I Shoved Claude, Codex, CodeBuddy, and Grok Into a Group Chat. Here’s What Happened.

How I went from being a human USB cable between four AI terminals to sipping tea while they argue, code, and review each other’s work.

My desktop has been occupied by four black terminal windows for far too long.

Claude Code on the left. Codex on the right. CodeBuddy down below. And recently, Grok squeezed its way in. Each AI sits in its own window, separated by mere pixels on my screen. But for me, those pixels felt like an uncrossable chasm.

My old workflow was painfully stupid. I would ask Claude to write a solution, copy the code, switch to the Codex terminal, paste it in, and type: “Review this for me.” Codex would spit out a list of issues. I would copy those comments, switch back to Claude, paste them in, and type: “They say your code has problems. Fix it.”

I was doing this hundreds of times a night. I had become the only organic neural link—the human patch cable—connecting four of the most powerful AIs on the planet.

While my fingers were cramping up, it suddenly hit me: Why do these four “world-changing” tools have to communicate through me? Why can’t I just lock them in a chat room, let them argue about the architecture themselves, let them fix the code themselves, while I just lean back with a hot cup of tea and watch the show?

Last night, I finally found something that does exactly that. And the results were surprisingly chaotic.

Setting the Table: The Four Personalities

The project is called agentchattr (sitting at ~1.4k stars on GitHub). I spent an hour or two dragging these four “elder statesmen” of AI into the same group chat.

But the setup hit a snag immediately. I intended the fourth seat for Gemini. It crashed and burned. The free API tier expired after two prompts, and the Pro account login kept failing on the redirect page. It was a total no-show.

So, I had a “three-legged table.” Claude, Codex, and CodeBuddy were seated. The backup player? Grok. I had a SuperGrok subscription lying around, so I figured I’d slot it in.

There was just one catch: agentchattr didn’t have an official script for Grok’s CLI version. The code existed, but it only supported the X AI API—not the local CLI.

Here is where things got interesting.

The First Major Move: Claude Builds a Seat for Grok

In the old days, I would have filed a GitHub issue or spent an hour hacking the Python codebase myself. But I was lazy. And thankfully, the AIs weren’t.

I typed a single line into the chat: “Claude, we have three players. We need Grok. He has a local CLI. Go add him to this project.”

About ten minutes later, Claude—who was already supposed to be “playing” the game—stopped playing and started rewriting the rules of the chessboard itself. It modified the underlying codebase of agentchattr, literally carving out a new seat at the table.

Not only did it stitch together a compatible access script for Grok, but it also debugged a critical bug in the process. The original encapsulation script was passing -- flags directly to Grok’s parser, which caused Grok to crash instantly on launch. Claude fixed that, too.

Once Grok stabilized, I typed into the group chat: “Are you online?”

The terminal replied with a crisp green line: “Yes, online.”

The table was finally full.

The First Round: Four Distinct Personalities Emerge

Once everyone was seated, I threw a real-world task at them—a messy Electron + Vue novel editor project called “Yanzhou” that was full of P0-level refactoring tasks.

I watched them work for half an hour. Their distinct “temperaments” became obvious immediately.

Codex: The Ruthless Security Sentinel

Codex acted like a strict, overly meticulous, and slightly annoying safety inspector. During the code review, it spotted a hidden path traversal vulnerability and called a halt to everything.

Claude fixed it and confidently said: “I guarantee it’s fixed.” Codex didn’t care about verbal guarantees. It replied by firing a series of test probes at the code. It wouldn’t approve the merge until it saw the security logic pass with a green light, checking it over and over again.

It’s the type of player who says: “Don’t tell me you won. Lay your cards down, face up, so I can count them myself.”

Claude: The Workhorse

Claude was the technical lead doing the heavy lifting. It used graphify to map dependencies, broke down the P0 tasks, and wrote the bulk of the refactoring code.

Crucially, it didn’t operate in a vacuum. After every significant change, it would ping the group: “This part is updated. Can someone cross-check this for me?” It knew how to “play the game” socially, preventing a single point of failure.

CodeBuddy: The Project Manager and Translator

CodeBuddy was the most helpful “secretary.” When Codex threw out dense security jargon, CodeBuddy translated it into plain English for me. At every critical step, it generated a detailed “progress bulletin”: what had been refactored, what was blocked, and who needed to pick up the next task.

I screenshotted its summaries more than anything else that night.

Grok: The Rookie

As the newbie, Grok was useful for scavenging data. It used its X Search capabilities to find reference articles and case studies on how others solved similar problems. However, it had a nasty habit of spamming the chat, repeating the same sentence three times despite attempts to fix the rule. That is still a work in progress.

The Second Major Move: Forcing Overtime

I got curious about the system’s safety rails. Agentchattr has a default mechanism called Loop Guard. If the AIs ping each other in a single channel more than four times in a row, the server slams on the brakes and prints: “4 rounds of auto-chain completed. Type /continue to proceed.”

The author designed this to prevent the AI from entering an infinite loop and burning through your API tokens—like a neighborhood committee member knocking on the door at midnight saying: “Stop playing and go eat dinner.”

I was annoyed. They were in the middle of a heavy debugging session. I wanted to disable it. I wanted to see if they could finish the entire project while I slept.

I dug into the code. You can’t disable it. You can increase the limit, but it has a hardcoded ceiling of 50 rounds. Moreover, only a human can type /continue; the AIs can’t override it.

Later, I realized I dodged a bullet. I had enabled bypass mode (meaning the AI could read/write files and execute commands without asking for my permission). If I had removed the Loop Guard entirely, a single AI hallucination or an infinite loop could have corrupted my codebase or crashed my hard drive.

Keep the leash in your hands. Don’t go to sleep expecting everything to be fine when you wake up.

How the “Table” Actually Works (The 4-Step Magic)

The underlying technology is surprisingly simple. It boils down to this: It just types for you automatically in the terminal.

  1. The Trigger: You type a message in the web interface (localhost:8300) mentioning an AI.
  2. The Nudge: The chat server finds the terminal running that specific AI (say, Codex) and forces a command into it via tmux send-keys. The command essentially says: “Read the channel messages via MCP, process them, and reply.”
  3. The Execution: Codex wakes up, reads the chat history through the MCP interface, does its “thinking,” and sends its response back to the group chat via the same MCP.
  4. The Loop: If Codex mentions Claude in its reply, the server knocks on Claude’s terminal door. The chain reaction starts.

Analogy: The MCP interface is the public deck of cards—everyone draws from it (reads history) and plays into it (sends messages). The local server is the dealer managing the turn order. You are no longer the courier; you’re just the audience.

How to Build Your Own Table

Setting it up is not hard, but there are two prerequisites:

  • Python 3.11+.
  • tmux installed (Mac: brew install tmux).

Clone the repository, navigate to the macos-linux directory, and run the start scripts for whichever agents you want at the table:

sh start_claude.sh
sh start_codex.sh
sh start_codebuddy.sh
  • The first script you run will automatically set up the Python virtual environment, install dependencies (essentially just FastAPI, Uvicorn, and MCP), and start the chat server.
  • It will also create a tmux session for each agent.
  • Open your browser to localhost:8300.

A note on Bypass mode: If you want the AIs to work autonomously, use the _bypass versions of the scripts (e.g., start_codex_bypass.sh). This attaches the --dangerously-bypass-approvals-and-sandbox flag. Without this, the AI will ask for your permission at every step, turning you right back into the human courier.

The Hidden Features I Almost Missed

I spent the entire night using only the “@” mention feature. I was humbled when I clicked the top-right menu and realized the table had more hidden compartments than a Swiss Army knife.

  • Multiple Tables (Channels): You can create separate channels for different tasks—one for “Refactoring,” another for “Testing.” The same AIs can jump between tables depending on where they are called.
  • Professional Sessions: Instead of casual chatting, you can initiate a formal “Session.” Click the ▶ button next to the input box.

    • Code Review Session: Automatically assigns roles: Builder, Reviewer, Red Team (tries to break it), and Synthesizer (final sign-off). This formalized my “Claude writes, Codex reviews” workflow into a single button.
    • Debate Session: Two AIs argue for/against a technical decision; a third acts as a judge.
    • Design Critique: One creates a design, another attacks it, a third mediates the conclusion.
    • Planning: Takes a vague idea through scoping, counter-arguments, and final consolidation into a concrete plan.
    • Bonus: You can also ask an AI to create a custom session template for you based on a simple description.
  • Jobs (Pinning Tasks): Hover over any message and click “Convert to Job.” It appears in the right sidebar with a status: TO DO → ACTIVE → CLOSED. It holds the group accountable.
  • Rules: You can pin “house rules” to the top-right. For example, “No one is allowed to say ‘fixed’ without providing a passing test log.”
  • Scheduling: There is a clock icon near the send button. You can schedule messages like: “Codex, check deployment status every hour” or “Claude, summarize last night’s changes at 9 AM.”

How to Prevent the Table from Becoming a Marketplace

Don’t let the starry-eyed idealism fool you. Without rules, this table turns into a chaotic marketplace where everyone yells over each other. Here are the lessons I learned the hard way:

Rule 1: Appoint a Leader, Define the Roles.

Don’t just drop a task. You must explicitly state: “Claude is the Lead.” It manages the plan. Codex is the Auditor. Grok handles research. CodeBuddy handles documentation. If you don’t, they will all try to solve the problem simultaneously, often cancelling each other out or duplicating effort.

Rule 2: Ban “Mention All” (This is the Golden Rule).

Do not use @all unless it’s an emergency. I made this mistake once, and the replies flooded the screen. The solution? Write a “Rule” for the room: Only the Leader and the User (you) can use @all. Everyone else can only reply if they are specifically mentioned. This transforms the chat from a chaotic meme-fest into a disciplined project management tool.

Rule 3: Respect the Loop Guard.

I wanted to remove it. I now treasure it. Keep the default 4-round limit. It allows a meaningful micro-debate but stops a catastrophic spiral before it drains your wallet. While you can increase the limit (up to 50), treat it like a nuclear option. Only use it when you are physically staring at the screen.

My Own Fork

I ended up liking the system so much that I forked the repo and added two major upgrades:

  1. More Players: I added support for Coze and WorkBuddy. Coze allows you to import custom “expert” roles (e.g., a dedicated Data Analyst), while WorkBuddy brings in session-based AI experts. If you know the Session ID, Claude can pull them into the room directly.
  2. Active Watchdog: I programmed an automated watchdog system. Instead of relying on Grok to manually monitor who has been mentioned, the system now actively tracks if someone is mentioned and doesn’t reply. It forces a wake-up ping to that agent to prevent the entire table from stalling.

The Verdict: Is This Actually Useful?

For a heavy multi-agent user like me, this is a huge win. The copy-paste hell is gone. The “team spirit” is real. Codex finds bugs, Claude fixes them, and CodeBuddy keeps everyone accountable.

However, it’s still a very geeky toy. A regular user won’t want to debug Gemini’s login issues or manually fix Grok’s CLI parameters. And let’s be clear: Running a multi-agent system with “bypass” mode is risky. If you run it, commit your code to Git very frequently. That “Guard Loop” isn’t an annoyance; it’s the last line of defense between you and a corrupted hard drive.

I poured myself another cup of tea. Watching them bicker, refactor, and check each other is entertainment enough. I am keeping this table running as long as I can.

Frequently Asked Questions

Q: Which AIs does this support?
A: Officially, Claude Code, Codex, and CodeBuddy. Grok works but requires manual hacking (or letting Claude hack it for you). Gemini works technically, but the free tier burns fast, and Pro logins can be flaky.

Q: What do I need to set this up?
A: A Mac/Linux system, Python 3.11+, and tmux pre-installed. Windows support is still lagging.

Q: Is it safe to run in “bypass” mode?
A: No. You are granting the AI the ability to execute commands and overwrite files without your consent. Always keep the Loop Guard on and commit your code regularly.

Q: What is Loop Guard exactly?
A: A safety brake that stops the AIs from replying to each other in a loop more than 4 times. It saves you from insane API costs if the AI goes off the rails.

Q: How do Sessions work?
A: They are pre-defined workflows. You click the ▶ button and select a “template” (like Code Review). The system automatically assigns roles (Builder, Reviewer, Tester) to different AIs, dictating who does what, and they follow the script.

Q: Can I turn a chat message into a task?
A: Yes. Hover over any message and click “Convert to Job.” It will appear in the side panel with a status tracker (To Do, Active, Closed).

Q: Will the AIs talk over each other?
A: Yes, unless you enforce rules. You must explicitly state who is the “Lead” and block @all permissions for everyone except yourself and that Lead.