Graphify: stop making agents grep
Watch an AI coding agent work on an unfamiliar codebase and you will see the same pattern over and over: find, grep, open a file, grep again, open another file. It works, but it is a rather naive way to build understanding, and on a large codebase it gets expensive.
Why grep and find don’t scale
Text search knows nothing about code. It matches strings, and the agent has to work out what they mean:
- A search for a function name returns every comment, test, log message and unrelated variable that happens to contain it.
- Following a call chain means repeating the cycle of search, read, search, read. Every step puts more files into the context window.
- The agent only learns what it happens to open. It has no picture of the whole system, so it can miss callers, subclasses or modules that are connected indirectly.
- Every round trip costs tokens, and the results of dead ends stay in the context.
Tokens are not the only cost. A context window filled with irrelevant search output leaves less room for what the agent should be reasoning about, which hurts quality as well as price.
We have had better tools for years
None of this is a new problem, and the solution is not new either. IDEs have understood code structurally for a long time. When your editor offers autocomplete, jumps to a definition, lists every caller of a method or renames a symbol safely across a project, it is not grepping. It parses the code into an abstract syntax tree (AST) and resolves the relationships between the pieces: which function calls which, which class inherits from which, what imports what.
Agents mostly skipped that step and went back to the tools of a shell prompt. The structure was always there in the code, but they had no cheap way to use it.
Enter Graphify
Graphify closes that gap. It parses a codebase into a queryable knowledge graph, and exposes it to your agent as a /graphify skill for Claude Code, Cursor, Codex and Gemini CLI. According to the project, it works like this:
- Local, deterministic parsing. Source code is parsed with tree-sitter, for about 40 languages. This happens on your machine, with no LLM involved.
- Relationships as edges. Calls, imports and inheritance are resolved across files and stored in the graph, each edge with an explanation of where it came from.
- No vector store. The graph is built from the structure of the code, not from embeddings of it.
- Structure at a glance. It identifies the most connected nodes (“god nodes”) and clusters the graph into communities that correspond to subsystems, and writes this up in a
GRAPH_REPORT.mdfor architecture review. - More than code. Docs, SQL schemas, configs and PDFs can be added to the same graph. Only that optional step needs an LLM backend.
Instead of grepping, the agent asks the graph:
graphify query "what connects auth to the database?"
graphify path "UserService" "DatabasePool"
graphify explain "RateLimiter" Each of these returns a small, targeted answer rather than a pile of files to read. Hooks and instruction files can nudge the assistant to consult the graph before it falls back to search, and a git hook keeps the graph up to date on commit and branch checkout.
Getting started is short:
uv tool install graphifyy # note the double y
graphify install Then type /graphify . in your assistant to build the graph for the current folder.
What the numbers say
We have not benchmarked this ourselves yet, so treat the following as the project’s own claims. On a cross-tool task over the ERPNext codebase, Graphify reports 82.0% key-fact coverage against 70.8% for a plain grep-and-read baseline. That is a measure of answer quality, not of token usage. The vendor also advertises large token savings for its hosted product, but we have not verified that figure.
Why this matters for KAIZEN
Scaling AI coding agents across a team depends on giving them enough context, fast feedback and reliable results. Helping an agent navigate a codebase, instead of letting it rediscover the structure on every task, fits that picture well. It is also the kind of practice we want to evaluate in the project: does a structural index measurably cut cost and improve output on real codebases, especially legacy ones?
We will report back as we try it out.