Development previewFeatures and availability may change while we test.

Arivaran product portfolio

Git made branching cheap. Arivaran makes the worktree—the AI agent playground—cheap.

Give Codex, Claude, and every parallel coding agent an isolated place to work without preparing another full repository tree up front. Then explore Twin, Aran, Reach, and Beam by the endpoint job you need to do.

Explore productsView Arivaran Git

Arivaran Git

Storage-efficient Git workspaces for parallel AI coding, with mode-specific isolation and visible platform status.

Open Arivaran Git
Illustrative workflow simulationWorkspace preparation only · not model performance

Three paths. One task. Isolation changes what ‘ready’ means.

Codex and Claude receive the same large repository, pinned commit, scoped task, and machine profile in all three paths. The simulation shows collision exposure when isolation is skipped, the eager workspace pressure of conventional worktrees, and aaGit/Mowi isolation with lazy on-touch materialization.

Repository
large-monorepo
Pinned commit
same commit
Assigned task
same scoped change
Machine profile
same CPU · memory · disk

Workspace-preparation path

Shared checkout

Collision risk active
Worktree isolation skippedConcurrent touch
Codexsame checkout
Claudesame checkout

Collision surface

  • Concurrent edits can overwrite or entangle changes in the same working tree.
  • Branch, index, and build-output state can move underneath another agent.
  • A passing or failing test can no longer be attributed cleanly to one agent’s change.

Work can start immediately, but change ownership and test attribution are unsafe: one session can silently revert another’s uncommitted edits.

Workspace-preparation path

Conventional Git worktrees

First task reached
Isolated path, eagerly materialized working treeFirst task
Codexat first task
Claudeat first task

Eager workspace cost

  • Worktrees share Git’s object database; this path does not duplicate Git objects.
  • Each isolated path still materializes working-tree bytes up front and pays setup and I/O.
  • Each path adds file-watcher and indexing work plus page-cache and working-set pressure.

Isolation restores change and test attribution, while eager large-workspace preparation delays first-task readiness.

Workspace-preparation path

aaGit / Mowi lazy worktrees

First task reached
Isolated path, immutable content shared, files materialized on touchFirst task
Codexat first task
Claudeat first task

Lazy isolation

  • Codex and Claude retain separate agent paths and isolated writes.
  • Sharing immutable content and materializing on touch reduce eager workspace bytes, setup I/O, indexing, watchers, and page-cache and working-set pressure.
  • This changes workspace pressure; it does not remove model or runtime memory.

Both agents keep worktree isolation while reaching useful work sooner with less eager workspace preparation.

Illustrative workflow simulation. It compares three workspace-preparation paths only—not Codex or Claude performance. Repository scale, commit, task, and machine profile are held constant; the animated pacing and path spacing are illustrative and assert no measured elapsed-time result. Open Arivaran Git for the evidence-bounded storage result and platform-mode qualifications.

Public aagit installation is not published yet.View release status

Arivaran dogfood

We learned the copy tax the hard way.

A Claude session put several coding agents in one checkout. Branch operations raced against uncommitted work, so the next run moved each agent into its own worktree.

“One honest note carried into memory for next time: I merged the P0 batch with agents but forgot isolation:"worktree", so they raced in the shared worktree (no damage — main is correct and my state intact, but it's the trap my own memory already flags; I'll pass isolation on parallel coding agents going forward).”
Internal Arivaran engineering-session note, July 20, 2026

The safe choice had a cost.

Plain Git worktrees isolate each agent, but each checkout materializes another copy of unchanged files.

Keep the isolation. Lose the copy tax.

Arivaran Git keeps separate worktrees and shares unchanged files. A write gets a private inode before it can change another branch.

15-39x

less incremental disk per agent worktree

One measured Git result.

The source-build benchmark remains inspectable while public activation is release-gated.

Measured on a 16,197-file, roughly 270 MB repository across XFS and ext4.

Read methodology #10862

Five destinations, one clear next step.

Choose the product page that owns your job. Each destination states its current scope and next action.

Release-ready. Saved on this browser.