← The Journal

Tool review8 min read5 / 10

Graphify: a code graph for coding agents, tested on three repos

Graphify turns a repository into a knowledge graph that Claude Code queries instead of reading files. It is free, local and well kept. On our own code it saved a little, slowed every answer down, and once led the agent to a confident, incomplete answer.

What it is

Graphify reads a repository with tree-sitter, a parser that understands about 40 languages, and builds a graph of what is in it: functions, classes, imports and the calls between them. The result goes in a graphify-out/ folder as graph.json, an HTML view and a GRAPH_REPORT.md summary. An agent then runs graphify query, graphify path or graphify explain to answer "how is this wired?" without reading the files itself.

For code, building the graph needs no language model and nothing leaves your machine. Docs, PDFs, images and video can be added with a "semantic pass", and that part does call a model: your assistant's, or whichever API key it finds.

graphify install adds a /graphify skill to Claude Code, a block for your CLAUDE.md, and hooks. A PreToolUse hook steers the agent to the graph before it reads or searches files, and a strict mode can refuse a Read or Grep until the agent has queried the graph. There is an optional MCP server too.

The project is busy. It has about 150,000 stars on GitHub, and 280 releases on PyPI, the latest on 17 November 2026. The PyPI package has a single maintainer account. The README says there is no telemetry; it does log every query to a file in your home folder unless you turn that off.

How we tested it

We wanted our own numbers rather than the project's, so we tested on code we know well.

  1. Three repositories of different sizes: a Rust game engine (252 tracked files), a web audio app in JavaScript (116 files) and a product-review web app in Python (141 files). Fresh clones only, nothing committed back.
  2. Code-only graphs, no language model. Graphify ran in its own virtual environment with GRAPHIFY_BACKEND=none, no API keys and no claude command on the path. We read its source first, and turned the query log off.
  3. Fifteen questions with checked answers, five per repository, written and checked against the code before any agent saw them. They were the kind of question an agent asks when it starts work: where a file-format version is set and what checks it, which modules depend on a given one, how a request travels from the entry point to the code that handles it.
  4. Each question answered twice by the same model, a fresh Claude Sonnet agent each time: once with plain Read, Grep and Glob, and once with the graph and Graphify's own CLAUDE.md block, word for word.
  5. What we recorded: total tokens and tool calls from the harness, wall-clock time, and a score of 0, 1 or 2 against the checked answer. An agent given no task at all used 67,708 tokens, which is the fixed cost of the system prompt and tool definitions. The rest of each answer is what the exploration cost.

Building the graphs was cheap: 52 to 104 seconds and at most 109 MB of memory, on a slow Windows-mounted disk. The game engine's graph had 5,734 nodes and 15,117 edges in a 5.8 MB file; the other two were under 1 MB.

What we found

RepositoryTokens, plainTokens, GraphifyChangeSeconds, plain → GraphifyScore, plain → Graphify
Rust game engine12,1669,980-18%18 → 339 → 9
Web audio app8,7189,509+9%20 → 3210 → 8.5
Product-review app13,30310,835-19%25 → 429.5 → 9.5
All 15 questions11,39610,108-11%21 → 3628.5 → 27

Tokens are the exploration tokens: the average per answer above the 67,708-token fixed cost. Seconds are the average time per answer. Scores are out of 10 per repository (out of 30 in total). Counting everything, the averages were 79,104 tokens without the graph and 77,816 with it.

  • Tokens: Graphify was cheaper on 9 of the 15 questions. On the two larger repositories it saved about a fifth of the exploration; on the small one it cost slightly more. The average saving was about 1,300 tokens per question.
  • Time: every repository got slower, by 63% to 83%. The agent ran the graph queries and then usually read the files anyway.
  • Tool calls: slightly fewer with the graph, 3.8 per answer against 4.3.
  • Query quality was mixed. On two questions graphify query returned nodes that matched words in the question but had nothing to do with it, and the agent fell back to grep. Asking which modules depend on another was answered from the build files, not from the graph.
  • Sometimes the graph helped. On two questions in the game engine, the agent with the graph went one level deeper and named a function or a code path that the plain agent missed.

What went wrong

One answer with Graphify was wrong in a way plain search never was in our trial. The question asked which files import a shared settings module, and which of its exports each one uses. The agent asked the graph, got the list of files back, and wrote its answer without opening them. The files were right, but for three of them it left out one of the exports they use, because the graph had no edge for it. It scored 1 out of 2.

That is the risk in the block Graphify asks you to put in CLAUDE.md. It tells the agent to query the graph before it searches, and to read files where the graph points. When the graph is incomplete, the agent gives an incomplete answer and sounds sure of it. A graph that is out of date after a pull would make this worse. Two more answers lost half a point for related reasons: one misdescribed a function, and one never opened the module that actually sends the reminders it was asked about.

Watch-outs before you install it

  • It can spend your Claude usage on its own. When no API key is set and the claude command is installed, community labelling falls back to running claude -p. It prints a line saying so, but nothing asks you first. Set GRAPHIFY_BACKEND=none to keep it off.
  • The hooks change how every session searches. The PreToolUse hook steers Read, Glob, Grep and shell reads towards the graph, and --strict refuses Read and Grep until the graph has been queried. If you try it, install it per project with no hooks, and never in strict mode.
  • The graph has to be kept fresh. It must be rebuilt after every change, with its git hook or graphify update . after a pull. A stale graph gives wrong answers with confidence.
  • Supply chain. One maintainer account publishes very frequent releases, and the package name is easy to mistype: it is graphifyy, with two y's, and the README itself warns that other graphify packages are not theirs. Pin the version.
  • Queries are logged. Every query goes to ~/.cache/graphify-queries.log unless you set GRAPHIFY_QUERY_LOG_DISABLE=1.

What this test does not show

The sample is small: 15 paired questions, one run each. The spread between questions was about 7,000 tokens either way, larger than the average difference, so read the token result as "perhaps 10 to 20% fewer exploration tokens on a repository of a few hundred files, none on a small one", not as a fixed figure. It is nowhere near the 80% on the Cloud page.

We did not test the semantic mode that adds docs and Markdown, the MCP server, the hooks themselves, or long sessions with many questions in a row. A long session is where a graph might pay back its setup, and also where the exploration tokens are a smaller share of the whole, because the system prompt, project notes and conversation dominate.

What it costs

The open-source tool is free, and a code-only graph costs nothing to build but a minute or two of a single core. The real costs are slower answers, a graph file to rebuild after every change, and a new way for an agent to be wrong. Graphify Cloud is a separate paid product with a free tier and no published prices; we did not try it.

The verdict

5 / 10. Graphify is well engineered, genuinely local for code, and open about where it calls a model. On repositories of a hundred to a few hundred files, a capable agent with grep was as accurate, faster, and only slightly more expensive in tokens. The saving we measured, about 1,300 tokens per question, does not justify a hook, a graph to keep fresh, and an agent that trusts the graph over the source.

It might suit a team with a very large or unfamiliar codebase, where exploration is a big share of every session, as long as they pin the version, set GRAPHIFY_BACKEND=none, skip the hooks and tell the agent to check graph answers against the source. For everyone else, the search tools already in the agent do the job.

Want this on your project?

Everything in the Journal comes from software we build and run ourselves. If you want the same discipline applied to your project, tell us what you are trying to do.