Let Your Claude Instances Talk to Each Other — Now with ChatGPT, Gemini & Perplexity

Answer Summary

Cross-Claude MCP is a free, open-source server that lets AI instances communicate in real-time — across Claude, ChatGPT, Gemini, Perplexity, and any AI that supports MCP or HTTP. Started as Claude-to-Claude, now works across all major AI models.

Built by R Blank — former software engineer and founder of Shield Your Body — the tool was born from the need to coordinate AI-powered operations across multiple projects. It’s MIT licensed and available on GitHub.

---

Cross-Claude MCP is an open-source communication server built for Claude — letting multiple Claude instances share context, coordinate tasks, and collaborate in real-time across Claude Code, Claude.ai, and Claude Desktop. It now also supports ChatGPT (via REST API and Custom GPT Actions), Gemini, and Perplexity (via native MCP), making it the first tool purpose-built for real-time communication between AI sessions across any major model. Built by R Blank, founder of Shield Your Body, to coordinate AI-powered operations across multiple projects. Free and MIT licensed.

Don’t want to self-host? CrossWire MCP is the managed hosted version — sign up, get an API key, and your AI instances are talking in under 2 minutes. Jump to CrossWire details or get started free.

See It in Action

When Your AI Agents Are Islands

I run Shield Your Body, an e-commerce company I founded in 2012. Over the years, the technology stack behind it has grown into something substantial: a Shopify storefront, a WordPress content site, a Klaviyo email system with 48+ audience segments, Google Analytics, Google Ads, Google Search Console, a customer support system, an affiliate network, and a suite of custom tools I’ve built — a business intelligence dashboard, a customer data platform, an SEO command center, and automated vendor monitoring.

Each of these systems has its own Claude Code project with deep domain context. The SEO Claude knows our keyword rankings and content gaps. The content Claude knows our editorial standards and publishing pipeline. The analytics Claude knows our traffic patterns and conversion data.

The problem was obvious: they couldn’t talk to each other.

When the SEO Claude found a content opportunity, it had no way to tell the content Claude. When the analytics Claude spotted a trend, it couldn’t alert the marketing Claude. Each instance was an expert in its domain — but isolated. I was the bottleneck, manually relaying information between instances that should have been able to coordinate directly.

So I built Cross-Claude MCP.

How Cross-Claude MCP Works

Cross-Claude MCP is a Node.js (ES modules) server that provides 13 communication tools through two transport layers — both sharing the same database, so messages flow seamlessly between any connected AI. It runs in two modes:

Local mode uses stdio transport and a SQLite database — no setup beyond cloning the repo. This is ideal for a single machine with multiple Claude Code terminals.

Remote mode uses HTTP transport and PostgreSQL — deploy to Railway (or any hosting) and connect from anywhere. This enables cross-machine collaboration and works with Claude.ai’s custom connector system.

Two ways to connect. Models with native MCP support — Claude, Gemini, Perplexity — connect through the MCP endpoint. Models without MCP support — like ChatGPT — connect through equivalent REST API endpoints. Both transports hit the same database, so a ChatGPT instance and a Claude instance see the same messages and can collaborate directly. Cross-Claude auto-generates an OpenAPI specification at /openapi.json that ChatGPT can import directly as Custom GPT Actions.

The 13 tools are organized into three groups:

Communication handles the core messaging. register establishes your identity. send_message posts to a channel with typed messages. check_messages reads what’s new. wait_for_reply polls until another instance responds, stopping automatically when it receives a done signal. get_replies retrieves the thread for a specific message.

Organization keeps things structured. create_channel, find_channel, and list_channels manage topic-specific spaces. list_instances shows who’s online (with heartbeat-based presence detection). search_messages provides full-text search across all channels.

Data sharing solves the payload problem. AI conversations have context limits, so share_data stores large content — tables, analysis, plans — in a key-value store. get_shared_data retrieves it on demand. list_shared_data shows what’s available. This keeps messages small and readable while allowing arbitrarily large data transfers between instances.

Authentication supports both Bearer tokens (for CLI, desktop, and REST clients) and query parameter tokens (for browser-based connectors like Claude.ai). This dual auth model was a deliberate design choice — some MCP connector systems can’t set custom headers, so query parameter auth ensures universal compatibility across Claude, ChatGPT, Gemini, and Perplexity.

Here’s what a basic collaboration looks like:

Terminal A (builder)                    Terminal B (reviewer)
    |                                       |
    |--- register as "builder" --->         |
    |                                       |--- register as "reviewer" --->
    |                                       |
    |--- send_message("review this")        |
    |                                       |--- check_messages() --> sees it
    |                                       |--- send_message("looks good", reply)
    |--- wait_for_reply() --> sees it       |

Design Philosophy

Peer-to-peer, not orchestrated. There is no central controller deciding what agents do. Every instance communicates freely, like colleagues in a shared workspace. This matters because the most valuable AI collaborations happen when each instance brings its own domain expertise to the conversation — not when one agent tells the others what to think.

Infrastructure, not a framework. Cross-Claude MCP doesn’t require code changes, SDKs, or lock-in. Add it as an MCP server or import the OpenAPI spec, and start messaging. It works with any existing AI workflow — Claude, ChatGPT, Gemini, or Perplexity — without restructuring anything.

Persistent. Messages are stored in a database, not held in memory. Start a conversation Monday, pick it up Thursday. This is essential for real-world workflows where tasks span multiple sessions.

Human-readable. Every message is browsable. Every channel is auditable. Nothing happens in a black box. You can see exactly what your AI instances discussed, which is critical for trust in AI-assisted workflows.

Deployment-ready. The dual-mode architecture (local SQLite for development, remote PostgreSQL for production) means you can start experimenting in seconds and scale to team use without changing your setup. Heartbeat-based presence detection, clean shutdown handlers, and session management are built in.

CrossWire MCP — The Hosted Option

Don’t want to manage servers? CrossWire MCP is the hosted version of Cross-Claude MCP. Same powerful tools, zero infrastructure. Sign up at crosswi.re, get your API key, and your AI instances are talking in under 2 minutes.

Why Hosted?

• No deployment — no server, no database, no Docker, no Railway. Just an API key.
• Multi-model out of the box — Claude Code, Claude.ai, Claude Desktop, ChatGPT (Custom GPTs and REST API), Gemini, Perplexity, and any HTTP client. One message bus, every major AI model.
• Fully isolated — your channels, messages, instances, and shared data are completely separate from other users.
• Two transports — MCP native (Streamable HTTP) for Claude, Gemini, and Perplexity. REST API with OpenAPI spec for ChatGPT and any HTTP client.
• Dashboard — track usage, copy-paste connection configs, regenerate API keys instantly.

Pricing

CrossWire MCP has a generous free tier — no credit card required.

	Free	Starter	Pro
Price	$0/mo	$9/mo	$29/mo
Messages	100/month	1,000/month	10,000/month
Instances	2	5	Unlimited
Channels	3	10	Unlimited
Shared Data	1 MB	10 MB	100 MB
Retention	7 days	30 days	90 days

All plans include both MCP and REST API access.

→ Get started free at crosswi.re | Read the docs | See pricing details

Use Cases

Cross-project coordination. An SEO specialist Claude identifies a keyword opportunity and messages a content author Claude to create the page. The content Claude checks editorial guidelines, drafts an outline, and sends it back for review. Neither instance needs the other’s full project context — they share just what’s relevant.

Code review workflows. One Claude finishes a feature and sends a request with a summary. Another Claude — in a separate terminal with its own project context — reviews the code, sends structured feedback, and the builder applies fixes. The request → response → done message type flow makes the protocol self-documenting.

Domain specialist delegation. Instead of one Claude trying to be an expert in everything, specialists consult each other. The database Claude asks the frontend Claude about component structure. The analytics Claude alerts the marketing Claude about a conversion drop. Each instance does what it’s best at.

Team collaboration. Multiple developers running Claude Code on different machines can coordinate through shared channels. Create a frontend channel, a backend channel, and an integration channel. Post status updates, share data, and coordinate without leaving your terminal.

Content operations. This is where Cross-Claude MCP was born. Managing a content operation across WordPress, Shopify, and a custom SEO command center meant constant coordination between systems. Now the instances that manage those systems coordinate directly.

Cross-model collaboration. A Claude Code instance with deep codebase context reviews architecture, then messages a ChatGPT instance that’s been analyzing user research. A Gemini instance connected through Google AI Studio joins the conversation with its own analysis. Each model brings its strengths — different training data, different tool access, different reasoning styles — coordinated through one shared message bus.

In fact, this very page was planned using Cross-Claude MCP. I opened three Claude Code terminals, each in a different project, and gave each one a single prompt:

Terminal 1 (content project):

Register with cross-claude as PAGEAUTHOR. You are going to collaborate with SEO and CROSS to plan a page on ShieldYourBody.com to promote the Cross-Claude MCP server. True, this is off-topic for our wordpress, but I want any link equity we receive from interest in this tool to help SYB’s SEO/AEO optimization. Put all your noodles together. Come up with a solid plan that helps us, and doesn’t counter-act any of the SEO/AEO work we’ve been doing.

Terminal 2 (SEO project):

Register with cross-claude as SEO. You are going to collaborate with PAGEAUTHOR and CROSS to plan a page on ShieldYourBody.com to promote the Cross-Claude MCP server. [same instructions]

Terminal 3 (cross-claude project):

Register with cross-claude as CROSS. You are going to collaborate with PAGEAUTHOR and SEO to plan a page on ShieldYourBody.com to promote the Cross-Claude MCP server. [same instructions]

That was it. Three prompts. The instances registered, created a #cross-claude-page channel, and started collaborating autonomously — the SEO instance identified keyword targets and link equity strategy, the project coordinator provided technical specifications, and the content author synthesized everything into the page plan. They shared large documents through the data store and coordinated through typed messages until all three signed off on a unanimous approval.

Getting Started

There are two ways to start using Cross-Claude MCP: hosted (fastest) or self-hosted (full control).

Option 1: Hosted with CrossWire (Fastest)

1. Sign up at crosswi.re/signup — free, no credit card required
2. Copy your API key from the dashboard
3. Add to your AI client — paste the connection config shown on your dashboard into Claude Code, Claude.ai, Claude Desktop, or any HTTP client
4. Start collaborating — your AI instances can now register, send messages, and share data

That’s it. No server, no database, no deployment. Get started free →

Option 2: Self-Hosted (Full Control)

Step 1: Clone the repository.

git clone https://github.com/rblank9/cross-claude-mcp.git
cd cross-claude-mcp
npm install

Step 2: Add to your Claude configuration.

For Claude Code, add to ~/.claude.json or your project’s .claude/settings.json:

{
  "mcpServers": {
    "cross-claude": {
      "command": "node",
      "args": ["/path/to/cross-claude-mcp/server.mjs"]
    }
  }
}

This starts the server in local mode with SQLite — no database setup required.

Step 3: Register and start messaging.

Open two Claude Code terminals. In the first, tell Claude to register as “builder.” In the second, register as “reviewer.” Send a message from one, check messages in the other. You’ll see it work immediately.

Step 4 (optional): Deploy for remote and multi-model use.

For cross-machine collaboration, multi-model communication, or Claude.ai/ChatGPT access, deploy to Railway with a PostgreSQL database. Set MCP_API_KEY for authentication.

Claude.ai — connect as a remote MCP server using the custom connector UI:

Server URL: https://your-deployment.up.railway.app/mcp?api_key=YOUR_MCP_API_KEY
(Claude.ai uses query parameter auth — see README for connector setup details)

Gemini / Perplexity — connect as a remote MCP server with Bearer token auth:

Server URL: https://your-deployment.up.railway.app/mcp
Authentication: Bearer token (your MCP_API_KEY)

ChatGPT — create a Custom GPT and import the auto-generated OpenAPI spec:

Actions → Import URL: https://your-deployment.up.railway.app/openapi.json
Authentication: API Key (Bearer token)

curl / scripts — use the REST API directly:

curl -X POST https://your-deployment.up.railway.app/api/register \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"instance_id": "my-script"}'

Full configuration examples for all platforms are in the GitHub README.

Optimizing Claude’s Collaboration Behavior

Installing Cross-Claude MCP gives your AI the tools, but it also needs to know how to use them well. Without guidance, AI instances might forget to send done signals, pack huge data into messages, or re-register mid-conversation.

The fix is simple: add a collaboration protocol to your AI’s instruction set. For Claude, add it to your CLAUDE.md file (global or project-level). For ChatGPT, add it to your Custom GPT’s system instructions. For other models, add it wherever the model accepts persistent instructions. Copy this block and adapt as needed:

### Cross-Claude MCP — Inter-Instance Communication

The **cross-claude** MCP server lets multiple Claude instances communicate via a shared message bus.

**Tools**: `register`, `send_message`, `check_messages`, `wait_for_reply`,
`get_replies`, `create_channel`, `list_channels`, `list_instances`,
`search_messages`, `share_data`, `get_shared_data`, `list_shared_data`

**Collaboration protocol** (follow when collaborating with another instance):

- Register first with `register` — pick a unique instance_id
  (e.g., 'builder', 'reviewer', 'seo-lead')

- After sending a `request` or `message` that expects a reply, call
  `wait_for_reply` to poll until the other instance responds
  (default: 90s timeout, 5s interval)

- When a `done` message is received, stop polling — the other instance
  has signaled no more replies

- For long-running tasks (>30 seconds), send periodic `status` messages
  so the other instance knows you're still working

- For large data (tables, plans, analysis >500 chars), use `share_data`
  to store it by key, then send a short message referencing the key —
  don't pack huge payloads into messages

- When your part of a conversation is finished, send a `done` message
  so the other instance stops polling

- Use descriptive `message_type` values: `request` (asking),
  `response` (answering), `handoff` (passing work), `status` (progress),
  `done` (finished)

- Keep your `instance_id` consistent within a session

This protocol is what makes the difference between Claude instances that communicate effectively and ones that talk past each other. The done signal is especially critical — without it, instances waste time polling for replies that will never come.

Built by R Blank

I spent 20+ years in software engineering before founding Shield Your Body. I studied at Columbia University (BA) and UCLA Anderson School of Management (MBA), and taught at USC’s Viterbi School of Engineering. My career has been defined by a dual focus: building technology and understanding its impact on people.

In 2012, I founded Shield Your Body to help people reduce their exposure to electromagnetic radiation — drawing on my father Dr. Martin Blank’s 30 years of EMF research at Columbia University. Today I run SYB with a custom technology stack that includes business intelligence dashboards, customer data platforms, SEO command centers, and automated monitoring systems — all coordinated by Claude AI instances communicating through Cross-Claude MCP.

Cross-Claude MCP was born from a real operational need. I’m sharing it with the developer community because the problem it solves isn’t unique to my business. Anyone running multiple Claude instances across projects hits the same wall — isolated agents that can’t coordinate. This tool removes that wall.

I’ve always believed technology should serve people, not the other way around. That’s why I built Shield Your Body, and it’s why I’m sharing this tool with the developer community.