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

What AgentSCM does today, and what we're building toward

A plain account of AgentSCM in alpha, covering the parts you can run on your own repos now, how they fit around Git, and which pieces are still experimental or only planned.

AgentSCM is a coordination layer for teams with several coding agents working in the same repositories. It runs alongside Git and your GitHub or GitLab flow, it’s in alpha, and the Community edition is something you run yourself on a laptop or your own server. This post covers what it does right now, how the pieces connect, and what’s on the roadmap (with the status of each, since a lot of it is experimental).

What you can do with it now

Here is the short version, by job:

You want to… What AgentSCM gives you Status
Pick up work someone else’s agent started Work claims, checkpoints, blockers, handovers and a bounded briefing of what changed since you last looked Alpha
Stop two agents editing the same file blind Shared file intents, overlap notices across machines, handoff requests Alpha
See overlap that’s already in your branches agentscm collisions, a read-only scan of branches and worktrees using git merge-tree Implemented
See what an agent changed and which checks ran on it Change capture that ties each observed command to the commit or working tree it ran against Experimental, Claude Code adapter
Browse code, history and agent context together agentscm open, a local page with committed files, diffs and any conversations you’ve kept on this machine Experimental, Unix
Gate an agent’s work on real evidence before it lands The native workflow: immutable revisions, pinned checks, single-use approvals Experimental

Supported agents today are Claude Code, Codex, Cursor, GitHub Copilot and Gemini CLI. How much each one exposes differs, and the agent support page lists what’s been qualified in live sessions versus installed.

How the pieces fit

There are three parts. The Hub is a server you run (SQLite or PostgreSQL behind it) that stores coordination records: who’s working on what, which files they’ve declared, what they reported at each checkpoint. Each computer runs the agentscm CLI, which installs hooks and MCP config into the agents it finds. And there’s a local page, opened with agentscm open, served from your own computer, which reads your checkouts there without fetching or changing anything.

Setup is one command per computer, not per repo:

npx agentscm

That installs a release binary, sets up a local Hub (natively on Apple Silicon Macs; Linux and Intel Macs use Docker or an existing Hub), signs you in and configures every agent it detects. It writes nothing into your repositories. The first time a local Hub runs, it walks you through creating its GitHub App. To join a Hub a teammate already runs, add --hub-url with its address.

Signing in once covers the computer. Agent tokens last 24 hours and renew in the background, and your access to each repository is re-checked when they do.

The coordination loop

Say two agents are working in one repo, one on invoices and one on rounding, and both end up needing billing.rs. With AgentSCM connected, each agent announces the files it’s about to change. When the second one goes to edit billing.rs, its hook (on Claude Code, Codex and Copilot) refuses that first edit and tells it, by name, which agent holds the file and what it’s doing. The agent can ask for a handoff, wait, or try the edit again, in which case it goes through. Cursor gets a note after the edit rather than before, and MCP-only clients get advice.

Nothing is locked. If the hook fails, the edit goes through. Only work that agents have announced is visible, and two agents touching one file doesn’t mean their changes conflict. We chose a notice over a lock. When a lock gets stuck, every agent queued behind it stops; a wrong notice costs one retried edit.

Work itself has a longer life than a session. An agent can claim a piece of work, report progress, decisions and blockers as checkpoints, and leave a handover that the next agent (or person) reads before starting. A lead who disconnects shows as stale, but the work stays claimed until someone takes it over explicitly. None of this proves the code ran or passed review; it’s what agents reported, labelled that way.

What gets recorded, and what doesn’t

Conversation capture defaults to metadata only, meaning no conversation text is kept or sent to the Hub. Per checkout, you can opt in to keeping conversations locally, or to sharing them with the Hub. Shared conversations are redacted on your machine first (best effort, so it isn’t a guarantee there are no secrets in them), only the person who shared them and Hub admins can read them, and the Hub deletes them after 30 days unless the operator changes that.

Change capture records bounded facts about a session and ties observed commands to the source they ran on. Outcome, coverage, freshness and whether the evidence is still available are kept as separate fields, so a passing test on last Tuesday’s commit doesn’t read as a passing test on today’s. Claude Code has the fuller capture adapter. Codex currently exposes session boundaries and selected edit starts, and not prompts or assistant messages.

The native workflow (experimental)

For teams who want stricter control than “the agent said it ran the tests”, there’s an optional native path. It’s a trusted-local, single-operator profile today, so treat it as a pilot.

In Git terms: a revision is like a commit without the author and message. A review context is a PR description that’s frozen and hashed, so an approval proves which description the reviewer saw. An approval is tied to one exact revision, review context, Change version, target and policy epoch, and it can be used once; push a fix and you need fresh evidence and a fresh approval. Command checks run in a locked-down container (no network, read-only source, no credentials), and the result is what the controller observed, not what the command printed about itself. Landing moves a protected target only if it’s still where you expected, in one transaction.

Git and your forge keep merge authority throughout. Native gates don’t see raw pushes or forge merges, and AgentSCM doesn’t configure branch protection for you.

What we’re building toward

Everything below is on the roadmap as proposed or experimental, and none of it has a date.

  • Resource claims. The same idea as file intents, for shared machine resources such as build slots, ports, disk budget and containers, with a notice when they’re oversubscribed.
  • A main-red signal. If a post-merge check fails on the target, every session based on or after that commit gets told it’s inheriting the failure, until a later run is green. Merging carries on as normal.
  • An orchestrator view. One read-only page across sessions with claims, intents, resource claims, skill gates, collisions between open branches and the main-red signal.
  • More supported skills. A catalog of versioned workflows (gates, required evidence, roles) that a repo pins in a committed lock file. One skill exists today, an experimental pr-gate for pull requests, and its evidence is self-reported by agents and labelled that way.
  • Optional native authority per target. For a team that chooses it, the native ledger could become the landing authority for one target, with a verified round trip back to Git. It’s opt-in and reversible, and we expect most teams to stay on Git.
  • Measured scale. Published numbers for capacity, latency and cost at tens to hundreds of agents. Nothing has been measured at that scale yet.

A hosted Hub at agentscm.ai is planned. There’s no launch date or pricing yet.

Who it’s for, right now

The best fit is a team of roughly 2 to 15 engineers with several agents in shared repos, or one developer regularly running three or more sessions at once. If you run one agent per repo, or you need audited production controls today, AgentSCM isn’t ready for you yet.

The limits, in one place: CLI, APIs and storage can change without migration. Production security and scale aren’t qualified. Running a hosted Hub isn’t supported in the alpha. Windows support is partial. The license is FSL-1.1-ALv2 (source-available, converting to Apache 2.0 after two years).

Try it

The scripted demo needs no account, Docker or forge, and doesn’t write to your repo. It starts a temporary Hub, runs three simulated agents through the real hook endpoint and opens the status page:

npx agentscm demo

When you want it on real work, run npx agentscm and restart your agents. Then, from inside a repository, ask one of them to “get started with AgentSCM”. The code is on GitHub, and the docs cover setup, data handling and the limits above in more detail.

All articles