TL;DR
Graphify turns a folder (code, docs, PDFs, images, audio) into a persistent local knowledge graph that a coding agent queries before it greps. Code is parsed with tree-sitter (about 40 languages) and never sent to an LLM; prose and images still go through LLM subagents. Every edge is labelled EXTRACTED, INFERRED (with a score) or AMBIGUOUS, and a Claude Code hook steers the agent from Grep/Read to the graph. The repo claims 147K stars and a 71.5x token cut per query on a 52-file corpus, but its own numbers show the win shrinks to about 1x on small repos and its QA accuracy trails a rival on LOCOMO. Treat it as a strong navigation layer for large, unfamiliar codebases, not as proof that graphs beat grep in general.
What it is and how it works
Graphify-Labs/graphify is a Python CLI plus a /graphify skill (Apache-2.0, created 2026-04-03; the company is in YC S26). The free CLI is open source; Graphify Cloud is the paid layer with cross-repo graphs, Sentry and Jira connectors, and what it calls formal verification. Install is pip install graphifyy (the PyPI name is temporary).
Extract, in three passes. Code goes through tree-sitter locally: functions, classes, imports, calls, inheritance and cross-file references. Audio and video are transcribed locally with faster-whisper. Docs, PDFs and images go to LLM subagents that each emit a JSON fragment, which are merged.
Label every edge. EXTRACTED edges come straight from the parse (confidence 1.0). INFERRED edges are scored from 0.95 down to 0.55. AMBIGUOUS edges are kept but flagged.
Cluster. Leiden community detection groups nodes into subsystems, with no embeddings.
Capture rationale. Comments marked NOTE or WHY, and ADR or RFC citations, become rationale nodes linked to the code they explain.
Persist and update. Output is
graph.json(NetworkX format), an interactivegraph.html, an Obsidian vault andGRAPH_REPORT.md(central nodes, surprising links, suggested questions). A SHA256 cache re-extracts only changed files; git hooks keep it fresh.Query.
query(default budget 2,000 tokens, depth 2),pathbetween two nodes (rated by its weakest hop) andexplain. Also exposed as an MCP server, with export to Neo4j or FalkorDB.Steer the agent. On Claude Code a PreToolUse hook redirects Grep/Read to the graph. A strict mode blocks reads of indexed files unless the graph was queried recently.
graphify prsreports each PR's graph impact and merge-order risk.
The post says it works with Claude Code, Codex, Cursor, Gemini CLI and 20+ other tools, with no embeddings, vector DB or paid API.
Claims and evidence
All numbers below are the project's own and have not been reproduced. Read together, they say the graph is very good at finding the right evidence and only average at answering from it.
| Benchmark | Graphify | Comparison | What it shows |
|---|---|---|---|
| LOCOMO recall@10 | 0.497 | mem0 0.048, supermemory 0.149 | Strong at finding the right evidence |
| LOCOMO QA accuracy | 45.3% | supermemory 49.7% | Finding is not answering; it loses here |
| LongMemEval-S | 76% | dense RAG 76% | A tie with plain retrieval |
| ERPNext key-fact coverage | 82.0% | grep 70.8% | Beats grep, but on only 6 questions |
| Tokens per query | 71.5x fewer | reading files directly, 52-file corpus | Savings grow with corpus size |
| Tokens per query | about 1x | reading files directly, 6-file corpus | No savings on small repos |
Two framing issues. "No LLM calls" holds only for code; docs, PDFs and images still need an LLM. LOCOMO and LongMemEval are conversational-memory benchmarks, so they say little about code navigation, which is the post's main pitch.
Tradeoffs and failure modes
Static graph, dynamic code. tree-sitter sees syntax, not runtime binding. Dependency injection, reflection, dynamic imports, string-keyed dispatch and generated code produce missing or INFERRED edges. A path query over those edges looks authoritative but isn't, which is why rating a path by its weakest hop matters.
Name resolution without a type checker. A call to
save()is resolved by heuristics, not by a compiler. On large polyglot repos expect wrong cross-file edges; check how many edges are EXTRACTED versus INFERRED before trusting "what depends on X".Staleness. The SHA256 cache and git hooks help, but an agent editing many files mid-task reads a graph that lags its own edits unless it re-indexes.
Strict mode can block the right move. Forcing graph queries before reads helps on big repos and hurts on small ones (the 1x result) or when the graph is wrong. R054 found agents drift back to grep even when given LSP tools; a hook that forbids it trades that drift for a new failure.
LLM passes on prose are not deterministic. Rationale and doc edges come from LLM subagents, so two builds can disagree, and those edges carry the usual hallucination risk.
Grep still wins exact lookups. Literal strings, error messages, config keys and recently written code are faster to grep than to model.
Open core. The verification, cross-repo and connector features sit in the paid cloud; judge the open CLI on its own.
Star count. 147K stars in seven months is unusual; treat it as a signal of attention, not of quality.
Review checklist
Before adopting a code graph like this for agents:
Run it on your largest repo and on a small one; measure tokens and task success against plain ripgrep plus tree-sitter on a held-out set of real tasks (R054's bar).
Report the EXTRACTED / INFERRED / AMBIGUOUS edge mix per language; spot-check 20 INFERRED edges by hand.
List the dynamic patterns your codebase uses (DI, reflection, plugins, codegen) and test path queries across them.
Decide when the graph rebuilds during an agent session, and test a task that edits files the graph indexes.
Start with the hook in advisory mode; turn on strict mode only where the measurements justify it.
Check which content leaves the machine: code stays local, but the docs, PDF and image passes call an LLM.
Pin the version and review the hook and MCP server code before installing it with broad tool access.
Related entries and sources
R054 (eleven coding harnesses): the counterpoint. None uses embeddings to find code, and its advice is no code index unless it beats ripgrep plus tree-sitter on a held-out eval. Graphify is tree-sitter plus a graph, so it is the kind of tool that eval should test.
R037 (Floorplan): a generated codebase map for humans; Graphify builds a similar map for agents.
R055 (Relate): an embedded graph database as agent memory; Graphify exports to Neo4j and FalkorDB.
R028 (auto-ontology-mcp): the same split between deterministic extraction and LLM steps, with provenance on each fact.
R010 (retrieval over long documents): navigation over similarity, the same bet applied to documents.
R059 (Memory Tax): the finding-versus-answering gap above is a case of memory adding structure but losing evidence.
R040 (WikiTrace): keeping the evidence behind each stored claim, as Graphify does with its edge labels.
Sources
Sandhya Ahuja's LinkedIn post, 2026-11-14
Graphify-Labs/graphify on GitHub (README, repo metadata and benchmark claims)