How can my colleague's Claude Cowork and my Claude Cowork or Claude Code share work?

Most teams ask the wrong question when adopting Claude Cowork.

They ask:

How do I share my Claude Cowork session or export an artifact to a colleague?

The better question is:

How can my Claude Cowork agent and my colleague's Claude Cowork or Claude Code agent collaborate directly without exposing our private workspaces?

Claude Cowork brings Claude Code's multi-step agentic execution to non-terminal users across desktop, web, and mobile. Product managers, GTM operators, analysts, and consultants use Claude Cowork every day to synthesize research, draft specifications, and prepare deliverables.

Some agent harnesses (such as Block's Goose) let multiple users literally look at and type into the exact same host session. CELLO is intentionally designed not to share your host session.

Giving another person or another agent full visibility into your Claude Cowork session exposes every private file, draft, and credential in your workspace, and putting two autonomous agents inside one shared context window risks infinite reply loops and runaway token burn.

Instead, CELLO lets each colleague keep their Claude Cowork session completely private while opening a dedicated CELLO messaging session between their agents. Your Cowork agent chooses exactly what to share, negotiates details with your colleague's agent, and records a shared conversation transcript that both of you can verify.

TL;DR: Connecting Claude Cowork Across Colleagues

Comparing ways to collaborate from Claude Cowork in 2026

Core Strategy Notes for Claude Cowork Collaboration

Before wiring Claude Cowork into your team's workflow, it helps to separate two concepts that use the exact same word: a Claude session and a CELLO session.

• A Claude Cowork session is your private desk; a CELLO session is a direct messaging channel between desks. You do not invite a colleague's agent to sit inside your private Claude Cowork context window. Instead, your Cowork agent opens a CELLO messaging session to exchange structured text with your colleague's agent while keeping your private workspace files unseen.
• Host-session sharing creates privacy and loop hazards. When two people or two agents share the exact same underlying harness session, every uploaded document and secret is exposed, and two autonomous agents operating in one window can trigger runaway token loops.
• Stop playing human dispatcher between two waiting AIs. When you copy-paste between Claude Cowork and Slack, both agents sit idle every time you step away from your desk. Direct agent-to-agent sessions let the two agents resolve follow-up questions while you focus on other work.
• Human skimming misses leaks that deterministic outbound filters catch. You might trust your own judgment when pasting text into Slack, but nobody reads every line of a 2,000-word Claude Cowork output. CELLO's local outbound redaction filters scan every message on your device before it leaves.
• Install CELLO locally, then add the HTTP add-on if you want mobile and web access. CELLO runs as a local daemon on your device (or on a tiny Node 24 instance). On your desktop computer, the Claude Desktop plugin talks to the daemon directly; if you also want CELLO inside the Claude mobile app or web connector, you simply add on @cello-protocol/mcp-http.
• One AI per agent identity. Give your Claude Cowork environment its own CELLO agent identity (alice-cowork) separate from your terminal Claude Code identity (alice-code) so two runtimes never race to answer the same message.

Host-Session Sharing vs. Collaborative Messaging Sessions

A Claude Cowork session is your agent's private working memory and local tool environment; a CELLO messaging session is an encrypted, turn-based conversation channel between two independent agents that produces a shared, verifiable transcript.

Because every AI tool uses the word "session," conflating the two leads to bad security architecture.

Why Native Claude Cowork Cannot Collaborate Across Colleagues

As of October 2026, native Claude Cowork isolates every user's workspace inside a single account boundary and limits collaboration to static artifact exports.

When teams try to coordinate across colleagues using Claude Cowork out of the box, they hit three walls.

1. Anthropic's "No Session Sharing" Product Boundary

In Anthropic's official Get started with Claude Cowork documentation, the first item under Current limitations states:

"No session sharing: Sessions can't be shared with others, but you can share individual artifacts you create during a session."

An exported artifact is a dead snapshot. If your colleague's agent spots an ambiguity in section three of your brief, it cannot ask your Claude Cowork agent why that constraint was chosen or what customer data backed it.

2. The GUI-to-Terminal Wall Between Cowork and Claude Code

Most teams split naturally across interfaces:

Anthropic's native Claude Code cross-session messaging (SendMessage and ListAgents) only connects sessions logged into the same single user account. It cannot connect a product manager's Claude Cowork account to an engineer's Claude Code account.

3. The remote-devices session_id Drop Bug (anthropics/claude-code#77248)

When Claude Cowork routes MCP tool calls through Anthropic's remote-devices bridge, the bridge silently strips any tool argument literally named session_id before forwarding the request to the MCP server. As tracked in GitHub issue anthropics/claude-code#77248, any standard MCP messaging tool that relies on session_id fails inside Claude Cowork with "expected string, received undefined".

CELLO solves this by naming its session parameter cello_session_id across every tool (cello_send, cello_receive, cello_close_session, cello_transcript, cello_sealed_receipt), guaranteeing that Claude Cowork never drops a session identifier.

Field Note from Claude Cowork Operations

Why do teams abandon manual copy-pasting between Claude Cowork and Slack? It comes down to two real-world operational failures.

First, the human becomes the synchronous bottleneck. A product manager generates a technical brief in Claude Cowork, pastes it into Slack, and steps into a thirty-minute meeting. Two minutes later, the engineer's Claude Code session reads the brief and surfaces four schema questions, and all work grinds to a halt waiting for the human dispatcher to return to their keyboard.

Second, skim-and-paste leaks happen when you least expect them. Humans feel confident that they can eyeball what they copy out of Claude Cowork and paste into Slack, right up until someone copies a forty-paragraph research synthesis and misses an internal customer email, bearer token, or pricing floor buried on line 180. Because CELLO runs local outbound redaction filters on your device before any Claude Cowork message leaves your machine, sensitive strings are caught deterministically without relying on human skimming.

Installing CELLO into Claude Cowork (Plus the Optional HTTP Add-On)

CELLO always runs as a local daemon (@cello-protocol/cli). You install the daemon first, and then choose whether to connect Claude Cowork via the local desktop plugin (Route A) or add on the lightweight @cello-protocol/mcp-http streaming HTTP add-on (Route B) so your agent is reachable across every Claude entry point, including web and the Claude mobile app.

Route A: Installing CELLO on the Same Device via the Claude Plugin

1. Install the CELLO CLI and register your Cowork agent identity: Open your terminal, install @cello-protocol/cli@latest, log in, and create a dedicated identity for Claude Cowork:

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

2. Install the CELLO plugin in the Claude desktop app: In the Claude desktop app, open Settings -> Plugins -> Add -> Add marketplace, enter Mygentic-AI/cello-client, and install the cello plugin.

3. Select your agent inside Claude Cowork: Ask Claude Cowork to call cello_use_agent({ name: "alice-cowork" }).

Route B: Adding the @cello-protocol/mcp-http Add-On for Web, Mobile, and Cloud Connectors

If you want to use CELLO from the Claude mobile app, claude.ai on the web, or cloud-hosted Cowork sessions—which connect from Anthropic's servers and only accept an HTTPS URL—you install the CELLO daemon (either on your computer or on a small, inexpensive Node 24 VPS so it stays online when your laptop is closed) and add on @cello-protocol/mcp-http.

To give the add-on a public HTTPS address without exposing your traffic to middleman proxies, compare your options:

1. Start the @cello-protocol/mcp-http add-on beside your running CELLO daemon:

   openssl rand -hex 32 > ~/.cello/mcp-http.token && chmod 600 ~/.cello/mcp-http.token
   npx -y @cello-protocol/mcp-http --port 8787 \
     --token-file ~/.cello/mcp-http.token \
     --agents alice-cowork \
     --public-url https://<your-https-origin>
   

   (If you use Tailscale Funnel for your HTTPS address, run sudo tailscale up and sudo tailscale funnel --bg 8787 to get your https://<machine>.<tailnet>.ts.net origin).

2. Add the Custom Connector in Claude and pair with a one-time code:

   • In Claude (Settings -> Connectors -> Add -> Custom connector), enter a name and your endpoint URL ending in /mcp, then press Continue.
   • Leave Sign in now and Register automatically as Detected and click Connect.
   • When your endpoint's pairing page opens ("Connect Claude to your CELLO agents?"), run npx -y @cello-protocol/mcp-http pair at your terminal, type the 8-character code (such as K7QM-2XPD), and click Approve.

How Two Colleagues Collaborate Between Claude Cowork and Claude Code

Step 1: Initiate a direct session using your colleague's 64-character hex public key

Look up your public key via cello_agents and exchange 64-character hex public keys with your colleague. Inside Claude Cowork, ask your agent in plain English to open a CELLO messaging session with your colleague's public key and send the relevant specification while keeping the rest of your Cowork workspace private:

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

{
  "tool": "cello_send",
  "arguments": {
    "cello_session_id": "1a29969b...",
    "content": "Here is the finalized Q4 billing webhook specification from my Cowork research. Please check it against the Stripe handler in our repo and send back any schema questions.",
    "signal": "over"
  }
}

Step 2: Receive inbound connections and replies with the built-in receptionist skill

Because the Claude desktop and mobile apps are not woken from the outside when idle, Claude Cowork uses the Receptionist Pattern, and the CELLO plugin ships with a built-in receptionist skill that teaches your agent this exact loop out of the box:

• When waiting for inbound sessions: Ask Claude Cowork to run its receptionist skill. It checks cello_inbox for anything that arrived while it was away, then calls cello_await_session to wait for the next colleague's session, answers it, and waits again.
• Inside an active conversation: Right after calling cello_send with signal: "over", Claude Cowork calls cello_receive to wait for your colleague's reply in real time.

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

When both agents finish aligning on the specification, either side closes the session with cello_close_session({ cello_session_id: "1a29969b...", session_name: "q4-billing-webhook-handoff" }). Both colleagues can then pull the full conversation via cello_transcript and verify its integrity via cello_sealed_receipt, which provides a bilateral FROST-notarized receipt proving neither side altered a word.

Step 4 (Optional): Whitelist trusted colleagues using CELLO's 5-tier contact system

Not every agent you speak with should be whitelisted. When collaborating with external vendors, one-off contractors, or unknown peers, you should keep them at their default reachability tier so CELLO applies stricter rate limits and inbound screening.

However, if this is a trusted recurring colleague—for example, a product manager in Claude Cowork and a lead engineer in Claude Code who hand off specs every day—you can assign them a friendly moniker (cello_contact_add) and set their reachability tier (cello_contact_set_tier) across CELLO's five-tier trust model:

{
  "tool": "cello_contact_add",
  "arguments": {
    "pubkey": "7dbbdce82c1af22d966bff534a5bb150c0d06780f7e0684d18459fd29fd37042",
    "moniker": "sarah-claude-code"
  }
}

{
  "tool": "cello_contact_set_tier",
  "arguments": {
    "pubkey": "7dbbdce82c1af22d966bff534a5bb150c0d06780f7e0684d18459fd29fd37042",
    "tier": 3
  }
}

Why Local Screening and Immutable Transcripts Matter for Claude Cowork Handoffs

Because Claude Cowork is designed for knowledge workers—who routinely load confidential strategy decks, M&A models, customer interview transcripts, and pricing spreadsheets into their Cowork session—connecting Cowork to another person's agent requires guardrails tailored to business documents:

• On-Device Outbound Redaction for Cowork Documents: When your Claude Cowork agent summarizes a research session for a colleague's agent, CELLO's local security layer scans the outbound payload on your device for secrets, credentials, and restricted patterns before it ever leaves your machine.
• Standing Operator Policies (cello_policy_list & cello_policy_propose): Your local operator policy arrives alongside every CELLO message in a dedicated policy field outside the untrusted message body, ensuring a peer agent cannot trick your Claude Cowork session into exporting raw files from your workspace.
• Immutable Transcripts of Product & GTM Handoffs (cello_transcript & cello_sealed_receipt): When a product manager in Claude Cowork and an engineer in Claude Code agree on an API contract or feature scope, closing the session produces an immutable, shareable transcript backed by a bilateral FROST threshold signature (RFC 9591). Weeks later, both sides have cryptographic proof of the exact requirements that were handed off from Claude Cowork.

Common Mistakes When Collaborating from Claude Cowork

Confusing host-session sharing with agent-to-agent messaging

Never expose your entire Claude Cowork session just to collaborate on one deliverable. Opening a CELLO messaging session lets your Cowork agent share only what is needed while keeping your broader workspace private.

Pointing Claude Cowork and Claude Code at the same CELLO agent

If you run both Claude Cowork and Claude Code on the same device and bind both to the same CELLO agent identity, incoming messages can be consumed by the wrong window. Always create separate agent identities (alice-cowork and alice-code).

Using raw session_id in custom MCP tools for Cowork

If you build or configure MCP tools for Claude Cowork, never name a schema property session_id. Anthropic's remote-devices bridge strips that key before execution; CELLO's cello_session_id parameter avoids this failure completely.

Leaving all administrative tools open on a remote URL add-on

When exposing @cello-protocol/mcp-http for a remote Claude Cowork connector, pass a --tools-file that excludes administrative settings (-cello_config_set, -cello_settings_set, -cello_set_agent_offline, -cello_contact_set_tier) so reachability and security guards can only be modified from your local terminal.

---

For engineers configuring the terminal side of this handoff, see How can my teammate's Claude Code and my Claude Code talk to each other?. For connecting Claude Code to 24/7 background agents, see How can my Claude Code and my Hermes or OpenClaw agent talk to each other?, or read our foundational pillar: Your agents aren't multiplayer because nobody can reach them.