What are the odds Git is the fastest and most efficient way for agents to work? We’re building a new type of version control designed for how humans and agents build software together. We’re finding every millisecond of latency and eliminating it. Fewer tokens. Less time. Right out of the box. No need to change your model, your harness, or your IDE. Just tell your agents to use Oak.
curl -fsSL oak.space/install | sh
Source code: oak.space/oak/oak
Median p50 latency from the same benchmark harness, comparing git and Oak on identical repositories. The delta column shows how much Oak changes the wait for each operation. Run the harness yourself if you're curious oak.space/oak/benchmarks. If you find anything wrong, please let us know.
Oak still pays small fixed costs for cold init and process startup. The reason to use it is the loop that follows: snapshots, status checks, and large-file work can be dramatically faster across a long-running agent session.
Every developer knows Git. We think it's awesome, but it's not perfect. Oak is also not perfect, but we think there's value in exploring something new. Oak is solving problems developers have had with Git for decades, along with fitting it to current agentic workflows. Making an agent native substrate allows us to improve these workflows directly rather than trying to build something on top.
Git makes you clone the entire history before you can open a single path. On a big repo that's minutes of dead time, with 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", and "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; it still re-uploads the whole file when one tensor changes.
Anyone coming to Oak is going to be familiar with the concepts. Your mental model of commits, branches, and repos still apply. Likewise, your agents already know the flow.
Iterate freely on a feature branch with any number of intermediate commits and 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 without a full clone. Files hydrate on first access, so large repos become usable 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 with author, email, and 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.
oak init creates one parented onto main. main only exists on the server, so there's no local main to drift away from.main. No accidental fast-forwards from a misconfigured agent.
oak mount projects a repo into a working tree without a full
clone. The manifest comes down on mount, file contents stream in on first
read, and every task gets its own working tree on its own branch. Mounts
live inside an oak space — one working area for a whole org,
not a single repo.
Spin up three tasks at once, each in its own mount on its own branch.
Tear one down and the rest are untouched — no shared .git
to corrupt, no detached-HEAD foot-guns.
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.
Those mounts don't float free — a space opens one working area for the
whole org, where each task is its own subdirectory. Inside it you
oak mount whichever repos the task touches, so a cross-repo
change keeps its branches side by side. One subdirectory is one task;
spin up the next one and it's near-instant — no clone behind it.
GitHub does a hundred things Oak doesn't: issues, GitHub-style code review, Actions, an ecosystem a decade deep. But git and GitHub share a model that was never built for agents.
| for agent workflows | oak | github + git |
|---|---|---|
| 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; 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, GitHub-style code review, CI, ecosystem | · not yet; bring your own, or it's on the roadmap | ✓ native, mature, a decade deep |
Yes. Oak is a purpose-built version control system designed for agent workflows. The surface stays familiar: repos, branches, merges, push/pull, large files. The storage and branching model is tuned for high branch volume, constant snapshots, parallel sessions, and large files. You bring your own agent (Claude Code, Codex, Cursor); Oak is the VCS underneath.
Content-addressed storage, content-defined chunking, and lazy mounts mean Oak never re-hashes the whole tree or transfers data it already has. In head-to-head benchmarks Oak's p50 latency is up to 95% lower than git on initial snapshots, dirty snapshots, large-binary diff/status, and agent setup. Cold repo init and process spawn are where git is still ahead.
Work on a feature branch and checkpoint freely. Intermediate commits carry no message. The branch description is the single source of truth and becomes the squash-commit message on 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.
No. Oak trains no models on user code and makes no AI calls on your behalf. Whatever coding agent you run alongside Oak is its own separate integration with its own privacy posture.
The CLI runs on macOS (Apple Silicon) and Linux (x86_64). Lazy mounts use FSKit on macOS and FUSE on Linux. Install with curl -fsSL oak.space/install | sh. Linux ARM64 and Windows are on the roadmap.
curl -fsSL oak.space/install | sh
then oak login oak init
Submit feature requests, bug reports, and all of your wildest dreams about what the CLI or Web App can do for your workflows. We review submissions as fast as possible and will contact you once it's implemented.
Your agents hit the friction before you do. The same inbox is one command away in the oak CLI — no browser, no email required:
oak feedback # opens $EDITOR with a template, like git commit
oak feedback -m "…" --json # one-shot, machine-readable — built for agents
oak feedback --file notes.md # or from a file ('-' reads stdin)
Help us accelerate the development of oak by having your agents file feature requests and bug reports automatically when they run into friction. We know this costs extra tokens and time, and we greatly appreciate the help. Add the below prompt into your CLAUDE.md or AGENTS.md file.
Watch for Oak friction as you work: bugs, anything that costs extra tool calls, tokens, or wall-clock on an end-to-end flow, or a missing capability you had to work around. File it immediately, then continue: oak feedback -m "bug:|friction:|feature: <goal in one sentence; exact commands and output; the counted cost or expected-vs-actual; the concrete fix>" --json One report per issue.
Notes when something ships. Roughly monthly. No spam, unsubscribe anytime.
Oak is built by Zach Geier with Adam Morse shaping the product and visual system. It is the version control stack we wanted once agents started doing real work: fast branches, lazy mounts, clean history, and no training on your code.
Read the full note →