bob@ubuntu: ~/acme/api — bash
⚡ ccrelay handoff --to @alice · context transferred · 0ms
alice@ubuntu: ~/acme/api — bash
waiting for handoff...
open source · AGPL v3 · self-hosted

Dev A codes.
Dev B continues.
Claude already knows.

CC Relay streams every Claude Code tool call, file edit, and AI conversation turn to your relay server in real time. When a teammate picks up where you left off, Claude already knows the full story. Zero re-explaining. Your infra, forever.

$ docker compose up -d → deploy your server · 2 min $ open github.com/xlncbasit → ⭐ … stars
✓ Works with Claude Code today · installed via npm or curl
✓ Your server · your data · no code leaves your infra
✓ AGPL v3 · free forever · self-hosted in 2 minutes
basit@ubuntu:~/ccrelay $ cat NOTE.md

I built CCRelay for everyone who's using AI to build — especially the ones doing it for the first time. The domain expert who finally has a way to turn their knowledge into software. The founder who knows exactly what to build but is still learning how. Tools like Claude Code are rewriting who gets to be a builder, and that's worth building for.

CCRelay exists so that building with AI doesn't have to be a solo act. Bring in a friend, a mentor, a collaborator — let them watch, suggest, and take the wheel without losing context.

This is free. It will stay free. Build something.

— Basit
0ms
handoff latency
100%
context fidelity
2 min
deploy your server
AGPL v3
free forever
user@ubuntu:~/acme/api $ ccrelay --why
Sound familiar?
WITHOUT CC RELAY
11:02  You start a Claude Code session.
      Claude learns your auth system,
      your rate limiter, every decision.
 
12:03  14 tests passing. Good work.
 
14:23  Your teammate needs to take over.
 
14:24  You open Slack.
14:25  "Ok so the rate limiter works like
      this... we chose token bucket
      because... auth runs before it
      because... check config.go for..."
 
17:46  Still re-explaining.
      [EXIT: context_death]
WITH CC RELAY
11:02  You start a Claude Code session.
      CC Relay streams every event.
 
12:03  14 tests passing. Good work.
 
14:23  Your teammate needs to take over.
 
14:24  $ ccrelay handoff --to @alice
      ⚡ 14 conversation turns
      ⚡ 3 files · 127 lines
      ⚡ context transferred · 0ms
 
14:24  $ ccrelay attach ← alice
      ✓ Claude already knows.
      ✓ Lease claimed. Ready.
$ claude implement rate limiting
[session closed]
Context lost.
Claude: "How can I help today?"
Context dies at terminal close
Every Claude Code session is isolated. The moment you close your terminal or switch machines, Claude forgets everything. Every time.
[Slack · #engineering]
bob: "ok so the auth system works
      like this, we chose JWT because
      ..." [1,247 characters]
Handoffs cost 30+ minutes
A 3-hour Claude session compresses into a wall of Slack text. The AI context is unrecoverable — your teammate starts Claude from scratch.
$ ssh cloud-box
$ claude
Claude: "How can I help you today?"
(30 sec ago: 14 tests passing)
Machine switch = start over
Switch from laptop to cloud VM mid-session? Start over. Claude on the new machine has no idea what you were building 30 seconds ago.
user@ubuntu:~/acme/api $ ccrelay --how
01
Start sharing · any repo

Run ccrelay start in your project directory. The daemon hooks into Claude Code via PreToolUse/PostToolUse and streams every tool call, file change, and AI message to your relay server in real time. Claude Code looks and behaves exactly the same.

$ ccrelay start
✓ Session started · id: xyz123
  streaming context to team...
[session active · 0 participants]
02
Work normally · Claude handles everything

Nothing changes about how you use Claude Code. Type prompts, review diffs, run tools. Every action auto-syncs: tool calls, file edits, git commits, AI responses. 17 event types streamed live.

$ claude implement rate limiting
✓ Read(router.go)
✓ Write(middleware/rate_limit.go)
✓ 14 tests pass
[session:xyz123 · 42 events ↑]
03
Hand off · teammate gets everything

Run ccrelay handoff --to @alice. Alice runs ccrelay attach. Claude on her machine has the full context — 14 conversation turns, 3 files changed, every decision made. She types her first message like Bob never left.

$ ccrelay handoff --to @alice
⚡ 14 conversation turns
⚡ 3 files · 127 lines
⚡ context transferred · 0ms

# alice's machine · 0ms later:
$ ccrelay attach
✓ Claude already knows.
user@ubuntu:~/acme/api $ ccrelay --help
@bob  $ ccrelay handoff --to @alice
⚡ Full context transferred · 0ms
@alice  $ claude add Redis █
Zero-friction handoff
Dev A leaves mid-thought. Dev B picks it up instantly — same context, same conversation, no re-explaining. The AI remembers everything.
$ ccrelay log --verify
[14:32] @bob impl rate limit · sha:a3f9
[15:10] @alice add Redis   · sha:7b2e
✓ Chain verified · tamper-evident
Tamper-evident audit trail
Every event SHA-256 chained. What Claude did — every tool call, every edit — is immutable and exportable for compliance.
$ ccrelay attach --machine mbp
✓ Attaching to session xyz · 0ms
✓ Full context synced
user@mbp:~/acme/api $ █
Works across any machine
Mac, Linux, cloud VM. The daemon syncs over WebSocket. Switch machines mid-session without breaking a single Claude tool call.
user@ubuntu:~/acme/api $ # what a handoff looks like
⚡ CC RELAY HANDOFF [xyz123 · a3f9e2]
FROM bob@ubuntu: ~/acme/api
TO    alice@ubuntu: ~/acme/api
REPO acme/api · branch: main · HEAD: a3f9e2
14 conversation turns
 3 files changed
127 lines written
⚡ Full context transferred · 0ms
$ ccrelay attach --session-id=xyz123
✓ Lease claimed. Claude already knows.
user@ubuntu:~/acme/api $ diff --with ccrelay
CC Relay Screen share Loom video Slack / notes
Context transfer time 0ms 30 min+ send a link type it out
Claude gets full history ✓ all turns ✗ ✗ ✗ partial
Works async ✓ ✗ sync only ✓ ✓
Self-hosted ✓ depends ✗ ✗
Cost $0 forever varies $8+/mo $0
Degrades over time never yes yes yes
⚡ The old way: "Ok so the auth system works like this…" [30-minute Slack thread]
The CC Relay way: ccrelay handoff --to @alice · 0ms
user@ubuntu:~ $ ccrelay deploy --quickstart
01
Deploy the server
Clone the repo and spin up the server + Postgres with Docker Compose. Done in under 2 minutes.
terminal 
git clone https://github.com/xlncbasit/claude-shared-session
cd claude-shared-session
cp .env.example .env
docker compose up -d

Server runs at http://localhost:8080 · Dashboard at /ui/

02
Install the client CLI
Install ccrelay on every machine that will join Claude Code sessions.
terminal 
npm install -g @bytlabs/ccrelay
03
Connect and start sharing
Create an account on your server, then start a shared Claude Code session from your repo.
terminal 
ccrelay login --server http://your-server:8080
ccrelay init
ccrelay start

AGPL v3 · free forever · your infra · github.com/xlncbasit/claude-shared-session

user@ubuntu:~ $ ccrelay trust --verify
# how CC Relay was built
CC Relay was built using CC Relay.

The rate limiter, the WebSocket hub, the checkpoint
service, the lease system — all built with Claude Code
sessions shared across machines using this same daemon.

handoffs completed during build: 23
context deaths: 0
⭐ …
stars on GitHub

AGPL v3. Every line of the relay server, the CLI, and the database migrations is public. Star it to follow the build, fork it to customize, deploy it to own it.

$ open github.com/xlncbasit → star ★
user@ubuntu:~/acme/api $ ccrelay --faq
Does CC Relay send my code to anyone? +
No. CC Relay is self-hosted — you run the server on your own infrastructure. No code, no file contents, no prompts ever leave your network. The relay server stores only session metadata, event types (which tool was called), and git SHAs. Your source code is never transmitted anywhere except within your own infrastructure.
Do I need to change how I use Claude Code? +
No. Install ccrelay, run ccrelay start in your project directory, and keep using Claude Code exactly as you do now. The daemon runs in the background watching Claude's output. You type the same prompts, review the same diffs, run the same tools. The only thing that changes: your teammate can pick up exactly where you left off.
What does "0ms handoff" actually mean? +
When you run ccrelay handoff --to @alice, Alice's machine already has the full event stream because it was syncing in real time while you were working. There's no upload step — the context was never lost. Alice runs ccrelay attach and Claude has every conversation turn, every file change, every tool result. The "0ms" is because there's no transfer: only attachment.
What do I need to run this? +
A machine to run the server (any Linux box — a $5 VPS, a cloud VM, or your home server), PostgreSQL (Docker Compose file included), and ccrelay CLI on each developer machine (install via npm install -g @bytlabs/ccrelay or the curl one-liner). Claude Code on each machine. That's it.
Can I use this free forever? +
Yes. CC Relay is AGPL v3 open source. You run the server, so there are no tiers or limits. The self-hosted version includes everything: unlimited sessions, unlimited team members, the full audit trail, cross-machine handoffs, everything. A managed cloud plan is available if you don't want to operate the server yourself.
How is this different from copy-pasting conversation history? +
When you copy-paste, you give your teammate a transcript — text Claude needs to re-parse. CC Relay gives Claude the conversation as structured context: every prompt as a prompt_submitted event, every response as an assistant_message event, every tool call with its actual inputs and outputs. Claude receives this as operational history, not text to interpret.
What happens if my relay server goes down mid-session? +
Active Claude Code sessions continue running unaffected — the PreToolUse hook falls through to "allow" if it can't reach the daemon within its timeout. On reconnect, the daemon re-syncs from the last checkpoint. Nothing is lost. For production, the deployment guide recommends Restart=on-failure in your systemd unit to handle transient crashes automatically.
BOB'S MACHINE
ALICE'S MACHINE
bob@ubuntu: ~/acme/api — bash
bob@ubuntu:~/acme/api $ 
alice@ubuntu: ~/acme/api — bash
waiting for handoff...
alice@ubuntu:~/acme/api $ 
Install › Auth › Setup › Work › Handoff › ✓
try:
← Back to home

Share Claude Code sessions across machines and teams

Sign in
No account? Create one

Dashboard

—
Workspaces
—
Active Sessions
—
Seats Used
—
Plan
Workspaces
Repository Branch Sessions Status
Loading…
Connect your machine
Authenticate the ccrelay CLI or Claude Code integration with your personal token.
CLI
terminal 
ccrelay login --token loading…
Claude Code
slash command 
/ccrelay-login loading…

Setup

1
Workspace
2
Session
3
Machine
✓
Done
Create Workspace
A workspace maps to a git repository. Each repo needs one workspace.
Run git remote get-url origin in your repo.

Team

Member Role Joined
Loading…

Billing