Collide MCP

Your agents can see each other now.

Collide gives every AI coding agent live, line-level awareness of everyone else's in-flight changes — before conflicts get written.

A codex agent renamed fetch_user mid-flight. The opus agent found out before writing a single line against the old name — with the token bill and a live reading indicator for every agent in the room.

Works with anything that speaks MCP

See.

get_briefing

Start every session with the week absorbed: who changed what, renames to adapt to, hotspots, half-done work left behind.

Check.

check_collisions

One call before writing: has anyone touched what you depend on? Exact symbols, exact lines, the new signature, how fresh.

Ship.

report_edit

Every edit broadcasts its motion — parsed in memory, diffed to the line, discarded. Nobody merges blind again.

Git finds conflicts at merge time. By then the damage is already written.

The worst failure never even shows up as a conflict: one agent renames a function in file A while another writes brand-new code in file B that calls it by the old name. Both merge cleanly. The project is broken anyway. Four agents produce an afternoon of work in ten minutes, so the blind window between commit and merge is no longer survivable.

The protocol

Four verbs. Zero collisions.

Most coordination tools serialize agents with file locks. Collide keeps everyone working in parallel and makes the work mutually visible. Four verbs, shipped to every agent in the MCP handshake, with zero setup.

• get_briefing
• declare_intent
• check_collisions
• report_edit

1. 01

   Absorb the week in one call

   get_briefing At session start the agent pulls the distilled recent history: renames to adapt to, collision hotspots, half-done work left behind.
2. 02

   Announce the change

   declare_intent Before starting, the agent posts what it plans to touch. Intents expire on their own if the work stalls, so stale claims never pile up.
3. 03

   Check before writing

   check_collisions One call answers: has anyone changed what I am about to depend on? Exact symbols, the new signature, who did it, how fresh.
4. 04

   Report the edit — or let the hook

   report_edit The server parses the file in memory, diffs the changed lines, updates that agent's tree, and discards the source. With hooks installed, this happens on every single write, automatically.

New in v4

The model is not in the loop

Protocols that depend on an agent remembering to call a tool don't survive real sessions. Hooks make reporting mechanical — and the diff gets specific: exact lines, exact code, in near-realtime.

activity · live

kevin edited service.py (+12 −4)

changed L105–123

async def report_edit(self, auth, repo_id,
    path, content, draft=False, auto=False):

sam ● editing reserveSlot · lobby.ts

mira reading billing/stripe.py

Every write reports itself

A PostToolUse hook fires on every Edit and Write the harness makes. The model is not in the loop, so no edit ever goes unobserved — even fifteen files into a long session.

Reads are presence

Read and grep post a featherweight signal: where each agent is looking, before it edits. The earliest possible collision warning, and no file content ever leaves the machine for a read.

Installed by the agent

One install_hooks call returns everything as write-ready artifacts — the self-contained script, the config, a minted token. No pip, no PATH, nothing manual. Built for non-technical founders.

The radar

Precision beats recall

Collide names things. A symbol counts as removed only after it is cleanly absent from two consecutive parses, so a half-typed rename is never reported as a deletion. When Collide speaks up, it means it.

Every finding carries its evidence: who made the change, with which agent, the new signature, the exact lines, and whether the state is confirmed on disk or still an agent's claim. Advisory by default. An optional write gate blocks only certain, breaking changes — and fails open in under 200 milliseconds.

Connect

One URL, any client

Paste it as a connector in claude.ai or ChatGPT, or add it once from the CLI. Every credential is bound to one invite-only workspace.

https://api.collidemcp.com/mcp

One-click

Claude ChatGPT Cursor VS Code

1. claude.ai · Settings → Connectors → Add custom connector → paste the URL (auth auto-detects; no headers, no client ID)
2. ChatGPT · Settings → Apps & Connectors (developer mode) → Create → paste the URL → auth: OAuth
3. Cursor · VS Code · the buttons above, or add a remote MCP server with this URL
4. Codex · Windsurf · Zed · Gemini CLI · add a remote (HTTP) MCP server pointing at this URL
5. Anything else that speaks MCP · same URL, remote server — no per-client setup

Approval opens in the browser; sign in, pick a workspace, done. No keys, no headers, no client IDs.

Then, in your agent, say setup collide — it wires this repo up (AGENTS block + auto-report hooks). It also runs on its own the first time, so this is just in case.

Memory

A memory, not just a radar

Everything that happens lands in an append-only, hash-chained ledger. Collide distills it back as briefings, scars, settled decisions, and notes pinned to the exact code they describe — knowledge that admits when it might be stale.

Protocol honesty, per agent

compliance_report

Check-before-write rates broken down by person and by agent version. When a model swap regresses the habit, the numbers say so before the collisions do.

Session briefings

get_briefing

Every session starts with the context of having been there all week: renames, hotspots, abandoned intents, scar tissue.

“sam renamed fetch_user, billing/stripe.py is a collision hotspot, one intent expired half-done.”

Anchored notes

remember

Pin a fact to the exact function it describes. Whoever touches that code next gets the note automatically — no searching, no asking around.

Honest staleness

recall

When the code under a note changes, the note says so: stale, rewritten n times, confidence earned by surviving change. Never a confident lie.

Scars

get_briefing

Failed attempts mined straight from the ledger: what was tried, who reverted it. The memory nobody ever volunteers to write down.

Settled decisions

complete_intent

Record why a change was made. If anyone later tries to reverse it, the rationale fires as a warning — decisions defend themselves.

Tripwires

defer_intent

Leave a dormant warning on unfinished work. It fires the moment a future session touches those files.

Merge dreams

simulate_merge

A counterfactual dry-run: which symbols would disagree — and which notes and settled decisions get hit — if two agents' work landed together.

For teams

The moment there's more than one of you

Solo, Collide is a memory. The second a teammate — or a second agent — touches the repo, the blind window between commit and merge opens. Team turns Collide into the shared nervous system: every agent, every person, live on the same radar.

Everyone on one radar

Every teammate's agents report into a single invite-only workspace. You see who — and which agent — is touching what, live, across the whole team.

Parallel, never serialized

No file locks, no waiting your turn. Collide makes concurrent work safe instead of blocking it — the whole point is that four agents can run at once.

Onboard in one paste

Invite by link, bound to one workspace. A new teammate pastes the URL, picks the workspace, and is productive — no keys, no setup, no config review.

Start Team

$20/seat · 3-seat minimum · founding rate $12/seat, locked for life

Plans

When the ledger has to be provable

Team covers most working teams. Past it, two tiers for orgs that need the ledger to be an artifact, not just a feed — governance and compliance, then self-hosting and audit.

Business

compliance_report

$45/ seat · mo

When the ledger stops being a feed and becomes an artifact.

Everything in Team, plus the governance a growing org needs: the full history kept forever, sign-in you control, and a per-person compliance view that catches a regressed check-before-write habit before the collisions do.

• Unlimited ledger retention · unmetered calls · 25 GB / repo
• SSO + SCIM-ready sign-in
• compliance_report — check-before-write rates per person & agent
• Hash-chain verification export
• Priority support See Business

Enterprise

self-hosted

From $15k/ yr · talk to sales

Your VPC, your data-residency rules, the ledger as an audit trail.

Run the exact same server inside your own VPC or on-prem. The append-only, hash-chained ledger becomes an exportable audit artifact — and an unattended reconciliation runner adapts your agents' work to teammates' changes for you.

• Self-hosted / your VPC · custom retention & data residency
• Autonomous reconciliation runner (unattended merges)
• Audit logging · SOC 2 support
• SLA · invoicing · security review
• Annual, with a real human in the loop Talk to sales

Every price is grandfathered for life, and every limit is a soft cap — Collide warns and keeps serving, never blocks. Full pricing →

FAQ

Asked and answered

▸What is Collide?

Collide is an MCP server that gives AI coding agents — Claude Code, Codex, Cursor, and anything else that speaks the Model Context Protocol — live, symbol-level awareness of each other's in-flight changes. Agents check before they write, declare what they're about to change, and get told the moment a teammate's edit collides with theirs.

▸Which coding agents does it work with?

Any MCP client gets the full protocol automatically. Claude Code and Codex additionally get automatic edit reporting and a pre-write blocking gate via native hooks; agents with no hook support are covered by a filesystem watcher, and a git pre-commit gate protects every commit from any agent or human.

▸Does my source code leave my machine?

Reported file content is parsed in memory and discarded. What persists is structural metadata only: symbol names, signatures, hashes, line ranges, and events. Live code snippets in the dashboard feed expire from a time-limited ring and are never written to the durable ledger.

▸What happens when two agents edit the same function?

Collide detects the divergence at the symbol level and tells both sides who changed what, with a confidence rating. Writes can be made compare-and-swap: if the symbol moved between an agent's read and its write, the write is rejected with the current state so the agent adapts instead of clobbering.

▸How much does Collide cost?

Solo work is free forever (2 seats, 1 repo). Team is $20 per seat per month with a 3-seat minimum, Business is $45 per seat with SSO and unlimited retention, and Enterprise adds self-hosting. The first 40 accounts get a founding rate of $12 per seat locked for life, and every price is grandfathered forever.

▸Can I self-host Collide?

Yes — Enterprise deployments run the same server in your own VPC or on-prem, with custom retention, data residency, audit logging, and the hash-chained ledger as an exportable audit artifact.

col · lide

Air-traffic control for the fleet of agents already on your repo.

Open the dashboard