Source control after Git

Git was built for people. With agents making thousands of changes a day, some to a single main branch, it's holding us back. T3 Theo said it well in a tweet from a while ago: "Someone else needs to use their psychosis to fix source control."

We're not the only ones who think Git isn't the future. GitHub's former CEO launched Entire saying "Git repositories were never extended to version everything developers build with in the AI era." Anthropic also recently moved their entire monorepo off Git and now merge over 30,000 changes per day.

We've felt this pain firsthand. With our own agents landing hundreds of changes an hour, Git's model of moving branches one at a time just doesn't scale. In a test with 16 agents all pushing to one branch, Git took 457 seconds to get all 16 changes in. That's untenable.

So we built something new from the ground up. It's called Onset, and it's open source version control designed for the agent era. Today, we're excited to announce that Onset is now in public preview. Here's how it works.

What Onset is

Onset is built around five core concepts. A Change represents one unit of work, with a unique ID (like rtnbkcvx) that keeps every save under the same ID from start to finish. Main is the project’s shared history, which only moves when a change lands, one version at a time. Land puts a change on main, with the server merging it with any other changes that landed since it started. A Workspace is a folder for a single change, where the work lives in the change, not the folder, allowing you to make as many as you need. Finally, a Save is a snapshot of a change that Onset saves automatically, keeping every save while the change is open.

With Onset, the whole development loop becomes editing files, then running on land -m "Title". No committing, no staging, no pulling or rebasing. Afterwards you’re on a brand new empty change, ready to go again.

How landing works

The magic of Onset is in how it handles landings. Each project has a queue on the server, and landings go through it in the order they arrive, with the server merging each one against the latest main.

on land saves your change and sends it off. Any edits after that go into your next change. The server then merges each file in your change against where you started from and the current state of main.

Two key things happen in this merge:

1. If two changes add code in the same spot, like new functions or tests, both go in. Same for keeping imports from both sides.
2. If two changes edit the exact same lines, main doesn't move. Only the one landing comes back with the conflicted files and lines. Everyone else keeps going.

This merge is language-aware too. It follows moved files and reads imports across JavaScript, TypeScript, Python, and more. JSON and TOML merge intelligently by key. And anywhere Git's line-based merge would be clean, Onset's result is identical.

We replayed 4,000 merges from Git's own history, and Onset matched Git's clean merges on all 6,416 files. But it scales to thousands of landings per second on a single branch. More on the speed in a bit.

For agents and their humans

Onset is built for agents, but it’s made to be simple as well for the humans working with them. Every on command saves your work automatically, so even if you delete a workspace, you don’t lose a thing. Just on get --change to open it again, and on undo or on restore to take back a mistake. Need to spin up workspaces for a whole fleet of agents? on workspaces add has you covered, and with --on . an agent builds on your change, so landing its work lands yours right along with it. And with on get --lazy, even massive projects are ready in seconds, pulling down each file as it’s needed.

Guiding agents is super simple as well. Using on guide gives you a ready-made AGENTS.md with everything they need to know. Keep them in line with scoped tokens that limit access to specific projects or make it read-only, and Onset’s host enforces it all. And don’t worry about leaking API keys again. Onset scans every line before it lands, and if something looks like a secret, it stops. Your .env files? They’re saved and follow you to every workspace, but never hit main.

With on access, you can lock down sensitive folders easily. Seal one and even the host can’t look inside, because your machine encrypts everything before it ever leaves your drive.

So whether you’re working with agents or writing code yourself, Onset has you covered. It’s version control reimagined for today’s development, not the workflows of the past.

And if you're not ready to dive fully into Onset, no worries. It still works with Git! Every Onset project on upstream.codes has a Git view you can push to like always. We'll mirror with GitHub and can import your history too.

Blazing fast

We built Onset on a new core in Rust and WebAssembly that runs on Cloudflare. Each project is its own tiny program that sleeps when idle, and a busy folder gets one of its own to merge landings side by side.

The result? A project taking 20,000 landings per second and one gathering dust run on the same code. The idle one costs nothing but its storage.

We tested Onset to its limits with agents editing and landing as fast as they could. Here's how it held up:

• With 6,144 agents, Onset handled over 20,000 landings per second on a single project. Median time for a landing: 270 ms.
• Our best single run hit 28,349 per second with 20,480 agents. Spread across more folders, one run reached 29,091.
• We held 20,000 too. 20,480 agents landing on ONE project for five straight minutes, 20,455 per second, 6.33 million total landings.

For comparison, Onset was 200x faster than Git in our 16 agent test. And it leaves other Git hosts in the dust. GitHub says its new Rubicon engine takes 7,200 pushes per second... and Git only gets there with every agent on its own branch. Onset lands right on main.

We also ran Onset through every scenario we could think of:

• 192 projects with 64 agents each: 51,394 landings/sec
• A massive project, 200,000 files: still 22,000/sec
• Agents editing existing files all across that 200,000-file project: 15,780/sec

In 64 runs across different project sizes, Onset landed 64.8 million changes. Not one project lost data or failed its integrity checks. The only errors were "busy" responses and six dropped calls, which the agents retried.

Open source

Onset is open source, and you can read all of it at upstream.codes/coline/onset. The core and the on command are Apache-2.0.

You can run it yourself too. onset-server is a single binary that keeps everything in one folder and speaks the same protocol as upstream.codes. It's AGPL-3.0 and ships with the Linux downloads. And if you only want to try Onset on your own machine, on init starts a project with no server at all, and on publish moves it to a host whenever you're ready.

Try Onset today

Onset is now in public preview for macOS, Linux, and Windows. To get started:

1. Install the CLI:
   • macOS/Linux: curl -fsSL https://downloads.coline.dev/onset/install.sh | sh
   • Windows (PS): irm https://downloads.coline.dev/onset/install.ps1 | iex
2. on login to authenticate
3. Bring in an existing Git repo: on import <git-url> --to upstream.codes/you/name Or start from scratch: on init <folder>

You can create projects up to 100 GB during the preview, with individual files up to 5 GB. Onset is included on every plan, including Free.

There are a few known limits while we're in preview - imports on massive repos may take a bit, and the Git view can lag behind during the most intense landing flurries. But overall, it's ready for you and your agents to push it to the limit.

We're excited to get Onset into your hands and see what you build with it. Head to our docs to dive deeper, and let us know what you think!