Your team is all running coding agents on one repo. They are overwriting each other.
Once every person on a project has an agent editing code, the collisions stop being occasional. Crosscode gives each teammate's checkout a small background daemon that notices every edit as it settles and shares it with everyone else. Nothing is ever written to your files behind your back — each change arrives as a proposal you accept or reject, like a pull request that takes seconds instead of a round trip through your Git host.
Built for shared projects. It keeps working when you're the only one online — your teammates' agents are still going to land work on this repo, and Crosscode is what makes that safe when they do. Free for small teams, and free forever if you self-host.
> 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
> ▌What your team is probably doing now — and what it costs you
Every team whose agents collide has already invented a workaround. Here's how each one actually plays out.
The common thread: Crosscode doesn't replace your editor, your agent, your branches, or your Git host. Turn it off and your repository is exactly what it was.
Use cases
Real scenarios teams run into once more than one agent touches a repo.
Everyone's agents on one repo, at the same time
- Your Claude Code and a teammate's Codex CLI can work the same branch without clobbering each other
- 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
> 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 loginin your terminal - Architecture and network protocol reference
- Install & quickstart for configuring the coordination service
- Safety model and current limitations in full
Why teams whose agents collide reach for Crosscode
Once more than one person on a project has an agent editing code, 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.
Pricing
The free plan is meant to cover a real team, not tease you into upgrading. Up to 5 people, unlimited repos, unlimited AI review, auto-apply — and if you host it yourself, everything is free forever with no limits at all.
No card. No trial timer.
- Up to 5 people or agents
- Unlimited repos and workspaces
- Unlimited AI conflict review
- Auto-apply when a change is clean
- 7 days of proposal history
- Every safety feature, nothing held back
billed monthly
- Up to 10 people or agents
- 30 days of proposal history
- Auto-apply always, unlocked
- Everything in Free
billed monthly
- Up to 25 people or agents
- 90 days of proposal history
- Priority support
- Everything in Essential
billed monthly
- Unlimited people and agents
- 1 year of proposal history
- Everything in Pro
Team
For organisations that need SSO, exportable audit logs, and an SLA. Priced per seat. Everything in Unlimited, plus the controls your security review will ask about.
Self-hosting is free forever
MIT-licensed, no seat limits, no history limits, no feature gates. Paid plans exist so you don't have to run it.
Students and public repos are free
Verified students get Pro-level limits. Work on a public repository is free the same way.
Your code stays yours
AI review runs on the agent already connected to your machine. Nothing is sent to a third-party model provider.
Heads up: the hosted coordination service is still being deployed, so paid plans aren't chargeable yet. Self-hosting works today — see the install & quickstart guide.
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.
Hidden Git checkpoints
Safety snapshots live under refs/crosscode/checkpoints/... and never pollute your branch history.
MCP-first
Works with any MCP-capable coding agent: Claude Code, Codex CLI, OpenCode, Cursor, and more.
Live presence & handoffs
WebSocket-backed presence, tasks, claims, and handoffs, with a durable poll fallback when offline.
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 --branchfor 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
- The hosted coordination service isn't deployed yet. Until it is, someone on your team runs it, backed by a Supabase project you create. That's the main setup cost today.
- No payment provider is wired up, so no paid plan is chargeable yet. Plan limits themselves are enforced server-side.
- Not on npm or any editor marketplace yet — you run it from a cloned checkout.
- No editor extension, and there won't be one: MCP is the single integration contract.
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?
Self-hosting is free forever with no limits — it's MIT-licensed and runs on your own infrastructure. The hosted plans (from $2.50/mo) exist so you don't have to run it yourself; see pricing. The hosted service is still being deployed, so nothing is chargeable yet.
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.
What if I'm the only one working on it today?
That's still the case Crosscode is for, as long as the project is shared. Your teammates' agents will land work on this repo again, and the proposals waiting for you when they do are exactly what Crosscode exists to make safe. What it is not built for is a project only you will ever touch — there is nothing to coordinate with, and you should just use Git.
Does my source code get sent to an AI provider?
No. The AI reviewer for ambiguous conflicts runs on the coding agent already connected to your own machine, so it never leaves your machine and there is no third-party model provider in the loop. That's also why AI review is unlimited on every plan, including free — it costs us nothing.