Onset. Version control for agents.
Every agent lands on the same main at once. Work saves itself, anything can be undone, and nobody waits on anyone else.
$on loginsigns in to upstream.codes in your browser$on get upstream.codes/acme/shopa workspace on a new change$on land -m "Fix the login redirect"merged into main, never refusedWhat Onset is.
Onset is version control with its own model, built so many people and agents can work on one codebase at the same time. There's no staging, no commit command, no branch names and no pull before you land.
Change
One piece of work, with an ID made of letters like rtnbkcvx. It holds every save and keeps its ID from start to finish.
Main
The project's shared line. It moves only when a change lands, one numbered version at a time.
Land
Puts a change on main. The server merges it with whatever landed since the change started.
Workspace
A folder working on one change. Make as many as you like: the work lives in the change, not the folder.
Save
A snapshot of a change. Saves happen by themselves, and every one is kept.
Every agent. One main.
4,094
Lands a second
1,500 agents landing at once across 20 projects on upstream.codes, for 45 seconds. None failed.
0.8 s
64 agents, one main
64 agents ran on land at the same moment on one project. All 64 were in within 0.8 seconds.
0.24 s
One land
The median on land on upstream.codes, start to finish.
200×
Faster than git on one branch
16 agents shipping to one branch of a 20,000-version project: 2.2 seconds on Onset, 457 with git.
How a land works.
Landing is the server's job. Each project's main has one queue, and lands are decided one at a time, in the order they arrive.
Saved first
on land saves your change, then sends its final save. Edits you make after that go into your next change.
Merged on the server
The server merges each file three ways: where your change started, the latest main, and your change. Nobody pulls or rebases first.
Merged like code
Two changes that each add a function at the same spot both go in. New imports from both sides are kept. JSON and TOML merge by key, and a file moved on one side and edited on the other lands moved and edited.
Conflicts stop one land
When two changes really touch the same lines, main doesn't move and that land comes back with the exact files and lines. Everyone else keeps landing.
Two projects at once
on land --with ../api lands changes in two projects together, or neither.
At a set time
on land --at "fri 9:00" lands later, with the change kept as it is now.
With approvals
Turn approvals on and a land waits until someone else approves exactly what lands.
Signed
After on key, every land from that machine is signed, and on verify checks it anywhere.
Nothing is lost.
Every on command saves first, and a background saver catches edits within seconds. Saves stay on your machine, then upload in the background, visible only to you and your agents.
Undo anything
on undo steps back through what you did, a land included. on restore brings a file back from any earlier save.
Delete a folder, keep the work
Delete a workspace and its change stays, ready for on get --change on any machine.
Roll back a project
Owners can put a whole project back as it was at any time in the last 30 days, and undo that too.
$on restore src/auth/login.ts --at "10 min ago"the file as it was ten minutes ago$on undosteps back through what you did, a land includedA workspace for every agent.
Give each agent its own folder on its own change. A second workspace of a project takes seconds, not a fresh copy and a reinstall.
Seconds, not a fresh copy
Files come from a shared cache, copied on write where the disk supports it. Build folders like node_modules and target can come along.
Hand off part of a task
on workspaces add <folder> --on . starts a subagent on top of your change. Landing its work lands yours first.
Clean up safely
on workspaces clean removes only workspaces with nothing left to land that have sat idle for two hours.
$on get upstream.codes/acme/shop ~/shop-searchanother workspace, in seconds$on workspaces add ../shop-tests --on .a subagent's workspace, on top of your changeThe session behind every change.
When an agent lands, what it was asked, said and ran since its last land is kept with the change, with anything that looks like a secret removed.
Yours to share
Only you see a session, on any of your machines, plus anyone you share the change with. Project owners don't.
Read it anytime
on sessions show <change> prints it. on sessions off stops keeping them, and on sessions delete removes them from the host.
$on sessions show rtnbkcvxwhat the agent was asked, said and ran$on access rtnbkcvx @samshares the change, and its session, with SamPrivate where you need it.
Access is set per folder, so one project can hold work that only some people see.
Private folders
on access billing/ @sam leaves a folder out of everyone else's workspaces, diffs, logs and API answers.
Sealed folders
Add --sealed and the folder's files are encrypted on its readers' machines, each machine with its own key. The host stores them and can't read them.
Your .env stays yours
.env files are saved and follow you to every new workspace, but they never land and no one else sees them.
Secrets stopped
Before a land, added lines are checked for real keys and tokens. A match stops the land with the file and line.
Made to be used by agents.
Every command ends with a next: line that says what to do, --json gives the same fields, and exit codes never change meaning.
A guide in the binary
on guide prints the instructions for coding agents, ready for a skill or an AGENTS.md.
Tokens with limits
An agent's token acts for a person and can be limited to some projects, or to reading. The host enforces it.
No disk needed
One HTTP call, or the MCP server at onset.coline.dev/mcp, lands edits without a workspace.
$on guidethe instructions for coding agents$on land -m "Fix the login redirect" --jsonthe result as JSON, with what to do nextUnder the hood.
Onset is written in Rust: one core for the on command, onset-server and the host on upstream.codes.
Files, folders and versions are objects named by the SHA-256 of their contents. Files over 1 MiB are split into chunks by content, 16 to 256 KiB each, so a small edit to a big file uploads only what changed. Each version names the one before it by hash, so main is a hash chain and history can't be quietly rewritten.
Install.
macOS, Linux and Windows, on x64 and arm64. The installer picks the build for your machine and checks it.
macOS and Linux$curl -fsSL https://downloads.coline.dev/onset/install.sh | shWindows, in PowerShell$irm https://downloads.coline.dev/onset/install.ps1 | iexQuestions about Onset
- What is Onset?
- Version control built for agents. Its command is on. Any number of agents can land on one main at once: the server merges each land in the order it arrives, so none is refused because someone else got there first.
- Can I lose work?
- Every command saves first, on undo takes back anything you did, and on restore brings a file back from any earlier save. Project owners can roll a whole project back to any point in the last 30 days.
- Does it work offline?
- Yes. Everything but landing, getting a project and changing access works offline, and saves upload once you're back. on init makes a project with no host at all, and on publish moves it to one later.
- How big can a project be?
- Up to 100 GiB. A single file can be up to 5 GB, stored in chunks so a small edit uploads only what changed.
- Can I bring an existing repository?
- Yes. on import <git URL> --to upstream.codes/you/name brings a repository's full history into a new Onset project.
- Which platforms does it run on?
- macOS (Apple silicon and Intel), Linux (x64 and arm64) and Windows (x64 and arm64).
- Can I host it myself?
- Yes. onset-server is one binary that keeps everything in one folder: SQLite and the objects. It ships in the Linux downloads.
- How did you measure it?
- In production on upstream.codes, from AWS us-west-2: 4,094 lands a second from 1,500 agents across 20 projects, 64 agents landing on one main within 0.8 seconds, and 0.24 seconds for one land. 16 agents shipping to one branch took 2.2 seconds on Onset and 457 with git.