Collide MCP

Collide gives coding agents a shared map of the repo so they stop clobbering each other.

CommunityOnlineNo sign-inGlobalFreeCan modify data

What it can do

  • Setup: Installation artifacts: the fenced AGENTS.md block (apply via sync_agents_block), claude_settings to merge into the repo's .claude/settings.json (auto-allows collide tool calls — no per-call pe
  • Sync Agents Block: Replace ONLY the region between the collide markers in the given AGENTS.md content with the current canonical block (byte-identical outside the markers; appended when markers are ab
  • Declare Intent: Register an in-flight change. PREFER typed `operations` — a closed algebra with structured operands: {op:"rename", symbol, new_name} | {op:"add_param", symbol, name, type?, default?} |

What data it sees

Do you need an account

No: the server works without sign-in

Collide gives coding agents a shared map of the repo so they stop clobbering each other. It tracks changes at the symbol level, flags collisions before a write lands, and leaves anchored notes that tell the next agent why the code is the way it is.

How to connect

How to connect Collide MCP to Claude

The server address to paste into Claude settings:

https://collidemcp--lithometric.run.tools

  1. Open Claude (claude.ai or the desktop app).
  2. Go to Settings → Connectors.
  3. Click Add custom connector.
  4. Paste the server address copied below into Remote MCP server URL and click Add.
  5. In a chat, click + → Connectors and switch the new connector on.

Custom connectors are available on Free, Pro, Max, Team and Enterprise plans (Free is limited to one). On Team and Enterprise an organization Owner adds the connector first under Organization settings → Connectors.

Authorization

After you click Add, a sign-in window for the service opens. Sign in with your own account and approve access. Claude never sees your password.

How to connect Collide MCP to ChatGPT

The server address to paste into ChatGPT settings:

https://collidemcp--lithometric.run.tools

  1. Open ChatGPT in a browser (chatgpt.com). A Plus, Pro, Business, Enterprise or Edu plan is required.
  2. Turn on developer mode once: Settings → Apps → Advanced settings → Developer mode.
  3. Open Settings → Connectors and click Create.
  4. Fill in the form: Name (anything), Description (one line about what the service does), MCP server URL (copy it below).
  5. Under Authentication choose OAuth if the service requires sign-in, otherwise None. Click Create.
  6. In a new chat open + → Apps/Connectors and enable the connector.

OpenAI has renamed this section before (Connectors → Apps/Plugins). If the label differs, search settings for "developer mode". On Business/Enterprise workspaces an admin must allow custom connectors first.

Authorization

On first use ChatGPT opens the service's sign-in window. Sign in and approve access.

How to connect Collide MCP to Cursor

The server address to paste into Cursor settings:

https://collidemcp--lithometric.run.tools

Fastest: click Open in Cursor below and confirm the prompt.

Manually:

  1. In Cursor open Settings → Cursor Settings → MCP and click Add new global MCP server.
  2. Paste the JSON copied below into ~/.cursor/mcp.json (per project: .cursor/mcp.json in the repo root).
  3. Save the file. The server appears in the MCP list; authorize it there if asked.

Authorization

If the service needs sign-in, an authorize button appears next to the server in the MCP list.

Server tool list (28)

Raw names from tools/list. Only developers need these.

setupInstallation artifacts: the fenced AGENTS.md block (apply via sync_agents_block), claude_settings to merge into the repo's .claude/settings.json (auto-allows collide tool calls — no per-call permission prompts), mcp_json for the repo's .mcp.json, and, for mode="enforce", the PreToolUse hooks JSON. ALSO returns user_files with THIS caller's personal hook credential (zero-touch: no separate install_hooks call needed) — write it under HOME, merging into any existing ~/.collide/credentials.json, and never commit it. Idempotent; never edits files; each call mints a fresh credential for the caller.
sync_agents_blockReplace ONLY the region between the collide markers in the given AGENTS.md content with the current canonical block (byte-identical outside the markers; appended when markers are absent). Apply the returned content yourself so it lands in your own diff.
declare_intentRegister an in-flight change. PREFER typed `operations` — a closed algebra with structured operands: {op:"rename", symbol, new_name} | {op:"add_param", symbol, name, type?, default?} | {op:"remove_param", symbol, name} | {op:"change_return", symbol, type} | {op:"extract", symbol, new_name, range?} | {op:"move", symbol, new_path} | {op:"delete", symbol} | {op:"add", symbol, signature?} | {op:"modify", symbol} (body edit, interface preserved) Typed intents get table-lookup conflict prediction against other live intents (COMMUTE / CONFLICT / honest UNKNOWN) returned as intent_conflicts, and enable scar mining + re-litigation notices. ref links the intent to an issue/PR (e.g. "#123", a URL, "PROJ-42"). Prose change_type (rename | signature | move | delete | add | refactor) survives as legacy input only — nothing is provable about it. TTL 15 minutes; extend with heartbeat.
heartbeatExtend an active intent's TTL. The response carries since_your_last_call — cross-agent events since your previous call — so heartbeating regularly keeps you aware without polling.
complete_intentMark an intent completed (otherwise it expires to abandoned). ALWAYS pass rationale for non-trivial changes: why this change was made and what was rejected. It's anchored to the changed symbols and fires as a blocking-level notice if anyone later declares an intent that would reverse this one (rename back, re-add a deleted symbol) — settled decisions defend themselves.
report_editSubmit a file you wrote or are about to write. The server parses in memory, updates your workspace tree, and discards the source. Returns parse confidence and your new root. Set draft=true while still composing a large change: teammates see which symbols are in motion (presence only — no tree advance, no ledger row); send the final call without draft once the write lands. expected_hashes ({symbol: hash | null}) makes the write compare-and- swap: pass the hashes you read (from check_collisions / get_symbol) for the symbols your change depends on; null means "I expect it absent". If any moved since your read, the write is REJECTED with the current state — re-read, adapt, retry. This closes the race where two agents both pass check_collisions and both write.
check_collisionsThe main call. Empty list means no collisions (root fast path). Otherwise: symbol, kind (renamed | modified | removed | added | unknown), detail, confidence (certain | likely | unconfirmed | unknown), author, freshness (live | stale + age), matching intents. Exact path and symbol matching only.
get_symbolCurrent signature and hash from the freshest clean parse across workspaces.
pending_reconciliationsActive collisions between agents' work, as claimable reconciliations. Each judgment-class lint finding (another agent renamed/removed/re-signatured a symbol your code uses) becomes a record here; calling this CLAIMS the unclaimed ones for you (15-minute claim) and returns the full bundle: rule, symbol, both users, exact lines, involved intents, anchored notes, and the ADDITIVE RESOLUTION mandate — build out what BOTH agents were building; never resolve by deleting either side's work. When your merged edit lands and verifies, call again with resolve=[ids]. Also auto-resolves when a fresh report of the affected file stops flagging the symbol.
recapWhat happened in this repo, from Collide's ledger: agent sessions (edits, +/- lines, per-session token cost, settled rationales, parse failures, watchdog alerts) plus the window's token/cost accounting. PREFER THIS OVER `git log` for "what changed / what did my agents do / summarize today" questions — git records committed OUTCOMES; the ledger records the PROCESS: uncommitted edits, reads and commands, which model spent which tokens, decisions with their rationales, and attempts that were reverted. Use git for code content; use recap for what actually happened.
explain_codeWhy is this code the way it is? The chain behind one path or symbol, oldest first: edits (who/when/what changed), completed intents with their rationales, scars (attempts that were reverted), and anchored notes. git blame answers who and when — this answers what was tried, what was settled, and why. Give path, symbol, or both to narrow.
get_briefingCall at session start: the distilled recent history of this repo — who changed what (and with which agent), renames to adapt to, collision hotspots, abandoned intents, protocol health. Complements list_activity (live state) with consolidated memory (past events). For history questions, prefer this + recap over `git log`: the ledger sees uncommitted work, reads, costs, and reverted attempts that git cannot.
defer_intentProspective memory: leave a tripwire that fires when a FUTURE edit touches these paths/symbols — e.g. "the Stripe migration in payments/ is half-done; finish webhooks before changing it". Fires once into the event feed, ledger, and everyone's next briefing.
blind_spotsMetacognition: where Collide's map is unreliable — files never cleanly parsed, files serving stale state, workspaces gone quiet. Treat answers about these as unverified.
simulate_mergeCounterfactual dry-run: if the given workspaces (default: all) landed together right now, which symbols would disagree? Reports only same-symbol divergence (signature or implementation), before any real merge exists.
differential_checkNarrow differential verification: does YOUR workspace preserve the interface assumptions OTHER_USER's code relies on (and vice versa)? Interface oracle only — signature preservation over the parsed reference graph. Returns PASS / FAIL / UNKNOWN with findings, and states exactly what was and was not checked; never claims beyond the oracle (no typecheck, no tests — the server retains no source).
rememberSave a durable team fact tied to this repo's workspace memory (decisions, constraints, gotchas — not code state, which report_edit already tracks). ALWAYS anchor when the fact is about specific code: anchor="auth.py::validateToken" pins it to that symbol (also "auth.py" for a file, "src/auth/" for a subtree). Anchored notes surface automatically to whoever touches that code, carry honest staleness when the anchor is rewritten, and a confidence earned by surviving change. supersedes=<memory_id> retires a conflicting note.
send_agent_messageSend a directed message to one teammate's agents (to = their account email, from the members list or activity feed). If their agent is awake, the message rides its next tool-call response; if their machine runs the Collide wake poller (`python .collide/wake.py --install`), a headless agent starts up to act on it. Use for cross-machine asks like "commit and push your work" or "take task X".
inbox_ackAcknowledge directed messages you have acted on (ids from messages_pending). Unacked messages redeliver on every response.
recallSearch the workspace's saved facts (substring + tag match, newest first). Empty query returns the most recent.
install_hooksEverything needed to make Collide reporting AUTOMATIC — no pip, no PATH, no manual steps; designed so an agent installs it for a non-technical user in one call. Returns file artifacts to write: repo_files (commit them: the self-contained hook script plus a no-secrets config), and user_files (the user's home directory, NEVER committed: a freshly minted 90-day workspace-bound token). Once written, every Edit/Write auto-reports line-level changes and every Read/Grep posts presence — the model is out of the loop. Idempotent to re-run; each run mints a fresh token.
move_repoPlace or move a repo into one of the caller's workspaces (id or name). Answers a workspace_choice notice: pass the repo's current workspace to PIN an automatic placement, or another workspace to MOVE it — its binding, live trees, ledger history, and setup state go along, and agents route there from their next call. The caller must be a member of both workspaces with write access; the person who moves it is granted access to the repo there.
remove_repoRemove a repo from a workspace — the cleanup for a stray entry (a wrong repo id, a test repo, a repo that landed in the wrong workspace). Bindings, live trees and setup state go; the ledger keeps its history, hidden. `workspace` (id or name) targets that workspace's copy instead of the repo's routed home — needed when the stray is a duplicate of a repo that lives elsewhere. Only do this when the human asked; an explicit dashboard watch brings a removed repo back.
switch_workspaceWithout an argument: list every workspace this account belongs to and which one THIS credential is currently bound to — present the options to the human when they ask to switch. With a workspace id or name: re-bind this credential to it immediately (membership-checked, no re-authentication). Scope note: repos already established in another workspace keep auto-routing to their home; switching governs where BRAND-NEW repos and defaults land.
connect_agentsOne-call multi-agent installer. Emits the REQUIRED Collide protocol into every agent's native rules file (AGENTS.md for Claude Code and Codex, .cursor/rules, .clinerules, .windsurfrules, copilot) plus the MCP config each client needs, so any agent that opens this repo is told — up front and in-band — to follow it. Returns repo_files (commit), user_files (per-user token, never commit), copy-paste snippets for user-global configs (Codex, Cline/Windsurf), and the collide-watch command that guarantees every edit is reported from disk even on agents with no hook support. Idempotent; each run mints a fresh token.
list_activityActive intents, workspace roots, last-update timestamps, recent events.
open_dashboardA human-clickable deep link into the Collide WEB DASHBOARD. Call this whenever the person wants to SEE something in Collide rather than just hear it — "catch me up", "show me the activity", "why is this code like this", "add seats / upgrade my plan" — and put the returned `url` at the END of your reply so they can click straight through. section (with what to pass): overview — the dashboard home activity — live intents, edits, collisions change — one edit in full; pass seq=<ledger #> why — the history behind a file; pass path=<file> worklog — shareable per-session worklog journal — agent sessions + token cost billing — this workspace's plan, seats, invoices seats / upgrade / pricing — the plan comparison page (pass seats=/interval=/plan= to prefill a checkout) Adding seats or changing plan routes to pricing. Membership-gated: resolves the caller's actual workspace.
compliance_reportFrom the ledger: check-before-write rate per user, intents completed vs abandoned, collisions vs blocks vs overrides.