We checked the code graphs built by CodeAlive and by open-source indexers against call graphs produced by the compiler. CodeAlive's call edges were almost always right, and it found about twice as many of the real calls as the best open-source tool we could score.
This matters because an agent trusts the graph. When it asks "who calls this method?" and the graph invents a caller, the agent reads the wrong code and builds its answer on it. When the graph misses a caller, the agent never learns that it exists.
How we measured
We took three open-source repositories, Playwright, Zod and FluentValidation, and built a reference graph for each with compiler tooling: the TypeScript Compiler API for TypeScript and a compiler-based index for C#.
Each call is identified strictly: the exact place in the source where it happens, plus the exact declaration it resolves to. If a method calls validate() three times, those are three facts. If an indexer points a call at the wrong overload, it counts as an error even when the name matches.
Results per repository
P is precision, R is recall, both for calls. Across all relationship types, including type references, inheritance, interface implementations and overrides, CodeAlive's precision is 0.976–0.987 and recall 0.85–0.94.
DeusData/codebase-memory-mcp was the strongest open-source tool we could score end to end. It does not store calls the way the compiler does, so we matched its edges by a looser key: the line of the call and the line of the target. That favours it, and it still found fewer than half of the calls.
The other tools
colbymchenry/codegraph found many calls on Playwright (recall 0.72), but only 12% of them matched the compiler. Its class hierarchy is much better: extends P 0.86 · R 0.96, implements P 1.00 · R 0.95. It ran on 1,307 of Playwright's files, the subset its parser processed cleanly.
vitali87/code-graph-rag publishes its own results: Django P 0.977 · R 0.938, Zod v4 P 1.00 · R 0.75. Their key is coarser than ours: a call counts as correct if the calling file and the called function's name match, so overloads and repeated calls collapse into one fact. These numbers cannot be compared with the table above. On FluentValidation we ran it ourselves: interface implementations scored P 0.95 · R 0.62, and its calls carry no location, so we could not score them strictly.
GitNexus built stable graphs for Zod and FluentValidation, but it does not store where a call happens either, so a strict score was not possible.
Where CodeAlive falls short
Recall on Playwright calls is 0.82, and interface implementations there scored only P 0.71. These are what we are working on now, against the same compiler references.
Speed is on par, not an advantage. On FluentValidation, codebase-memory-mcp indexed in 1.5 seconds against 2.8 for CodeAlive. On Playwright, CodeAlive took 22 seconds to index and score, codebase-memory-mcp 31 seconds to index.
Caveats
The runs were made between 30 July and 10 August 2026 on pinned commits of each repository and each tool. Three repositories in two languages is not a general ranking, and the keys for other tools only approximate ours. A fairer comparison would run every tool on one frozen file list with one relationship format; that is our next step.
Does a better graph make a better agent?
Not automatically. When we gave this graph to our research agent, it helped on a large repository, barely mattered on a medium one, and some models would not use it at all: GraphRAG for code. The agent around the tools mattered more than the graph: CodeAlive harness vs OpenCode.