axiomcodegraph

What it does

Give it a repository. It builds a knowledge graph of your code using formal methods: for every function, exactly who calls it and what it calls, derived by logical rules rather than guessed. Your AI agents, and you, then understand, explore, search and edit the code from that map instead of grepping. Grep cannot see calls through an interface, a subclass or a callback, and its output gets truncated, so agents silently miss what was cut. The map prunes 99.9% of the codebase, so agents keep their context for the task, not the search.

On real bugs. On 748 held-out Defects4J bugs, scored once after the rules were frozen, the tests AxiomCode picks from source include every bug-revealing test for 94.9% of bugs (best tree-sitter builder: 61.5%), at an F1 of 72.4 against what Defects4J observes by running the suite.

Why: types make a better graph. Choosing tests means following calls several hops back from a change, and one wrong link loses every test beyond it. A tree-sitter based CST builder matches a call to a declaration by name; AxiomCode resolves it the way the compiler does, from the receiver's type. Scored against the compiler's own answer, compiled bytecode for Java and the type checker for TypeScript, over five open-source projects per language:

Across files, it recovers which files call into which with an F1 of 0.976 in Java and 0.896 in TypeScript (best CST-based: 0.876 and 0.708), and finds the call path from one method to another 97.4% and 87.7% of the time (80.6% and 65.8%).

AxiomCode supports Java, TypeScript and Python, with JavaScript and C# in beta (Language and skill maturity). These benchmarks are Java and TypeScript, the languages where a compiler gives an independent ground truth to score against. Details in Benchmark results and Measured cross-file coverage.

Why AxiomCode Graph?

A typed graph is a more accurate graph. Compared with a tree-sitter-based graph builder, which guesses a call's target from syntax (the name, the imports, a variable's declared type), AxiomCode resolves each call from the receiver's declared and inferred type, as the compiler does. Through an interface, an override, a generic, or a callback, syntax alone cannot decide the target, and every wrong guess is a missing or invented edge; a resolved edge is a call the program actually makes. That matters because an agent follows edges several hops deep, and one missed link loses everything beyond it.

The call graph of an open-source TypeScript web framework, drawn as a page and asked which tests a change to basicAuth can affect. Source files form the inner ring and test files the outer one. The solid blue paths are chains of resolved calls from basicAuth to the 7 test files that must run; the dashed red ones mark the other 130, which have no chain to it and can be skipped. Green is the shared compare that basicAuth calls, and gold the 11 other files that also reach it.

AI agents work from an incomplete picture of a codebase, and the reason is structural: what a call reaches is usually decided somewhere else. The type comes from another file, the implementation from another module, the binding from a dependency or a configuration key. Reading the file in front of you cannot show any of that, so a missed dependency becomes an incomplete change and a second fix.

AxiomCode Graph makes the structure behind the code queryable. Agents can understand a task's scope, from the implementation to downstream effects and affected tests, before acting. This supports more reliable changes, more complete task execution, and up to 50% fewer tool calls to explore a new codebase in our benchmarks.

The graph is grounded in formal methods, using deterministic, language-aware rules. Source locations and confidence tiers make its results inspectable, while unresolved calls remain explicit rather than being presented as established relationships that could lead to false positives.

Get Started

AxiomCode Graph is two parts. The engine (@axiomcode/code-graph on npm) parses a repository and builds its graph; it also provides the axiomcode command and an MCP server. The plugin (plugins/axiomcode/) is the agent-facing frontend: a skill, five MCP tools, and hooks. Install the engine first.

Requirements: Node ≥ 22.13 and Python 3 (python3, or python / py on Windows). On Windows, also Git for Windows: the CLI runs under its bash. The engine ships as a prebuilt binary for macOS (Apple Silicon and Intel), Linux (x64 and arm64) and Windows x64, and npm install takes the one for your platform. No Soufflé and no compiler are needed, with one exception:

Linux arm64 (Graviton or Ampere servers, Raspberry Pi, node:*-slim or Alpine containers on an Apple Silicon Mac): the parser's native modules compile