AgentSCM is in alpha. Good for a pilot on one repository, not yet for work you depend on.

See how AgentSCM works.

Pick a situation and play it: what your agents tell the hub, what it tells them back, and what is kept.

Situations

Two agents, one file

The hub tells the second agent before it repeats the work, and the two settle it without you.

  1. Codex says what it is starting on.

    Before it edits, Codex tells the hub it is starting on src/session.ts. The hub records the hold.

  2. Claude Code reaches for the same file.

    Its edit is refused once, with the reason and the name of the agent that holds the file.

    A nudge, not a lock: a repeat of the same edit would go through.

  3. The hub asks Codex for the file.

    The refusal also sends Codex a request to hand the file over, so the agents sort it out between them.

    Handoff is experimental.

  4. Codex hands it over.

    Codex finishes its part and lets go of the file. The hub moves the hold to Claude Code.

  5. Nothing gets done twice.

    Claude Code makes its change on top of Codex’s. The claim, the refusal and the handoff all stay in the history.

A check fails, then passes

Each check is recorded against the exact change it ran on, so an old pass can’t cover a newer edit.

  1. You ask for a change.

    You ask Claude Code to sign people out after 30 minutes. It tells the hub what it is working on.

  2. Claude Code makes the change.

    The change is recorded as a1b2c3d, with the files it touched.

  3. The tests fail.

    The failure is recorded against a1b2c3d and shows up straight away, while the fix is still small.

  4. The fix gets its own check.

    Claude Code fixes it. That is a new change, d4e5f6a, so the tests run again and pass on it.

    An old pass can’t count for a newer edit.

  5. You approve it.

    The hub shows you what was asked, what changed and which checks passed on d4e5f6a. You say yes.

    The approval step is optional and experimental. An agent’s report is not proof.

  6. Git and GitHub decide the merge.

    The change goes up as a pull request, the way it always has. AgentSCM never merges for you.

Catch up after being away

The hub tells you what finished, what is still going and what needs you.

  1. Your agents keep working.

    While you are away, each agent reports to the hub: what it started, what it changed and how its checks went.

  2. You come back.

    You open the hub with npx agentscm open.

  3. The hub catches you up.

    A short summary of what happened since you last looked: one task finished, one still going, one failed.

    The written summary needs a connected agent to write it. The list of work is there either way.

  4. One thing needs you.

    Claude Code’s tests failed on a1b2c3d. Everything else can carry on without you.

  5. You hand out the next task.

    You ask Codex to fix the failing test. The notes from Claude Code’s work go with the request.

Handover between sessions

The next session picks the task up from the hub’s notes instead of starting over.

  1. Codex is halfway through.

    Codex holds src/refresh.ts and reports its progress to the hub as it goes.

  2. The session ends.

    Codex’s session stops before the task is done. It leaves a note: what is finished and what comes next.

    An agent’s “finished” is a report, not proof.

  3. The hub keeps the task.

    The task stays open with its notes. The file is let go, so nobody waits on a session that has gone.

  4. A new session asks what is open.

    You start Claude Code. Before it plans anything, it asks the hub for unfinished work and reads the notes.

  5. It picks up where Codex stopped.

    Claude Code takes the same task and the file, and starts with the expiry test. Nothing is redone.

Watch it on your own repository.

One command starts a hub on your computer. npx agentscm demo plays three pretend agents first, and writes nothing to your repository.