Source control for agent‑native work.

Better keeps Git as the bridge, then gives parallel coding agents a native model: sessions, checkpoints, context, composition, and an accepted release frontier.

Install Better Agents read the skill
Git import Agent sessions Release frontier Git export
launch frontier
compose: clean
git/head
a92f1c4
codex
3 ckpts
cursor
2 ckpts
frontier
accepted
Release frontier replaces "merge branch."

Agents checkpoint scoped work. Better composes compatible sessions. Humans accept the frontier that should ship.

1shared source-control truth
Nparallel agent sessions
0Git-native assumptions required

A cleaner shape for crowded repos.

Git gave humans branches and pull requests. Better gives agents a coordination surface before they edit, while Git stays available for migration and publishing.

1

Context before motion

Agents ask Better for related sessions, checkpoints, superseded attempts, and active claims before repeating work.

2

Checkpoints over commits

A checkpoint is a native save point tied to a session and file claim. It can be composed, inspected, reused, or superseded.

3

Frontiers over branches

The accepted release frontier is the source of truth. Git patches and commits are bridge artifacts when the outside world needs them.

From Git repo to accepted frontier.

This is the launch story: import what already exists, let agents coordinate through Better-native state, accept the release frontier, then export back to Git when you need interoperability.

01 / import

Start where your repo already lives.

Better imports the current Git HEAD as an accepted release frontier. Nothing asks your team to abandon the public upstream on day one.

developer terminalGit -> Better
better init
better import git
imported HEAD as accepted frontier
02 / context

Agents read the map before editing.

The first move is not a branch. It is a context query, a scoped session, and an explicit claim so nearby agents can coordinate.

agent loopread, claim, isolate
better --json context \
  --task "rate-limit /login" \
  --file src/auth.rs

better --json session start \
  --task "rate-limit /login" \
  --owner agent:codex \
  --file src/auth.rs

better workspace create --session <session-id>
03 / checkpoints

Save progress in native units.

Checkpoints are scoped to the claimed files in a session. That gives later agents a useful artifact without turning every save point into a Git commit.

checkpointnative save point
better --json workspace status --session <session-id>
better --json checkpoint \
  --session <session-id> \
  --workspace \
  --message "add login rate limit"

checkpoint keeps provenance with the session claim
04 / compose

Integrate by composition, not surprise merges.

Better checks active sessions for overlapping claims, stale work, missing checkpoints, and provenance risk before the release frontier moves.

release frontiercompose -> accept
better compose --json
composition clean

better --json release propose \
  --message "ship login rate limit"
better --json release accept <release-id> \
  --by human:reviewer
better restore frontier
05 / export

Publish through Git when the frontier is ready.

Git remains the compatibility bridge: export the accepted Better tree, create the Git commit if your workflow needs one, and verify parity.

bridge artifactBetter -> Git
better export git frontier \
  --patch /tmp/better-frontier.patch
better --json verify git-export
better --json export git frontier \
  --patch /tmp/better-frontier.patch --verify

Built for developers and agents.

Humans keep product judgment and release authority. Agents get a source-control protocol that tells them where to look, what to claim, and when their work can compose.

For developers

  • Import existing Git repositories without changing how the public remote is published.
  • Review Better sessions, checkpoints, compose output, and release frontier proposals.
  • Use Git export only when you need a patch, commit, or conventional publishing bridge.
  • Self-host `better-remote` today while hosted remote sync moves toward launch.

For agents

  • Read skills/better-source-control/SKILL.md before source-control work.
  • Run context queries before editing so previous sessions and active claims are visible.
  • Start a session, claim files accurately, checkpoint often, and compose before release.
  • Treat Git as import/export compatibility, not the native collaboration model.

Install the tool. Give agents the skill.

The skill tells agents how to use Better-native state. The binary gives them the local source-control runtime.

Agent skill

Add the Better operating loop to your agent environment.

npx skills add logesh45/better-source-control

Curl installer

Installs better and better-remote into $HOME/.local/bin by default. Add the PATH export only if the installer says your shell cannot see that directory.

curl -fsSL https://raw.githubusercontent.com/logesh45/better-source-control/main/install.sh | bash

Homebrew

Use the repository tap when you prefer package-manager updates.

brew tap logesh45/better-source-control https://github.com/logesh45/better-source-control

brew install logesh45/better-source-control/better

Hosted remote sync is coming soon.

Better remotes sync native objects, metadata, and frontier state. Today, teams can self-host `better-remote`; the hosted version is the missing piece for effortless multi-machine and multi-agent coordination.

Today
better-remote --bind 127.0.0.1:8787
Coming
hosted remotes for shared frontier sync
Always
Git import/export remains the bridge

Stop making agents pretend branches are coordination.

Let Git stay excellent at interoperability. Let Better carry the agent-native work: context, sessions, checkpoints, composition, and the frontier you choose to release.

Start with the skill View GitHub