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:
| share of calls linked to their exact target | AxiomCode | GitNexus | CodeGraph | Code-Review-Graph | Graphify |
|---|
| Java, 33,257 calls (bytecode) | 96.5% | 78.9% | 78.5% | 71.9% | 67.5% |
| TypeScript, 9,829 calls (type checker) | 88.8% | 65.1% | 65.4% | 71.6% | 49.8% |
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 during npm install, so install build tools first, e.g.
sudo apt install build-essential python3. The full node:* Docker images already include them.
Before every release, the exact packages that ship are installed without Soufflé and run end to end (every CLI verb,
six language engines, including HTML/CSS) on macOS arm64 and x64, Linux x64 and arm64, and Windows x64. Check an install with
axiomcode --version.
This is the beginning of the README. Read the rest at the original. Read the full README ↗
