We Built a Multiverse Version Control System in Rust for Parallel AI Swarms

Pathomphong Mos — Fri, 18 Sep 2026 15:03:18 +0000

was built for a single working tree. What happens when 10 AI agents code on your repo at once? Introducing Draft (dft).

In 2005, Linus Torvalds engineered Git in two weeks. His core insights—content-addressable object storage, cryptographically immutable commit graphs, and Merkle trees—revolutionized software engineering forever.

For 20 years, Git has been the undisputed king of version control. But Git was designed around a fundamental assumption: a human developer sitting in front of a single checked-out working tree, sequentially switching branches.

In 2026, software development changed: we now deploy autonomous AI coding agents (Google Antigravity, Claude Code, Cursor, AutoGen, CrewAI) working concurrently on single codebases.

The moment you run 5 to 10 AI agents in parallel on a traditional Git repository, the single-tree model fractures:

Disk Bloat: Each agent needs its own clone or git worktree, duplicating gigabytes of files and build caches.
Blind Collisions: Agents modifying code across branches have zero real-time awareness of each other until merge time.
Serial Lock Bottlenecks: Committing simultaneously triggers serial lock contention on .git/index.lock and .git/refs/.

To solve this, we built Draft (dft) — an open-source Multiverse Version Control System engineered in Rust.

⚡ What is Draft?

Draft allows developers and autonomous AI swarms to spawn parallel development dimensions in 0.06 seconds that share storage with zero duplicate disk blocks, sense concurrent hot zones in real-time, and pre-test 3-way merges in memory before touching mainline.

Best of all: You don't have to abandon Git. Draft works as a local concurrency acceleration layer—you build in the multiverse locally, and push standard Git commits upstream to GitHub or GitLab.

🔬 How It Works: Kernel Reflinks & Lock-Free CAS

Draft is architected as 6 modular Rust crates:

┌────────────────────────────────────────────────────────┐
│               DraftMultiverse Web GUI                  │ (Self-hosted on :3333)
└───────────────────────────┬────────────────────────────┘
                            │
┌───────────────────────────▼────────────────────────────┐
│                  daft-cli (`dft` CLI)                  │
└───────────────────────────┬────────────────────────────┘
         ┌──────────────────┼──────────────────┐
         ▼                  ▼                  ▼
┌─────────────────┐ ┌───────────────┐ ┌─────────────────┐
│ daft-dimension  │ │ daft-awareness│ │daft-convergence │
│ (CoW Reflinks)  │ │ (Live Radar)  │ │(Foresee & CAS)  │
└─────────────────┘ └───────────────┘ └─────────────────┘

1. Copy-on-Write (CoW) Workspaces via Kernel Reflinks

Instead of copying files byte-by-byte, Draft leverages kernel-level reflink primitives:

macOS: clonefile() / fclonefileat() via Apple File System (APFS).
Linux: ioctl(FICLONE) on Btrfs, XFS, and ZFS.

Spawning an isolated 10,000-file workspace completes in single-digit milliseconds and consumes 0 KB of additional physical disk until a byte is actually modified.

2. Lock-Free Multi-Agent Commits

In Git, parallel workers contend on .git/index.lock. In Draft, every parallel dimension maintains its own independent binary staging index (.dft/dimensions/<name>/index) and ref pointer, sharing the root SHA-256 CAS object pool without lock contention.

3. Real-Time Collision Radar (`dft radar`)

Agents and developers can sense active hot zones across other dimensions in real-time:

$ dft radar --hot
[RADAR] 3 Active Parallel Dimensions:
  • feat-auth (Agent Alpha) -> Editing src/auth/jwt.rs [CLAIMED]
  • feat-db   (Agent Beta)  -> Editing src/db/pool.rs
  • mainline  (Main)        -> Divergence H = 0.04 (minimal)

4. In-Memory Predictive Merge Foresight (`dft foresee`)

Instead of discovering merge conflicts after executing a merge or rebase, Draft runs a pure in-memory 3-way simulation:

$ dft foresee feat-auth mainline
[FORESEE] Simulating 3-way merge between 'feat-auth' and 'mainline'...
[FORESEE] Clean auto-merge predicted: 0 conflicts detected.
[FORESEE] Divergence Metric: H = 0.04

📊 Empirical Benchmarks: Git vs. Jujutsu (`jj`) vs. Draft (`dft`)

We ran empirical benchmarks on Apple Silicon (macOS APFS) with 1,000 tracked files across identical repository trees:

1. Parallel Workspace Creation Latency

Concurrency Scale	Git (`worktree add`)	Jujutsu (`workspace add`)	Draft (`dimension create`)	Draft Advantage
1 Workspace	200.78 ms	290.51 ms	9.46 ms	21x faster vs. Git
5 Workspaces	849.44 ms	1,350.78 ms	36.84 ms	23x faster vs. Git
10 Workspaces	1,651.92 ms	2,823.91 ms	81.26 ms	20x faster vs. Git

2. Physical Disk Block Consumption (`du -sk`)

Scale	Git Worktrees	Jujutsu Workspaces	Draft Dimensions (CoW)	Disk Reduction
1 Workspace	4,004 KB	4,040 KB	100 KB	97.5% less disk
5 Workspaces	20,020 KB	20,200 KB	600 KB	97.0% less disk
10 Workspaces	40,040 KB	40,400 KB	1,600 KB (~1.6 MB)	96.0% less disk (25x reduction)

3. System Overhead (Darwin Kernel Process Telemetry via `/usr/bin/time -l`)

Metric (1,000 files)	Git (2.39)	Jujutsu (`jj` 0.45.1)	Draft (`dft` 0.1.0)	Technical Rationale
Peak RSS Memory	5.23 MB	25.47 MB	8.02 MB	68.5% leaner than `jj`
CPU Instructions Retired	453.2M	239.9M	45.6M	10x fewer instructions than Git (`memmap2` zero-copy I/O)
Context Switches	1,272	605	16	Zero scheduler thrashing

4. 10 Parallel Autonomous Agents Committing Concurrently

Concurrency Metric	Git Worktrees	Jujutsu Workspaces	Draft Dimensions
10 Parallel Commits (Wall Clock)	1,392.36 ms	537.41 ms	129.42 ms (10.8x faster)
Average Latency per Agent	1,199.36 ms	418.75 ms	119.23 ms (10.1x faster)
Concurrency Model	Serial ref locks	Operation log lock	Lock-Free Parallel Commits

🤖 The Multi-Agent Protocol: `SKILL.md`

Draft ships with a standardized agent skill definition in the repository root: SKILL.md.

When you use Google Antigravity, Claude Code, or Cursor, the agent reads SKILL.md and automatically follows the 8-step multiverse lifecycle:

┌────────────────────────────────────────────────────────┐
│ 1. Register:   dft agent register <id> --type ai       │
│ 2. Dimension:  dft dimension create <id>/<task_name>   │
│ 3. Radar:      dft radar --hot                         │
│ 4. Claim:      dft claim <file_path>                   │
│ 5. Code & Save:dft add . && dft commit -m "feat: ..."  │
│ 6. Foresee:    dft foresee <dimension> mainline        │
│ 7. Converge:   dft converge <dimension> mainline       │
│ 8. Yield:      dft yield <file_path>                   │
└────────────────────────────────────────────────────────┘

You can instruct your agent with one prompt:

"@skill.md Follow the Draft agent protocol: spawn an isolated dimension, claim src/auth.rs, implement the feature, run dft foresee, and converge back to mainline."

🛠️ Try It Out

Option 1: In Your Browser (Zero Installation)

We deployed an interactive, client-side web demo with a simulated terminal, Myers diff inspector, and Spacetime DAG:
👉 Try the Live Web Demo on GitHub Pages

Option 2: Install via Homebrew (macOS & Linux)

brew install Pathomphong-i/draft/dft

Option 3: Shell Installer

curl -fsSL https://draftmultiverse.org/install.sh | bash

Option 4: Build from Source in Rust

git clone https://github.com/Pathomphong-i/draft.git
cd draft
cargo build --release
cargo install --path crates/daft-cli

💬 Let's Discuss!

GitHub Repository: https://github.com/Pathomphong-i/draft
Community Discussions: https://github.com/Pathomphong-i/draft/discussions

How are you currently handling concurrency when running multiple AI coding agents? We'd love to hear your thoughts and feedback in the comments below!

DEV Community: Pathomphong Mos