We're not the biggest tool in this category.
Here's the bet we're making instead.

The category converged on one pattern: a local graph, served over MCP.

A year ago "give your agent codebase context" meant embeddings and a vector DB. It doesn't anymore. The tools that broke out — CodeGraph (~47K stars, MIT) and GitNexus (~42K stars) — both pre-compute a structural graph on-device and expose it to agents over the Model Context Protocol (MCP): no cloud, no embeddings API, no code leaving the machine. graphify popularized the central-store idea; potpie took the funded, Neo4j-backed platform route; Serena skips the graph entirely and wraps live language servers. We share the local-first, deterministic half of that consensus — and we make one deliberately contrarian choice, spelled out below.

Where everyone stands, as honestly as we can draw it.

green = a genuine strength, amber = partial / caveated, red = a real weakness. Notice ours has red in it. The most important red is MCP — see "our bet."

Two kinds of numbers: what we measured, and what's structurally true of everyone.

1. Setup & footprint — true for every rival, by architecture

You don't need a benchmark to count dependencies. This is the win we hold against the whole field, not just one tool — the deterministic single binary carries none of the runtime cost a graph-DB, a model, or a language-server does:

2. Measured head-to-head — CodeGraph, GitNexus, graphify, ast-grep (2026-07-24 run)

Four public corpora, pinned SHAs, same machine (M5 Pro), every tool on its fastest deterministic path — no embeddings, no LLM, no clustering. ctx-optimize cells re-measured on the incremental-sync build (011f50d); versions: CodeGraph 1.5.0 · GitNexus 1.6.9 · graphify 0.9.12 · ast-grep 0.45.0. Raw data: results-multi.json. Note: “graphify src” below is a 754-file bounded corpus from this run — a different, smaller corpus than the 12,484-file full-tree run quoted above and on the front page; don’t mix the two.

Where we lose, shown as-is: CodeGraph wins cold gather on flask (0.46 s vs our 0.65 s). Honest footnotes: ctx-optimize’s cold gather includes the full markdown wiki; its warm number is the tree-signature short-circuit that shipped in this build — earlier releases re-extracted fully and were slower warm than CodeGraph, which is why this row was our loss until 011f50d. † GitNexus’s warm cells on those two corpora were a forced full rebuild (schema-version bump mid-run), not a true incremental re-sync — read them as worst-case, not typical. ‡ ast-grep is grep-style structural search with no index — no gather/store rows apply; its two Python query cells were re-run with a corrected pattern after the original matched zero results (our authoring error, not the tool’s). Each tool builds a different graph (node counts differ up to ~1.6×); disk and query numbers compare each tool’s own artifact, not identical outputs.

3. Our absolute numbers + their published claims

potpie and Serena still have no measured row — different architectures (Neo4j + LLM-in-loop; LSP server) that need their own harness, and we won't fake a head-to-head we haven't run. Raw data behind ours: proof/agent · bench/results.json · bench/results-multi.json.

What each competitor is genuinely better at — and where we'd pick ourselves.

A single deterministic binary you extend, not a service you run.

Strip away the scoreboard and the difference is philosophical. Everyone else is a store format + a server (SQLite, LadybugDB, Neo4j) or a live service (LSP). We're a single static Go binary — no database process, no embeddings, no model, no network except what you invoke yourself (a self-update, a one-time toolchain fetch, your own remote scripts) — whose artifacts are plain, sorted, git-diffable files. What that buys:

• +Truly zero setup. npm i -g or one binary, works offline, nothing to stand up — not even a local DB daemon.
• +Extend without forking. Routes, manifests, languages, and any data source are drop-in packs/adapters — commit the file, the whole team's agents inherit it. No other tool here lets you add a framework recognizer as a committed JSON file.
• +Honest provenance + freshness. Every edge is EXTRACTED (parsed) or INFERRED (name-matched); fresh gates answers against git HEAD so the agent never trusts a stale graph.
• +More than code. Routes→handlers, dependencies that federate across build tools, k8s topology, git co-change, community subsystems — in one graph, one query.
• ±Agent skill over MCP — a deliberate bet. The leaders distribute over MCP; we bet on the agent-skill + hook + committed pointer path instead. A skill is richer than a fixed MCP tool list — it teaches the agent when and how to use the store, carries the query-craft rules, and drives onboarding and customization end-to-end. The tradeoff, stated plainly: on MCP-only hosts (Cursor, Kiro, Gemini CLI) you'd wire the CLI in yourself — there's no MCP server, by choice, and there won't be one. On Claude Code, Codex, Copilot and Devin the skill lands the moment you run install --skills.
• −Call edges are conservative, not LSP-exact. We parse with tree-sitter (real ASTs, same engine class as CodeGraph/GitNexus/graphify) and resolve a call to its declaration by unique name — dropping ambiguous matches rather than guessing, so there are no false edges. That's the same precision tier as the other graph tools; only Serena's language server is genuinely type-exact (it knows the exact overload). Closing that last gap (go/x/tools first) is on the roadmap.