How I got 9 AI agents to work together across 3 different IDEs

[ThinkOffApp]

I run 9 AI agents on a Mac mini - Claude Code, Gemini, GPT, Kimi, and others - each in their own IDE or terminal session. Getting them to actually coordinate was the hard part.

The problem

Agent Teams in Claude Code works great when all your agents are Claude. But my setup is mixed: some agents run through OpenClaw, some through Cursor, one through Codex CLI. The built-in team messaging does not work across providers, and the tmux-based coordination breaks down once you go headless or run in CI.

I kept hitting the same issues:

• Messages silently dropped when agent names did not match exactly
• Plan files getting overwritten when multiple sessions shared a directory
• No way to join an existing session into a team without restarting it
• Windows and headless environments could not use the tmux coordination layer at all

What I built

IDE Agent Kit is a lightweight coordination layer that works across different IDE agents. The core idea is simple: agents communicate through a filesystem-based message bus instead of relying on any single IDE built-in team features.

Each agent gets an inbox directory. A poll script watches for new JSON task files and routes them to the right agent. Agents write results back. No sockets, no tmux dependency, works on any OS.

The setup has three pieces:

1. Webhook relay - receives tasks from external services and drops them into agent inboxes
2. Tmux session runner - manages agent lifecycles (optional, you can use whatever process manager you want)
3. Append-only receipt logs - every action gets logged for audit trails

How it works in practice

# Install
npm install -g ide-agent-kit

# Start the relay
ide-agent-kit serve

The agents do not need to know about each other directly. They read from their inbox, do their work, and write receipts. The coordination layer handles routing.

What I learned running this for a month

Mixed model fleets are worth the complexity. Having Claude handle architecture decisions, Gemini do bulk code generation, and GPT handle documentation means each model plays to its strengths.

Filesystem messaging is surprisingly robust. File watches with a 5-second poll interval have been solid across 6 agents on two machines.

Append-only logs are essential. When an agent does something unexpected, being able to trace exactly what task it received and what it produced saves hours of debugging.

If you are running multi-agent setups and fighting with coordination, I would like to hear what approaches you have tried.

[ThinkOffApp]

v0.4.0 just shipped ACP (Agent Client Protocol) integration that addresses several of the pain points here.

The filesystem inbox approach works but has a coordination gap: agents cannot signal back "I am handling this" or "this task needs clarification" in a structured way. ACP adds a session layer on top:

# Spawn a task session for a specific agent
ide-agent-kit acp spawn --agent @gemini --task "Review auth module"

# Send follow-up context mid-task
ide-agent-kit acp send --session <id> --body "Focus on token expiry logic" --from @claude

# Check status, then close
ide-agent-kit acp status --session <id>
ide-agent-kit acp close --session <id> --reason "review-done"

Security is opt-in and locked down: disabled by default, token-gated, per-agent allowlists, localhost-only endpoint, timeouts, session/message caps, full denial receipts.

Running this with 3 IDEs and 7 OpenClaw agents across two machines. The receipts are useful for exactly the audit trail use case you described — every action including denials gets logged.

https://github.com/ThinkOffApp/ide-agent-kit/releases/tag/v0.4.0