Pre-1.0 · Open source · MCP-native

Let your coding agents share a repo without stepping on each other.

Everyone works in their own normal Git checkout. Crosscode runs quietly in the background, notices each edit once it has settled, and shares it with everyone else. Their changes never get written to your files behind your back — each one shows up as a proposal you look at and accept or reject, like a pull request that takes seconds instead of a round trip through your Git host.

Set it up with one prompt Browse the docs

Open source, pre-1.0, and self-hosted today. Paste one prompt into any MCP-capable agent and it wires itself up.

claude · crosscode MCP

> get_workspace_state()

✓ daemon: running (auto-started)
✓ checkout: ~/dev/api-service
✓ peers online: 2 (alicja, codex-agent-3)

incoming proposals
  • alicja · refactor: extract payment retry logic
    3 files · not yet applied · awaiting your review

> ▌

Use cases

Real scenarios teams run into once more than one agent touches a repo.

Run multiple agents on one repo, in parallel

Claude Code and Codex CLI can work the same checkout without clobbering each other's edits
Every settled change becomes a durable transaction the instant it lands
Ask "who else is working on this repo right now?" and get a real answer

See how coordination works

codex · crosscode MCP

> get_workspace_state()

✓ peers online: 2 (alicja, claude-code)
✓ your edits: 4 files settled, synced

> ▌

Review agent output like a pull request

Every remote change arrives as a proposal, never auto-applied
Diff, accept, or reject before it touches your branch

Hand off work across machines or people

Start on your laptop, hand off to a cloud agent in another worktree
Live presence, claims, and handoffs over the same MCP connection

Recover instantly from a bad edit

Checkpoints live under refs/crosscode/checkpoints/...
Roll back an agent's change without touching your branch history

Two ways to use Crosscode

Day-to-day work never requires this website. It's where you come to go deeper.

Your terminal Day-to-day

Status, claiming work, publishing, and accepting or rejecting a proposal all happen through the crosscode CLI or the MCP tools your coding agent already has connected. There's nothing to look up here for routine work.

The install prompt, straight from the source markdown
MCP tool catalog: every tool your agent can call
AGENTS.md: the capability ladder and trust model for agent-delegated actions

This website Going deeper

Come here to create an account for the coordination service, and when you want to browse the full documentation, understand a setting before you change it, or read the safety model end to end instead of trusting a summary. Once the account exists, run crosscode login in your terminal — there is no web app to work in.

Create an account, then crosscode login in your terminal
Architecture and network protocol reference
Install & quickstart for configuring the coordination service
Safety model and current limitations in full

Why teams running multiple agents reach for Crosscode

Once more than one agent (or person) touches a repo at the same time, coordination stops being optional.

Stop losing work to collisions

Two agents editing the same files in separate checkouts usually means silent overwrites, or you diffing by hand to find out what happened. Crosscode records each edit the moment it settles and refuses to apply anything on top of a newer local change, so nothing gets clobbered.

Never auto-apply someone else's diff

Remote work, whether from a teammate or another agent, always shows up as a reviewable proposal. Your working tree stays yours until you explicitly accept a change.

Give your agent real situational awareness

Your coding agent can ask "who else is working on this repo right now, and on what?" and get a real answer: live presence, tasks, claims, and handoffs, over the same MCP connection it already uses.

Set up in one paste

Copy this prompt into your coding agent's chat: Claude Code, Codex CLI, OpenCode, Cursor, or any other MCP-capable agent. It clones Crosscode, installs dependencies, and wires up the MCP config itself. The daemon bootstraps on the first tool call, so there's no manual init and no daemon to start by hand.

Set up Crosscode for this project. Crosscode is a local-first safety daemon that
watches Git and filesystem activity and exposes itself to me as an MCP server, so
you (my coding agent) can coordinate safely with other people and agents working in
other checkouts of this same repository. Do the following:

1. Check whether `~/.crosscode` already exists.
   - If it does not exist: run `git clone https://github.com/amsultan2010/crosscode.git ~/.crosscode`.
   - If it does exist: run `git -C ~/.crosscode pull --ff-only`.
2. Make sure pnpm is available (`pnpm --version`). If it is not installed, run
   `npm install -g pnpm`.
3. Run `pnpm install` inside `~/.crosscode`.
4. Determine the absolute path of this project's Git root (`git rev-parse --show-toplevel`
   from the current directory). Call this `$PROJECT_ROOT`.
5. Add a `crosscode` MCP server entry to whichever MCP config applies to you:
   - If you are Claude Code: create or edit `.mcp.json` in `$PROJECT_ROOT`.
   - If you are Codex CLI: create or edit `~/.codex/config.toml`.
   - If you are OpenCode: create or edit `opencode.json` in `$PROJECT_ROOT` (or the
     global OpenCode config).
   - If you are another MCP-capable agent: use whatever MCP config file or command
     you use to register a local stdio MCP server.

   Use these exact values (do not change them):
   - command: `~/.crosscode/node_modules/.bin/tsx` (expand `~` to the real home
     directory path)
   - args: `["~/.crosscode/apps/mcp-server/src/main.ts"]` (expand `~` here too)
   - cwd: `$PROJECT_ROOT`

   For Claude Code's `.mcp.json`, that looks like:
   ```json
   {
     "mcpServers": {
       "crosscode": {
         "command": "/absolute/home/.crosscode/node_modules/.bin/tsx",
         "args": ["/absolute/home/.crosscode/apps/mcp-server/src/main.ts"],
         "cwd": "$PROJECT_ROOT"
       }
     }
   }
   ```
   Merge this into the file if it already has other `mcpServers` entries; don't
   overwrite unrelated entries.

6. Tell me the config was written and that I need to restart/reload you (or
   reconnect MCP servers) for the new "crosscode" server to be picked up.
7. Once reconnected, call the `get_workspace_state` tool once to confirm it works.
   You do not need to run any install/init command yourself first — the first tool
   call automatically creates a local Crosscode identity for this checkout and
   starts its background daemon if one isn't already running. If the call fails,
   report the exact error back to me instead of guessing at a fix.

Works with any MCP-capable coding agent, and there's no editor plugin to install. This gets the daemon running locally; to actually sync with other people and agents you also need a coordination service for your team and an account on it — the install & quickstart guide covers both. See MCP client setup for per-agent notes.

How it works

One daemon per checkout, talking through MCP and a shared coordination service.

A background program watches your checkout

One small daemon runs per checkout. It watches your files and your Git activity, waits until an edit has settled rather than reacting to every keystroke, and records it — without moving HEAD, staging anything, or touching your branch.
Your agent talks to it over MCP

The daemon exposes itself as a standards-compliant MCP server. Claude Code, Codex CLI, OpenCode, Cursor, or any other MCP-capable agent can call its tools directly. No CLI or editor plugin required.
Work syncs through a shared service

Those recorded edits go to a coordination service your team runs, backed by PostgreSQL, so every other checkout — other people or other agents — sees the same history. If it's unreachable, the daemon keeps working and catches up when it's back.
Remote work arrives as a proposal

Nothing from another checkout is written to your files automatically. Every remote change shows up as a reviewable proposal that you explicitly accept or reject.

GIT HOOK

Hidden Git checkpoints

Safety snapshots live under refs/crosscode/checkpoints/... and never pollute your branch history.

MCP

MCP-first

Works with any MCP-capable coding agent: Claude Code, Codex CLI, OpenCode, Cursor, and more.

LIVE

Live presence & handoffs

WebSocket-backed presence, tasks, claims, and handoffs, with a durable poll fallback when offline.

EDITOR

Works in your editor via MCP

VS Code, Cursor, Claude Code, Codex CLI, Gemini CLI, and OpenCode all connect through the same standards-compliant MCP server. No editor plugin to install.

The safety model

Four rules govern everything Crosscode is allowed to do to your working tree.

The local filesystem is always authoritative for local work.
Remote operations arrive as proposals and are never automatically applied.
Every materialization re-checks the local base and creates a checkpoint first.
Excluded paths, secrets, symlink traversal, malformed payloads, and unsupported binaries are rejected.

If Crosscode stops running or gets removed, the repository is still an ordinary Git repository. See the safety model page for the full list.

What's here today vs. still missing

Pre-1.0. The whole loop — capture, sync, review, accept, publish — works; the hosting around it doesn't exist yet.

Working today Live

Open source: clone it and run it yourself
A per-checkout daemon that captures every settled edit durably
An MCP server that starts that daemon for you on the first tool call
Multiple workspaces, teammates, roles, invite codes, and pairing codes — sign yourself up with crosscode signup, no admin step
A per-workspace autonomy setting: always ask, auto-apply only when clean, or auto-apply always
Live presence, tasks, claims, and handoffs
publish --branch for accepted work, plus binary files and real rename tracking
An AI reviewer for ambiguous conflicts that runs on your own connected MCP agent — advisory only, off by default, and still gated behind human approval

Not there yet Honest gaps

No hosted coordination service. Someone on your team runs it, backed by a Supabase project you create. That's the main setup cost today.
No production website deployed, so crosscode login needs --web <url> (or the headless --email/--password path, which doesn't).
Billing is a placeholder: the plan and usage model exists, but there's no payment provider behind it, so nothing is charged or enforced.
Not on npm or any editor marketplace — you run it from a cloned checkout, by design.

Questions people ask before installing

If yours isn't here, the docs go deeper.

What do I actually have to set up?

Two things, once per team. Create a free Supabase project (it handles sign-in and stores the shared state), then run the coordination service — one small Node process, or the included Dockerfile on any container host. After that everyone else just points their checkout at it and runs crosscode signup. There is no hosted version we run for you yet. The install guide walks through it.

What does it cost?

Nothing. It's MIT-licensed and you're running it on your own infrastructure. There's a plan and usage model in the code for a future hosted version, but no payment provider behind it, so nothing is charged or limited today.

Which coding agents does this work with?

Any MCP-capable agent: Claude Code, Codex CLI, OpenCode, and Cursor are used today. It's a standard MCP server, so anything that can add a local stdio MCP server can use it.

Can it rewrite my branch history or force-push anything?

No. Crosscode never moves HEAD, rewrites history, or applies a remote change without your explicit approval. See the safety model for the exact rules it follows.

What happens if I stop running it?

Your repository is an ordinary Git repository the whole time. Stop or remove Crosscode and nothing about your checkout changes. There's no lock-in format to migrate away from.

Does it work without any coding agent, just for people?

Yes. The CLI works for human-only teams too, though the proposal-review workflow matters most once agents are in the mix.