AI-native version control · Rust · MIT

Version control that remembers — and knows when it's wrong.

Agents change code continuously and keep notes that go stale silently. gpp captures every change as it happens, versions project knowledge inside the repo, and when a commit invalidates something you believed about the code, names that commit — deterministically, no LLM in the loop.

$ cargo install gpp-cli copy View source

Works alongside git — the bridge round-trips real commits. Recording below is scripts/demo.sh: deterministic, no mockups.

gpp — recorded demo (15s)

Recorded terminal demo: gpp captures changes, promotes a changeset, records a belief, and belief bisect names the commit that invalidated it

The problem

Your agent's memory doesn't know when the code moved.

Every serious agent setup carries a memory — a CLAUDE.md, a memory bank, a git-like memory store. They all keep knowledge beside the repository, so drift between memory and code has to be detected after the fact: re-read, re-embed, ask a model. And models are bad judges of their own memory — on the STALE benchmark the best frontier model spots an invalidated memory 55.2% of the time. gpp hosts knowledge on the repo's own event stream, so drift is witnessed — the change that staled a fact arrives as a commit with author, time, and diff attached.

memory file, six months later silent

## Auth notes
- token expiry is 24h   <- false since June. Nothing flags it.

Served verbatim into the agent's context, every session.

the same fact, as a gpp belief witnessed

$ gpp belief bisect "token expiry is 24h"
INVALIDATED  cs:fhcpef7c  2026-06-03
  "raise token expiry to 7 days"
 -  7 | pub const EXPIRY_HOURS: u64 = 24;
 +  7 | pub const EXPIRY_HOURS: u64 = 168;

Validated on real history

Five repos, four languages, 21 beliefs — every culprit pinned.

Beliefs seeded true at an old release tag with evidence spans in the real source, bisected across a major version imported through the git bridge, and asserted against pinned expected commits: axum 0.6→0.7 (Rust, 288 commits), flask 1.1→2.0 (Python, 221), clap 3→4 (Rust, 616), zod 3→4 (TypeScript, 1237), go-redis 8→9 (Go, 388). All 21 expectations pass. The axum run in detail:

Belief (true at v0.6.0)	Verdict	Culprit commit
`Router` is generic over the body type (`Router<S, B>`)	invalidated	`4e4c2917` — Remove `B` type param (#1751)
axum re-exports `hyper::Server`	invalidated	`c9796725` — Add `serve`, remove `Server` re-export (#1868)
bodies stream via `extract::BodyStream`	invalidated	`4e4c2917` — Remove `B` type param (#1751)
shared state is extracted with `State<T>`	holds	— (unchanged in 0.7; survives all 288 commits)

Scope-only intersection marks a belief stale-candidate, never false; only evidence-span content change or deletion marks it invalidated. Evidence spans are drift-adjusted commit by commit. The wider matrix also catches quiet mid-series fixes (zod's nil-UUID regex widening, #483) and reports undocumented reorgs honestly (clap's internal flatten kills file-anchored evidence at the true moment it vanished). Full matrix, per-repo configs + method: demos/belief-bisect. Import of 1,251 commits ≈ 8s; a full bisect rescan ≈ 0.5s.

Why gpp

Three things no plain VCS gives you.

Everything else — P2P sync, replay, review, RBAC, a TUI — is the platform underneath.

Continuous capture

A high-frequency timeline records every file change automatically (SQLite WAL, debounced watcher). Curated changesets are promoted from it with explicit intent, author kind (human or agent), and a cost record. Nothing is lost between commits.

Knowledge, versioned with the code

Graphex is an encrypted knowledge graph inside the repo: architecture, conventions, decisions, and beliefs with evidence spans. Tier-gated per agent trust level, audited on every read, and staleness-checked by the history it rides on.

Agent governance

First-class agent identity with reputation scoring, compliance-as-code policies enforced at capture, promote, and sync, anomaly detection, and per-changeset token/cost attribution (gpp cost --report).

vs. the usual setup

Different assumptions, not a feud.

git tracks files superbly. gpp assumes the contributors and the questions have changed.

	the usual setup	gpp
Recording	Manual commits when someone remembers; work between them is invisible	Continuous timeline capture; commits become curated promotions with intent
Project knowledge	External memory files beside the repo; staleness detected (maybe) after the fact	In-repo versioned knowledge; staleness witnessed by the same history, down to the commit
Diff review	Line diffs; a mechanical rename reads as hundreds of changed lines	Tree-sitter semantic ops; a rename or move collapses to one reviewable operation
Contributors	All committers equal; agent provenance squeezed into author strings	Agent identity, trust, policy, and cost as first-class, auditable data

git stays. The bridge (gpp git-import / git-export / git-bridge) round-trips real git commits with an idempotent hash map, so GitHub, CI, and your teammates' clones keep working untouched. The axum validation above ran entirely on bridge-imported history.

For agents

Connect Claude Code — or any MCP client.

Agents query the knowledge graph (stale beliefs arrive flagged ⚠/✗ in the projection), propose changesets, and report token costs. Local stdio only — no network listener, reads audited, content encrypted at rest.

// .mcp.json at your repo root { "mcpServers": { "gpp": { "command": "gpp", "args": ["mcp-server", "--stdio"] } } }

$ gpp init --graphex $ gpp mcp-server --stdio # tools: graphex_query · graphex_status # glossary · conventions # propose_changeset # propose_graph_update · report_cost

Client setup for Claude Desktop and generic stdio clients: docs/MCP.md.

Project status

Built, tested, honestly scoped.

177

workspace tests passing

crates, pure Rust, no unsafe

9/9

roadmap phases implemented

65.7%

line coverage, measured in CI

The honest version (verified 2026-07-12): every layer is implemented — clippy/fmt clean, no stub crates — but test depth is uneven. Foundational crates are well covered and the CLI has end-to-end suites (policy enforcement, cost reporting, belief bisect); several integration crates remain at smoke level. "Implemented" means built and tested against its milestone, not exhaustively hardened. The gap and its plan live in TODO.md; the running engineering log in WORKLOG.md.

The platform underneath

Twelve layers back the headline.

Each is a focused crate in one Cargo workspace; one static binary comes out.

All 17 crates, one line each ›

gpp-corecontent-addressed store — BLAKE3 + zstd, atomic idempotent writes

gpp-timelinecontinuous capture — SQLite WAL, .gppignore, debounced watcher

gpp-historychangesets + intents promoted from the timeline; DAG, branch refs

gpp-diffline + tree-sitter semantic diff (Rust/Py/TS/Go), rename/move detection

gpp-graphexencrypted knowledge graph — tiers, projection, audit, beliefs + staleness

gpp-git-bridgeimport/export/bridge to real git history, idempotent hash map

gpp-trustagent reputation scoring, status transitions, overrides

gpp-policycompliance-as-code at capture/promote/sync, secrets templates

gpp-costper-changeset token/$ attribution, budgets, agent self-reporting

gpp-anomalyscope/burst/size pattern detection with resolution workflow

gpp-syncP2P over Noise_XX — objects, refs, policies, zero-knowledge graphex

gpp-replayreproducible environment snapshots + drift diff

gpp-review · gpp-rbacreview lifecycle; roles + branch protection

gpp-notify · gpp-remoteevents/webhooks; GitHub/GitLab/Bitbucket PRs + CI import

gpp-relayalways-on sync hub — a persistent peer, no special authority

gpp-sdkAgentSession + the MCP server surface

gpp-cli · gpp-tui · gpp-depsfull CLI, ratatui TUI, dependency intel + OSV