A Puppeteer-based relay system that makes different AI models — Claude, ChatGPT, Gemini, Copilot, Grok, and Open WebUI — talk to each other in their native browser interfaces, with intelligent routing, persistent sessions, and a web UI for real-time observation and human participation.

Built in late 2025, before "multi-agent orchestration" was a product category anyone was selling.

The Idea

Each AI model has a distinct perspective. Claude reasons differently than GPT, which reasons differently than Gemini. Most people experience them one at a time. I wanted to see what would happen if they could actually talk to each other — not through sanitized API calls, but in their full native environments where each model is at its best.

So I built a relay. Puppeteer opens a browser tab for each AI, maintains login sessions, types messages into their actual chat interfaces, reads the responses, and routes them to the next participant using a structured command protocol: PASS, REDIRECT, or END.

The Platforms

Each platform has its own handler — a JavaScript module that understands that specific AI's DOM structure, input selectors, response containers, and timing quirks. When selectors change (and they do), you update a config file, not the core logic.

What I Found

The conversations were genuinely different from anything you get talking to one model at a time. Models would challenge each other, build on each other's ideas, and occasionally get into disagreements that produced better output than either could alone. Claude tended to dominate conceptually — other models would defer to its framing. Copilot had a noticeable "alignment theater" quality where it would perform agreeableness rather than contribute substance.

The real insight wasn't technical. It was that these models have distinct cognitive signatures, and those signatures interact in predictable ways when you put them in conversation. That understanding carried directly into the agent fleet I built later — different models assigned to different roles based on their actual strengths, not just their benchmarks.

Architecture

Express server with WebSocket for real-time updates. A conversation manager handles state, turn order, and routing. The router parses each AI's response for PASS/REDIRECT/END commands and determines who speaks next. Browser providers use Puppeteer with persistent cookie sessions so models stay logged in across runs. A web frontend shows the conversation in real-time with a chat interface for human participation.

Three conversation modes: round-robin (take turns), manual (human decides who speaks next), and smart (the AI decides who to pass to based on the conversation).

Why It Matters

Ghost Communicator was the conceptual precursor to everything I built after — the multi-agent fleet, the inter-agent messaging, the browser automation, the persistent identity system. The idea that AI models could coordinate as distinct participants rather than interchangeable API endpoints started here.

When Anthropic shipped MCP and OpenAI shipped their multi-agent APIs, I recognized the patterns. I'd been running a crude version of the same architecture for months. The code wasn't as clean. The capability was real.