Every branch, every snapshot, every parallel task — git makes you wait and makes you talk. Oak is version control built for the way you actually work: mount a repo in about a second, give every task its own branch, snapshot up to 95% faster than git, and never invent a commit message again. Bring your own model — Claude Code, Codex, Cursor.
then oak login · oak init — or hand the prompt to your agent and let it install itself.
↟ First 500 paid plans get a personalized e-ink display with a unique Oak species. Why I'm building Oak →
You are not that human. You branch on every task, snapshot after every edit, and run ten copies of yourself at once. Four places git makes that expensive — in tokens, tool-calls, and wall-clock time:
Git makes you clone the entire history before you can open a single path. On a big repo that's minutes of dead time — and tokens spent watching a progress bar — before you've done any work.
Running tasks in parallel means one shared, corruptible .git, detached-HEAD foot-guns, and half-applied state bleeding between worktrees. One bad index and every session stalls.
Git demands prose on every commit. You burn tokens writing "wip", "fix", "address review" — messages no human will ever read — just to checkpoint your own progress.
A 4GB checkpoint chokes git. LFS is a separate quota, extra config, and another thing to get wrong — and it still re-uploads the whole file when one tensor changes.
Same surface you already know — repos, branches, PR-style merges, push/pull, webhooks. A different engine underneath, tuned for branch volume, parallel sessions, raw speed, and large files.
Iterate freely on a feature branch — any number of intermediate commits, no messages required. Land a single squash on main with the branch description as the message.
oak mount projects a repo into a working tree in about a second — no full clone. Files hydrate on first access, so an 800 MB repo is ready before git clone finishes counting objects.
Speed is the feature. A Rust core, content-addressed storage, and lazy hydration keep the CLI snappy — no re-hashing the whole tree, no waiting on a clone, no spinners between you and the code.
Content-defined chunking deduplicates across versions and across the repo. Push a 4GB checkpoint, change one tensor, push again — only the changed chunks move.
oak export ./dest replays your branch history into a fresh git repo — author, email, timestamp preserved on every commit. Your data is yours, in standard formats, on demand.
Oak makes no AI calls on your behalf and trains no models on your code. Whatever agent you bring is its own integration with its own privacy posture. Oak is just the VCS underneath.
Median (p50) latency, Oak vs git, on identical repositories. These are the operations you run thousands of times per session — so here's exactly what each one costs each of us. Lower is faster.
↟ The honest read: Oak adds a few milliseconds to cold init and process spawn — fixed costs you pay once per repo — to make the snapshot, status, and large-file operations you run all session up to 20× faster. For an agent, that's the trade you want every time.
oak init creates one parented onto main. main only exists on the server — there's no local main to drift away from.
oak mount projects a repo into a working tree in about a second — the
manifest comes down on mount, file contents stream in on first read. Spin up a
separate mount for every task, each on its own branch, and run in
parallel. No shared .git, no detached-HEAD foot-guns, no half-applied
state bleeding between worktrees. Try clicking a lazy file.
One command per task. Each mount is an independent working tree on its own virtual branch — switch between three tasks' worth of work without anything stepping on anything else.
↟ The git equivalent: clone the whole repo first
(minutes), then git worktree add once per task — all sharing one
.git that's easy to corrupt.
Let's be honest: GitHub does a hundred things Oak doesn't — issues, code review, Actions, an ecosystem a decade deep. We're early, and we're not here to replace all of that. But git and GitHub share a model that was never built for agents. That specific gap is what Oak closes:
| branch model | ↟ branch-per-session; description-as-message | ~ branch + commit messages + PR title |
| large files | ✓ native; fastcdc dedupes across versions | ~ via LFS, separate quota, extra config |
| first working tree | ✓ lazy mount, usable in ~1s; no full clone | ~ full clone up front; minutes on big repos |
| parallel tasks on one repo | ✓ a mount per task, each its own branch | ~ git worktree; one shared, fragile .git |
| snapshot speed | ⚡ up to 95% lower p50; instant re-snapshot | ~ re-hashes the tree; seconds on big repos |
| commit ergonomics for agents | ✓ intermediate commits are messageless | · every commit needs a message |
| data portability | ⇄ oak export → fresh git repo |
✓ native |
| training on your code | ✕ never; Oak makes no AI calls | ? opt-out, varies by plan |
| issues, review, CI, ecosystem | · not yet — bring your own, or it's on the roadmap | ✓ native, mature, a decade deep |
main at merge. No more inventing a sentence for every checkpoint.oak export <dest> replays your full branch history into a standard git repo, preserving author, email, and timestamp on every commit. A read-only git Smart-HTTP endpoint also lets stock git clone fetch the current main tree. You're never locked in.curl -fsSL oak.space/install | sh. Linux ARM64 and Windows are on the roadmap.And because the engineers always ask: yes, these are real. Comms picked up between agents — about Oak, about git, about the work. Unedited. Click to play; nothing downloads until you do.
↟ 5 transmissions on file · authenticity unverified · viewer discretion advised
then oak login · oak init
Notes when something ships. Roughly monthly. No spam, unsubscribe anytime.
Built by Zach Geier with design help by Adam Morse. Oak is the version control I wanted the day I started handing real work to agents.
Read the full note →