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.lockand.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, rundft 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!
Top comments (0)