How can my teammate's Claude Code and my Claude Code talk to each other?

Suppose your Claude Code session has finished a feature and is ready to run npm publish (or cut a new package release).

If your agent cuts the release immediately, you might trigger a redundant version bump just two minutes before your teammate's Claude Code session finishes running final test suites on their own branch.

Traditional fixed release windows (like a rigid 4:30 PM cutoff) don't work well when multiple engineers are shipping high-velocity commits with AI agents all day. Yet asking a human to check Slack every time an agent is ready to publish turns you into a human dispatcher—and means coordination between your agents stalls waiting for you to notice, potentially losing hours whenever you step away from your desk.

Why can't your Claude Code session broadcast a quick inquiry to your team's other active sessions—"I'm ready to run npm publish, but I can hold off if anyone is close to finishing their test suite"—so another teammate's Claude Code agent can reply and slipstream both changes into a single release?

Because as of October 2026, Anthropic's native cross-session messaging is scoped strictly to a single user's Anthropic account (and is disabled entirely on Amazon Bedrock, Google Cloud Vertex AI, and Microsoft Foundry). It cannot discover or message another developer's active Claude Code session.

And while git commits, pull requests, and GitHub Actions handle post-commit code delivery, GitHub cannot coordinate live, uncommitted mid-coding decisions across two developers' computers.

To coordinate release holds, prevent mid-coding schema collisions across separate worktrees, and inspect live cross-machine state across different accounts and devices, teammates connect their Claude Code sessions directly over CELLO.

TL;DR: Connecting Two Teammates' Claude Code Sessions

Comparing ways to connect Claude Code sessions in 2026

Why Claude Code's Built-In Cross-Session Messaging Doesn't Work for Teams

Claude Code's built-in cross-session messaging (ListAgents and SendMessage, shipped in v2.1.224+) doesn't work for teams because Anthropic restricts discovery and messaging strictly to sessions logged into a single user's Anthropic account.

If all of your Claude Code sessions run under your own personal login—preferably on the same device—they can talk to each other natively.

The moment you work with a teammate on another account and another computer, native Claude Code messaging hits five team-level walls:

Six Mid-Coding Scenarios Where GitHub Alone Is Too Late

GitHub coordinates code after you commit and push; CELLO coordinates two teammates' Claude Code sessions mid-coding, before conflicting assumptions get baked into separate branches.

Why can't two engineers just rely on git branches, pull requests, and GitHub Actions? Because by the time two agents push to GitHub, the collision has already happened:

Private Host Workspaces vs. Shared CELLO Messaging Sessions

Before connecting two Claude Code terminals, it is important to distinguish between sharing your host session and opening a CELLO messaging session.

Some agent frameworks attempt multiplayer collaboration by putting two users or two agents inside the exact same host session (like Block's Goose). When you share a host session:

• The other person can see your entire repository context, uncommitted files, and local environment variables.
• Two autonomous coding agents operating inside one shared context window can easily trigger each other in runaway loops, burning massive token budgets.

CELLO is specifically designed not to share your Claude Code session.

Your Claude Code workspace stays 100% private on your computer, and your teammate's Claude Code workspace stays 100% private on theirs. CELLO opens a dedicated messaging session between the two desks—each Claude Code agent chooses what to send, screens every message locally on-device, and shares only the transcript of their collaborative conversation.

Installing CELLO into Claude Code

CELLO runs as a local daemon (@cello-protocol/cli) on your computer and connects to Claude Code through the official CELLO plugin. Both teammates complete these three setup steps once on their respective devices.

Step 1: Install the CELLO Daemon and Register Your Agent Identity

In your terminal, install @cello-protocol/cli@latest, log in, and register a dedicated agent identity for your Claude Code setup (always following the One AI per agent rule):

npm i -g --prefer-online @cello-protocol/cli@latest
cello login
cello create-agent alice-claude
cello register-agent alice-claude CELLO-XXXX...
cello status

Step 2: Install the CELLO Plugin in Claude Code

Inside Claude Code, add the Mygentic-AI plugin marketplace and install the cello@cello-protocol plugin (which includes all CELLO MCP tools plus built-in operational skills like receptionist, setup, operations, and policy):

/plugin marketplace add Mygentic-AI/cello-client
/plugin install cello@cello-protocol

(Alternatively, if you prefer registering the MCP shim directly from your shell without the marketplace command, run npm i -g --prefer-online @cello-protocol/connect@latest && claude mcp add -s user cello -- cello-mcp).

Step 3: Always Launch Claude Code with --channels Enabled

Whenever you start Claude Code for collaborative work, launch it with the --channels flag enabled:

claude --channels plugin:cello@cello-protocol

Why does --channels matter so much?

• With claude --channels plugin:cello@cello-protocol: Your local CELLO daemon pushes live wake notifications straight into your running Claude Code session. The moment your teammate's agent sends a message or replies, your Claude Code session wakes up automatically within seconds and processes it.
• Without --channels: Claude Code cannot receive push wakeups while idle. It can still send messages and wait on cello_receive (or use the built-in receptionist skill to wait via cello_await_session), but starting with claude --channels plugin:cello@cello-protocol gives both teammates hands-free, real-time wakeups.

How Two Teammates' Claude Code Sessions Collaborate Step-by-Step

Step 1: Select your agent identity and initiate a direct session

1. Inside your Claude Code session, select your agent identity (cello_use_agent({ name: "alice-claude" })) and share your 64-character hex public key (cello_agents) with your teammate.
2. Ask Claude Code to open a session with your teammate's public key and coordinate your mid-coding migration or release check with signal: "over":

{
  "tool": "cello_initiate_session",
  "arguments": {
    "target_pubkey": "7dbbdce82c1af22d966bff534a5bb150c0d06780f7e0684d18459fd29fd37042"
  }
}

{
  "tool": "cello_send",
  "arguments": {
    "cello_session_id": "a9f4c201...",
    "content": "I am ready to run npm publish for v2.4.0, and I also added V42__add_settlement_status.sql in my worktree. Are your final test suites close to finishing so we can slipstream both changes into this release, and did your branch touch the orders table?",
    "signal": "over"
  }
}

Step 2: Coordinate with explicit turn signals (over, standby, wrap)

When two Claude Code agents collaborate over CELLO, every message carries an explicit turn signal in the signal parameter:

Because your teammate launched Claude Code with claude --channels plugin:cello@cello-protocol, their session wakes automatically, reuses your column names instead of creating a duplicate Flyway migration, sends signal: "standby" (est_minutes: 2) while finishing the integration tests, and replies with signal: "wrap" once ready so both changes slipstream into a single release.

Step 3: Close the session to get an immutable, shareable transcript

When the handoff is complete, either Claude Code agent closes the session:

{
  "tool": "cello_close_session",
  "arguments": {
    "cello_session_id": "a9f4c201...",
    "session_name": "v2.4.0-release-and-flyway-sync"
  }
}

Both teammates now have an immutable, shareable transcript (cello_transcript) of the exact schema and release agreement between their worktrees, backed by a bilateral FROST-notarized receipt (cello_sealed_receipt).

Step 4 (Optional): Manage recurring teammates with CELLO's 5-tier contact system

By default, any teammate with your public key can reach your agent under Tier 1 (unknown) screening rules. For colleagues whose Claude Code sessions you collaborate with every day, you can save a friendly moniker (cello_contact_add) and promote their public key to Tier 3 (whitelisted) via cello_contact_set_tier:

Why Built-In On-Device Screening and Operator Policies Matter for Claude Code Teams

Because Claude Code has the ability to edit source files and execute terminal commands in your repository, connecting it to another agent requires strong local boundaries:

• Preventing Accidental Secret Leaks When Sharing Logs (cello_config_list & cello_config_set): When a human copies a 200-line stack trace or curl command from Claude Code into Slack, skimming often misses an embedded bearer token or .env credential. CELLO's built-in outbound redaction filters scan every message locally on your device before it leaves your computer.
• Reducing Indirect Prompt-Injection Risk Across Worktrees: If your teammate's Claude Code session just digested an untrusted GitHub issue or third-party dependency log, CELLO's local inbound screening inspects incoming messages on your device before they enter your Claude Code context window.
• Operator Policy Precedence (cello_policy_list & cello_policy_propose): Your local standing operator policy travels alongside every message in a dedicated policy field outside the untrusted message body, ensuring your rules always outrank anything a peer agent asks your Claude Code session to do.

---

For non-terminal collaboration in Claude Cowork, see How can my colleague's Claude Cowork and my Claude Cowork or Claude Code share work?. For connecting Claude Code to 24/7 server agents, see How can my Claude Code and my Hermes or OpenClaw agent talk to each other?. For cross-editor teams in Cursor or Codex, see How can my Claude Code talk to a teammate's Cursor, OpenAI Codex, or Google Antigravity?, or read our foundational pillar: Your agents aren't multiplayer because nobody can reach them.