collide
Collide is an MCP layer that keeps concurrent AI agents from stepping on each other in a shared codebase.
Community: Submitted by a user or imported; check the owner before granting accessOnlineNo sign-inGlobalFreeRead-only
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 is an MCP layer that keeps concurrent AI agents from stepping on each other in a shared codebase. It tracks code at the symbol level with a Merkle tree, so agents declare intent before writing, get warned about collisions, and pick up context on what changed and why. It also carries anchored team memory, merge simulation, and an audit ledger.
Server tool list (26)
Raw names from tools/list. Only developers need these.
| 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 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_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 absent). Apply the returned content yourself so it lands in your own diff. |
| 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?} | {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. |
| heartbeat | Extend 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_intent | Mark 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_edit | Submit 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_collisions | The 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_symbol | Current signature and hash from the freshest clean parse across workspaces. |
| pending_reconciliations | Active 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. |
| recap | What 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_code | Why 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_briefing | Call 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_intent | Prospective 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_spots | Metacognition: where Collide's map is unreliable — files never cleanly parsed, files serving stale state, workspaces gone quiet. Treat answers about these as unverified. |
| simulate_merge | Counterfactual 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_check | Narrow 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). |
| remember | Save 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_message | Send 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_ack | Acknowledge directed messages you have acted on (ids from messages_pending). Unacked messages redeliver on every response. |
| recall | Search the workspace's saved facts (substring + tag match, newest first). Empty query returns the most recent. |
| install_hooks | Everything 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. |
| switch_workspace | Without 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_agents | One-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_activity | Active intents, workspace roots, last-update timestamps, recent events. |
| open_dashboard | A 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_report | From the ledger: check-before-write rate per user, intents completed vs abandoned, collisions vs blocks vs overrides. |