Conflict Resolution

When multiple agents or users modify the same data at the same time, PuppyOne provides a complete system for detecting and resolving conflicts.

The challenge of concurrent editing

In multi-agent collaboration, concurrent conflicts are unavoidable:

• Agent A is updating /specs/api-design.md while Agent B edits the same file at the same time
• You are editing a JSON file in the Dashboard while a sync connection is pulling fresh data from Notion
• Two agents modify content under the same folder through MCP

Without a conflict management mechanism, the later write silently overwrites the earlier one, causing data loss.

PuppyOne's Solution

PuppyOne uses the MUT (Mutation) engine to handle concurrency. It offers two primary strategies:

┌──────────────────────────────┬──────────────────────────────┐
│  Three-way Merge             │  Last-write-wins             │
│  Optimistic concurrency      │  Latest write wins           │
│                              │                              │
│  On push, MUT compares the   │  Timestamps decide the       │
│  base version and both sets  │  winner. The overwritten      │
│  of changes, then auto-      │  version is preserved in     │
│  merges or flags conflicts.  │  commit history.             │
│                              │                              │
│  Best for:                   │  Best for:                   │
│  collaborative editing       │  file sync, data sources     │
└──────────────────────────────┴──────────────────────────────┘

1. Three-Way Merge (MUT Push)

The MUT engine uses three-way merge during push operations. Multiple actors can edit at the same time. When changes are pushed, the system compares the common base version and both sets of changes:

• Non-conflicting changes are merged automatically
• Conflicting parts are flagged for resolution

The write endpoint also supports base_version for optimistic concurrency control — if the file was modified since you last read it, the write returns a conflict instead of silently overwriting.

2. Last-write-wins

The simplest strategy: the later write directly overwrites the earlier one. The overwritten content is automatically preserved in commit history and can be rolled back at any time.

This is the default strategy for filesystem sync operations.

How to choose a strategy

Learn more