repository-navigation CAP-0039 · activeFinding what matters in a large codebase
Whether an agent can locate the files, symbols and call paths relevant to a task in a repository too large to read, and avoid editing the wrong place; the failure is a plausible patch in the wrong file.
Also called: issue localization, fault localization, code localization, bug localization
Tags: coding-agent, context
Filed from Russ's capability map (2026-09-12). The SWE-agent and SWE-bench findings in the catalog show that interface design changes agent success, and part of what the interface changes is navigation. This entry isolates the navigation competence: retrieval over code, search strategy, and knowing when enough context has been gathered.
What counts as this capability
Scope boundary used when deciding whether a paper is really about this capability, rather than merely mentioning it.
In scope when the paper measures whether the agent finds the right locations in a repository, or ablates the navigation tools. NOT in scope when repository-level success is reported without isolating navigation from editing.
Claims
- observationsingle paper↑1↓0Adding a repository-wide line-level graph of definitions and references, queried for the ego-graph around names the model is looking at, raised SWE-bench resolve rates for all four frameworks it was plugged into (two agentic, two procedural) by an average of about 33% relative, at a modest cost increase that was larger for the agentic ones; the same plug-in also helped on CrossCodeEval.
- observationsingle paper↑1↓0Constraining a localization agent with a priority queue over candidate code regions scored for relevance, decomposition of each search action, and pruning of context by distance from the issue's anchors reached a 65% function-level match rate on SWE-bench Lite, the best open-source result at the time, and feeding its locations to an open-source repair pipeline raised the resolved rate by about 6 points.
- observationsingle paper↑1↓0Giving an agent a parsed code graph (files, classes, functions with import, call and inheritance edges) and tools to search and traverse it lets a fine-tuned 32B open model localize issues about as well as proprietary agents at roughly an eighth of the cost, reaching about 93% file-level accuracy, and better localization carried through to about 12 points more resolved issues at Pass@10 when plugged into a fixed repair pipeline.
- observationsingle paper↑1↓0Issue localization can be done as retrieval-and-rerank with no agent at all: an embedding model and reranker trained on issue-to-patched-function pairs mined from public GitHub (SweLoc) localize functions on SWE-bench Lite and LocBench at least as accurately at Acc@10 as agents built on Claude 3.5 Sonnet, at a small fraction of the per-issue cost and with one pass instead of seven to ten model rounds.
- observationsingle paper↑1↓0On SWE-bench Lite, asking the model to name suspicious files from the issue plus a repository tree finds the ground-truth file in about 79% of cases and embedding retrieval over the issue text in about 68%, and taking the union of the two raises file-level localization to about 82% because the two methods miss different files; a fixed three-step narrowing (files, then classes and functions, then edit lines) with no agent loop then supported the best open-source resolve rate at the time (32%).
- observationsingle paper↑1↓0Without training or a prebuilt index, searching a module call graph built on the fly for breadth at file level and then expanding it into a function call graph for depth reached about 43-44% function-level Top-1 localization on SWE-bench Lite and Verified with open 32B and 72B models, beating prior LLM localizers, and the better locations raised an issue-solving pipeline's resolve rate by roughly 3 to 30 points depending on model.
Techniques
- Code-graph tools for localization agentstoolingParse the repository once into a heterogeneous graph of code entities and their dependency edges, expose search, traverse and retrieve-entity tools over it, and let the agent hop across the graph from the issue's mentioned names to the func
- Hierarchical localization from tree, then union with embeddiprocessShow the model the repository's file tree and the issue and have it rank suspicious files, retrieve files by embedding similarity to the issue, merge the two lists, then narrow within the chosen files to classes and functions and finally to
- Priority-scheduled search with distance-aware context pruninprocessKeep a scored queue of code entities to inspect, let the model decompose each search into smaller lookups it scores for relevance, and drop context whose graph distance from already-relevant anchors is large, so the agent spends its budget
- Repository code graph as a navigation plug-intoolingBuild a graph whose nodes are definition and reference lines and whose edges are contain and invoke relations across the whole repository, then answer the agent's or pipeline's lookups with the sub-graph around a queried symbol so it sees c
- Retrieve-and-rerank localization trained on mined issue-patcretrievalMine issues paired with the functions their fixing commits changed, train a code embedding model and a listwise reranker on those pairs so they read failure-style queries, then localize new issues by embedding search over the repository's f
- Two-phase call-graph search, files broad then functions deepprocessStart from files the issue mentions, build a module-level call graph dynamically and explore it broadly to pick files, then expand only the chosen files into a function call graph and search it iteratively, with the graph structure steering
Sources
Every paper, post or observation behind this capability. Ones cited by a claim show the claim and its stance; ones filed directly are about the capability but have no claim drafted from them yet. Open one to add support or contest it.
- ↑ supports a claim here
- ↑ supports a claim here
- ↑ supports a claim here
- ↑ supports a claim here
- ↑ supports a claim here
- ↑ supports a claim here
Capabilities are a way of carving up the subject, and carvings are arguable. Say so if this one is wrong — especially a proposed one, which a pipeline added because several papers used the same framing, not because anyone decided it was right.