Real-time collaboration
How Pathrule syncs team knowledge live, detects overlapping edits at save time, and lets you resolve a conflict by keeping yours, taking theirs, or merging with AI.
Pathrule is a shared knowledge layer, so two people will eventually edit the same memory, rule, or skill at the same time. The short version: changes sync live, overlaps are caught when you save rather than after you have lost work, and you decide how to resolve them.
This page covers how live sync behaves, how an overlapping edit is detected, and the three ways to resolve a conflict.
Live sync
When anyone on your team writes or updates a memory, rule, or skill, the change propagates to the rest of the team within a couple of seconds. This is not a manual refresh.
- Other people's UI updates on its own. A teammate's new memory shows up in your sidebar without a reload.
- The MCP context that AI clients read updates too. The context an external client such as Claude Code or Cursor pulls in is kept current, so the next time an assistant asks for context on that path it gets the fresh version, not a stale copy.
The two surfaces stay in step on purpose. The same write a teammate makes in the UI is the one your assistant reads through MCP, and the other way around. There is no private cache that drifts apart.
Overlap detection at save time
Pathrule does not lock an item while someone has it open. Locking would stall the team for edits that never actually collide. Instead, every save carries a version token (the same token described in Writing memories), and overlap is detected only when two saves target the same starting version.
Two things follow from that.
| Situation | What you see |
|---|---|
| You open an item, a teammate saves a change to it, you have unsaved edits | A stale-base warning before you save, so you know your starting point is no longer current |
| You open an item, a teammate saves a change, you have no unsaved edits | The newer version loads in place, with nothing to resolve |
| You save and your starting version is still current | The save goes through normally |
| You save but your starting version is stale and you have edits | A conflict, resolved with the choices below |
The warning is not the conflict. It is an early heads-up that the item moved under you. The actual conflict only appears at the moment you try to save against a version that is no longer the latest. Because the check is scoped to the individual item, teammates editing different memories never block each other.
Resolving a conflict
When a save hits a conflict, Pathrule keeps your local edits in the editor and shows both versions side by side: yours and the current one in the cloud. You then pick one of three resolutions.
| Choice | What it does |
|---|---|
| Keep mine | Saves your version over the current cloud version. This discards the other person's change, so it asks you to confirm first. |
| Take theirs | Loads the current cloud version and drops your local edits. It asks you to confirm first. |
| AI merge | Combines both versions and returns an editable result you approve before it saves. |
The two destructive options never fire silently. Keep mine and take theirs each ask for explicit confirmation, and until you choose, your unsaved work stays in the editor.
AI merge
AI merge is for the common case where two people changed different parts of the same item and you want both, not one or the other.
- It is a three-way merge. The merge works from the common version both of you started from, plus your edit and the cloud edit, so it can tell what each person added rather than guessing from the two end states alone.
- It returns a draft, not a final write. The merged text appears in its own pane and you can edit it before accepting. Nothing is saved until you approve it.
- When both edits add distinct content, the result keeps both. When both touch the same line, the merge reconciles them into one coherent version for you to review.
AI merge runs on Pathrule's own AI access, not your personal key. Your source code is not involved in a merge. The merge operates on the conflicting text of the item, the same content already stored in your workspace.
Change history
Every change to a memory, rule, or skill is recorded in a read-only history you can open per item or for the whole workspace.
- Each entry shows who made the change, when, and whether it came from a person in the UI or from an AI client.
- Entries produced by AI merge are labeled as such, so a merged version is never indistinguishable from a hand-edit.
The history is for visibility. It tells you how an item reached its current state, which is the same question the self-audit helps answer when knowledge starts to drift.
What to read next
- Writing memories for how the version token works on a single item.
- Suggestions and self-audit for how stale or conflicting knowledge gets flagged.
- MCP overview for how external AI clients read the synced context.