The agent-native VCS
Write code 10x faster with AI agents — by skipping codebase rediscovery.
Coding agents spend 90% of their time waiting for files to read: scanning thousands of lines just to find a function definition, grepping names, and rebuilding context. Ganvil indexes your workspace inside the version control system and hands agents instant, structured answers. The feedback loop drops from minutes to seconds, multiplying your team's code-writing speed. Saving 10.7× on context tokens is just a side effect.
Why teams pick it up
Three outcomes. Each one backed by machinery you can inspect.
Put an AI answer in front of an auditor and defend every byte of it. Ganvil treats canonical history like a bank ledger: agents can draft entries, but only a human signature posts them.
- ▸Agents never mutate canonical history — they file proposals you review and accept (ADR-0005, an architectural invariant, not a setting).
- ▸Commits carry Ed25519 signatures, so authorship is cryptography rather than convention.
- ▸Every answer is stamped with freshness: captured-at, the head it was read against, good until the next mutation.
Every time your agent reads a 5,000-line file to find one reference, you wait. By serving structured signatures instead of raw file dumps, Ganvil shrinks the feedback loop to seconds. Code writing becomes an instant conversation.
- ▸Structured answers instead of file dumps: callers returns a list of names where grep-and-read costs eight whole files — 105× on the benchmark corpus.
- ▸Embeddings run on the neural engine of the machine you already own. No cloud round trip, no per-query bill.
- ▸Prefer zero local compute? The hosted hammer tier picks up indexing while queries keep their local shape.
Nothing about your team changes on day one. Your repo can keep living on GitHub while your agent gets the graph.
- ▸gan is a 1:1 git CLI — the commands your hands already know.
- ▸The git bridge round-trips byte-perfectly in both directions; gan import is reversible by construction.
- ▸Dual-mode repos: .git and .ganvil coexist, so trying it costs a directory, not a decision.
Fleets
Version control that knows two agents are alive in the same checkout.
One agent in a repository is a user. Five are a coordination problem git was never asked to solve, because git has no concept of a live actor. Concurrent sessions in one working tree stage over each other, and the first symptom is unresolved-conflict wreckage in a file neither of them finished editing. Every team running agent fleets has hit this.
Workspace leases
A mutating command takes a per-agent lease on the working tree before it touches anything. The second agent that tries to write gets a clean refusal that names the holder — so the fleet routes around a busy checkout instead of shredding it.
Burst coalescing + throttling
Ten cold agents arriving at once used to mean ten identical index warm-ups. Coalescing folds the burst into one: the first request pays, the other nine ride the same warm index. Per-agent throttling keeps a runaway session from starving the rest.
Agent identity + signed proposals
When something lands, you can say which agent did it and on whose authority. Agents operate under named identities, their proposals carry Ed25519 signatures, and canonical history still takes a human signature to move. Attribution is cryptography, not log-file forensics.
Anvil Pods
Hammer Server + Anvil Pods: The Multi-Agent Coordinator.
Ganvil's core Rust library (ganvil-mcp) orchestrates your local development host (The Hammer) and ephemeral cloud sandboxes (Anvil Pods). The Hammer runs the local MCP tools and handles content-addressed workspace file sync, while the Anvil spins up isolated sandboxes per agent so a fleet of fifty subagents can write code concurrently without corrupting your local working tree.
Isolated Agent Compute (Anvil Pods)
Each subagent gets an isolated, ephemeral pod sandbox with its own checkout and build container. 50 subagents can build and test concurrently without ever corrupting your local working tree.
Fast Workspace Sync (Hammer Server)
Real-time, content-addressed file synchronization syncs changes between the Hammer (your machine) and the Anvil Pod in milliseconds, pulling file bodies lazily only when read.
The Unified Brain (ganvil-mcp)
The same underlying Rust library engine runs on both local CLI and cloud gateway. Same deterministic MCP tool contracts, same 10.7× token savings, zero runtime behavior drift.
VCS-Native Leases & Cryptographic Auditing
Lease locks prevent write collisions. Every execution on a pod is appended to a cryptographically signed, hash-chained audit log—authorship is cryptography, not log forensics.
A pod doesn't wait for a full copy of your repository before it opens for work. It gets a map of what's there instantly, and pulls in a file's actual contents only the moment one of your agent's tools reads that file — so a pod is ready in about the time it takes to describe your repo, not the time it takes to copy it.
That lazy pull is also the privacy story, and it's the sharpest line we've got: files your agent never touches during a session never leave your control as content, only as an anonymous fingerprint the pod uses to know the file exists. Nothing you don't read gets read. And if you stepped away mid-edit with uncommitted changes, only the files you actually changed travel to the pod — never the whole repository.
How it works
gan mcp → 15 tools → your agent
The repository becomes a content-addressed knowledge graph: symbol graphs, dependency DAGs, commit reachability. Indexes update sub-second per file as a side effect of normal version control — and because everything is keyed by OID, the graph is queryable at any commit, not just the last time an indexer ran.
A stdio MCP server with 15 read-only, deterministic tools: repo_map, outline, get_symbol, callers, impact, search, context_pack, symbol_diff, blame_symbol, why, and more. Each response is budgeted, truncation is explicit, and every answer carries its freshness stamp.
Claude Code, Cursor, any MCP client. The first touch on a file becomes a 1,700-token outline instead of a 4,800-token read. Agents digest your files in milliseconds instead of seconds, keeping code-generation speed at its absolute maximum.
Zero Friction Setup
Plug Ganvil directly into your existing agent.
Ganvil implements the open Model Context Protocol (MCP) standard. Connecting it to Cursor, Claude Code, or any other agent client takes less than 30 seconds.
For Claude Code
Add Ganvil to your global MCP configuration to make it available to Claude:
// ~/.code_mcp_config.json
{
"mcpServers": {
"ganvil": {
"command": "gan",
"args": ["mcp"]
}
}
}For Cursor
Open Cursor Settings ➔ Features ➔ MCP, click "+ New MCP Server", and enter:
| Name | Ganvil |
| Type | command |
| Command | gan mcp |
Dependency mirroring
SHIPPEDYour agent stops guessing dependency APIs.
Half of an agent's wrong turns aren't in your code. They're in what it thinks it remembers about someone else's: a builder renamed two versions ago, an output type that grew a field. Ganvil serves your dependencies through the same tools as your repository, so the agent looks things up instead of reciting them.
- ▸Query any dependency the way you query the repo — outline a module, get_symbol a signature, search the docs. Same tools, same freshness stamps.
- ▸Versions resolve from your lockfile, so the answer matches what your build actually links, not whatever the model last memorized.
- ▸Sources come from what is already on your disk; public package mirrors are hosted once and shared, so nobody pays to re-index tokio.
- ▸A miss never dead-ends. The response carries a hint with the exact follow-up call, so the agent corrects in one step instead of guessing again.
- ▸License attribution rides on every answer.
While we built this feature, one of our own agents integrated the ort crate from memory. It burned three build-fix cycles on builder and output APIs that don't exist in the pinned version, and the correct signature sat one get_symbol call away the entire time.
Guess, compile, read the error, guess again — it is the most expensive way to discover an API, and agents were running that loop dozens of times a day. It is now a single lookup: version from the lockfile, source from disk, license on the answer.
Structurally new
Commands git doesn't have a word for.
Git stores what you wrote. Ganvil also keeps what it means — and that difference shows up as commands, not slideware.
Diff two revisions by symbol. A 4,000-line textual diff becomes twenty lines of meaning: what was added, removed, re-signatured.
Blame a function, not a line range. The history of the thing you care about, without the whitespace archaeology.
Decision archaeology — the commits, messages, and related tests that explain why a symbol looks the way it does.
Install
Up and running in 10 minutes or less!
gan v0.1.1 ships as tarballs for macOS (Apple silicon) and Linux (x86_64). Every release publishes SHA256SUMS next to the artifacts — verify before you extract, the same way you'd want your auditors to.
# macOS (Apple silicon) curl -LO https://github.com/S7-Works/ganvil/releases/download/v0.1.1/ganvil-v0.1.1-aarch64-apple-darwin.tar.gz # Linux (x86_64) curl -LO https://github.com/S7-Works/ganvil/releases/download/v0.1.1/ganvil-v0.1.1-x86_64-unknown-linux-gnu.tar.gz # verify against the published checksums, then install curl -LO https://github.com/S7-Works/ganvil/releases/download/v0.1.1/SHA256SUMS shasum -a 256 -c --ignore-missing SHA256SUMS # sha256sum -c on Linux tar xzf ganvil-v0.1.1-*.tar.gz install ganvil-v0.1.1-*/gan ganvil-v0.1.1-*/gv ~/.local/bin/
The tarball carries two binaries: gan, the CLI, and gv, its helper. Then gan import any repo and point your agent at gan mcp.
All artifacts and their checksums live on the releases page.
Product shape
One engine, three surfaces.
The same crates compute the graph everywhere. The surfaces just point at it.
gan CLI
SHIPPED · V0.1.1The 1:1 git drop-in and the MCP server, one small binary pair. This is where agents live.
Ganvil Desktop
SHIPPED · 3 PLATFORMSThe instrument panel: history, symbol diff, proposal review. macOS on both architectures, plus Linux.
Web
IN DEVELOPMENTThe same engine served through Ganforge, for the reviews that happen in a browser tab.
Ganforge · the hosted side
Local is free forever. Hosted is where the org-scale wins live.
The trust split runs through the product the same way it runs through the UI: warm forge for canonical truth that stays yours, cool phosphor for derived intelligence you can rebuild — or rent.
The full VCS and the full MCP surface on your machine. On-device embeddings, offline operation, and every tool functional with AI disabled. This tier is the product, not a trial.
Hammer compute and indexing are hosted fully in the cloud—no laptop battery drain. For an extra fee, open up local machines to be coordinated directly with your cloud workspaces.
Org-built vectors sync down to your machines and queries run there. Query text never leaves your infrastructure — the index travels to the question, not the other way around.
Where the hosted side goes next: indexes that are always warm because every push re-warms them; merge coordination that catches semantic conflicts a clean line-merge would wave through; impact analysis that crosses repository boundaries; and dependency scouting that warns "this upgrade breaks 3 call sites" before anyone asks. It sits in this box rather than the tier cards because none of it has shipped, and the labels on this site mean something.
Your VCS is the knowledge graph. No sidecar indexer.
Sidecar graph tools proved the demand, then went stale between runs. Ganvil makes the graph a property of the repository — incremental, versioned, and queryable at any commit.