CodeCompass resolves your whole repo into a call graph and code-tuned search, and serves it to your agent as ~20 tools over MCP, structure it can query and prove, not text it has to grep.
ccx login, or join waitlist →CodeCompass syncs your repo to a container only your account can reach - one per repo, token-gated. It builds your analysis graph there, and that is the only thing your source is ever used for.
CodeCompass reads every file and builds one resolved graph of your codebase: the files, the symbols, and the calls between them. An edge is only drawn when a call resolves to exactly one target; anything ambiguous stays unknown, never guessed. So the map is something you can actually trust.
Every answer, whether it's search, callers, impact or audit, comes from this same graph, so they never disagree. Rebuilds are incremental, and a cross-language linker even recovers Rust→GPU-kernel calls that no compiler or language server can see.
Ask what any file is for and CodeCompass answers from the graph: its role, what it imports, and everything that depends on it. Your agent reasons from resolved structure instead of guessing from the handful of lines it managed to grep.
Zoom out to the dependency graph between modules, or down to a single function's control flow and cyclomatic complexity. It's the same map at every altitude, and it fits in a context window.
Point it at a change and it walks the graph in reverse: everything that transitively depends on what was touched, ranked by risk from fan-in and complexity rather than distance alone. Lined up with the live git diff, it surfaces what an edit will reach before the change ships, not after CI goes red. Change a leaf utility, watch it light up half the service.
Search blends a semantic model with a symbol index and ripgrep into one ranked answer, so a question in plain words lands on the exact code, and every hit shows how it was found.
The model is our own: a 0.5B-parameter code embedding model, trained on 86B tokens of code, and state-of-the-art on code retrieval. Weights and evals on Hugging Face →
The structural side runs no model: parsing, the graph, callers, impact and audit are all deterministic. Dead code is confirmed by the actual compiler, clang -Wunused and cargo check. When it can't resolve something it says so, so the facts your agent builds on are verified, not generated.
That pass ran clean, zero false positives, across ~30,000 files, the Linux kernel included.
The whole engine is one MCP server: around 20 tools that all answer from the same graph, with honest provenance and results paginated to fit a context window. It even keeps a memory across sessions and a task-scoped workset, so your agent picks up where it left off instead of re-reading the repo each time.
search "…"Hybrid retrieval, semantic + symbol + grep.
callers <fn>Resolved callers repo-wide, confidence-scored.
impactReverse-dependency blast radius over your diff.
context <file>Role, imports, and consumers of any file.
dependency-graphThe module and file dependency map.
arg/flow <fn>Control-flow graph and cyclomatic complexity.
auditCompiler-checked dead code and unused symbols.
memoryNotes that persist across sessions.
worksetA task-scoped view of what you're changing.
arg/query · structure · graph/refs · detect-projects, all over the same server.
ccx 0.1.22 client reporting a release-signature failure? Re-run the HTTPS installer to refresh its trusted release keys.