Pith. sign in

REVIEW 2 major objections 5 minor 83 references

CodeNib: A Multi-View Data System for Serving Repository Context to Coding Agents

T0 review · 2 major / 5 minor · reviewed 2026-08-01 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read Coding-agent repository context can be served from reusable multi-view indexes that are incrementally maintained orders of magnitude faster than rebuilds, with latency and token savings tied to explicit output-match checks.

desk verdict CodeNib is one of the more honest systems papers around, but the headline 8.7x graph speedup rests on an exact-match gate against a rebuild oracle that the paper itself shows is noisy for Rust/TS — that is the thing to fix before taking the number at face value. read the letter →

arxiv 2607.25431 v1 pith:WZDQXQL3 submitted 2026-07-28 cs.SE

Zhongming Yu , Hengjia Yu , Boqin Yuan , Shuting Zhao , Yizhao Chen , Aryan Dokania , Mihir Jagtap , Jiayu Chang
show 7 more authors
Yitong Ma Yash Jayswal Wentao Ni Hejia Zhang Zhaoling Chen Gangda Deng Jishen Zhao
This is my paper · ORCID
classification cs.SE
keywords repositorycontextservingcodingagentsmaterializedviewsincrementalmaintenancesymbolgraphrepairvectorreusestaticandlivenavigationpolicies
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper argues that repository context for coding agents should be treated as a data-lifecycle problem: build reusable lexical, dense, and structural views once per commit, map every result to repository-relative source ranges, maintain each view through its own incremental path, and serve them through one runtime with a manifest recording what is available. The central evidence is that when incremental updates reproduce the output of an independent fresh rebuild, graph repair is 8.7x and vector reuse 25.4x faster at the median; static navigation matches live language-server results on 63% of requests and is 4.7x faster on that subset; and context policies deliver 50-87% token reductions while preserving localization across five models. The paper's distinctive move is to report these gains only under explicit validity boundaries — conditional on output matches — rather than as unconditional speedups.

What carries the argument

The central object is the repository manifest M_c and the multi-view materialization it controls: a lexical view (BM25/trigram), a dense view (FAISS embeddings), and a structural view (typed symbol graph with occurrence records), all aligned to repository-relative source ranges. The manifest records per-artifact status, commit, configuration, and capabilities, making stored state discoverable without a shared storage engine. The argument's load-bearing mechanism is the conditional output-match gate: incremental maintenance results (Eqs. 1-2) and static/live navigation equality (projection N) are verified offline against independent rebuilds or live servers, so reported speedups and latency s

What would settle it

Rebuild the same eight repositories with a pinned compiler/language-server toolchain and run the incremental maintenance; if the Rust and TypeScript/JavaScript fresh-rebuild outputs are not bitwise reproducible across identical runs (as Appendix F's 3/4 changed-scope exactness suggests), then the 8.7x/25.4x conditional speedups cannot be attributed to the maintenance path alone. Conversely, if the match rate on a new, larger request sample for Q3 stays around 63% with the same per-language definition/reference split, the static provider's conditional latency advantage would be confirmed as a s

Watch

Extended reading notes

Core claim

CodeNib's claim is that a multi-view repository serving system can make coding-agent context reuse measurable and economical. The key mechanism is the repository manifest M_c, which binds lexical (BM25/trigram), dense (embedding), and structural (symbol graph) views to a commit and to repository-relative source addresses, while leaving each view its own physical layout and update path. On the maintenance side, LSP-assisted graph repair and content-addressed vector reuse are compared offline against independent rebuilds, and speedups are reported only when the outputs match (Eqs. 1-2). On the serving side, static navigation is compared against live language servers on normalized path/start-li

Load-bearing premise

The whole maintenance-speedup argument rests on treating an independent fresh rebuild as the deterministic ground truth for what incremental output should be; the paper's own audit shows fresh rebuilds are not exactly reproducible for Rust and TypeScript/JavaScript, so speedups are measured against a reference that is itself noisy for 2 of the 4 language groups.

Editorial extensions

If this is right

  • Incremental graph repair and vector reuse can make repository-context maintenance an order of magnitude cheaper than full rebuilds on transitions where outputs match (8.7x/25.4x median).
  • Static symbol navigation can absorb a majority of definition requests (80-99% match per language) and some references at 4.7x lower median latency, but references match only 22-73%, so live servers remain necessary.
  • Context policies with eager top-10 candidate injection plus one-time compaction preserve the localization margin at 50-87% fewer provider-reported trajectory tokens across five models.
  • The manifest's capability-driven loading lets one failed view (e.g., vector build) not invalidate successful siblings, so partial availability is explicit.
  • Operation-specific validity boundaries prevent conflating exact maintenance with projection-compatible navigation with policy-dependent delivery.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • If the conditional speedups hold in production, a practical recipe is to run incremental maintenance and fall back to rebuild when the offline match gate fails, combining 25x typical speedups with guaranteed exactness.
  • The 63% static/live match rate suggests a hybrid navigation service: route requests whose normalized location sets are predictable (e.g., definitions) to the static provider and keep live LSP for references; the workload-level latency saving would then depend on the request mix, not the conditional 4.7x.
  • The one-time compaction policy's model-dependent effect (123% tokens on Haiku vs 28% on Gemma) hints that context delivery should be per-model tuned rather than globally optimized — a claim the paper leaves open.
  • The same-commit rebuild audit (99.75% edge F1, but Rust/TS failures) suggests that the incremental-maintenance speedup numbers could shift if ground truth were measured against a more deterministic oracle; an editor would like to see the speedups re-reported on the subset of repositories where fresh rebuilds are exactly reproducible.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

2 major / 5 minor

Summary. CodeNib is a multi-view repository-context data system that materializes lexical, dense, and structural views per commit, maintains selected views incrementally, and serves ranked retrieval, symbol navigation, and bounded context to coding agents through a manifest-mediated runtime. The paper's main contributions are: (C1) a view compiler that links heterogeneous artifacts to repository-relative source ranges; (C2) view-specific incremental maintenance whose speedups are reported only when the updated artifact exactly matches an independently rebuilt target; and (C3) a cost-visible agent runtime with evaluated context-delivery policies. Across 100 snapshots and five evaluation questions, the headline results are: 8.7x/25.4x median graph/vector update speedups on matching transitions, a 4.72x median live/static latency ratio on the 63% of navigation requests whose normalized locations match, and 50–87% token reductions with localization preserved for selected policies across five agent models. The paper is notable for reporting null results (graph expansion), conditional claims (static/live compatibility), and explicit validity boundaries throughout.

Significance. If the results hold, CodeNib provides a principled data-systems blueprint for repository-context serving that separates ranked candidates, source locations, and prompt history instead of collapsing them into one abstraction. The paper is unusually careful in distinguishing quality, compatibility, update fidelity, latency, and token usage, and it reports conditional speedups only where output equality is verified offline. It also ships code/data with frozen dataset IDs and includes a same-commit rebuild audit, which strengthens reproducibility. The main quantitative claim—exact-output incremental maintenance with large speedups—is defensible in principle, but its central Q4 evidence depends on the stability of an independent-rebuild oracle that the paper itself shows to be nondeterministic for Rust and TS/JS. The Q5 'preserve localization' claim similarly rests on an operational margin that is a reporting threshold rather than an externally justified equivalence bound. These two points are the key risk to the paper's headline contributions.

major comments (2)
  1. [§4.2, §9.5, Appendix F, Table 8] The conditional graph speedup claim (8.67x median, 15/33 transitions) depends on the independent rebuild in Eqs. (1)–(2) being a deterministic oracle. Appendix F's same-commit audit reports fresh-vs-fresh edge F1 of 99.75% and serving agreement of 99.35%, with changed-scope exactness on only 3/4 cases, and all 18 Rust and TS/JS graph transitions fail the exact checks. Thus the 15/33 match count and the median are measured against a single draw of a nondeterministic reference; a different fresh rebuild could yield different matches and a different median. The paper honestly reports this limitation, but the abstract still presents the conditional speedup as the headline without noting that, for graph maintenance, the matched transitions are entirely Go/Python. Please (i) run multiple independent rebuilds and require equality with all (or report the distribution across rebuild draws), or (i
  2. [§4.3, §9.7] The Q5 claim that selected context policies 'preserve localization' with 50–87% fewer tokens rests on the operational margin ε=0.05 applied to the lower bound of a paired 95% CI. This is a reporting threshold, not a pre-registered equivalence margin, as the paper acknowledges. However, the selection is margin-sensitive: for Haiku, the selected Eager arm has ΔAR@5 = −0.009 with lower bound −0.043, so a slightly stricter margin (e.g., ε=0.04) would change the selection. The headline token reduction is therefore contingent on a non-justified threshold. I recommend either justifying ε from an external operational requirement or presenting the results as a token–quality frontier and softening the 'preserve localization' wording in the abstract and conclusion.
minor comments (5)
  1. [Figure 10(c)] The panel appears twice in the submitted text (duplicate caption and identical plot). Please check the figure assembly.
  2. [Appendix F] The phrase 'Reported protocols are 21/4' is ambiguous. Please spell out which protocol numbers are pooled and which are excluded, and why.
  3. [§9.1] The sentence 'Qwen-4B/8B score means use n=99/98 at k′=30/50' could be clarified: state why the sample sizes differ for those operating points.
  4. [§9.1] The description of the lifecycle trace (20 sessions, 42 requests) is clear, but the initial paragraph says 'Materialize/load/mixed trace; isolated/resident' in Table 2; consider adding a cross-reference to §9.6 for the derived request count.
  5. [§7.4] The transition in Eq. (4) is well defined, but the claim that 'invocation j+1 consumes Ĥ_j' should be stated even more explicitly to avoid implying the rewrite is visible to the model before the next call; the surrounding text does clarify this, but a one-sentence restatement would help.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: headline results are measured against external references or explicit conditional gates, and self-citations are background-only.

full rationale

CodeNib's central quantitative claims are all anchored to external references rather than to the paper's own outputs. Q1 targets come from developer patches in SWE-Bench Verified/Multilingual; Q2 compares approximate ANN indexes against exact Flat search; Q3 compares static serving against live LSP providers on a normalized-location equality predicate; Q4 compares incremental updates against independently rebuilt targets; Q5 compares against paired grep/read trajectories under a pre-specified localization margin. In each case the reference is an independent measurement, not a parameter fitted from the result being claimed. The Q4 speedups are explicitly conditional on Eqs. (1)-(2) matching an independent rebuild, and the paper reports non-matching transitions openly, excluding them from the conditional summary but retaining raw ratios. The Appendix F audit showing that fresh rebuilds are not fully deterministic for Rust/TS is a genuine validity caveat, but it does not make the claim circular: an incremental output is not defined as 'whatever the rebuild returns,' and the comparison is performed after timing on a separate path. The same applies to Q3, where the matched subset is a compatibility gate, not a construct that defines the latency advantage into existence. The only self-citations ([7] LocAgent and [72] OrcaLoca) appear in related-work positioning and are not load-bearing; no uniqueness theorem, ansatz, or design choice is imported from them. Accordingly, no derivation step reduces by construction to its own inputs, and the paper's explicit limitation statements are properly treated as threats to validity rather than circularity.

Assumptions & free parameters 6 free parameters · 6 assumptions · 0 invented entities

The load-bearing premises are the evaluation's reference agreements, not new domain entities; no invented entities (new forces, dimensions, mediators) appear, and the manifest M_c is a design artifact rather than a postulated entity. Free parameters are almost all disclosed reporting thresholds and protocol choices; the only fitted number with a proper held-out split is w_g=0.5. The epsilon margin and @5 cutoff gate the Q5 headline and are explicitly non-pre-registered, so they belong in the ledger as hand-chosen.

free parameters (6)
  • graph fusion weight w_g = 0.5
    Q1 dense-graph fusion (Sec. 7.2). Swept over {0.25,0.5,...,2} on a 58-snapshot/15-repo tuning partition, selected lexicographically by File Success@10, frozen before the 42 held-out snapshots. Properly held out, but directly defines the graph-expansion ablation.
  • operational margin epsilon = 0.05 = 0.05
    Q5/Sec. 4.3: a policy 'preserves quality when LB.95[DeltaAR@5] >= -0.05'. Hand-chosen and non-pre-registered; it selects which arms produce the headline 50-87% token savings. Three of five models pass 0.001-0.013 above it (Table 9).
  • AnswerRecall@5 cutoff and zero-recall rule = k=5; zero for answers with no committed span
    Q5/Sec. 4.3: reporting choice stated as not an output cap; combined with the margin it defines the localization-preservation claim.
  • RRF constant kappa=60 with w_d=1 = kappa=60, w_d=1
    Q1 graph fusion (Sec. 7.2). kappa is the standard RRF constant from Cormack et al. [11] but is fixed rather than derived; w_d fixed at 1.
  • 0.95 Neighbor Recall bar for ANN selection = mean overlap >= 0.95
    Q2/Sec. 9.3: each approximate family contributes its fastest configuration meeting this bar, which determines the reported HNSW 33.9x/IVF 4.1x component-local search speedups. Disclosed, but paper-chosen.
  • Navigation and lifecycle probe selection = 5 evenly spaced positions/snapshot; 8 def/40 ref limits
    Q3 and lifecycle trace (Secs. 9.1, 9.4): probes are static-graph-anchored and the lifecycle calibrates only stable/matching probes while excluding references that drift. These choices bound the reported match rates.
assumptions (6)
  • domain assumption A fresh, independent rebuild of a view is a deterministic, valid correctness oracle for incremental output (Eqs. 1-2, Sec. 4.2).
    Load-bearing for Q4: the 15/33 and 28/31 exact-match qualifications and the 8.67x/25.44x conditional speedups are defined against it. Appendix F's own audit shows fresh/fresh rebuilds differ (99.75% edge F1; changed-scope exactness 3/4), and all Rust/TS/JS graph rows fail the exact gate — so the oracle is noisy for 2 of 4 language groups.
  • domain assumption Pre-patch source units that overlap the developer patch are a valid localization ground truth (Sec. 4.2, Appendix A).
    Q1-Q2 targets and Q5 AnswerRecall@5 both derive from changed/deleted blocks. The paper calls this 'a localization proxy, not an assertion that every useful supporting block was changed'; useful context in unedited support files is systematically invisible to the metric.
  • domain assumption Normalized path/start-line set equality is a sufficient compatibility contract for navigation (Sec. 4.2, Sec. 9.4).
    Q3's match predicate N(.) projects away characters, end ranges, hover text, and diagnostics. The paper states equality 'does not prove interchangeability,' so the 63.2% match rate and 4.72x conditional latency must be read within this weaker-than-full-equivalence contract.
  • domain assumption Provider-reported prompt+completion token sums, charged on every re-appearance, are a faithful cross-model cost measure (Sec. 4.3, Eq. 5).
    Q5 token savings are computed under this accounting, which deliberately ignores prefix-cache reuse and KV/latency/billing effects. Defensible as a proxy but not an end-to-end cost; tokenizer differences across the five providers are not adjusted.
  • domain assumption Warm-host, single-trajectory, quiescent-checkout measurements represent agent and lifecycle costs (Sec. 9.1, Appendix G).
    Q5 uses one trajectory per query-policy-model cell with intervals over snapshot variation only; lifecycle projections assume warm caches and no concurrency/queueing. The paper says the serve-only term 'is not an end-to-end or hardware bound.'
  • standard math Clustered bootstrap percentile intervals are valid under the study's sampling design (Sec. 9.1).
    10k-20k bootstrap resamples clustered by repository snapshot are used for all intervals; this relies on standard exchangeability-within-cluster assumptions, unobjectionable but unstated in the main text.

how reviews work

0 comments
Cite this review

Pith. "Pith review of CodeNib: A Multi-View Data System for Serving Repository Context to Coding Agents." pith.science (2026). https://pith.science/paper/WZDQXQL3

@misc{pith2026260725431,
  author       = {Pith},
  title        = {Pith review of: CodeNib: A Multi-View Data System for Serving Repository Context to Coding Agents},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/WZDQXQL3}},
  note         = {Machine review of arXiv:2607.25431}
}
abstract

Coding agents repeatedly search, navigate, and retain context from evolving repositories, but disconnected indexes, language servers, and task-local histories force repeated discovery and obscure lifecycle costs. CodeNib builds reusable lexical, dense, and structural views per repository commit, maps outputs to repository-relative source ranges, maintains selected views across edits, and serves ranked search, symbol navigation, and bounded context through one runtime. Across 100 snapshots, we map quality-cost frontiers across the repository-context lifecycle. When outputs match an independent rebuild, graph and vector updates are $8.7\times$ and $25.4\times$ faster at the median. On the static-navigation subset matching normalized live-server locations (63% of 1,000 requests), the median per-request live/static latency ratio is $4.7\times$. Across five models, selected context policies preserve localization with 50--87% fewer trajectory tokens than paired grep/read. Together, these results support multi-view repository-context serving with explicit, operation-specific validity boundaries.

Figures

Figures reproduced from arXiv: 2607.25431 by the authors.

Figure 1
Figure 1. CodeNib compiles and maintains heterogeneous [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. CodeNib’s repository-to-agent dataflow. The left column lists supported applications and dependencies, not a pipeline [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. LSP-assisted incremental graph maintenance. (a–b) Old and target graphs for diff (c). Full rebuild (d) recreates the [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figures from the paper (11 more)
Figure 4
Figure 4. Figure 4: Agent loop, view loading, and evaluated context poli [PITH_FULL_IMAGE:figures/full_fig_p008_4.png]
Figure 5
Figure 5. Figure 5: Deterministic ranked-query compilation. (a) Sig [PITH_FULL_IMAGE:figures/full_fig_p009_5.png]
Figure 6
Figure 6. Figure 6: Embedding and pointwise-reranker operating points on the 100-snapshot corpus; Qwen-4B/8B score means use [PITH_FULL_IMAGE:figures/full_fig_p011_6.png]
Figure 7
Figure 7. Figure 7: Task-level graph and physical ANN ablations. (a) Paired graph-minus-dense [PITH_FULL_IMAGE:figures/full_fig_p012_7.png]
Figure 8
Figure 8. Figure 8: Dense-view construction and query profiles over 100 snapshots. (a) L0 file and (b) L2 callable construction time versus [PITH_FULL_IMAGE:figures/full_fig_p013_8.png]
Figure 9
Figure 9. Figure 9: Static-index versus live JSON-RPC replay over 100 [PITH_FULL_IMAGE:figures/full_fig_p013_9.png]
Figure 10
Figure 10. Figure 10: Incremental maintenance and lifecycle accounting. (a) Update speedup; fill denotes exact output match, labels [PITH_FULL_IMAGE:figures/full_fig_p014_10.png]
Figure 11
Figure 11. Figure 11: Agent context-policy effects. (a–b) Model-level token and [PITH_FULL_IMAGE:figures/full_fig_p015_11.png]
Figure 12
Figure 12. Figure 12: Pure-embedding Recall@𝑘 on the 100 CodeNib Base snapshots used by Q1, without graph expansion or reranking. Bar labels are macro means. (a) File results use path deduplication; (b) symbol results use 𝐿2 identities. Fig￾ure 6 shows the 𝑘 = 10 slice. F INCREMENTAL-MAINT…
Figure 14
Figure 14. Figure 14: Matched-request latency distribution for Q3. Each [PITH_FULL_IMAGE:figures/full_fig_p023_14.png]
Figure 15
Figure 15. Figure 15: Expanded workload-slice view underlying Fig [PITH_FULL_IMAGE:figures/full_fig_p023_15.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

83 extracted references · 7 canonical work pages

  1. [1]

    Anomaly. 2025. OpenCode: The open source coding agent. https://opencode.ai/ docs/tools. Accessed 2026-07-25; LSP integration is experimental

    2025

  2. [2]

    Anthropic. 2024. Model Context Protocol: Transport Specification. https:// modelcontextprotocol.io/specification/2024-11-05/basic/transports. Version 2024-11-05; accessed 2026-07-25

    2024

  3. [3]

    Anthropic. 2025. Introducing Claude Haiku 4.5. https://www.anthropic.com/ news/claude-haiku-4-5

    2025

  4. [4]

    Anthropic. 2026. Model IDs and Versioning. https://platform.claude.com/docs/ en/about-claude/models/model-ids-and-versions Accessed 2026-07-25

    2026

  5. [5]

    Ishaan Bhola, Adithyan Krishnan, Sravanth Kurmala, and Mukunda NS. 2026. Code Isn’t Memory: A Structural Codebase Index Inside a Coding Agent. arXiv:2606.22417. https://arxiv.org/abs/2606.22417

    arXiv 2026

  6. [6]

    Shravan Chaudhari, Rahul Thomas Jacob, Mononito Goswami, Jiajun Cao, Shihab Rashid, and Christian Bock. 2025. SpIDER: Spatially Informed Dense Embedding Retrieval for Software Issue Localization. arXiv:2512.16956. https://arxiv.org/ abs/2512.16956

    arXiv 2025

  7. [7]

    Zhaoling Chen, Robert Tang, Gangda Deng, Fang Wu, Jialong Wu, Zhiwei Jiang, Viktor Prasanna, Arman Cohan, and Xingyao Wang. 2025. LocAgent: Graph- Guided LLM Agents for Code Localization. InProceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers). Association for Computational Linguistics, Vienna, Aus...

    doi:10.18653/v1/2025.acl-long.426 2025

  8. [8]

    Tsvi Cherny-Shahar and Amiram Yehudai. 2026. Repository Intelligence Graph: Deterministic Architectural Map for LLM Code Assistants. arXiv:2601.10112. https://arxiv.org/abs/2601.10112

    arXiv 2026

Show all 83 references
  1. [9]

    CocoIndex contributors. 2025. CocoIndex. Incremental data-transformation framework. https://cocoindex.io/docs-v0/ Accessed 2026-07-25

    2025

  2. [10]

    Gheorghe Comanici, Eric Bieber, Mike Schaekermann, Ice Pasupat, Noveen Sachdeva, Inderjit Dhillon, et al. 2025. Gemini 2.5: Pushing the Frontier with Advanced Reasoning, Multimodality, Long Context, and Next Generation Agentic Capabilities. arXiv:2507.06261. https://arxiv.org/...

    2025 arXiv

  3. [11]

    Cormack, Charles L

    Gordon V. Cormack, Charles L. A. Clarke, and Stefan Büttcher. 2009. Reciprocal rank fusion outperforms condorcet and individual rank learning methods. In Proceedings of the 32nd International ACM SIGIR Conference on Research and Devel- opment in Information Retrieval (SIGIR). ...

    2009

  4. [12]

    Creager and Hendrik van Antwerpen

    Douglas A. Creager and Hendrik van Antwerpen. 2023. Stack Graphs: Name Resolution at Scale. InEvolution, Originality, and Community in Computer Science (EVCS) (OpenAccess Series in Informatics (OASIcs)), Vol. 109. 8:1–8:12. https: //doi.org/10.4230/OASIcs.EVCS.2023.8

    2023 doi

  5. [13]

    Elmore, Michael Stonebraker, Magdalena Balazinska, Bill Howe, Jeremy Kepner, Samuel Madden, David Maier, Tim Mattson, and Stanley B

    Jennie Duggan, Aaron J. Elmore, Michael Stonebraker, Magdalena Balazinska, Bill Howe, Jeremy Kepner, Samuel Madden, David Maier, Tim Mattson, and Stanley B. Zdonik. 2015. The BigDAWG Polystore System.ACM SIGMOD Record 44, 2 (2015), 11–16. https://doi.org/10.1145/2814710.2814713

    2015

  6. [14]

    Fabio James Fehr, Prabhu Teja S, Luca Franceschi, and Giovanni Zappella. 2025. CoRet: Improved Retriever for Code Editing. InProceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 2: Short Papers). Association for Computational Linguist...

    2025 doi

  7. [15]

    Jia Feng, Zhanyue Qin, Cuiyun Gao, Ruiqi Wang, Chaozheng Wang, Yingwei Ma, and Xiaoyuan Xie. 2026. On the Effectiveness of Context Compression for Repository-Level Tasks: An Empirical Investigation. arXiv:2604.13725. https: //arxiv.org/abs/2604.13725 Work in progress

    2026 arXiv

  8. [16]

    Zhangyin Feng, Daya Guo, Duyu Tang, Nan Duan, Xiaocheng Feng, Ming Gong, Linjun Shou, Bing Qin, Ting Liu, Daxin Jiang, and Ming Zhou. 2020. CodeBERT: A pre-trained model for programming and natural languages. InFindings of the Association for Computational Linguistics: EMNLP 2...

    2020 doi

  9. [17]

    Paul Gauthier and Aider contributors. 2024. Aider: Repository map. https: //aider.chat/docs/repomap.html. Accessed 2026-05-12

    2024

  10. [18]

    Gemma Team. 2026. Gemma 4 Technical Report. arXiv:2607.02770. https: //arxiv.org/abs/2607.02770

    2026 arXiv

  11. [19]

    Thibaud Gloaguen, Niels Mündler, Mark Müller, Veselin Raychev, and Martin Vechev. 2026. Evaluating AGENTS.md: Are Repository-Level Context Files Helpful for Coding Agents? arXiv:2602.11988. https://arxiv.org/abs/2602.11988

    2026 arXiv

  12. [20]

    Goetz Graefe and William J. McKenna. 1993. The Volcano Optimizer Generator: Extensibility and Efficient Search. InProceedings of the 9th International Confer- ence on Data Engineering. IEEE Computer Society Press, Los Alamitos, CA, USA, 209–218. https://doi.org/10.1109/ICDE.19...

    1993

  13. [21]

    Daya Guo, Shuai Lu, Nan Duan, Yanlin Wang, Ming Zhou, and Jian Yin. 2022. UniXcoder: Unified cross-modal pre-training for code representation. InProceed- ings of the 60th Annual Meeting of the Association for Computational Linguistics (ACL). Association for Computational Lingu...

    2022 doi

  14. [22]

    Clement, Dawn Drain, Neel Sundaresan, Jian Yin, Daxin Jiang, and Ming Zhou

    Daya Guo, Shuo Ren, Shuai Lu, Zhangyin Feng, Duyu Tang, Shujie Liu, Long Zhou, Nan Duan, Alexey Svyatkovskiy, Shengyu Fu, Michele Tufano, Shao Kun Deng, Colin B. Clement, Dawn Drain, Neel Sundaresan, Jian Yin, Daxin Jiang, and Ming Zhou. 2021. GraphCodeBERT: Pre-training Code ...

    2021

  15. [23]

    Ashish Gupta, Inderpal Singh Mumick, and V. S. Subrahmanian. 1993. Maintain- ing Views Incrementally. InProceedings of the 1993 ACM SIGMOD International Conference on Management of Data. Association for Computing Machinery, New York, NY, USA, 157–166. https://doi.org/10.1145/1...

    1993

  16. [24]

    Gwihwan Go, Quan Zhang, Chijin Zhou, Zhao Wei, and Yu Jiang. 2026. LSPRAG: LSP-Guided RAG for Language-Agnostic Real-Time Unit Test Generation. InProceedings of the 48th International Conference on Software Engineering (Rio de Janeiro, Brazil)(ICSE ’26). Association for Comput...

    2026

  17. [25]

    Yu Huo, Kun Zeng, Siyu Zhang, Yuquan Lu, Cheng Yang, Yifu Guo, and Xiaoying Tang. 2026. RepoShapley: Shapley-Enhanced Context Filtering for Repository- Level Code Completion. InFindings of the Association for Computational Linguis- tics: ACL 2026. Association for Computational...

    2026 doi

  18. [26]

    Zhonghao Jiang, Xiaoxue Ren, Meng Yan, Wei Jiang, Yong Li, and Zhongxin Liu

  19. [27]

    Jimenez, John Yang, Alexander Wettig, Shunyu Yao, Kexin Pei, Ofir Press, and Karthik Narasimhan

    Carlos E. Jimenez, John Yang, Alexander Wettig, Shunyu Yao, Kexin Pei, Ofir Press, and Karthik Narasimhan. 2024. SWE-bench: Can language models resolve real-world GitHub issues?. InInternational Conference on Learning Representations (ICLR)

    2024

  20. [28]

    Jeff Johnson, Matthijs Douze, and Hervé Jégou. 2021. Billion-Scale Similarity Search with GPUs.IEEE Transactions on Big Data7, 3 (July 2021), 535–547. https://doi.org/10.1109/TBDATA.2019.2921572

    2021

  21. [29]

    Jimenez, Ofir Press, and John Yang

    Kabir Khandpur, Kilian Lieret, Carlos E. Jimenez, Ofir Press, and John Yang

  22. [30]

    Myeongsoo Kim, Chao-Chun Hsu, Dingmin Wang, Shweta Garg, Varun Ku- mar, and Murali Krishna Ramanathan. 2026. CODESTRUCT: Code Agents over Structured Action Spaces. InProceedings of the 64th Annual Meeting of the As- sociation for Computational Linguistics (Volume 1: Long Paper...

    2026 doi

  23. [31]

    SWE-bench benchmark release

    SWE-bench Multilingual. SWE-bench benchmark release. https://www. swebench.com/multilingual.html Accessed 2026-07-25

    2026

  24. [32]

    Barr, Federica Sarro, Zhaoyang Chu, and He Ye

    Han Li, Letian Zhu, Bohan Zhang, Rili Feng, Jiaming Wang, Yue Pan, Earl T. Barr, Federica Sarro, Zhaoyang Chu, and He Ye. 2026. ContextBench: A Benchmark for Context Retrieval in Coding Agents. arXiv:2602.05892. https://arxiv.org/abs/ 2602.05892

    2026

  25. [33]

    Daria Kryvosheieva, Saba Sturua, Michael Günther, Scott Martens, and Han Xiao. 2025. Efficient Code Embeddings from Code Generation Models. InFourth Workshop on Deep Learning for Code (DL4Code), NeurIPS. https://openreview. net/forum?id=smR7RPdWZs arXiv:2508.21290

    2025 arXiv

  26. [34]

    Zhuofeng Li, Haoxiang Zhang, Cong Wei, Pan Lu, Ping Nie, Yi Lu, Yuyang Bai, Shangbin Feng, Hangxiao Zhu, Ming Zhong, Yuyu Zhang, Jianwen Xie, Yejin Choi, James Zou, Jiawei Han, Wenhu Chen, Jimmy Lin, Dongfu Jiang, and Yu Zhang. 2026. Beyond Semantic Similarity: Rethinking Retr...

    2026 arXiv

  27. [35]

    Yichen Li, Qiye Lin, Yun Peng, Zhihan Jiang, Jinyang Liu, Chaozheng Wang, Yintong Huo, and Cuiyun Gao. 2026. One Size Does Not Fit All: Revisiting Code Context Engineering for Repository-Level Code Generation.Proceedings of the ACM on Software Engineering3, FSE (2026), 2952–29...

    2026

  28. [36]

    Tobias Lindenbauer, Igor Slinko, Ludwig Felder, Egor Bogomolov, and Yaroslav Zharov. 2025. The Complexity Trap: Simple Observation Masking Is as Efficient as LLM Summarization for Agent Context Management. InFourth Workshop on Deep Learning for Code (DL4Code), NeurIPS. https:/...

    2025

  29. [37]

    Zhihao Lin, Mingyi Zhou, Yizhuo Yang, and Li Li. 2026. How Much Static Structure Do Code Agents Need? A Study of Deterministic Anchoring. To appear in the 35th ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA). https://arxiv.org/abs/2606.26979 arXiv:...

    2026 arXiv

  30. [38]

    Shukai Liu, Bo Jiang, Jian Yang, Yizhi Li, Jinyang Guo, Xianglong Liu, and Bryan Dai. 2026. Context as a Tool: Context Management for Long-Horizon SWE- Agents. InFindings of the Association for Computational Linguistics: ACL 2026. Association for Computational Linguistics, San...

    2026 doi

  31. [39]

    Jinshi Liu, Hanying Zuo, Congyin Cao, Anran Zhang, Yixuan Liu, and Xinzhou Xie. 2026. AOCI: Symbolic–Semantic Indexing for Practical Repository-Scale Code Understanding with LLMs. arXiv:2605.02421. https://arxiv.org/abs/2605. 02421

    2026 arXiv

  32. [40]

    George Ma, Anurag Koul, Qi Chen, Yawen Wu, Sachit Kuhar, Yu Yu, Aritra Sen- gupta, Varun Kumar, and Murali Krishna Ramanathan. 2026. SpecAgent: A Spec- ulative Retrieval and Forecasting Agent for Code Completion. InProceedings of the 64th Annual Meeting of the Association for ...

    2026 doi

  33. [41]

    Xiangyan Liu, Bo Lan, Zhiyuan Hu, Yang Liu, Zhicheng Zhang, Fei Wang, Michael Qizhe Shieh, and Wenmeng Zhou. 2025. CodexGraph: Bridging Large Language Models and Code Repositories via Code Graph Databases. InPro- ceedings of the 2025 Conference of the Nations of the Americas C...

    2025 doi

  34. [42]

    Simon Marlow. 2022. Incremental indexing with Glean. Glean documentation, https://glean.software/blog/incremental/. Accessed 2026-07-15

    2022

  35. [43]

    Malkov and D

    Yu A. Malkov and D. A. Yashunin. 2020. Efficient and robust approximate nearest neighbor search using hierarchical navigable small world graphs.IEEE Transactions on Pattern Analysis and Machine Intelligence42, 4 (2020), 824–836. https://doi.org/10.1109/TPAMI.2018.2889473

    2020

  36. [44]

    Microsoft. 2022. LSIF: Language Server Index Format specification, v0.6.0. https://microsoft.github.io/language-server-protocol/specifications/lsif/0. 6.0/specification/. Accessed 2026-05-12

    2022

  37. [45]

    Meta Engineering. 2024. Indexing code at scale with Glean. https://engineering.fb. com/2024/12/19/developer-tools/glean-open-source-code-indexing/. Accessed 2026-07-15

    2024

  38. [46]

    Han-Wen Nienhuys and Sourcegraph contributors. 2024. Zoekt: Fast trigram- based code search. https://github.com/sourcegraph/zoekt. Accessed 2026-05-12

    2024

  39. [47]

    Microsoft. 2024. Language Server Protocol Specification. https://microsoft.github. io/language-server-protocol/. Accessed 2026-05-12

    2024

  40. [48]

    Oraios AI. 2026. Serena: The IDE for Your Coding Agent. Software, version 1.6.1. https://github.com/oraios/serena/tree/v1.6.1 Accessed 2026-07-25; MIT License

    2026

  41. [49]

    OpenAI. 2024. Introducing SWE-bench Verified. https://openai.com/index/ introducing-swe-bench-verified/. Accessed 2026-05-12

    2024

  42. [50]

    Junsong Pu, Yichen Li, and Zhuangbin Chen. 2026. TypeScript Repository Indexing for Code Agent Retrieval. arXiv:2604.18413. https://arxiv.org/abs/2604. 18413 Tool demonstration; unrefereed preprint

    2026 arXiv

  43. [51]

    Siru Ouyang, Wenhao Yu, Kaixin Ma, Zilin Xiao, Zhihan Zhang, Mengzhao Jia, Jiawei Han, Hongming Zhang, and Dong Yu. 2025. RepoGraph: Enhancing AI Software Engineering with Repository-level Code Graph. InInternational Conference on Learning Representations (ICLR). https://openr...

    2025

  44. [52]

    Revanth Gangi Reddy, Tarun Suresh, JaeHyeok Doo, Ye Liu, Xuan Phi Nguyen, Yingbo Zhou, Semih Yavuz, Caiming Xiong, Heng Ji, and Shafiq Joty. 2026. SweRank: Software issue localization with code ranking. InInternational Con- ference on Learning Representations (ICLR). https://a...

    2026 arXiv

  45. [53]

    Qwen Team. 2026. Qwen3.5-9B and Qwen3.5-27B. Official model cards at https://huggingface.co/Qwen/Qwen3.5-9B and https://huggingface.co/Qwen/ Qwen3.5-27B. Accessed 2026-07-25

    2026

  46. [54]

    Brian Sam-Bodden. 2026. What Context Does a Coding Agent Actually Need to Act? arXiv:2607.09691. https://arxiv.org/abs/2607.09691

    2026 arXiv

  47. [55]

    Stephen Robertson and Hugo Zaragoza. 2009. The probabilistic relevance frame- work: BM25 and beyond.Foundations and Trends in Information Retrieval3, 4 (2009), 333–389. https://doi.org/10.1561/1500000019

    2009 doi

  48. [56]

    Chuanqi Shi, Miao Gao, and Zhiqiang Gao. 2026. AIRCoder: Adaptive Integration of Multi-dimensional Retrieval for Repository-level Code Completion. InProceed- ings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers). Association f...

    2026 doi

  49. [57]

    SCIP contributors. 2026. SCIP: A Language-Agnostic Protocol for Indexing Source Code. Protocol specification and software, version 0.9.0. https://github.com/scip- code/scip/tree/v0.9.0 Accessed 2026-07-25

    2026

  50. [58]

    Weiwei Sun, Lingyong Yan, Xinyu Ma, Shuaiqiang Wang, Pengjie Ren, Zhumin Chen, Dawei Yin, and Zhaochun Ren. 2023. Is ChatGPT good at search? In- vestigating large language models as re-ranking agents. InProceedings of the 2023 Conference on Empirical Methods in Natural Languag...

    2023 doi

  51. [59]

    Sourcegraph. 2024. Sourcegraph: Code search and intelligence. https:// sourcegraph.com/. Accessed 2026-05-12

    2024

  52. [60]

    The Cognition Team. 2025. DeepWiki: AI docs for any repo. https://cognition. com/blog/deepwiki. Accessed 2026-05-13; public, no-login wiki for any GitHub repository, powered by Devin

    2025

  53. [61]

    Tamás Szabó. 2023. Incrementalizing Production CodeQL Analyses. InProceed- ings of the 31st ACM Joint European Software Engineering Conference and Sympo- sium on the Foundations of Software Engineering (ESEC/FSE ’23). Association for Computing Machinery, 1716–1726. https://doi...

    2023

  54. [62]

    Martin Vogel, Falk Meyer-Eschenbach, Severin Kohler, Elias Grünewald, and Felix Balzer. 2026. Codebase-Memory: Tree-Sitter-Based Knowledge Graphs for LLM Code Exploration via MCP. arXiv:2603.27277. https://arxiv.org/abs/2603.27277

    2026

  55. [63]

    Tree-sitter contributors. 2026. Tree-sitter Parser and Node Documentation. https: //tree-sitter.github.io/tree-sitter/using-parsers/1-getting-started.html. Accessed 2026-07-25

    2026

  56. [64]

    Xu, Xiangru Tang, Mingchen Zhuge, Jiayi Pan, Yueqi Song, Bowen Li, Jaskirat Singh, Hoang H

    Xingyao Wang, Boxuan Li, Yufan Song, Frank F. Xu, Xiangru Tang, Mingchen Zhuge, Jiayi Pan, Yueqi Song, Bowen Li, Jaskirat Singh, Hoang H. Tran, Fuqiang Li, Ren Ma, Mingzhang Zheng, Bill Qian, Yanjun Shao, Niklas Muennighoff, Yizhe Zhang, Binyuan Hui, Junyang Lin, Robert Brenna...

    2025

  57. [65]

    Peiding Wang, Li Zhang, Fang Liu, Chongyang Tao, and Yinghao Zhu. 2026. CodeMEM: AST-Guided Adaptive Memory for Repository-Level Iterative Code Generation. InFindings of the Association for Computational Linguistics: ACL

    2026

  58. [66]

    Di Wu, Wasi Uddin Ahmad, Dejiao Zhang, Murali Krishna Ramanathan, and Xiaofei Ma. 2024. Repoformer: Selective Retrieval for Repository-Level Code Completion. InProceedings of the 41st International Conference on Machine Learn- ing (Proceedings of Machine Learning Research), Vo...

    2024

  59. [67]

    Scott Wu and Cognition Labs. 2024. Introducing Devin, the first AI software engineer. https://cognition.com/blog/introducing-devin. Accessed 2026-05-12

    2024

  60. [68]

    Yuhang Wang, Yuling Shi, Mo Yang, Rongrui Zhang, Shilin He, Heng Lian, Yuting Chen, Siyu Ye, Kai Cai, and Xiaodong Gu. 2026. SWE-Pruner: Self-Adaptive Context Pruning for Coding Agents. arXiv:2601.16746. https://arxiv.org/abs/ 2601.16746

    2026 arXiv

  61. [69]

    Yuan-An Xiao, Pengfei Gao, Chao Peng, and Yingfei Xiong. 2026. Reducing Cost of LLM Agents with Trajectory Reduction.Proceedings of the ACM on Software Engineering3, FSE (June 2026), 1241–1263. https://doi.org/10.1145/3797084

    2026 doi

  62. [70]

    Jimenez, Alexander Wettig, Kilian Lieret, Shunyu Yao, Karthik Narasimhan, and Ofir Press

    John Yang, Carlos E. Jimenez, Alexander Wettig, Kilian Lieret, Shunyu Yao, Karthik Narasimhan, and Ofir Press. 2024. SWE-agent: Agent–computer inter- faces enable automated software engineering. InAdvances in Neural Information Processing Systems (NeurIPS), Vol. 37. Neural Inf...

    2024 doi

  63. [71]

    Chunqiu Steven Xia, Yinlin Deng, Soren Dunn, and Lingming Zhang. 2025. Demystifying LLM-Based Software Engineering Agents.Proceedings of the ACM on Software Engineering2, FSE (2025), 801–824. https://doi.org/10.1145/3715754

    2025 doi

  64. [72]

    Zhongming Yu, Hejia Zhang, Yujie Zhao, Hanxian Huang, Matrix Yao, Ke Ding, and Jishen Zhao. 2025. OrcaLoca: An LLM Agent Framework for Software Issue Localization. InProceedings of the 42nd International Conference on Machine Learning (Proceedings of Machine Learning Research)...

    2025

  65. [73]

    Fengji Zhang, Bei Chen, Yue Zhang, Jacky Keung, Jin Liu, Daoguang Zan, Yi Mao, Jian-Guang Lou, and Weizhu Chen. 2023. RepoCoder: Repository-level code completion through iterative retrieval and generation. InProceedings of the 2023 Conference on Empirical Methods in Natural La...

    2023

  66. [74]

    Narasimhan, and Yuan Cao

    Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik R. Narasimhan, and Yuan Cao. 2023. ReAct: Synergizing Reasoning and Acting in Language Models. InInternational Conference on Learning Representations (ICLR). https://openreview.net/forum?id=WE_vluYUL-X

    2023

  67. [75]

    Yanzhao Zhang, Mingxin Li, Dingkun Long, Xin Zhang, Huan Lin, Baosong Yang, Pengjun Xie, An Yang, Dayiheng Liu, Junyang Lin, Fei Huang, and Jingren Zhou

  68. [76]

    Yuntong Zhang, Haifeng Ruan, Zhiyu Fan, and Abhik Roychoudhury. 2024. AutoCodeRover: Autonomous Program Improvement. InProceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA). ACM, 1592–1604. https://doi.org/10.1145/3650212.3680384

    2024

  69. [77]

    Shaoqiu Zhang, Yuhang Wang, Jialiang Liang, Yuling Shi, Wenhao Zeng, Mao- quan Wang, Shilin He, Ningyuan Xu, Siyu Ye, Kai Cai, and Xiaodong Gu

  70. [78]

    arXiv:2606.07297

    SWE-Explore: Benchmarking How Coding Agents Explore Repositories. arXiv:2606.07297. https://arxiv.org/abs/2606.07297

    arXiv

  71. [80]

    arXiv:2506.05176

    Qwen3 Embedding: Advancing Text Embedding and Reranking Through Foundation Models. arXiv:2506.05176. https://arxiv.org/abs/2506.05176

    arXiv

  72. [82]

    Zelin Zhao, Xizao Wang, Zhaogui Xu, Zhenhao Tang, Yongchao Li, and Peng Di

  73. [2023]

    Represent this query for searching relevant code

    Incremental Call Graph Construction in Industrial Practice. InProceedings of the 45th International Conference on Software Engineering: Software Engineering in Practice (ICSE-SEIP). 471–482. https://doi.org/10.1109/ICSE-SEIP58684.2023. 00048 17 Zhongming Yu et al. A DATASET CO...

    2023

  74. [2025]

    In 2025 40th IEEE/ACM International Conference on Automated Software Engineering (ASE)

    Issue Localization via LLM-Driven Iterative Code Graph Searching. In 2025 40th IEEE/ACM International Conference on Automated Software Engineering (ASE). IEEE, 3034–3045. https://doi.org/10.1109/ASE63991.2025.00249

    2025

  75. [2026]

    https://doi.org/10.18653/v1/2026.findings-acl.834

    Association for Computational Linguistics, San Diego, California, United States, 16903–16917. https://doi.org/10.18653/v1/2026.findings-acl.834

    2026 doi

Pith tools

Reviewed August 1, 2026 · model on record in the stance chip above.