Koragraph vs Graphify

Declaration extraction, indexing speed and retrieval, across ten languages and 102 repositories

Koragraph against Graphify v0.9.28 at depth 6. August 2026.

99.70%

Graphify 82.07%

declaration recall across 10 languages

3.78×

ahead on 17 of 17 repositories

less CPU to index

0.824

Graphify’s best 0.769, on 45% fewer tokens

retrieval recall against their ceiling

4 of 6

2 ties, none lost

context budgets won on retrieval

NoteThese benchmarks were run with our enterprise-scale Koragraph architecture, not our MCP.

The short version

99.70% to 82.07%
declaration recall over 1,550,979 declarations
461,804
declarations Graphify never indexes at all
20 of 20
extraction cells won, every language and corpus
3.78× and 2.92×
less CPU and less wall clock, one process against their pool
0.824 to 0.769
retrieval recall against their best result at any depth, on 45% fewer tokens
4 of 6
context budgets won, 2 tied, none lost

What a system never indexes, it can never return

10 languages, 102 repositories, 1,550,979 declarations. Both systems are scored against an independent referee rather than against each other, wherever possible the language’s own compiler front end: go/parser, CPython ast, Roslyn, tsc. Declarations are matched as a file and name pair, so an overload one side collapses into a single node counts as a miss rather than being forgiven.

Recall is 99.70% against 82.07%, and Koragraph leads in 20 of 20 language and corpus cells. The gap is coverage rather than correctness. Graphify models no field plane in 7 of 10 languages, which is 461,804 declarations it cannot return because it never indexed them.

language	repos	declarations	K recall	K precision	G recall	G precision
Java	7	116,866	99.86%	99.73%	85.55%	100.00%
TypeScript	5	72,581	99.94%	100.00%	69.57%	99.91%
JavaScript	6	48,044	99.92%	100.00%	66.40%	99.97%
Python	6	90,881	100.00%	100.00%	90.63%	100.00%
C#	6	189,803	99.90%	99.81%	82.57%	99.97%
SQL	6	9,903	99.87%	99.83%	75.64%	98.19%
C/C++	6	39,820	98.25%	98.22%	52.16%	98.39%
Go	6	49,005	100.00%	100.00%	93.24%	99.84%
PHP	6	60,039	100.00%	100.00%	97.40%	100.00%
Kotlin	6	53,490	98.31%	99.97%	87.66%	99.76%

Recall and precision on the planes both systems model fully. Pooled precision is 99.78% for Koragraph and 99.86% for Graphify.

held-out corpus	Java	TypeScript	JavaScript	Python	C#	SQL	C/C++	Go	PHP	Kotlin
Koragraph	99.57%	99.96%	100.00%	99.99%	99.96%	99.68%	96.59%	100.00%	100.00%	99.25%
Graphify	88.45%	75.84%	45.77%	76.74%	73.11%	84.47%	39.62%	90.75%	98.31%	92.59%

Faster on one core than Graphify is on ten

Handicapping ourselves, a single Koragraph process against Graphify’s full multi-process pool, Koragraph is 2.92× faster in wall clock and uses 3.78× less CPU, 30.8 seconds against 116.3, on 17 of 17 repositories.

measure	ratio	Koragraph ahead on
Wall clock, one Koragraph process against Graphify’s pool	2.92×	15 of 17
Wall clock, ten workers each, matched pool size	3.19×	16 of 17
Wall clock, each configuration’s best per repository	4.66×	17 of 17
CPU seconds, 30.8 against 116.3	3.78×	17 of 17

This is Koragraph’s extraction pass against Graphify’s index pass.

Their best answer, on 45% fewer tokens

A question is a maintainer’s own commit subject. The gold answer is the set of declarations that commit modified, located by Universal Ctags, a third-party indexer neither system uses. The scorer is blind: it sees no system identity, and the rows are pooled and shuffled before grading. 401 questions across 4 repositories, paired question by question.

Graphify runs at depth 6, its documented maximum. We first benchmarked it at its command-line default of 2, which made the gap read about three times its true size. Every number below is against the setting that flatters them most.

Graphify’s best result at any depth and any budget is 0.769 recall using 20,414 tokens. Koragraph reaches 0.824 using 11,343, which is +0.055 recall with a 95% confidence interval of [+0.006, +0.103] on 45% fewer tokens. Matched at the same spend of roughly 11,400 tokens, the margin is +0.096 recall and +0.102 attributed recall [+0.052, +0.153].

Pooled recall against context budget, Graphify at depth 6. Koragraph passes Graphify’s best-ever result at a 16,000-token budget while spending 45% fewer tokens than the run that produced it.

budget	Koragraph	Graphify d6	paired difference	95% CI
1,000	0.521	0.432	+0.089	[+0.044, +0.135]
2,000	0.543	0.528	+0.015 (tie)	[-0.031, +0.063]
4,000	0.649	0.614	+0.035 (tie)	[-0.016, +0.085]
8,000	0.732	0.681	+0.051	[+0.001, +0.100]
16,000	0.824	0.728	+0.096	[+0.048, +0.144]
32,000	0.891	0.769	+0.122	[+0.077, +0.167]

Pooled recall, paired by question, n = 401. Koragraph leads at 4 of 6 budgets and loses none. At 2,000 and 4,000 the confidence interval crosses zero: those are ties, not wins, and are marked as such.

Check it yourself

Koragraph is closed source, so a third party can reproduce Graphify’s column exactly but not ours. That asymmetry is real and worth stating rather than implying the comparison is symmetric. What is published is our inputs, our returned context, the questions, the gold sets and the scorer, so every number above can be re-scored against the artifacts.

Pinned corpus. requests (Python), viper (Go), zlib (C), commons-cli (Java), 20 to 63 source files each, every repository at a published commit SHA.
Third-party gold. Answers located by Universal Ctags 6.2.1, and every gold declaration verified to still exist at the pinned commit.
Blind scoring. The scorer sees no system identity, and rows are pooled and shuffled before grading.
Zero API cost at measurement time. Neither system spends a paid model call to produce its answers. Graphify runs update --no-cluster at depth 6.
Graphify at its best setting. Depth 6 is its documented maximum. Our first run used its command-line default of 2, which overstated our lead by roughly a factor of three. The depth sweep is published with the results.

Benchmarks and code on GitHub →