Graphify v0.9.9: Benchmarks, a New Org, and Why the Graph Beats Grepping

I've watched an agent spend half its context window re-deriving the same architecture it walked through in the last session. Grep finds the string, but it doesn't tell you why that function matters or what breaks if you change it. That's the gap Graphify is built around.

Instead of having your assistant read files in sequence every time, Graphify builds a graph once and lets the assistant traverse it like a map. The bet is that precomputed relationships are cheaper and more accurate than re-reading source code on demand.

What Happened

The Graphify-Labs/graphify repository shipped v0.9.9, its 155th release, with 137 contributors under a YC S26 badge and an MIT license.

Install is two steps: uv tool install graphifyy (the PyPI package carries a double-y, the CLI command stays graphify), then graphify install to register the skill with your assistant. After that, /graphify . builds three files in graphify-out/: an interactive graph.html, a GRAPH_REPORT.md summary, and a graph.json you query later without re-reading the source.

One addition in recent releases worth flagging: the README now recommends adding graphify-out/ to .claudeignore. Without it, every time graphify writes output files, Claude Code's prompt cache is invalidated, forcing a full re-upload at cache-write rates on the next turn.

Key Features

• Local, deterministic code parsing: 36 tree-sitter grammars handle code with zero LLM tokens. A code-only corpus runs fully offline with no API key.
• Explained edges: Every connection carries a confidence tag: EXTRACTED (explicit in the source) or INFERRED (resolved by graphify). You can tell what was read from what was guessed.
• Query, path, explain: graphify query "what connects auth to the database?", graphify path "UserService" "DatabasePool", and graphify explain "RateLimiter" all run against graph.json. No files opened.
• Beyond code: SQL schemas, Terraform/HCL, docs, PDFs, images, and video/audio map into the same graph. Live PostgreSQL introspection works via --postgres DSN.
• Team sharing over HTTP: python -m graphify.serve graph.json --transport http --port 8080 serves the graph to a whole team as an MCP server, with Bearer-key auth and loopback-only binding by default.
• Git-aware rebuild: graphify hook install rebuilds the graph on every commit using AST only, no API cost, and sets a merge driver so graph.json never lands with conflict markers after two developers commit in parallel.

Why It Matters

Most AI assistants answer codebase questions by reading files one at a time or by grepping. Both approaches burn tokens and fail to capture cross-file relationships. Graphify precomputes those relationships once and lets the assistant traverse a graph instead.

The demo in the repo README shows a three-hop path between FastAPI and ModelField resolved with zero files opened. That's the concrete version of the efficiency argument.

For teams, the workflow is straightforward: one person runs /graphify . and commits graphify-out/, everyone else pulls, and their assistant reads the map immediately. On Claude Code and Gemini CLI, a hook fires before search-style tool calls and nudges the assistant toward graph queries. On Codex, OpenCode, and Cursor, the same guidance comes through AGENTS.md or .cursor/rules/ instruction files.

Example Use Case

Say you inherit a FastAPI service and need to understand its auth flow before touching anything. Run /graphify . in Claude Code. Graphify parses the Python with tree-sitter and writes graph.json. Then ask graphify query "show the auth flow" or trace a specific connection: graphify path "DigestAuth" "Response".

The response returns a scoped subgraph. graphify explain "APIRouter" prints the node's source location, its community, its degree (47 connections in the FastAPI example from the repo demo), and each edge tagged EXTRACTED or INFERRED. You get the shape of the code before opening a single file.

Competitive Context

Graphify is not an assistant. It sits under Claude Code, Cursor, Codex, and others as a shared skill layer. Cursor uses embeddings and semantic search over your repo; Claude Code reads and greps files during each session. Both work per query and re-read the source each time.

Graphify takes a different approach: a persistent graph you traverse. The README is direct about this: "Not a vector index. No embeddings, no vector store: a real graph you traverse." The LOCOMO benchmark figures in BENCHMARKS.md back that up with a shared harness, blind judge validation at 90.6% agreement (Cohen's kappa 0.81), and per-system tables available for reproduction.

The gap it fills is structured, explained retrieval that any of these assistants can call, rather than a replacement for any one of them.

My Take

79.5k stars and 155 releases for a tool that's fundamentally about indexing tells you context efficiency has become a real pain point, not a nice-to-have. Watching an agent burn its budget re-deriving architecture it already walked through adds up fast across a team.

The benchmark results are the part I'd actually scrutinize before adopting this at scale. The LOCOMO recall gap over mem0 and supermemory is large enough to raise the question of why, and the reproduction commands being public in BENCHMARKS.md means you can run it yourself on your own corpus rather than taking the numbers on faith.

[ Free report ]

The Agentic SDLC

How teams like Stripe, Ramp, and Uber move from solo coding agents to a coordinated, team-level system.

Download the guide