Your team's Claude Code, shared.

One engineer's Claude context, queryable by another engineer's Claude. No pasted transcripts. No GitHub pushes. No shared bucket setup. One command per session.

Live on PyPI: pipx install teammate-sync

The problem

You and your teammate are both using Claude Code on the same project. You need to know what they decided about the database schema, or which file they touched, or why they picked one library over another.

Today you have two bad options:

# Option 1: ping them on Slack and wait
You:     hey saketh whats the pagination approach for Account?
Saketh:  brb in a meeting, will get back in an hour
(45 minutes later)

# Option 2: get them to send their session transcript
Saketh:  here's my whole .jsonl, 50k lines, good luck
You:     *pastes into Claude*
Claude:  context window: 200,000 tokens used. session degraded.

What teammate-sync does

Your teammate types /share in their session. From your own terminal, your Claude can ask theirs anything and gets back a cited answer in three seconds.

❯ Use teammate-sync. What did Saketh decide about pagination for
   Account, and why?

Called teammate-sync (3.1s)

Claude:
  Cursor-based on Id, NOT offset.
  Reason: 2.4 million rows with concurrent writes from the integration
  user made offset pagination produce inconsistent results — rows would
  skip or double-process. Cursor pagination on Id gives deterministic
  ordering. Same pattern recommended for Contact lookups.

  Cited: saketh/CLAUDE.md, session abc-123 (yesterday 2:14pm)
  Context cost: ~500 tokens. Saketh was not interrupted.

That is the whole experience. Everything else on this page is the engineering that makes it actually work.

"Why not just push to GitHub?"

This is the first question every engineer asks. Here is the honest answer with a concrete example.

A real scenario

Saketh is debugging a recursive trigger problem on a Salesforce migration. He has been at it for 90 minutes. He has not pushed anything to GitHub yet. Engineers do not push mid-debugging. The work is not done. The commit message would be misleading. The branch would break review.

Om hits the same problem 30 minutes later on a different object. He needs to know if Saketh figured it out.

Without teammate-sync, here is what Om can read from GitHub: nothing. Saketh has not pushed. Om's choices are:

• Ping Saketh on Slack and interrupt his flow.
• Wait until tomorrow when the PR lands and read the sanitized commit message.
• Try to reverse-engineer the problem from scratch.

With teammate-sync, Om types in his Claude:

❯ What is Saketh seeing about the recursive trigger right now?

Called teammate-sync (3.2s)

Claude:
  Saketh's most recent message in his session, 94 seconds ago in
  cwd /Users/saketh/penguin: he found that the Account_History
  trigger fires on every migration insert, creating a feedback
  loop. He disabled it before the run with this SOQL:

    UPDATE TriggerHandler__c SET Active__c = false
    WHERE Object__c = 'Account_History__c';

  Same pattern is likely on Contact_History__c. Expect to disable
  yours before your Contact migration too.

  Cited: saketh's live session, last message 94s ago.
  Not in GitHub — Saketh has not committed yet.

This is reasoning Saketh has not committed, not documented, not mentioned in Slack. It exists only in his live Claude session, right now. teammate-sync surfaces it the moment Om asks.

The three deeper reasons behind this example

1. Most reasoning never reaches a commit. Engineers iterate dozens of times for every commit. The dead ends, the experiments, the "wait let me try X" moments — that is where the actual knowledge lives. Git ignores all of it.

2. Commits show the decision, not the reasoning. "Use cursor pagination" is a one-line commit. The 90 minutes of figuring out why offset failed first is what your teammate actually needs when they hit the same fork in the road.

3. PR-reviewed code is sanitized. By the time something lands in main, the messy real reasoning has been edited out for "code quality." The questions, the alternatives considered, the bug that was almost shipped — gone. Your teammate will hit those exact same questions next week with no record they were ever asked.

The one-line version: GitHub captures the finished work that survives review. teammate-sync captures the live reasoning that produced it — including the parts your teammate is figuring out right now, this second.

Install

One PyPI package, one binary, three commands. Works on any machine where Claude Code already runs.

# Prereq: pipx (one-time, if you don't already have it)
❯ brew install pipx && pipx ensurepath

# 1. Install the binary (~15s)
❯ pipx install teammate-sync

# 2. Sign in with GitHub, wire up hooks / MCP / slash commands (~1 min)
❯ teammate-sync init

# 3. Start the sync daemon — leave this terminal open
❯ teammate-sync daemon
[sync] daemon starting
[sync] share-mode INACTIVE — daemon idle until /share is run

That's it. Restart any open Claude Code sessions so they pick up the new hooks + MCP, then type /share in any session to start sharing it. Full walkthrough: INSTALL.md.

Requires Python 3.11+, Claude Code CLI, and an ANTHROPIC_API_KEY in your shell. Works on macOS and Linux. Why pipx instead of pip: PEP 668 blocks plain pip on modern Python; pipx gives the binary its own isolated venv automatically.

How it works

Four steps. One-time setup is under two minutes per engineer.

Frequently asked

Pricing

Pre-launch. Free during beta. At general availability:

Enterprise plan with SSO, SOC2, and on-prem deployment available later. Email om at turgon.ai for early access pricing.

Request beta access

We are taking on 3 engineering teams for the closed beta over the next two weeks. Best fit: 3 to 15 engineers, all on Claude Code, same GitHub org.

Email om at turgon.ai with your team size and what you use Claude Code for. We will reply within 24 hours with setup instructions.