Ambolt
A git forge where a merge is a decision it can explain. Every change carries test claims with the command that produced them, an independent runner re-runs them, and repository policy decides whether it lands — all recorded in an append-only event log, with an Ed25519-signed receipt on every landed commit.
$ cargo install --git https://ambolt.sh/git/ambolt/ambolt amboltRust · Axum · Tokio · SQLite · Git smart HTTP · MCP · Ed25519 · WebAuthn
v0.1.0-alpha.3 · AGPL-3.0 server, Apache-2.0 client · hosts its own repository
- 398
- Rust tests across five crates
- 97
- signed merge receipts on its own history
- 57
- MCP tools for agents
The problem
When most code comes from agents, the diff stops being the useful thing to read. What matters is what was claimed about a change, who checked that claim, and why it was allowed to land.
Ambolt speaks ordinary git: push to refs/for/main with a Change-Id trailer and you get a change; push again and you get a new revision. Branches move only by merge, and a direct push is refused with the reason.
The log is the product
Every fact is one of 74 event kinds in an append-only SQLite log in ambolt-core. The tree, the review queue, blame, attention ranking and the inbox are all projections built by applying that log.
A schema change is a replay, not a migration: the derived tables are dropped and rebuilt, and the log is never touched. ambolt admin fsck replays into empty projections and diffs them against the live ones.
git push web pages ambolt mcp (stdio)
│ │ │ HTTP
▼ │ ▼
┌──────────────┐ ▼ ┌──────────────────────────────────┐
│ ambolt-git │────────────▶│ ambolt-server (Axum) │
│ smart HTTP │ │ auth · routes · queue · receipts │
└──────────────┘ └────────────────┬─────────────────┘
│ commands
▼
┌─────────────────────────────────────────┐
│ ambolt-core │
│ append-only event log (SQLite) │
│ │ apply / replay │
│ ▼ │
│ projections: tree · queue · blame · │
│ attention · inbox · records │
└─────────────────────────────────────────┘git push web pages ambolt mcp (stdio)
│ │ │ HTTP
▼ │ ▼
┌──────────────┐ ▼ ┌──────────────────────────────────┐
│ ambolt-git │────────────▶│ ambolt-server (Axum) │
│ smart HTTP │ │ auth · routes · queue · receipts │
└──────────────┘ └────────────────┬─────────────────┘
│ commands
▼
┌─────────────────────────────────────────┐
│ ambolt-core │
│ append-only event log (SQLite) │
│ │ apply / replay │
│ ▼ │
│ projections: tree · queue · blame · │
│ attention · inbox · records │
└─────────────────────────────────────────┘Claims, runners, policy
A claim records the command it ran and what it deliberately did not check. A runner holding the verify capability re-executes it. Authors can't verify their own claims, and a claim nobody could reproduce blocks the change.
Policy is evaluated again at landing time and the full requirement trace is written into the change_merged event. A proposed policy can be previewed against open changes, or simulated against past landings — had we required a runner since March, what would have waited?
The log doubles as the outbox: the landing is recorded first and the ref is moved second. Anything recorded but not yet moved is reconciled at startup.
push ──▶ revision ──▶ claim (command, declared gaps)
│
▼
runner re-run (verify capability)
│
▼
policy evaluated ──▶ requirement trace
│ satisfied
▼
log: change_merged ──▶ advance ref ──▶ Ed25519 receipt
git note: refs/notes/amboltpush ──▶ revision ──▶ claim (command, declared gaps)
│
▼
runner re-run (verify capability)
│
▼
policy evaluated ──▶ requirement trace
│ satisfied
▼
log: change_merged ──▶ advance ref ──▶ Ed25519 receipt
git note: refs/notes/amboltAgents as principals
People and agents hold the same kind of identity, with typed capabilities — task, push, review, merge, verify, admin — that can be scoped to a repository, time-limited, and revoked. A refusal names the missing capability and the grant that would fix it.
The same binary is an MCP server over stdio. Every write it makes carries an idempotency key, so retrying a call after a transport failure is safe.
Receipts that travel
A receipt covers the change, the revision, the policy trace, the claims, the re-runs and their verdicts. It's serialized as canonical JSON, signed with Ed25519 and attached as a git note, so ambolt receipt verify can check it offline against the forge's public key.
Ambolt hosts its own repository. Since it started hosting itself in September 2026, every commit — 97 so far — has landed under its own policy and carries a signed receipt.