Rather than quoting published claims, we ran live, physical benchmarks on the same machine across both codebases — including torvalds/linux at 74,619 files. Here's what happened when we put Synapse MCP and Graphify head-to-head on real code, on real hardware, with real timing and token counts.
The setup
Two codebases. Same Apple Silicon machine. No warm caches.
Round 1 — cross-indexing: Each tool indexed the other tool's codebase. Graphify (Python, tree-sitter AST) indexed Synapse's Elixir code. Synapse (Elixir OTP, per-language chunkers) indexed Graphify's Python code. Then we ran five tasks that represent what an AI coding agent actually does all day.
Round 2 — the stress test: We pointed both engines at torvalds/linux. 74,619 code files. 96,038 total paths. C and Assembly, kernel macros and all. We measured memory, concurrency, and whether you can query while the indexer is still running.
Round 1: Task-by-task results
Task 1: Python symbol discovery
Find extract_elixir in Graphify's own codebase.
Graphify (query): 806.7 ms · 6,509 bytes (~1,626 tokens) · 75 lines
Ran BFS depth=2, hit 2,168 nodes, dumped 70 noisy test nodes before truncating with [!] TRUNCATED: showing 70 of 2168 nodes.
Synapse (regex): 464.6 ms · 669 bytes (~167 tokens) · 1 line
Synapse — 1.7× faster, 9.7× fewer tokens
Task 2: Elixir symbol discovery
Find put_chunk in Synapse's own codebase.
Graphify (query): 383.8 ms · 18,716 bytes (~4,678 tokens) · 149 lines
Over-budget blowout — ~6,069 tokens vs 2,000 budget. Dumped 45 nodes and 100 raw edges.
Synapse (symbol put_chunk): 480.9 ms · 1,228 bytes (~307 tokens)
Returned 3 exact matching chunks, including those in the data store and feature helpers.
Synapse — 15.2× token reduction
On Elixir code, the gap is enormous. Graphify's tree-sitter-elixir parser gives it AST awareness, but without alias resolution it can't tell where tokens actually point. So it falls back to BFS neighbourhood traversal — dumping everything within two hops of the match. Synapse knows exactly which module put_chunk lives in, because it walked the Elixir AST with native tools and built the full qualified call graph.
Task 3: Elixir dead code analysis
"Is `get_callers` safe to delete?" The query that separates a tool that gives you data from a tool that gives you a decision.
Graphify (affected "get_callers()"): 174.3 ms · 227 bytes
No affected nodes found. Failed completely — no alias/import resolver for Elixir.
Synapse (dead_code): 489.1 ms · 2,050 bytes (~512 tokens)
It returned a clear verdict: safe_to_delete: false, with high confidence and a warning not to delete as production callers exist.
Synapse — prevented an agent from destroying production code
Synapse uses native Elixir AST traversal with an edge resolver pass that explicitly tracks module aliases, imports, and use directives directives to construct full remote call paths. It found two production callers and returned an actionable decision with arity qualification, confidence scoring, and agent instructions. The agent doesn't need to follow up. It has a verdict.
Task 4: File impact and test mapping
"What breaks if I modify the `store/ets.ex` module?"
Graphify (affected ets.ex): 170.0 ms · 1,626 bytes (~406 tokens)
16 raw lines showing which files import ets.ex. No impact analysis, no risk scoring, no test mapping.
Synapse (impact): 1,840 ms · Compressed payload
Full structural blast radius with risk scores, contract signals, and exact test features (test targets) mapped.
Synapse — Graphify gives you imports; Synapse gives you an impact assessment
Why Synapse wins across every meaningful dimension
Token efficiency. Synapse delivered 9.7× to 15.2× fewer tokens than Graphify on equivalent queries. Graphify's BFS neighbourhood dumps routinely blow through token budgets, flooding the context window with thousands of raw nodes and edges. This is a fundamental architectural difference, not a tuning issue.
Query latency at scale. Synapse's ETS tables provide sub-millisecond in-process reads. Graphify has no persistent daemon — every CLI query must cold-load and parse a multi-megabyte graph file from disk into Python objects. On the Linux kernel (1.6 GB graph), Graphify took 59.3 seconds just to deserialize the graph before answering a query. Synapse answered the same query in 148.1 ms — 400× faster.
Elixir/BEAM intelligence. Synapse is written in Elixir and walks the Elixir AST natively with native tools. It resolves aliases, imports, and uses the same module graph the compiler does. Graphify's tree-sitter-elixir has no alias resolver — it cannot follow cross-module calls, which means it returns empty results for the most common Elixir query patterns.
Write safety. Synapse's Shadow Graph simulates edits in memory, validates with standard linters, and only commits to disk on success. Graphify is read-only — it can show you what a change affected after the fact, but it cannot prevent a bad write from reaching disk.
Dead code decisions. Synapse returns structured verdicts: safety verdicts. Graphify returns a list of zero-caller functions with no safety assessment. One prevents incidents. The other provides a list.
Round 2: The Linux kernel stress test
Small repos tell you about precision. Large repos tell you about architecture. We pointed both engines at torvalds/linux — 74,619 code files across 96,038 paths — and watched what happened.
| Dimension | Synapse MCP | Graphify v0.9.64 | Winner |
|---|---|---|---|
| Filesystem discovery | 2.0s (native BEAM concurrent traversal) | 1m 15s (single-threaded Python os.walk) | Synapse — 37.5× faster |
| Peak memory | 877 MB (ETS tables) | 5.21 GB – 5.75 GB (Python + graph libraries) | Synapse — 5.9× lower |
| Query availability during build | 100% available (provisional queries from 2s) | 0% (blocked until graph file fully written to disk) | Synapse |
| Live query latency under load | 148.1 ms (50 matches, 24 workers ingesting) | N/A (process blocked during graph construction) | Synapse |
| Cold query latency (a common kernel symbol) | 148.1 ms (in-memory ETS) | 59.3 seconds (45.8s CPU to deserialize 1.6 GB JSON) | Synapse — 400× faster |
| CPU scheduling | Preemptive BEAM scheduling across 24 workers | Single-core bottleneck — 100% CPU for 15+ min during clustering | Synapse |
| Syntax fault tolerance | Streamed through without halting | 6,765 files flagged with kernel macro errors | Synapse |
At 74,000 files, Graphify's Python architecture hits its ceiling: 5.21 GB RAM, 59-second cold query latency, and a single-core CPU bottleneck that blocks all queries for 15+ minutes. Synapse uses 877 MB, answers queries in 148 ms, and never blocks on a single core. The architectural difference is the difference between a tool that works and a tool that seizes your machine.
What Synapse has that Graphify doesn't
- Safe writes. Shadow Graph simulates edits in memory, verifies every caller, auto-rolls back if anything would break. Graphify is read-only.
- Dead code decisions. Structured
safe_to_deleteverdicts with confidence, evidence, and agent instructions. Graphify lists function names. - Stack trace resolution. Paste a crash trace, get the root cause mapped to your code. No other MCP server does this.
- 100% local, zero cloud, zero telemetry. Your code never leaves your machine. Graphify's SaaS tier uploads your graph to the cloud.
- Knowledge cache. Learns from searches and persists across sessions. Graphify re-extracts the graph each session.
- Git worktree overlay. Sub-50ms delta indexing for parallel agents. Graphify creates a separate output directory per worktree with no delta awareness.
- SmartCrusher compression. 30–60% token reduction on every response through key minification, outline mode, and budget hints.
- BDD and schema ingestion. Native chunkers for Markdown, Gherkin feature files, SQL DDL, Protobuf, GraphQL, and Terraform HCL — all directly queryable in the ETS graph.
- Automated IDE and agent rule configuration. Compiled Rust CLI auto-configures 20+ IDEs and injects Synapse-first discovery policies across multiple agent instruction surfaces.
Which one should you use?
If you're a developer who wants your AI coding agent to stop breaking things — to simulate edits before writing, to know with confidence whether a function is dead, to resolve crash traces to code, and to do all of this locally without your code touching a cloud — Synapse is built for that. The benchmarks prove it.
The free tier is the full product — AST indexing across 50+ languages, three search modes, SmartCrusher compression, background file watching, Git worktree overlay, unlimited repos. No time limit. No credit card. Pro ($19/mo) adds the safety layer: safe writes, crash resolution, dead code decisions, change review, and persistent knowledge cache.
curl -fsSL https://downloads.synapse-mcp.dev/install.sh | shAll benchmark scripts and raw outputs published for reproducibility. Run it yourself.
What about CodeGraph and code-graph-mcp?
Graphify isn't the only code-graph MCP server on the market. In September 2026 we source-verified every claim below by indexing all three codebases through Synapse MCP and reading the actual implementations. No assumptions. Verified code.
CodeGraph (colbymchenry, TypeScript + Rust kernel) has two capabilities no competitor matches: HTTP route-chain tracing for 17 web frameworks following URL→controller→template edges, and cross-language Swift↔ObjC / React Native bridge awareness. It is read-only — no write safety, no change review, no semantic search, no multi-repo support.
code-graph-mcp (sdsrss, pure Rust single binary) has the most sophisticated indexer of the three: BLAKE3 Merkle tree incremental indexing, hybrid BM25 + vector search via Reciprocal Rank Fusion, and a 2,551 LOC dead code SQL module with per-language constructor exclusions. It is also read-only, supports 20 languages (no Elixir, Erlang, Haskell, OCaml, Scala, Solidity, COBOL, Zig, Gherkin, HCL, Protobuf, GraphQL, SQL DDL), and its dead code detection is intentionally unlisted from the MCP tool surface.
Why Synapse still wins
Write safety — Neither CodeGraph nor code-graph-mcp can prevent an AI agent from breaking production. Synapse's Shadow Graph simulates edits in memory, validates with linter, and only commits atomically on success. This is the difference between a tool that observes and a tool that protects.
Language breadth — Synapse covers 50+ languages including Elixir, SQL DDL, Protobuf, GraphQL, HCL/Terraform, Gherkin, and Clojure — all languages neither competitor supports.
Search quality — Synapse's native BM25F + random projection embedding engine runs entirely in-process at 10-50 µs per chunk with zero external dependencies. code-graph-mcp requires a 419-dependency Candle ML model and a daily cargo audit to secure it.
Dead code decisions — Synapse returns structured verdicts with confidence scoring, production vs test caller splitting, and agent instructions. code-graph-mcp's SQL-based approach has better per-language exclusions but is structurally simpler.
Multi-repo and worktrees — Synapse supports multiple repos per process with Git worktree delta indexing. Both competitors are per-project only.
The honest bottom line: code-graph-mcp is built with impressive engineering discipline — BLAKE3-pinned C sources, compile-time instruction budget guards, a detailed changelog. CodeGraph has genuine unique capabilities for web API debugging and mobile cross-language bridging. Neither offers the write-safety / change-review / multi-repo / worktree capability cluster that makes Synapse the only tool that prevents agents from breaking production — not just observes what they did after the fact.
Stop Letting Your Agent Break Things
Full AST indexing, safe writes, SmartCrusher compression, and dead code decisions — free, forever. Add crash resolution and change review for $19/mo.
Download Now — for FREE →